require('es6-promise').polyfill();
require('whatwg-fetch');
require('jquery-touchswipe');
require('string.fromcodepoint');

import Emiter from './Emiter';
import Sass from 'Sass';
import Mcu from 'mcu';
import MessageTypes from 'MessageTypes';
import Loger from 'Loger';
import ConferApe from 'apes/ConferApe';
import ChatApe from 'apes/ChatApe';
import VideoApe from 'apes/VideoApe';
import DocApe from 'apes/DocApe';
import WhiteBoardApe from 'apes/WhiteBoardApe';
import EngineUtils from "EngineUtils";
import GlobalConfig from 'GlobalConfig';
import ApeConsts from 'apes/ApeConsts';
import Base64 from 'base64-js';
import ArrayBufferUtil from 'libs/ArrayBufferUtil';
import UTF8 from 'utf-8';

let loger = Loger.getLoger('MessageEntrance');
let _sdkInfo={"version":"v.1.0.1","author":"www.3mang.com"};

//APE
let _sass;
let _mcu ;
let _confer_ape;
let _chat_ape;
let _video_ape;
let _doc_ape;
let _whiteboard_ape;

//初始化成功回调函数
let _initSuccessCallBackFun;

//加入会议成功回调函数
let _joinClassSuccessCallBackFun;

//监听mcu所有错误异常回调函数
let _mcuErrorCallBackFun;

//MCUClient 外部实例化主类
export default class MessageEntrance extends Emiter {
  constructor() {
    super();
    //sdk 信息
    this.sdkInfo = _sdkInfo;
    loger.log(this.sdkInfo);

    //初始化状态
    GlobalConfig.setCurrentStatus(GlobalConfig.statusCode_0);

    //全局的Error处理
    this.on(MessageTypes.MCU_ERROR, this._mcuErrorHandler.bind(this));

    // Sass平台层
    _sass = Sass;
    _sass.on('*', (type, data) => this._emit(type, data));
    _sass.on(_sass.SUCCESS, this._sassJoinSuccessHandler.bind(this));//通过SASS平台验证(密码和MD5)
    _sass.on(_sass.CLASS_INIT_SUCCESS, this._sassInitSuccessHandler.bind(this));//获取会议初始化信息
    _sass.on(_sass.CLASS_GET_CLASS_DETAIL, this._sassGetClassDetailSuccessHandler.bind(this));//获取会议的基本信息
    _sass.on(_sass.CLASS_GET_CLASS_PARAM, this._sassGetClassParamSuccessHandler.bind(this));//获取会议的最全信息和历史保存的数据
    _sass.on(_sass.CLASS_SAVE_STATUS_INFO_SUCCESS, this._sassSaveClassStatusInfoSuccessHandler.bind(this));//保存会议状态信息
    _sass.on(_sass.DELETE_DOCUMENT_SUCCESS, this._sassDeleteDocumentSuccess.bind(this));//sass删除文档成功

    // 底层MCU消息层
    _mcu = Mcu;
    _mcu.on('*', (type, data) => this._emit(type, data));
    _mcu.on(MessageTypes.CLASS_JOIN_SUCCESS, this._joinClassSuccessHandler.bind(this));//加入MCU会议完成


    // 注册所有应用Ape
    _confer_ape = new ConferApe();
    _confer_ape.on('*', (type, data) => this._emit(type, data));
    _confer_ape.on(MessageTypes.CLASS_EXIT, this._doClassExit.bind(this));//监听自己的关闭事件
    _confer_ape.on(MessageTypes.CLASS_STATUS_INFO_CHANGE, this._onClassStatusInfoChange.bind(this));//当前会议状态信息发生改变
    _confer_ape.on(MessageTypes.CLASS_DELETE_ROSTER, this._onClassDeleteRoster.bind(this));//当前会议人员离开

    _chat_ape = new ChatApe();
    _chat_ape.on('*', (type, data) => this._emit(type, data));

    _video_ape = new VideoApe();
    _video_ape.on('*', (type, data) => this._emit(type, data));
    _video_ape.on(MessageTypes.VIDEO_UPDATE, this.videoUpdate.bind(this));

    _whiteboard_ape = new WhiteBoardApe();
    _whiteboard_ape.on('*', (type, data) => this._emit(type, data));
    //_whiteboard_ape.on(MessageTypes.WHITEBOARD_ANNOTATION_UPDATE, this.annoUpdateHandler.bind(this));


    _doc_ape = new DocApe();
    _doc_ape.on('*', (type, data) => this._emit(type, data));
    _doc_ape.on(MessageTypes.DOC_UPDATE, this.docUpdateHandler.bind(this));
    _doc_ape.on(MessageTypes.DOC_DELETE, this.docDeleteHandler.bind(this));
    _doc_ape.on(DocApe.DOC_JOIN_CHANNEL_SUCCESS, this.docJoinChannelSuccess.bind(this));



    //公开外部调用的方法
    //class
    this.init = this._init;
    this.joinClass = this._joinClass;
    this.leaveClass = this._leaveClass;
    this.getMcuClientStatus = this._getMcuClientStatus;
    this.getClassDetail = this._getClassDetail;
    this.sendStartClass = this._sendStartClass;
    this.sendPauseClass = this._sendPauseClass;
    this.sendCloseClass = this._sendCloseClass;

    //chatApe
    this.sendChatMsg = this._sendChatMsg;

    //videoApe
    this.getPlayVideoPath = this._getPlayVideoPath;
    this.getPublishVideoPath = this._getPublishVideoPath;
    this.publishVideo = this._publishVideo;
    this.stopPublishVideo = this._stopPublishVideo;
    this.sendVideoCommandMsg=this.sendVideoCommandMsg;


    //whiteBoradApe
    this.sendInsertAnnotaion = this._sendInsertAnnotaion;
    //this.sendDeleteAnnotaion=this._sendDeleteAnnotaion;
    this.sendDeleteAllAnnotation = this._sendDeleteAllAnnotation;
    this.sendDeleteCurPageAnnotation = this._sendDeleteCurPageAnnotation;
    this.sendGotoPrev = this._sendGotoPrev;

    //DocApe
    this.sendDocumentUpload = this._sendDocumentUpload;//上传文档
    this.sendDocumentSwitchDoc = this._sendDocumentSwitchDoc; //切换文档
    this.sendDocumentSwitchPage = this._sendDocumentSwitchPage;//翻页
    this.sendDocumentDelete = this._sassDeleteDocument;//删除文档,先通过Sass删除,sass删除成功之后再同步mcu
    //this.sendDocumentDeleteAll= this._documentDeleteAll;//删除所有文档
    this.sendDocumentCommand = this._sendDocumentCommand;//操作文档(翻页、缩放、滚动...)
    this.getDocFullPath=this._getDocFullPath;//获取文档的完整路径
  }


  //mcu异常监听
  _mcuErrorHandler(_data, _option) {
    if (_mcuErrorCallBackFun) {
      let option = _option || "";
      let errorMessage = {"code": _data, "reson": MessageTypes.ErrorReson[_data] + " " + option};
      loger.error("MCU_ERROR", errorMessage);
      _mcuErrorCallBackFun(errorMessage);
    }
  }

  //获取当前的状态
  _getMcuClientStatus() {
    return GlobalConfig.getCurrentStatus();
  }

//获取会议信息
  _getClassDetail() {
    return GlobalConfig.getClassDetail();
  }

  //关闭会议，所有人都退出
  _doClassClose(_param) {
    this._leaveClass();
  }

  //离开会议，断开连接
  _doClassExit() {
    this._leaveClass();
  }

  //当前的会议状态信息发生改变,需要保存会议状态到Sass
  _onClassStatusInfoChange(_param) {
    this._sassSaveClassStatusInfo();
  }
  //有人员离开
  _onClassDeleteRoster(_data){
    //{"nodeId":nodeId}
    //当有人员离开的时候，如果离开的人员已经推流，那么需要停止推流，然后释放channel；
    //只有自己是主持人的时候出才处理下面的事情
    if(_data!=null&&_data.nodeId!=null&&GlobalConfig.isHost){
      loger.log("有人员离开，检查一下离开的人员是否关闭推流");
      if(_video_ape){
        _video_ape.stopPublishVideo(_data.nodeId);
      }
    }
  }

  //Sass
  //初始化
  _init(_param, _onSuccess, _mcuErrorCallBack) {
    _initSuccessCallBackFun = _onSuccess;
    _mcuErrorCallBackFun = _mcuErrorCallBack;
    //{"classId":"1653304953","portal":"112.126.80.182:80","userRole":"normal","userId":0}
    //判断传入的参数是否存在
    if (_param == null || EngineUtils.isEmptyObject(_param) || _onSuccess == null || _mcuErrorCallBack == null) {
      loger.error('init初始化失败,参数错误');
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_INIT_PARAM);
      return;
    }
    //判断必要的参数字段值
    if (_param.classId == null || isNaN(_param.classId) || _param.portal == null || _param.portal == "") {
      loger.error('init初始化失败', _param);
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_INIT_PARAM);
      return;
    }
    loger.log('init', _param);
    //保存参数
    GlobalConfig.classId = parseInt(_param.classId);
    GlobalConfig.portal = _param.portal;
    GlobalConfig.userRole = _param.userRole || ApeConsts.normal;
    GlobalConfig.userId = _param.userId || "0";
    GlobalConfig.userName=_param.userName || "";
    //获取课堂校验信息
    if (_sass) {
      _sass.getJoinParams(GlobalConfig.getClassInfo());
    }
  }

  //外部请求加入会议
  _joinClass(_param, _onSuccess) {
    _joinClassSuccessCallBackFun = _onSuccess;
    //{"userName":"名字","password":""}
    if (_param == null || EngineUtils.isEmptyObject(_param) || _onSuccess == null) {
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_JOIN_PARAM);
      loger.log('不能进入会议，传递的参数不对.', _param);
      return;
    }
    //判断userName
    if (_param.userName == null || _param.userName == "") {
      loger.log('不能进入会议，传递的参数不对.名字不能为空');
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_JOIN_PARAM);
      return;
    }

    if(GlobalConfig.userName==null||GlobalConfig.userName==""){
      GlobalConfig.userName = _param.userName;
    }
    GlobalConfig.password = _param.password || "";
    GlobalConfig.hasCamera=(typeof  _param.hasCamera=="boolean")? _param.hasCamera:false;
    GlobalConfig.hasMicrophone=(typeof  _param.hasMicrophone=="boolean")? _param.hasMicrophone:false;
    debugger;
    //开始校验
    if (_sass) {
      _sass.passwordAndMd5Checking(GlobalConfig.getClassInfo());
    }
  }

  // 用classId向SASS平台获取入会验证信息成功
  _sassInitSuccessHandler(_data) {
    //{"siteId":"h5test","passwordRequired":true,"md5":"de399d5540b3da2fbc1eb0a770d4fd66","code":0,"msType":1}
    //储存数据
    GlobalConfig.md5 = _data.md5 || "";//这个暂时用假数据，后台接口写完就有数据了
    GlobalConfig.msType = _data.msType || 1;
    GlobalConfig.siteId = _data.siteId || "";
    GlobalConfig.classType = _data.meetingType || 0;

    /*//host默认需要密码，Sass服务器只判断学生是否需要密码，没有判断老师的
    if (GlobalConfig.userRole == "host") {
      GlobalConfig.passwordRequired = true;
    } else {
      GlobalConfig.passwordRequired = _data.passwordRequired || false;
    }
    */
    GlobalConfig.passwordRequired = _data.passwordRequired || false;//md5验证的时候需要Sass返回的值,不能更改

    loger.log('SASS平台获取入会验证信息成功.');

    //设置当前的会议状态
    GlobalConfig.setCurrentStatus(GlobalConfig.statusCode_1);

    if (_initSuccessCallBackFun) {
      //返回给客户端初始化成功的数据
      let initSuccessCallBackData = {};
      initSuccessCallBackData.siteId = GlobalConfig.siteId;
      initSuccessCallBackData.classId = GlobalConfig.classId;
      initSuccessCallBackData.userRole = GlobalConfig.userRole;
      initSuccessCallBackData.userId = GlobalConfig.userId;
      initSuccessCallBackData.classType = GlobalConfig.classType;

      //host默认需要密码，Sass服务器只判断学生是否需要密码，没有判断老师的
       if (GlobalConfig.userRole== ApeConsts.host) {
         initSuccessCallBackData.passwordRequired =true;
       } else {
         initSuccessCallBackData.passwordRequired = GlobalConfig.passwordRequired;
       }

      _initSuccessCallBackFun(initSuccessCallBackData);
    }
  }

  // 通过SASS平台验证
  _sassJoinSuccessHandler(_data) {
    //返回值
    /* flag	数值型	无		True:成功
     Flag：失败
     h5_mcu_list	字符串			H5muc列表
     maxVideoChannels	数值型			最大视频路数
     maxAudioChannels	数值型			最大音频路数
     h5Module	数值型			H5开关
     ms	字符串			Ms列表
     mcu	字符串			Mcu列表
     rs	字符串			Rs列表
     doc	字符串			Doc列表*/

    /*    {
     "record": "112.126.80.182:80",
     "flag": "true",
     "h5Module": 1,
     "maxVideoChannels": 1,
     "mcu": "123.56.73.119:7000;123.56.69.230:7000;112.126.80.182:7000",
     "ms": "pubms.3mang.com:1935",
     "doc": "101.200.150.192:80",
     "rs": "pubms.3mang.com:1935",
     "type": 1,
     "maxAudioChannels": 1,
     "h5_mcu_list": "123.56.73.119:7001;123.56.69.230:7001;112.126.80.182:7001"
     }*/
    if (_data.h5_mcu_list) {
      //MCU地址默认使用第一个
      let server = _data.h5_mcu_list.split(";")[0];
      GlobalConfig.MCUServerIP = server.split(":")[0];
      GlobalConfig.MCUServerPort = server.split(":")[1];
    }

    //视频推流播流地址
    if (_data.ms) {
      //MS地址默认使用第一个
      let server = _data.ms.split(";")[0];
      GlobalConfig.MSServerIP = server.split(":")[0];
      GlobalConfig.MSServerPort = server.split(":")[1];
    }

    GlobalConfig.docServer = _data.doc;
    GlobalConfig.h5_mcu_list = _data.h5_mcu_list;
    GlobalConfig.h5Module = _data.h5Module;
    GlobalConfig.mcu = _data.mcu;
    GlobalConfig.ms = _data.ms;
    GlobalConfig.record = _data.record;
    GlobalConfig.rs = _data.rs;
    GlobalConfig.maxVideoChannels = _data.maxVideoChannels;
    GlobalConfig.maxAudioChannels = _data.maxAudioChannels;
    GlobalConfig.maxMediaChannels = _data.maxVideoChannels + _data.maxAudioChannels;

    if (_sass) {
      _sass.getClassDetail();//会议基本信息
    }
  }

  //获取会议所有参数 getClassH5
  _sassGetClassDetailSuccessHandler(_data) {
    loger.log('获取getClassDetail完成.');
    /*  {
     "cycle": 0,
     "repeatmonthweekweek": 0,
     "status": 1,
     "repeatmonthday": 0,
     "repeatmode": 0,
     "beginTime": "2017-02-03 09:00:00",
     "frequency": 1,
     "endmode": 0,
     "meetingContent": "",
     "endTime": "2017-03-31 11:00:00",
     "repeatweek": "",
     "category": "",
     "finalenddate": "",
     "repeatday": 0,
     "meetingName": "mcu1",
     "errorCode": 0,
     "monthType": 0,
     "repeatmonthweekday": 0,
     "endcount": 1
     }*/
    GlobalConfig.classDetail = _data;
    GlobalConfig.className = _data.meetingName || "";
    GlobalConfig.classBeginTime = _data.beginTime || "";
    GlobalConfig.classEndTime = _data.endTime || "";

    //获取会议所有信息和以前保存的会议状态信息
    if (_sass) {
      _sass.getClassParam();
    }
  }

  //获取会议所有参数 api/meeting/detail.do?      flash中的接口文件是 getClassParam.do
  _sassGetClassParamSuccessHandler(_data) {
    //console.log(GlobalConfig.classStatusInfo)
    loger.log('获取api/meeting/detail.do完成.');
    // console.log(_data);
    //包含整个会议最全的信息,储存数据
    if (_data) {
      GlobalConfig.setDocListPrepare(_data.docListPrepare);  //提前上传的文档列表
      GlobalConfig.setDocRecordList(_data.docRecordList);//
      GlobalConfig.setDocList(_data.docList);//
      GlobalConfig.setMsList(_data.msList);//
      GlobalConfig.setMcuList(_data.mcuList);//
      GlobalConfig.setMusicList(_data.musicList);//
      GlobalConfig.setMusicListPrepare(_data.musicListPrepare);//
      GlobalConfig.setRsList(_data.rsList);//

    }
    if (_data.currentInfo) {
      //根据从Sass获取的数据信息,同步最后一次保存的会议状态信息
      loger.log("同步最后一次保存过的会议状态信息");

      /*//解析BASE64的数据
       loger.log("11111111111111111111111111111111");
       console.log(GlobalConfig.classStatusInfo);
       //已经保存过会议状态信息，读取之前的数据
       let _classStatusInfo=EngineUtils.objectFromBase64(_data.currentInfo);
       loger.log("classStatusInfo",_classStatusInfo);
       GlobalConfig.classStatusInfo=_classStatusInfo;
       loger.log("2222222222222222222222222");
       console.log(GlobalConfig.classStatusInfo);*/

      //console.log(_data.currentInfo);
      GlobalConfig.setClassStatusInfo(_data.currentInfo);
      console.log(GlobalConfig.classStatusInfo)
    } else {
      loger.log("还没有保存过会议状信息");
    }

    //所有Sass流程完成，开始MCU连接
    this._joinMCU();
  }

  //保存会议状态信息
  _sassSaveClassStatusInfo() {
    if (GlobalConfig.isHost) {
      //用get保存数据,数据内容需要转为BASE64
      //let _classStatusInfo=EngineUtils.objectToBase64(GlobalConfig.classStatusInfo);
      //loger.log("保存会议状态信息",_classStatusInfo);
      //_sass.saveClassStatusInfo({"classStatusInfo":_classStatusInfo});//保存会议状态信息

      //只有加入会议之后才能保存数据
      if (GlobalConfig.getCurrentStatus().code == GlobalConfig.statusCode_2.code) {
        //POST 保存数据
        _sass.saveClassStatusInfo({"classStatusInfo": GlobalConfig.classStatusInfo});//保存会议状态信息
      } else {
        loger.error("不能保存会议数据", GlobalConfig.getCurrentStatus());
      }
    } else {
      loger.log("没有保存会议状态信息的权限  isHost", GlobalConfig.isHost);
    }
  }

  //保存会态信息成功
  _sassSaveClassStatusInfoSuccessHandler(_data) {
    loger.log('保存会议状态信息成功.', _data);
  }

  //Sass校验流程结束之后，开始加入MCU
  _joinMCU() {
    loger.log('加入底层MCU会议.');
    if (_mcu) {
      _mcu.joinMCU(GlobalConfig.getClassInfo());
    }
  }

  // MCU 会议成功
  _joinClassSuccessHandler(_data) {
    loger.log('MCU 会议成功.');
    GlobalConfig.setCurrentStatus(GlobalConfig.statusCode_2);

    //返回给客户数据
    if (_joinClassSuccessCallBackFun) {
      //返回给客户端初始化成功的数据
      let initSuccessCallBackData = {};

      //GlobalConfig.MCUServerIP=_data.MCUServerIP;
      // GlobalConfig.MCUServerPort=_data.MCUServerPort;

      initSuccessCallBackData.docServer = GlobalConfig.docServer;//文档服务器地址
      initSuccessCallBackData.classId = GlobalConfig.classId;
      initSuccessCallBackData.className = GlobalConfig.className;
      initSuccessCallBackData.h5Module = GlobalConfig.h5Module;
      initSuccessCallBackData.isHost = GlobalConfig.isHost;
      initSuccessCallBackData.maxAudioChannels = GlobalConfig.maxAudioChannels;
      initSuccessCallBackData.maxVideoChannels = GlobalConfig.maxVideoChannels;
      initSuccessCallBackData.maxMediaChannels = GlobalConfig.maxMediaChannels;
      initSuccessCallBackData.mcuDelay = GlobalConfig.mcuDelay;

      initSuccessCallBackData.msType = GlobalConfig.msType;
      initSuccessCallBackData.nodeId = GlobalConfig.nodeId;
      initSuccessCallBackData.password = GlobalConfig.password;
      initSuccessCallBackData.passwordRequired = GlobalConfig.passwordRequired;//  老师的默认是true
      //GlobalConfig.passwordRequired  老师的默认是true
      //GlobalConfig.portal=_data.portal;
      initSuccessCallBackData.role = GlobalConfig.role;
      initSuccessCallBackData.siteId = GlobalConfig.siteId;
      initSuccessCallBackData.topNodeID = GlobalConfig.topNodeID;
      initSuccessCallBackData.userId = GlobalConfig.userId;
      initSuccessCallBackData.userName = GlobalConfig.userName;
      initSuccessCallBackData.userRole = GlobalConfig.userRole;
      initSuccessCallBackData.userType = GlobalConfig.userType;

      initSuccessCallBackData.siteId = GlobalConfig.siteId;
      initSuccessCallBackData.classId = GlobalConfig.classId;
      initSuccessCallBackData.userRole = GlobalConfig.userRole;
      initSuccessCallBackData.userId = GlobalConfig.userId;
      initSuccessCallBackData.passwordRequired = GlobalConfig.passwordRequired;
      initSuccessCallBackData.classType = GlobalConfig.classType || ApeConsts.CLASS_TYPE_INTERACT;
      loger.log('加入会议成功', initSuccessCallBackData);
      _joinClassSuccessCallBackFun(initSuccessCallBackData);
    }


    //loger.log('MCU 会议成功.');
    //GlobalConfig.setCurrentStatus(GlobalConfig.statusCode_2);
    //if(_sass){
    //  _sass.getClassDetail();//会议信息
    //  _sass.getClassParam();//会议参数大全
    //}
    //
    ////储存数据
    //GlobalConfig.MCUServerIP=_data.MCUServerIP;
    //GlobalConfig.MCUServerPort=_data.MCUServerPort;
    //GlobalConfig.classId=_data.classId;
    //GlobalConfig.h5Module=_data.h5Module;
    //GlobalConfig.maxAudioChannels=_data.maxAudioChannels;
    //GlobalConfig.maxVideoChannels=_data.maxVideoChannels;
    //GlobalConfig.maxMediaChannels=_data.maxMediaChannels;
    //GlobalConfig.mcuClassInfo=_data.mcuClassInfo;
    //GlobalConfig.mcuDelay=_data.mcuDelay;
    //GlobalConfig.md5=_data.md5;
    //GlobalConfig.msType=_data.msType;
    //GlobalConfig.nodeId=_data.nodeId;
    //GlobalConfig.password=_data.password;
    //GlobalConfig.portal=_data.portal;
    //GlobalConfig.role=_data.role;
    //GlobalConfig.siteId=_data.siteId;
    //GlobalConfig.topNodeID=_data.topNodeID;
    //GlobalConfig.userId=_data.userId;
    //GlobalConfig.userName=_data.userName;
    //GlobalConfig.userRole=_data.userRole;
    //GlobalConfig.userType=_data.userType;
    //
    ////返回给客户数据
    //if(_joinClassSuccessCallBackFun){
    //  //返回给客户端初始化成功的数据
    //  let initSuccessCallBackData={};
    //
    //  //GlobalConfig.MCUServerIP=_data.MCUServerIP;
    // // GlobalConfig.MCUServerPort=_data.MCUServerPort;
    //
    //  initSuccessCallBackData.docServer=GlobalConfig.docServer;//文档服务器地址
    //  initSuccessCallBackData.classId=GlobalConfig.classId;
    //  initSuccessCallBackData.className=GlobalConfig.className;
    //  initSuccessCallBackData.h5Module=GlobalConfig.h5Module;
    //  initSuccessCallBackData.isHost=GlobalConfig.isHost;
    //  initSuccessCallBackData.maxAudioChannels=GlobalConfig.maxAudioChannels;
    //  initSuccessCallBackData.maxVideoChannels=GlobalConfig.maxVideoChannels;
    //  initSuccessCallBackData.maxMediaChannels=GlobalConfig.maxMediaChannels;
    //  initSuccessCallBackData.mcuDelay=GlobalConfig.mcuDelay;
    //
    //  initSuccessCallBackData.msType=GlobalConfig.msType;
    //  initSuccessCallBackData.nodeId=GlobalConfig.nodeId;
    //  initSuccessCallBackData.password=GlobalConfig.password;
    //  initSuccessCallBackData.passwordRequired=GlobalConfig.passwordRequired;//  老师的默认是true
    //  //GlobalConfig.passwordRequired  老师的默认是true
    //  //GlobalConfig.portal=_data.portal;
    //  initSuccessCallBackData.role=GlobalConfig.role;
    //  initSuccessCallBackData.siteId=GlobalConfig.siteId;
    //  initSuccessCallBackData.topNodeID=GlobalConfig.topNodeID;
    //  initSuccessCallBackData.userId=GlobalConfig.userId;
    //  initSuccessCallBackData.userName=GlobalConfig.userName;
    //  initSuccessCallBackData.userRole=GlobalConfig.userRole;
    //  initSuccessCallBackData.userType=GlobalConfig.userType;
    //
    //  initSuccessCallBackData.siteId=GlobalConfig.siteId;
    //  initSuccessCallBackData.classId=GlobalConfig.classId;
    //  initSuccessCallBackData.userRole=GlobalConfig.userRole;
    //  initSuccessCallBackData.userId=GlobalConfig.userId;
    //  initSuccessCallBackData.passwordRequired=GlobalConfig.passwordRequired;
    //  initSuccessCallBackData.classType=GlobalConfig.classType||ApeConsts.CLASS_TYPE_INTERACT;
    //  loger.log('加入会议成功',initSuccessCallBackData);
    //  _joinClassSuccessCallBackFun(initSuccessCallBackData);
    //}
  }

  //Sass删除文档数据
  _sassDeleteDocument(_param) {
    //判断传入的参数是否存在
    if (_param == null || EngineUtils.isEmptyObject(_param)) {
      loger.error('sassDeleteDocument失败,参数错误', _param);
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_DOC_DELETE_FAILED_PARAM);
      return;
    }
    //判断必要的参数字段值
    if (_param.itemIdx == null || isNaN(_param.itemIdx) || _param.docId == null || _param.docId == "") {
      loger.error('sassDeleteDocument失败', _param);
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_DOC_DELETE_FAILED_PARAM);
      return;
    }
    loger.log('_sassDeleteDocument', _param);

    if (_sass) {
      _sass.sassDeleteDocument(_param);
    }
  }

  //Sass删除文档成功之后，同步删除MCU数据
  _sassDeleteDocumentSuccess(_param) {
    loger.log('sassDeleteDocumentSuccess', _param);
    this._sendDocumentDelete(_param);
  }

  //ConferApe
  //开始上课
  _sendStartClass(_param){
    if(_confer_ape){
      _confer_ape.startClass(_param);
    }
  }
  //暂停上课
  _sendPauseClass(_param){
    if(_confer_ape){
      _confer_ape.pauseClass(_param);
    }
  }
  //停止上课
  _sendCloseClass(_param){
    if(_confer_ape){
      _confer_ape.closeClass(_param);
    }
  }
  // 离开会议
  _leaveClass() {
    //停止推流
    if(_video_ape){
      _video_ape.stopPublishVideo();
    }
    //离开会议
    if(_confer_ape){
      _confer_ape.leaveClass();
    }
    //断开MCU连接
    if(_mcu){
      _mcu.leaveMCU();
      GlobalConfig.setCurrentStatus(GlobalConfig.statusCode_3);
    }
  }

  //ChatApe
  // 发送聊天消息
  _sendChatMsg(_messageInfo) {
    if(_messageInfo===null||EngineUtils.isEmptyObject(_messageInfo)){
      loger.log('sendChatMsg 传递的参数不对',_messageInfo);
      return ;
    }
    if (_chat_ape) {
      _chat_ape.sendChatMsg(_messageInfo);
    }
  }

  //VidoeApe
  videoUpdate(_data){
    //视频同步的消息发送改变,需要通知ferApe模块中的用户更新状态
    if(_confer_ape){
      _confer_ape.updaterRosterStatus(_data);
    }
  }

  sendVideoCommandMsg(_param){
    if(_video_ape){
      return _video_ape.sendVideoCommandMsg(_param);
    }
  }

  _getPlayVideoPath(_param){
    if(_video_ape){
      return _video_ape.getPlayVideoPath(_param);
    }
  }

  _getPublishVideoPath(_param){
    if(_video_ape){
      return _video_ape.getPublishVideoPath(_param);
    }
  }

  _publishVideo(_param){
    if(_video_ape){
      return _video_ape.publishVideo(_param);
    }
  }

  _stopPublishVideo(_param){
    if(_video_ape){
      return _video_ape.stopPublishVideo(_param);
    }
  }

  //WhiteBoardApe
  // 添加标注,发送信息
  _sendInsertAnnotaion(_param){
    if(_whiteboard_ape){
      _whiteboard_ape.sendInsetAnnotaion(_param);
    }
  }

  //删除标注，发送信息
  _sendDeleteAnnotaion(_param){
    if(_whiteboard_ape){
      _whiteboard_ape.sendDeleteAnnotaion(_param);
    }
  }
  //删除当前页面上的所有标注
  _sendDeleteCurPageAnnotation(_param){
    if(_whiteboard_ape){
      _whiteboard_ape.sendDeleteCurPageAnnotation(_param);
    }
  }
  //删除所有标注
  _sendDeleteAllAnnotation(_param){
    if(_whiteboard_ape){
      _whiteboard_ape.sendDeleteAllAnnotation(_param);
    }
  }
  //返回上一步标注
  _sendGotoPrev(_param){
    if(_whiteboard_ape){
      _whiteboard_ape.sendGotoPrev(_param);
    }
  }


  //DocApe
  //获取文档完整路径
  _getDocFullPath(_param){
    if(_doc_ape){
      return _doc_ape.getDocFullPath(_param);
    }else {
      loger.error("文档模块还没有创建,无法获取");
      return "";
    }
  }
  //上传文档
  _sendDocumentUpload(_param){
    if(_doc_ape){
      _doc_ape.documentUpload(_param);
    }
  }
  //切换文档
  _sendDocumentSwitchDoc(_param){
    if(_doc_ape){
      _doc_ape.documentSwitchDoc(_param);
    }
  }
  //操作文档(翻页)
  _sendDocumentSwitchPage(_param){
    if(_doc_ape){
      _doc_ape.documentSwitchPage(_param);
    }
  }
  //操作文档(缩放、滚动...)
  _sendDocumentCommand(_param){
    if(_doc_ape){
      _doc_ape.documentCommand(_param);
    }
  }
  //删除文档
  _sendDocumentDelete(_param){
    if(_doc_ape){
      _doc_ape.documentDelete(_param);
    }
  }
  //删除所有文档
  _documentDeleteAll(_param){
    if(_doc_ape){
      _doc_ape.documentDeleteAll(_param);
    }
  }

  //// 文档变更，白板也需要做处理
  docUpdateHandler(_data) {
    loger.log('Doc UpdateId ->');
    console.log(_data);
    if(_whiteboard_ape){
      _whiteboard_ape.docUpdateHandler(_data);
    }
  }

  //文档删除，白板也需要做处理
    docDeleteHandler(_data){
      if(_whiteboard_ape){
        _whiteboard_ape.docDeleteHandler(_data);
      }
    }

  //文档加入频道成功，同步到MCU服务器上的数据
  docJoinChannelSuccess(){
    loger.log("docJoinChannelSuccess  isHost=",GlobalConfig.isHost);
    console.log(GlobalConfig.docListPrepare);
    loger.log("docJoinChannelSuccess  docListPrepare=");
    //如果是主持人，那么需要判断一下文档模块同步的数据和从sass获取的文档数据是否相同，如果mcu服务器不存在的，需要上传
    if(GlobalConfig.isHost){
      for (let value of GlobalConfig.docListPrepare){
        if(value){
          //{
          //  "MD5": "f3feb3fac8cd3a953bded00e07a0c66b",
          //    "absoluteLocation": "http://101.200.150.192/DocSharing/data/526661904/20170203-115400026/f3feb3fac8cd3a953bded00e07a0c66b.swf",
          //    "createUserID": "972",
          //    "createUserIP": "114.241.81.175",
          //    "createUserName": "base",
          //    "dynamicPPT": 0,
          //    "dynamicTransferStatic": "",
          //    "id": "8ab3b0ed5a00f2fa015a0219a3df016c",
          //    "meetingNumber": "",
          //    "name": "McuClient_v.1.0.1_API.pdf",
          //    "orderStr": "",
          //    "pdfSize": 5,
          //    "processEndTime": "2017-02-03 11:54:31",
          //    "processRate": 0,
          //    "processStartTime": "2017-02-03 11:54:27",
          //    "relativeLocation": "/DocSharing/data/526661904/20170203-115400026/f3feb3fac8cd3a953bded00e07a0c66b.swf",
          //    "siteID": "h5test",
          //    "size": 360920,
          //    "status": 3,
          //    "type": "pdf",
          //    "uploadEndTime": "2017-02-03 11:54:27",
          //    "uploadStartTime": "2017-02-03 11:54:27"
          //}
          loger.log("判断是否需要把提前上传的文档上传到mcu",value);
          let paramInfo={
            "pageNum": value.pdfSize,
            "fileName": value.name,
            "fileType": value.type,
            "relativeUrl": value.relativeLocation,
            "url":  value.absoluteLocation,
            "creatUserId":value.createUserID,
            "docId": value.id,
            "md5":value.MD5,
            "visible": false
          };

          this._sendDocumentUpload(paramInfo);
        }
      }
    }
  }
}