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}`;
    let url = `${GlobalConfig.locationProtocol+_initInfo.portal}/3m/api/meeting/joinParams.do?meetingNumber=${_initInfo.classId}&userID=${_initInfo.userId}`;
    loger.log('1.初始化init获取课堂校验信息.');
    loger.log(url);
    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('=====================STEP2=======================');
    loger.log('2.开始Sass校验');
    loger.log(_param);
    confInfo = _param;
    // 密码校验
    //课堂如果设置了密码或身份是老师，需要密码校验
    if (confInfo.passwordRequired == 'true' || confInfo.passwordRequired == true||GlobalConfig.isHost) {
      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}`;
    let url = `${GlobalConfig.locationProtocol+confInfo.portal}/3m/api/meeting/signIn.do?siteId=${confInfo.siteId}&classId=${confInfo.classId}&isTeacher=${isTeacher}&password=${confInfo.password}`;

    loger.log('=====================STEP3=======================');
    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}`;
    let url = `${GlobalConfig.locationProtocol+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('=====================STEP4=======================');
    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}`;
    let url = `${GlobalConfig.locationProtocol+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
     */
    let timestamp = new Date().getTime();
    let authId = MD5(GlobalConfig.classId + "" + timestamp); //课堂号+时间戳 的字符串，转成MD5
    //let url = `http://${GlobalConfig.portal}/3m/api/meeting/detail.do?meetingNumber=${GlobalConfig.classId}&timestamp=${timestamp}&authId=${authId}`;
    let url = `${GlobalConfig.locationProtocol+GlobalConfig.portal}/3m/api/meeting/detail.do?meetingNumber=${GlobalConfig.classId}&timestamp=${timestamp}&authId=${authId}`;

    loger.log('=====================STEP5=======================');
    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;
    }
    let timestamp = new Date().getTime();
    let 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}`;
    let url = `${GlobalConfig.locationProtocol+GlobalConfig.portal}/3m/api/document/deleteRelation.do?docId=${_param.docId}&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_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);
      });
  }

  //删除Music共享文件
  sassDeletMusicShare(_param) {
    if (GlobalConfig.isRecordPlayBack) {
      loger.log('录制回放中，能删除文件');
      return;
    }
    console.warn('删除Music共享实现...');
    let timestamp = new Date().getTime();
    let authId = MD5(_param.fileId + "" + _param.classId + "" + timestamp); // docId+classId+timestamp的字符串，转成MD5
    //let url = `http://${GlobalConfig.portal}/3m/api/media/deleteRelation.do?mediaId=${_param.fileId}&classId=${GlobalConfig.classId}&timestamp=${timestamp}&authId=${authId}`;
    let url = `${GlobalConfig.locationProtocol+GlobalConfig.portal}/3m/api/media/deleteRelation.do?mediaId=${_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_MUSICSHARE_DELETE_FAILED);

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

  //删除媒体共享文件
  sassDeletMediaShare(_param) {
    if (GlobalConfig.isRecordPlayBack) {
      loger.log('录制回放中，能删除文件');
      return;
    }
    let timestamp = new Date().getTime();
    let 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}`;
    let url = `${GlobalConfig.locationProtocol+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;
    }
    if(!_param||!_param.classStatusInfo){
      return;
    }
    //{"classStatusInfo":classStatusInfo}
    let timestamp = new Date().getTime();
    let authId = MD5(GlobalConfig.classId + "" + timestamp); // (classId+timestamp)的字符串，转成MD5
    _param.classStatusInfo.lastClassActiveTime=timestamp;
    let classStatusInfo = JSON.stringify(_param.classStatusInfo);
    //let url = `http://${GlobalConfig.portal}/3m/api/meeting/saveInfo.do`;
    let url = `${GlobalConfig.locationProtocol+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.recordTimestamp;//GlobalConfig.classTimestamp;//使用录制时间，不再使用课堂的进行时间

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

    loger.log('保存开始录制信息:', 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}`);
      });
  }
  //调用服务器端获取加入音视频通话模块的token
  getChannelKeyToken(_callback){
    if(!GlobalConfig.getChannelToken){
      loger.log("获取channelKey->失败->接口地址无效");
      if(_callback){
        _callback(null);
      }
      return;
    }
   /* let userIpInfo = {
      "appId": key.value,
      "appCertificate": channelKey.value,
      "channel": channel.value,
      "uid": userUid
    }*/
    let url=GlobalConfig.locationProtocol+GlobalConfig.getChannelToken;
    fetch(encodeURI(url), {
      method: 'POST',
      headers: {
        "Content-Type": "application/x-www-form-urlencoded"
      },
      body: `appId=${GlobalConfig.appId}&channel=${GlobalConfig.channelId}&appCertificate=${GlobalConfig.appCertificate}&uid=${GlobalConfig.userUid}`,
      timeout: 4000
    })
      .then(ret => {
        if (ret.ok) {
          return ret.json();
        } else {
          loger.error(`获取channelKey-网络异常.状态码:${ret.status}`);
          if(_callback){
            _callback(null);
          }
          throw '';
        }
      })
      .then(ret => {
        //channelKey :"005AQAoADZBQzk0M0UzMjVGQzgxREU5Njk1REUyRkVFMEYyMkRBRjFCRjIxN0QQANylukzO70ocgrNX9hlkNNWwKDdW9buDA68oN1YAAA=="
        // code: 200
        // uid:"2882341273"
        if (ret.code == 200) {
          loger.log('获取channelKey 完成',ret);
          if(_callback){
            _callback(ret);
          }
        } else {
          loger.warn('获取channelKey 失败.', ret);
          if(_callback){
            _callback(null);
          }
        }
      })
      .catch(err => {
        loger.error(`获取channelKey.状态码:${err}`);
        if(_callback){
          _callback(null);
        }
      });
  }

  //答题卡-------------------------------------------------------
  //创建答题数据
  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; //课堂号
      let 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`;
      let url = `${GlobalConfig.locationProtocol+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; //课堂号
      let 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`;
      let url = `${GlobalConfig.locationProtocol+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`;
    let url = `${GlobalConfig.locationProtocol+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`;
    let url = `${GlobalConfig.locationProtocol+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);
      });
  }
  //点名---------------------------------------------------------


  //获取课堂保存的信息
  getClassRecordInfo(_callback){
    //http://networkschool.xuedianyun.com/server/recordInfo/getOldRecordInfo
    let path="networkschool.xuedianyun.com/server/recordInfo/getOldRecordInfo";
    let url = `${GlobalConfig.locationProtocol+path}`;
    loger.log('获取课堂保存的状态信息', url);
    //接口中用的是GET
    fetch(encodeURI(url), {
      method: 'POST',
      headers: {
        "Content-Type": "application/x-www-form-urlencoded; charset=utf-8"
      },
      body: `meetingNumber=${ GlobalConfig.classId}`,
      timeout: 5000
    })
      .then(ret => {
        if (ret.ok) {
          return ret.json();
        } else {
          loger.error(`获取课堂保存的状态信息-网络异常.状态码:${ret}`);
          if(_callback){
            _callback();
          }
          throw '';
        }
      })
      .then(ret => {
        loger.log('获取课堂保存的状态信息-完成');
        /* {
         "code": 200,
         "returnData": {
         "data": {
         "id": 28,
         "meeting_number": "1170105412",
         "info": "{\"siteId\":\"h5dev\",\"classId\":1170105412,\"className\":\"mcuClientSdk20170318\",\"classType\":1,\"classStatus\":2,\"classStartTime\":\"2017-3-24-20-9-56\",\"classStopTime\":\"2017-3-28-22-20-56\",\"classTimestamp\":25402,\"recordPlaybackMaxTime\":0,\"classBeginTime\":\"2017-03-18 19:00:00\",\"classEndTime\":\"2017-03-29 21:00:00\",\"recordStatus\":false,\"recordTimestamp\":0,\"recordFileName\":\"h5dev/20170318/1170105412_20170318.rec\",\"recordDownloadUrl\":\"\",\"serverTimestamp\":1490710856,\"activeDocId\":666519474,\"activeDocCurPage\":1}",
         "create_time": "2017-03-18T21:12:19.000Z"
         }
         }
         }*/
        if(ret&&ret.code==200){
          try{
            if(ret.returnData&&ret.returnData.data){
              if(_callback) {
                _callback(ret.returnData.data.info);
              }
            }
          }catch (err){
            if(_callback){
              _callback();
            }
          }

        }else {
          if(_callback){
            _callback();
          }
        }
      })
      .catch(err => {
        loger.error(`AGOR-获取媒体录制信息-异常.状态码:${err}`);
        if(_callback){
          _callback();
        }
      });
  }
}

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.DELETE_MUSICSHARE_SUCCESS = Sass.DELETE_MUSICSHARE_SUCCESS = 'sass_class_deleteMusicShareSuccess_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;