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 AudioApe from 'apes/AudioApe';
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 _audio_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.CLASS_SAVE_RECORD_INFO_SUCCESS, this._sassSaveClassRecordInfoSuccessHandler.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._mcuJoinClassSuccessHandler.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));//当前会议人员离开
    _confer_ape.on(MessageTypes.CLASS_NONENTITY_ROSTER,this._onClassNonentityRoster.bind(this));//当前会议中视频或音频占用channel的nodeId ，在人员列表中不存在
    _confer_ape.on(MessageTypes.CLASS_RECORD_START,this._onClassRecordStart.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));

    _audio_ape= new AudioApe();
    _audio_ape.on('*', (type, data) => this._emit(type, data));
    _audio_ape.on(MessageTypes.AUDIO_UPDATE, this.audioUpdate.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.getClassStatusInfo = this._getClassStatusInfo;
    this.sendStartClass = this._sendStartClass;
    this.sendPauseClass = this._sendPauseClass;
    this.sendCloseClass = this._sendCloseClass;


    //chatApe
    this.sendChatMsg = this._sendChatMsg;

    //videoApe
    this.getVideoPlayPath = this._getVideoPlayPath;
    this.getVideoPublishPath = this._getVideoPublishPath;
    this.publishVideo = this._publishVideo;
    this.stopPublishVideo = this._stopPublishVideo;
    this.sendVideoBroadcastMsg=this._sendVideoBroadcastMsg;


    //audioApe
    this.getAudioPlayPath = this._getPlayAudioPath;
    this.getAudioPublishPath = this._getPublishAudioPath;
    this.publishAudio = this._publishAudio;
    this.stopPublishAudio = this._stopPublishAudio;
    this.sendAudioBroadcastMsg=this.sendAudioCommandMsg;

    //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.getDocImageFullPath=this._getDocImageFullPath;//获取文档图片的完整路径
    this.getDocPDFFullPath=this._getDocPDFFullPath;//获取文档的完整路径
  }


  //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();
  }

  //获取当前会议的状态信息
  _getClassStatusInfo(){
    return GlobalConfig.classStatusInfo;
  }
  //关闭会议，所有人都退出
  _doClassClose(_param) {
    this._leaveClass();
  }

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

  //当前的会议状态信息发生改变,需要保存会议状态到Sass
  _onClassStatusInfoChange(_param) {
    //如果MCU连接已经断开，不发送
    if(GlobalConfig.getCurrentStatus().code!=GlobalConfig.statusCode_2.code){
      loger.warn("不能保存会议状态",GlobalConfig.getCurrentStatus());
      return;
    }
    this._sassSaveClassStatusInfo();
  }

  //如果是第一次点击开始上课，需要创建录制时的文件名
  _onClassRecordStart(_param){
    if(GlobalConfig.getCurrentStatus().code!=GlobalConfig.statusCode_2.code){
      loger.warn("不能保存会议状态",GlobalConfig.getCurrentStatus());
      return;
    }
    if(_sass){
      _sass.saveClassRecordContrlInfo(_param);
    }
  }


  //有人员离开
  _onClassDeleteRoster(_data){
    //{"nodeId":nodeId}
    //当有人员离开的时候，如果离开的人员已经推流，那么需要停止推流，然后释放channel；
    //只有自己是主持人的时候出才处理下面的事情
    if(_data!=null&&_data.nodeId!=null&&GlobalConfig.isHost){
      loger.log("有人员离开，检查一下离开的人员是否关闭推流");
      if(_video_ape){
        _video_ape.stopPublishVideo(_data);
      }
      if(_audio_ape){
        _audio_ape.stopPublishAudio(_data);
      }
    }
  }

  //当前会议中视频或音频占用channel的nodeId ，在人员列表中不存在，这种情况是占用channel的人员掉线或离开的时候没有释放channel
  //的占用状态导致，对于这种情况，需要释放掉
  _onClassNonentityRoster(_param){
    if(_param==null||_param.nodeId==null){
      loger.warn("onClassNonentityRoster.参数错误")
      return;
    }
    let data={"nodeId":_param.nodeId};
    if(_video_ape){
      _video_ape.stopPublishVideo(data);
    }
    if(_audio_ape){
      _audio_ape.stopPublishAudio(data);
    }
  }


  //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服务器只判断学生是否需要密码，没有判断老师的
    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.userName=GlobalConfig.userName;
      initSuccessCallBackData.classType = GlobalConfig.classType;

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

      _initSuccessCallBackFun(initSuccessCallBackData);
    }
  }

  // 通过SASS平台验证(密码和MD5)
  _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];
     }

     //m3u8播流地址
     if(_data.rs){
     //RS地址默认使用第一个
     let server = _data.rs.split(";")[0];
     GlobalConfig.RSServerIP = server.split(":")[0];
     GlobalConfig.RSServerPort = 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;

     */


   /*
   //这个接口获取的数据在getClassParam接口的数据中都有，内容重复，这个接口废弃
    //获取会议基本信息
    if (_sass) {
      _sass.getClassDetail();
    }
    */

    //获取会议最完整的数据
    if (_sass) {
      _sass.getClassParam();
    }
  }

  //获取会议基本信息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('获取课堂会议的完整信息完成.');
    // console.log(_data);
    //包含整个会议最全的信息,储存数据
    if (_data) {
      GlobalConfig.mcuDelay= _data.mcuDelay || 60;
      GlobalConfig.className = _data.meetingName || "";
      GlobalConfig.classBeginTime = _data.beginTime || "";
      GlobalConfig.classEndTime = _data.endTime || "";

      GlobalConfig.maxVideoChannels = _data.maxVideoChannels;
      GlobalConfig.maxAudioChannels = _data.maxAudioChannels;

      GlobalConfig.setDocListPrepare(_data.docListPrepare);  //提前上传的文档列表
      GlobalConfig.setRecordList(_data.recordList);//录制回放地址
      GlobalConfig.setDocList(_data.docList);//文档地址
      GlobalConfig.setMsList(_data.msList);//推流播流服务器地址
      GlobalConfig.setRsList(_data.rsList);//播放m3u8格式的地址
      GlobalConfig.setMcuList(_data.mcuList);//mcu
      GlobalConfig.setMusicList(_data.musicList);//
      GlobalConfig.setMusicListPrepare(_data.musicListPrepare);//提前上传的声音文件列表


      if (_data.mcuList) {
        //MCU地址默认使用第一个
        GlobalConfig.MCUServerIP =_data.mcuList[0].ip||"";
        GlobalConfig.MCUServerPort =_data.mcuList[0].port||"";
      }

      //视频推流播流地址
      if (_data.msList) {
        //MS地址默认使用第一个
        GlobalConfig.MSServerIP =_data.msList[0].ip||"";
        GlobalConfig.MSServerPort =_data.msList[0].port||"";
      }

      //m3u8播流地址
      if(_data.rsList){
        //RS地址默认使用第一个
        GlobalConfig.RSServerIP =_data.rsList[0].ip||"";
        GlobalConfig.RSServerPort =_data.rsList[0].port||"";
      }

      //文档地址
      if(_data.docList){
        //doc地址默认使用第一个
        GlobalConfig.DOCServerIP =_data.docList[0].ip||"";
        GlobalConfig.DOCServerPort =_data.docList[0].port||"";
      }

      //record
      if(_data.recordList){
        //地址默认使用第一个
        GlobalConfig.RecordServerIP =_data.recordList[0].ip||"";
        GlobalConfig.RecordServerPort =_data.recordList[0].port||"";
      }

    }

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

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

  //保存会议状态信息
  _sassSaveClassStatusInfo() {
    if (GlobalConfig.isHost) {
      //只有加入会议之后才能保存数据
      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);
  }
  _sassSaveClassRecordInfoSuccessHandler(_data){
    loger.log('保存会议录制信息成功.', _data);
  }

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

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

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

      initSuccessCallBackData.DOCServerIP =GlobalConfig.DOCServerIP;
      initSuccessCallBackData.DOCServerPort =GlobalConfig.DOCServerPort;

      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.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('加入会议成功');
      console.log(initSuccessCallBackData);
      _joinClassSuccessCallBackFun(initSuccessCallBackData);
    }
  }

  //Sass删除文档数据
  _sassDeleteDocument(_param) {
    if(!_mcu.connected){
      loger.warn(GlobalConfig.getCurrentStatus());
      return;
    }

    //判断传入的参数是否存在
    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(!_mcu.connected){
      loger.warn(GlobalConfig.getCurrentStatus());
      return;
    }

    if(_confer_ape){
      _confer_ape.startClass(_param);
    }
  }
  //暂停上课
  _sendPauseClass(_param){
    if(!_mcu.connected){
      loger.warn(GlobalConfig.getCurrentStatus());
      return;
    }
    if(_confer_ape){
      _confer_ape.pauseClass(_param);
    }
  }
  //停止上课
  _sendCloseClass(_param){
    if(!_mcu.connected){
      loger.warn(GlobalConfig.getCurrentStatus());
      return;
    }
    if(_confer_ape){
      _confer_ape.closeClass(_param);
    }
  }
  // 离开会议
  _leaveClass() {
    if(!_mcu.connected){
      loger.warn(GlobalConfig.getCurrentStatus());
      return;
    }

    //停止推流
    if(_video_ape){
      _video_ape.stopPublishVideo();
    }
    if(_audio_ape){
      _audio_ape.stopPublishAudio();
    }
    //离开会议
    if(_confer_ape){
      _confer_ape.stopRecord();
      _confer_ape.leaveClass();
    }
    //断开MCU连接
    if(_mcu){
      _mcu.leaveMCU();
      GlobalConfig.setCurrentStatus(GlobalConfig.statusCode_3);
    }
  }


  //ChatApe
  // 发送聊天消息
  _sendChatMsg(_messageInfo) {
    if(!_mcu.connected){
      loger.warn(GlobalConfig.getCurrentStatus());
      return;
    }
    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);
    }
  }

  _sendVideoBroadcastMsg(_param){
    if(!_mcu.connected){
      loger.warn(GlobalConfig.getCurrentStatus());
      return;
    }
    if(_video_ape){
      return _video_ape.sendVideoBroadcastMsg(_param);
    }
  }

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

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

  _publishVideo(_param){
    if(!_mcu.connected){
      loger.warn(GlobalConfig.getCurrentStatus());
      return;
    }
    if(_video_ape){
      return _video_ape.publishVideo(_param);
    }
  }

  _stopPublishVideo(_param){
    if(!_mcu.connected){
      loger.warn(GlobalConfig.getCurrentStatus());
      return;
    }
    if(_video_ape){
      return _video_ape.stopPublishVideo(_param);
    }
  }

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

  sendAudioCommandMsg(_param){
    if(!_mcu.connected){
      loger.warn(GlobalConfig.getCurrentStatus());
      return;
    }
    if(_audio_ape){
      return _audio_ape.sendAudioBroadcastMsg(_param);
    }
  }

  _getPlayAudioPath(_param){
    if(_audio_ape){
      return _audio_ape.getAudioPlayPath(_param);
    }
  }

  _getPublishAudioPath(_param){
    if(_audio_ape){
      return _audio_ape.getAudioPublishPath(_param);
    }
  }

  _publishAudio(_param){
    if(!_mcu.connected){
      loger.warn(GlobalConfig.getCurrentStatus());
      return;
    }
    if(_audio_ape){
      return _audio_ape.publishAudio(_param);
    }
  }

  _stopPublishAudio(_param){
    if(!_mcu.connected){
      loger.warn(GlobalConfig.getCurrentStatus());
      return;
    }
    if(_audio_ape){
      return _audio_ape.stopPublishAudio(_param);
    }
  }


  //WhiteBoardApe
  // 添加标注,发送信息
  _sendInsertAnnotaion(_param){
    if(!_mcu.connected){
      loger.warn(GlobalConfig.getCurrentStatus());
      return;
    }
    if(_whiteboard_ape){
      _whiteboard_ape.sendInsetAnnotaion(_param);
    }
  }

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


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

  //// 文档变更，白板也需要做处理
  docUpdateHandler(_data) {
    if(!_mcu.connected){
      loger.warn(GlobalConfig.getCurrentStatus());
      return;
    }
    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);
        }
      }
    }
  }
}