import Emiter from 'Emiter';
import Loger from 'Loger';
import MessageTypes from 'MessageTypes';
import GlobalConfig from 'GlobalConfig';
import MD5 from "md5";
import ApeConsts from 'apes/ApeConsts';
import iphunter from 'iphunter';

import fetchJsonp from 'fetch-jsonp';

// 日志对象
const loger = Loger.getLoger('Sass');

let confInfo = {};
class Sass extends Emiter {
    constructor() {
        super();
    }

    ///////////////////////////////////////Sass 接口///////////////////////////////////////////////////
    //Sass init初始化获取课堂校验信息-----------------------------------------------------------------
    getJoinParams(_initInfo) {
        /* 获取用于加入课堂的参数
         /3m/api/meeting/joinParams.do
         参数 (application/x-www-form-urlencoded):
         名称	        类型	可选	默认值	说明
         meetingNumber	String	否   	null	课堂号
         userID	        String	是	     0	   用户id
         返回 (application/json):
         code	int	0 正常
         1 课堂号必填
         2 无效的课堂号
         3 没有对应的站点
         4 站点已过期
         siteId	String	站点号
         passwordRequired	Boolean	是否需要输入密码
         md5	String	用于后续加入课堂验证
         msType	int	媒体服务器类型
         classType 课堂类型
         */
        let url = `http://${_initInfo.portal}/3m/api/meeting/joinParams.do?meetingNumber=${_initInfo.classId}&userID=${_initInfo.userId}`;
        loger.log('1.初始化init获取课堂校验信息.');
        loger.log(url);
        loger.log(_initInfo);
        fetch(url, {
            timeout: 5000
        })
            .then(ret => {
                if (ret.ok) {
                    return ret.json();
                } else {
                    loger.error(`初始化init获取课堂校验信息-网络异常.状态码:${ret.status}`);
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_INIT_NETWORK);
                    throw '';
                }
            })
            .then(ret => {
                //  code	int	0 正常
                // 1 课堂号必填
                //2 无效的课堂号
                //3 没有对应的站点
                //4 站点已过期
                if (ret.code === 0) {
                    loger.log('初始化init获取课堂校验信息-完成');
                    this._emit(Sass.CLASS_INIT_SUCCESS, ret);
                } else if (ret.code === 1) {
                    //loger.warn('Sass获取课堂校验信息失败.');
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_INIT_FAILED_1);
                } else if (ret.code === 2) {
                    //loger.warn('Sass获取课堂校验信息失败.');
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_INIT_FAILED_2);
                } else if (ret.code === 3) {
                    //loger.warn('Sass获取课堂校验信息失败.');
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_INIT_FAILED_3);
                } else if (ret.code === 4) {
                    //loger.warn('Sass获取课堂校验信息失败.');
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_INIT_FAILED_4);
                } else {
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_INIT_FAILED, ret);
                }
            })
            .catch(err => {
                loger.error(`初始化init获取课堂校验信息-异常.状态码:${err}`);
                this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_INIT_PROTOCOL, err);
            });
    }

    // Sass校验开始-->密码校验(如果需要密码)--->MD5校验----------------------------------------------------
    passwordAndMd5Checking(_param) {
        loger.log('2.开始Sass校验');
        loger.log(_param);
        confInfo = _param;
        // 密码校验
        if (confInfo.passwordRequired === 'true' || confInfo.passwordRequired === true) {
            this.sendPWDChecking();
            return;
        }
        // MD5校验
        this.sendMD5Checking();
    }

    // 入会密码校验---------------------------------------------------------------------------------------
    sendPWDChecking() {
        //let url = `http://${classInfo.portal}/3m/getCheckMeetinig.do?siteId=${classInfo.siteId}&classId=${classInfo.classId}&password=${classInfo.password}`;
        /*
         /3m/api/meeting/signIn.do
         siteId  站点号
         classId  课堂号（meetingNumber)
         isTeacher 是否是老师：1 是 0 否
         password 输入的密码
         // 请求格式 http://112.126.80.182/3m/api/meeting/signIn.do?siteId=h5test&classId=526661904&password=111111&isTeacher=0
         */
        //判断是否是老师
        let isTeacher = 0;
        if (confInfo.userRole == ApeConsts.host) {
            isTeacher = 1
        }

        let url = `http://${confInfo.portal}/3m/api/meeting/signIn.do?siteId=${confInfo.siteId}&classId=${confInfo.classId}&isTeacher=${isTeacher}&password=${confInfo.password}`;
        loger.log('3.课堂密码校验', url);
        fetch(url, {
            timeout: 5000
        })
            .then(ret => {
                if (ret.status === 200) {
                    return ret.text();
                } else {
                    loger.error(`课堂密码校验-网络异常.状态码:${ret.status}`);
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_JOIN_NETWORK);
                    throw '';
                }
            })
            .then(ret => {
                let rectObj = JSON.parse(ret);
                if (rectObj.flag === 'false' || rectObj.flag === false) {
                    loger.error(`课堂密码校验-失败.`);
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_PASSWORD_WRONG);
                    return;
                }
                if (rectObj.flag === 'true' || rectObj.flag === true) {
                    loger.log(`课堂密码校验-成功.`);
                    this.sendMD5Checking();
                    return;
                }
                loger.error(`课堂密码校验-协议异常.`, rectObj);
                this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_JOIN_PROTOCOL);
            })
            .catch(err => {
                loger.error(`课堂密码校验-异常.状态码:${err}`);
                this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_JOIN_FAILED);
            });
    }

    //MD5校验-----------------------------------------------------------------------------------------
    sendMD5Checking() {
        let url = `http://${confInfo.portal}/3m/meeting/md5CheckMeeting.do?siteId=${confInfo.siteId}&meetingNumber=${confInfo.classId}&userId=${confInfo.userId}&userName=${confInfo.userName}&userType=${confInfo.userType}&nopassword=${confInfo.passwordRequired}&md5=${confInfo.md5}`;
        loger.log('4.MD5校验', url);
        fetch(url, {
            timeout: 5000
        })
            .then(ret => {
                if (ret.status === 200) {
                    return ret.json();
                } else {
                    loger.error(`MD5校验-网络异常.状态码:${ret.status}`);
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_JOIN_NETWORK);
                    throw '';
                }
            })
            .then(ret => {
                if (ret.flag == "true" || ret.flag == true) {
                    loger.log('MD5校验完成');
                    loger.log(ret);
                    this._emit(Sass.SUCCESS, ret);
                } else {
                    loger.log('MD5校验-失败.');
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_MD5_WRONG);

                }
            })
            .catch(err => {
                loger.error(`MD5校验-异常.状态码:${err}`);
                this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_JOIN_FAILED);
            });
    }

    // 获取课堂基本详情------------------------------------------------------------------------------------
    getClassDetail() {
        let url = `http://${GlobalConfig.portal}/3m/meeting/getClassH5.do?classNumber=${GlobalConfig.classId}`;
        loger.log('获取Class详情.', url);
        fetch(url, {
            timeout: 5000
        })
            .then(ret => {
                if (ret.ok) {
                    return ret.json();
                } else {
                    loger.error(`获取Class详情-网络异常.状态码:${ret.status}`);
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_GET_CLASS_DETAIL);
                    throw '';
                }
            })
            .then(ret => {
                if (ret.errorCode === 0) {
                    loger.log('获取Class详情完成');
                    this._emit(Sass.CLASS_GET_CLASS_DETAIL, ret);
                } else {
                    loger.warn('获取Class详情失败.');
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_GET_CLASS_DETAIL);
                }
            })
            .catch(err => {
                loger.error(`获取Class详情异常.状态码:${err}`);
                this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_GET_CLASS_DETAIL);
            });
    }

    //获取课堂课堂的完整信息--------------------------------------------------------------------------------
    getClassParam() {
        /*
         参数 (application/x-www-form-urlencoded):
         名称	类型	可选	默认值	说明
         meetingNumber	String	否	null	课堂号
         timestamp	String	否	null	时间戳
         authId	String	否	null	验证信息 md5(meetingNumber + timestamp)
         返回 (application/json):
         名称	类型	说明
         code	int	0 正常
         1 课堂号必填
         2 无效的课堂号
         3 没有对应的站点
         4 站点已过期
         siteId	String	站点号
         meetingNumber	String	课堂号 对应的是classId
         */
        var timestamp = new Date().getTime();
        var authId = MD5(GlobalConfig.classId + "" + timestamp);//课堂号+时间戳 的字符串，转成MD5
        let url = `http://${GlobalConfig.portal}/3m/api/meeting/detail.do?meetingNumber=${GlobalConfig.classId}&timestamp=${timestamp}&authId=${authId}`;
        loger.log('5.获取课堂课堂的完整信息 ');
        loger.log(url);
        fetch(url, {
            timeout: 5000
        })
            .then(ret => {
                if (ret.ok) {
                    return ret.json();
                } else {
                    loger.error(`获取课堂课堂的完整信息-网络异常.状态码:${ret.status}`);
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_GET_CLASS_PARAML);

                    throw '';
                }
            })
            .then(ret => {
                if (ret.code === 0) {
                    loger.log('获取课堂课堂的完整信息完成');
                    this._emit(Sass.CLASS_GET_CLASS_PARAM, ret);
                } else {
                    loger.warn('获取课堂课堂的完整信息 失败.');
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_GET_CLASS_PARAML);
                }
            })
            .catch(err => {
                loger.error(`获取课堂课堂的完整信息异常.状态码:${err}`);
                this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_GET_CLASS_PARAML);
            });
    }

    //删除文档-----------------------------------------------------------------------------------------------------
    /*
     删除课堂中的文档，即删除课堂与文档的关联
     /api/document/deleteRelation.do
     参数
     docId       文档的唯一id
     classId     课堂号
     timestamp   时间戳
     authId       md5(docId+classId+timestamp)
     返回 (application/json):
     0 成功， 1 验证信息错误
     */
    sassDeleteDocument(_param) {
        if(GlobalConfig.isRecordPlayBack){
            loger.log('录制回放中，能删除文档');
            return;
        }
        var timestamp = new Date().getTime();
        var authId = MD5(_param.docId + "" + _param.classId + "" + timestamp);// docId+classId+timestamp的字符串，转成MD5
        let url = `http://${GlobalConfig.portal}/3m/api/document/deleteRelation.do?docId=${_param.docId}&classId=${GlobalConfig.classId}&timestamp=${timestamp}&authId=${authId}`;
        loger.log('sassDeleteDocument', url);

        fetch(url, {
            timeout: 5000
        })
            .then(ret => {
                if (ret.ok) {
                    return ret.json();
                } else {
                    loger.error(`删除文档-网络异常.状态码:${ret.status}`);
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_DOC_DELETE_FAILED);

                    throw '';
                }
            })
            .then(ret => {
                if (ret.code === 0) {
                    loger.log('删除文档-完成');
                    this._emit(Sass.DELETE_DOCUMENT_SUCCESS, _param);
                } else {
                    loger.warn('删除文档-失败.')
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_DOC_DELETE_FAILED);
                }
            })
            .catch(err => {
                loger.error(`删除文档-异常.状态码:${err}`);
                this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_DOC_DELETE_FAILED);
            });
    }

    //删除媒体共享文件
    sassDeletMediaShare(_param) {
        if(GlobalConfig.isRecordPlayBack){
            loger.log('录制回放中，能删除文件');
            return;
        }
        var timestamp = new Date().getTime();
        var authId = MD5(_param.fileId + "" + _param.classId + "" + timestamp);// docId+classId+timestamp的字符串，转成MD5
        let url = `http://${GlobalConfig.portal}/3m/api/sharedMedia/deleteRelation.do?fileId=${_param.fileId}&classId=${GlobalConfig.classId}&timestamp=${timestamp}&authId=${authId}`;
        loger.log('删除媒体共享文件', url);

        fetch(url, {
            timeout: 5000
        })
            .then(ret => {
                if (ret.ok) {
                    return ret.json();
                } else {
                    loger.error(`删除媒体共享文件-网络异常.状态码:${ret.status}`);
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_MEDIASHARE_DELETE_FAILED);

                    throw '';
                }
            })
            .then(ret => {
                //code  0 成功， 1 验证信息错误
                if (ret.code === 0) {
                    loger.log('删除媒体共享文件 完成');
                    this._emit(Sass.DELETE_MEDIASHARE_SUCCESS, _param);
                } else {
                    loger.warn('删除媒体共享文件 失败.');
                    this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_MEDIASHARE_DELETE_FAILED);
                }
            })
            .catch(err => {
                loger.error(`删除媒体共享文件-异常.状态码:${err}`);
                this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_MEDIASHARE_DELETE_FAILED);
            });
    }


    //保存课堂的当前信息-----------------------------------------------------
    /*保存课堂的当前信息，首次是插入，后面是更新
     /api/meeting/saveInfo.do
     参数(application/x-www-form-urlencoded):
     info Json字符串课堂信息，由前端自己维护
     classId  课堂号
     timestamp  时间戳
     authId  做基本验证，md5(classId+timestamp)

     返回 (application/json):
     code 0 成功  1 课堂号为空 2 无效的课堂号 3 验证信息错误*/

    saveClassStatusInfo(_param) {
        if(GlobalConfig.isRecordPlayBack){
            loger.log('录制回放中，不需要保存课堂信息');
            return;
        }
        //{"classStatusInfo":classStatusInfo}
        var timestamp = new Date().getTime();
        var authId = MD5(GlobalConfig.classId + "" + timestamp);// (classId+timestamp)的字符串，转成MD5
        let classStatusInfo = JSON.stringify(_param.classStatusInfo);
        let url = `http://${GlobalConfig.portal}/3m/api/meeting/saveInfo.do`;
        loger.log('saveClassStatusInfo', url);
        fetch(url, {
            method: 'POST',
            headers: {
                "Content-Type": "application/x-www-form-urlencoded"
            },
            body: `classId=${GlobalConfig.classId}&info=${classStatusInfo}&timestamp=${timestamp}&authId=${authId}`,
            timeout: 5000
        })
            .then(ret => {
                if (ret.ok) {
                    return ret.json();
                } else {
                    loger.error(`saveClassStatusInfo-网络异常.状态码:${ret.status}`);
                    //this._emit(MessageTypes.MCU_ERROR,MessageTypes.ERR_DOC_DELETE_FAILED);
                    throw '';
                }
            })
            .then(ret => {
                if (ret.code === 0) {
                    loger.log('saveClassStatusInfo 完成');
                    this._emit(Sass.CLASS_SAVE_STATUS_INFO_SUCCESS, _param);
                } else if (ret.code === 1) {
                    loger.log('saveClassStatusInfo 失败 课堂号为空');
                } else if (ret.code === 2) {
                    loger.log('saveClassStatusInfo 失败 无效的课堂号');
                } else if (ret.code === 3) {
                    loger.log('saveClassStatusInfo 失败 验证信息错误');
                } else {
                    loger.warn('saveClassStatusInfo 失败.', ret);
                    //this._emit(MessageTypes.MCU_ERROR,MessageTypes.ERR_DOC_DELETE_FAILED);
                }
            })
            .catch(err => {
                loger.error(`saveClassStatusInfo.状态码:${err}`);
                //this._emit(MessageTypes.MCU_ERROR,MessageTypes.ERR_DOC_DELETE_FAILED);
            });
    }

    //保存录制的信息，主要是录制文件的名称，必须和MCU录制的文件名相同
    saveClassRecordContrlInfo(_param) {
        if(GlobalConfig.isRecordPlayBack){
            loger.log('录制回放中，不需要保存');
            return;
        }
        loger.log('保存开始录制信息');
        let key = "3mang123A";
        let siteID = GlobalConfig.siteId;
        let meetingID = GlobalConfig.classId;
        let userID = GlobalConfig.userId;
        let userName = GlobalConfig.userName;
        let meetingName = GlobalConfig.className;
        let startTime = GlobalConfig.classBeginTime;
        let endTime = GlobalConfig.classEndTime;
        let playUrl = "";
        let streamName = GlobalConfig.recordFileName;
        let confRecordFileName = GlobalConfig.recordFileName;
        let downloadUrl = "";
        let recordStatus = GlobalConfig.classStatus;
        let recordTimestamp = GlobalConfig.classTimestamp;

        let timestamp = new Date().getTime();
        let authId = MD5(key + siteID + meetingID + timestamp);
        let url = `http://${GlobalConfig.portal}/3m/recordingMeeting/insertRecordingMeeting.do`;
        loger.log('saveClassRecordContrlInfo', url);

        fetch( encodeURI(url),  {
            method: 'POST',
            headers: {
                "Content-Type": "application/x-www-form-urlencoded"
            },
            body: `siteID=${siteID}&meetingID=${meetingID}&userID=${userID}&userName=${userName}&meetingName=${meetingName}&startTime=${startTime}&endTime=${endTime}&playUrl=${playUrl}&streamName=${streamName}&downloadUrl=${downloadUrl}&configFile=${confRecordFileName}&timestamp=${timestamp}&recordTimestamp=${recordTimestamp}&authId=${authId}`,
            timeout: 5000
        })

            .then(ret => {
                if (ret.ok) {
                    return ret.json();
                } else {
                    loger.error(`保存开始录制信息-网络异常.状态码:${ret.status}`);
                    throw '';
                }
            })
            .then(ret => {
                if (ret.errorCode === 0) {
                    loger.log('保存开始录制信息 完成');
                    this._emit(Sass.CLASS_SAVE_RECORD_INFO_SUCCESS, _param);
                } else {
                    loger.warn('保存开始录制信息 失败.', ret);
                }
            })
            .catch(err => {
                loger.error(`保存开始录制信息异常.状态码:${err}`);
            });
    }


    //答题卡-------------------------------------------------------
    //创建答题数据
    creatQuestion(_param){
        if(GlobalConfig.isRecordPlayBack){
            loger.log('录制回放中->创建答题数据->不做操作');
            return;
        }
       /* {
            "type": 1,//1单选，2多选，3判断，4点名
            "content": "题目",//没有就传""
            "timeLimit": 88,//有效时间（秒）
            "correct": "[]",//正确答案，没有就传[]
            "options": {},//选项数组，没有就传[]
            "option": []//学生选择的答案，没有就传[]
        }*/
        if(!_param){
            loger.warn('创建答题数据->参数错误->param:',_param);
            this._emit(Sass.SASS_CREAT_QUESTION_FAILED);
            return;
        }
        let classId=GlobalConfig.classId;//课堂号
        var timestamp = new Date().getTime();
        let authId = MD5(classId+""+timestamp);

        let type = parseInt(_param.type);//1单选，2多选，3判断，4点名
        let content =_param.content||"";
        let timeLimit = parseInt(_param.timeLimit);
        let correct = _param.correct.toString();
        let options = JSON.stringify(_param.options);

        let url = `http://${GlobalConfig.portal}/3m/api/question/add.do`;
        loger.log('创建答题数据', url);

        fetch( encodeURI(url),  {
            method: 'POST',
            headers: {
                "Content-Type": "application/x-www-form-urlencoded; charset=utf-8"
            },
            //classId=1&timestamp=2&authId=3&content=&options=["A","B","C","D"]&type=1&correct=0&timeLimit=60
            body: `classId=${classId}&timestamp=${timestamp}&authId=${authId}&content=${content}&options=${options}&type=${type}&correct=${correct}&timeLimit=${timeLimit}`,
            timeout: 5000
        })

            .then(ret => {
                if (ret.ok) {
                    return ret.json();
                } else {
                    loger.error(`创建答题数据-网络异常.状态码:${ret.status}`);
                    this._emit(Sass.SASS_CREAT_QUESTION_FAILED);
                    throw '';
                }
            })
            .then(ret => {
                if (ret.code== 0) {
                    //errorCode int  0 正常  1 没有指定的课堂 4 验证信息错误（authId）
                    // {"code":0,"id":1}
                    let question={};
                    question.questionId=ret.id;
                    question.type=type;
                    question.content=_param.content||[];
                    question.timeLimit=timeLimit;
                    question.correct=_param.correct||[];
                    question.options=_param.options||[];
                    loger.log('创建答题数据->完成->',question);
                    this._emit(Sass.SASS_CREAT_QUESTION_SUCCESS, question);
                } else {
                    loger.warn('创建答题数据->失败.', ret);
                    this._emit(Sass.SASS_CREAT_QUESTION_FAILED);
                }
            })
            .catch(err => {
                loger.error(`创建答题数据->状态码:${err}`);
                this._emit(Sass.SASS_CREAT_QUESTION_FAILED);
            });
    }
    //保存答题数据
    sendAnswer(_param){
        if(GlobalConfig.isRecordPlayBack){
            loger.log('录制回放中->保存答题数据->不做操作');
            return;
        }
        if(!_param){
            loger.warn('保存答题数据->参数错误->param:',_param);
            this._emit(Sass.SASS_SEND_ANSWER_FAILED);
            return;
        }
        /*classId	String课堂号
        timestamp 时间戳
        authId String验证信息md5(classId+timestamp)

        questionId	long 题目id
        answer	String 选择的选项的索引，如果是多选，用英文逗号分隔。例如：'0,3'
        userId	String 用户id
        userName  String 用户名字*/

        let classId=GlobalConfig.classId;//课堂号
        var timestamp = new Date().getTime();
        let authId = MD5(classId+""+timestamp);

        let type = parseInt(_param.type);//1单选，2多选，3判断，4点名

        let questionId = parseInt(_param.questionId);//题目id
        let answer = _param.answer.toString();
        let userId = _param.userId;
        let userName = _param.userName;

        let url = `http://${GlobalConfig.portal}/3m/api/question/answer.do`;
        loger.log('保存答题数据', url);

        fetch( encodeURI(url),  {
            method: 'POST',
            headers: {
                "Content-Type": "application/x-www-form-urlencoded; charset=utf-8"
            },
            //classId=1&timestamp=2&authId=3&questionId=1&answer=0&userId=111&userName=zhang3
            body: `classId=${classId}&timestamp=${timestamp}&authId=${authId}&questionId=${questionId}&answer=${answer}&userId=${userId}&userName=${userName}`,
            timeout: 5000
        })

            .then(ret => {
                if (ret.ok) {
                    return ret.json();
                } else {
                    loger.error(`保存答题数据-网络异常.状态码:${ret.status}`);
                    this._emit(Sass.SASS_SEND_ANSWER_FAILED);
                    throw '';
                }
            })
            .then(ret => {
                if (ret.code== 0) {
                    // 0 正常 1 没有指定的课堂  4 验证信息错误（authId） 5 没有指定的题目 6 题目不属于该课堂
                    //{"code":0}
                    let question=_param;
                    loger.log('保存答题数据->完成');
                    this._emit(Sass.SASS_SEND_ANSWER_SUCCESS, question);
                } else {
                    loger.warn('保存答题数据->失败.', ret);
                    this._emit(Sass.SASS_SEND_ANSWER_FAILED);
                }
            })
            .catch(err => {
                loger.error(`保存答题数据->状态码:${err}`);
                this._emit(Sass.SASS_SEND_ANSWER_FAILED);
            });
    }
    //查询题目数据
    getQuestion(_param){
        if(GlobalConfig.isRecordPlayBack){
            loger.log('录制回放中->查询题目数据->不做操作');
            return;
        }
        if(!_param){
            loger.warn('查询题目数据->参数错误->param:',_param);
            this._emit(Sass.SASS_GET_QUESTION_FAILED);
            return;
        }
        //questionId   long    题目id

        let questionId = parseInt(_param.questionId);//题目id
        let url = `http://${GlobalConfig.portal}/3m/api/question/get.do`;
        loger.log('查询题目数据', url);
        //接口中用的是GET
        fetch( encodeURI(url),  {
            method: 'POST',
            headers: {
                "Content-Type": "application/x-www-form-urlencoded; charset=utf-8"
            },
            body: `questionId=${questionId}`,
            timeout: 5000
        })

            .then(ret => {
                if (ret.ok) {
                    return ret.json();
                } else {
                    loger.error(`查询题目数据-网络异常.状态码:${ret.status}`);
                    this._emit(Sass.SASS_GET_QUESTION_FAILED);
                    throw '';
                }
            })
            .then(ret => {
                if (ret.code== 0) {
                    //0 正常 5 没有指定的题目
                    //{"timeLimit":90,"code":0,"options":"[\"A\",\"B\",\"C\"]","id":22,"type":2,"content":"题目"}
                    loger.log('查询题目数据->完成');
                    let question={};
                    question.questionId=ret.id||questionId;
                    question.type=ret.type;
                    question.timeLimit=ret.timeLimit;
                    question.options=ret.options;
                    question.content=ret.content;

                    this._emit(Sass.SASS_GET_QUESTION_SUCCESS, question);
                } else {
                    loger.warn('查询题目数据->失败.', ret);
                    this._emit(Sass.SASS_GET_QUESTION_FAILED);
                }
            })
            .catch(err => {
                loger.error(`查询题目数据->状态码:${err}`);
                this._emit(Sass.SASS_GET_QUESTION_FAILED);
            });
    }
    //查询答题结果数据
    getQuestionResult(_param){
        if(GlobalConfig.isRecordPlayBack){
            loger.log('录制回放中->查询答题结果数据->不做操作');
            return;
        }
        if(!_param){
            loger.warn('查询答题结果数据->参数错误->param:',_param);
            this._emit(Sass.SASS_GET_QUESTION_RESULT_FAILED);
            return;
        }
        //questionId   long    题目id

        let questionId = parseInt(_param.questionId);//题目id
        let url = `http://${GlobalConfig.portal}/3m/api/question/results.do`;
        loger.log('查询答题结果数据', url);

        fetch( encodeURI(url),  {
            method: 'POST',
            headers: {
                "Content-Type": "application/x-www-form-urlencoded; charset=utf-8"
            },
            body: `questionId=${questionId}`,
            timeout: 5000
        })

            .then(ret => {
                if (ret.ok) {
                    return ret.json();
                } else {
                    loger.error(`查询答题结果数据-网络异常.状态码:${ret.status}`);
                    this._emit(Sass.SASS_GET_QUESTION_RESULT_FAILED);
                    throw '';
                }
            })
            .then(ret => {
                if (ret.code== 0) {
                    //int 0 正常5  没有指定的题目
                   /* list	array	数组
                    userId string 用户id
                    userName string	用户姓名
                    answer  string 答案。选项的索引，多个时用逗号分隔
                    {"timeLimit":0,"content":"test question","id":11,"code":0,"type":3,"options":"["True", "False"]"}*/

                    loger.log('查询答题结果数据->完成');
                    let result=_param||{};
                    result.questionId=questionId;
                    result.list=ret.list;
                    this._emit(Sass.SASS_GET_QUESTION_RESULT_SUCCESS, result);
                } else {
                    loger.warn('查询答题结果数据->失败.', ret);
                    this._emit(Sass.SASS_GET_QUESTION_RESULT_FAILED);
                }
            })
            .catch(err => {
                loger.error(`查询答题结果数据->状态码:${err}`);
                this._emit(Sass.SASS_GET_QUESTION_RESULT_FAILED);
            });
    }

    //点名---------------------------------------------------------
}

Sass.prototype.SUCCESS = Sass.SUCCESS = 'Sass_success';
Sass.prototype.CLASS_INIT_SUCCESS = Sass.CLASS_INIT_SUCCESS = 'sass_class_init_success';
Sass.prototype.CLASS_GET_CLASS_PARAM = Sass.CLASS_GET_CLASS_PARAM = 'sass_class_getClassParam.message';
Sass.prototype.CLASS_GET_CLASS_DETAIL = Sass.CLASS_GET_CLASS_DETAIL = 'sass_class_getClassDetail_message';
Sass.prototype.DELETE_DOCUMENT_SUCCESS = Sass.DELETE_DOCUMENT_SUCCESS = 'sass_class_deleteDocumentSuccess_message';//删除文档成功
Sass.prototype.DELETE_MEDIASHARE_SUCCESS = Sass.DELETE_MEDIASHARE_SUCCESS = 'sass_class_deleteMediaShareSuccess_message';//删除文档成功

Sass.prototype.CLASS_SAVE_STATUS_INFO_SUCCESS = Sass.CLASS_SAVE_STATUS_INFO_SUCCESS = 'sass_class_saveClassStatusInfoSuccess_message';//保存课堂状态信息
Sass.prototype.CLASS_SAVE_RECORD_INFO_SUCCESS = Sass.CLASS_SAVE_RECORD_INFO_SUCCESS = 'sass_class_saveClassRecordInfoSuccess_message';//保存录制课堂信息

//答题卡和点名
Sass.prototype.SASS_CREAT_QUESTION_SUCCESS = Sass.SASS_CREAT_QUESTION_SUCCESS = 'sass_creat_question_success';//创建答题卡问题成功
Sass.prototype.SASS_CREAT_QUESTION_FAILED = Sass.SASS_CREAT_QUESTION_FAILED = 'sass_creat_question_failed';//创建答题卡失败

Sass.prototype.SASS_GET_QUESTION_SUCCESS = Sass.SASS_GET_QUESTION_SUCCESS = 'sass_get_question_success';//获取问题成功
Sass.prototype.SASS_GET_QUESTION_FAILED = Sass.SASS_GET_QUESTION_FAILED = 'sass_get_question_failed';//获取问题失败

Sass.prototype.SASS_GET_QUESTION_RESULT_SUCCESS = Sass.SASS_GET_QUESTION_RESULT_SUCCESS = 'sass_get_question_result_success';//获取问题结果成功
Sass.prototype.SASS_GET_QUESTION_RESULT_FAILED = Sass.SASS_GET_QUESTION_RESULT_FAILED = 'sass_get_question_result_failed';//获取问题结果失败

Sass.prototype.SASS_SEND_ANSWER_SUCCESS = Sass.SASS_SEND_ANSWER_SUCCESS = 'sass_send_answer_success';//保存答案成功
Sass.prototype.SASS_SEND_ANSWER_FAILED = Sass.SASS_SEND_ANSWER_FAILED = 'sass_send_answer_failed';//保存答案失败

export default new Sass;