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

import Emiter from './Emiter';
import Sass from 'Sass';
import ServerCheck from 'ServerCheck';
import RecordPlayBackParse from 'RecordPlayBackParse';
import MD5 from "md5";
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.8.0.20170314-1", "author": "www.3mang.com"};

//APE
let _sass;
let _serverCheck;
let _mcu;
let _confer_ape;
let _chat_ape;
let _video_ape;
let _audio_ape;
let _doc_ape;
let _whiteboard_ape;
let _parseBuf;

//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删除文档成功

        //ServerCheck ip
        _serverCheck = ServerCheck;
        _serverCheck.on(_serverCheck.SEVER_CHECK_BEST_IP_SUCCESS, this._serverCheckBestIpSuccessHandler.bind(this));//ip选点，获取最佳ip完成


        // 底层MCU消息层
        _mcu = Mcu;
        _mcu.on('*', (type, data) => this._emit(type, data));
        _mcu.on(MessageTypes.CLASS_JOIN_MCU_SUCCESS, this._mcuJoinMCUClassSuccessHandler.bind(this));//加入MCU课堂完成

        //录制回放
        _parseBuf = RecordPlayBackParse;
        _parseBuf.on('*', (type, data) => this._emit(type, data));
        _parseBuf.on(RecordPlayBackParse.CLASS_JOIN_RECORD_PLAYBACK_SUCCESS, this._joinRecordPlaybackSuccessHandler.bind(this));//加入录制回放完成


        // 注册所有应用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));//这个监听事件不能删除，需要通知课堂模块，检查channel占用


        _audio_ape = new AudioApe();
        _audio_ape.on('*', (type, data) => this._emit(type, data));
        _audio_ape.on(MessageTypes.AUDIO_UPDATE, this.audioUpdate.bind(this));//这个监听事件不能删除，需要通知课堂模块，检查channel占用

        _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.bind(this);
        this.joinClass = this._joinClass.bind(this);
        this.leaveClass = this._leaveClass.bind(this);
        this.getMcuClientStatus = this._getMcuClientStatus.bind(this);
        //this.getClassDetail = this._getClassDetail;//停用
        this.getClassStatusInfo = this._getClassStatusInfo.bind(this);
        this.sendStartClass = this._sendStartClass.bind(this);
        this.sendPauseClass = this._sendPauseClass.bind(this);
        this.sendCloseClass = this._sendCloseClass.bind(this);

        //录制回放
        this.initRecordPlayback = this._initRecordPlayback.bind(this);
        this.startRecordPlayback = this._startRecordPlayback.bind(this);
        this.stopRecordPlayback = this._stopRecordPlayback.bind(this);
        this.pauseRecordPlayback = this._pauseRecordPlayback.bind(this);
        this.seekRecordPlayback = this._seekRecordPlayback.bind(this);

        //chatApe
        this.sendChatMsg = this._sendChatMsg.bind(this);

        //videoApe
        //this.getVideoPlayPath = this._getVideoPlayPath.bind(this);
        this.getVideoPublishPath = this._getVideoPublishPath.bind(this);
        this.getVideoAllChannelInfo = this._getVideoAllChannelInfo.bind(this);
        this.publishVideo = this._publishVideo.bind(this);
        this.stopPublishVideo =this.unPublishVideo= this._stopPublishVideo.bind(this);
        this.sendVideoBroadcastMsg = this._sendVideoBroadcastMsg.bind(this);


        //audioApe
        //this.getAudioPlayPath = this._getPlayAudioPath.bind(this);
        this.getAudioPublishPath = this._getPublishAudioPath.bind(this);
        this.getAudioAllChannelInfo = this._getAudioAllChannelInfo.bind(this);
        this.publishAudio = this._publishAudio.bind(this);
        this.stopPublishAudio =this.unPublishAudio= this._stopPublishAudio.bind(this);
        this.sendAudioBroadcastMsg = this.sendAudioCommandMsg.bind(this);

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

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

    }

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

        this._emit(MessageTypes.ERROR_EVENT, errorMessage);

        /*    if (_mcuErrorCallBackFun) {
         _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) {

        //在conferApe中做处理，这里不需要再处理
        //{"nodeId":nodeId}
        //当有人员离开的时候，如果离开的人员已经推流，那么需要停止推流，然后释放channel；
        /*    if(_data!=null&&_data.nodeId!=null){
         loger.log("有人员离开，检查一下离开的人员是否关闭推流");
         if(_video_ape){
         _video_ape.stopPublishVideo(_data);
         }
         if(_audio_ape){
         _audio_ape.stopPublishAudio(_data);
         }
         }*/
    }

    //当前课堂中视频或音频占用channel的nodeId ，在人员列表中不存在，这种情况是占用channel的人员掉线或离开的时候没有释放channel
    //的占用状态导致，对于这种情况，需要释放掉
    _onClassNonentityRoster(_param) {
        if(GlobalConfig.isRecordPlayBack){
            loger.warn("录制回放中，不处理")
            return;
        }

        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) {
        //{"classId":"1653304953","portal":"112.126.80.182:80","userRole":"normal","userId":0}
        //判断传入的参数是否存在
        if (_param == null || EngineUtils.isEmptyObject(_param)) {
            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.isRecordPlayBack=false;//设置为非录制回放状态
        GlobalConfig.classId = parseInt(_param.classId);
        GlobalConfig.portal = _param.portal;
        GlobalConfig.userId = _param.userId || "0";
        GlobalConfig.userName = _param.userName || "";

        //设置角色身份
        GlobalConfig.userRole = _param.userRole || ApeConsts.normal;
        if(GlobalConfig.userRole!=ApeConsts.host&&
            GlobalConfig.userRole!=ApeConsts.presenter&&
            GlobalConfig.userRole!=ApeConsts.assistant&&
            GlobalConfig.userRole!=ApeConsts.record&&
            GlobalConfig.userRole!=ApeConsts.invisible){
            GlobalConfig.userRole= ApeConsts.normal;
        }

        //客户端决定是否延迟接收消息
        GlobalConfig.messageDelay = _param.messageDelay || false;

        //最长允许录制的时间
        if(_param.allowRecordMaxTime){
            GlobalConfig.allowRecordMaxTime=parseInt(_param.allowRecordMaxTime);
        }

        //获取课堂校验信息
        if (_sass) {
            _sass.getJoinParams(GlobalConfig.getClassInfo());
        }
    }

    //外部请求加入课堂
    _joinClass(_param) {
        //_joinClassSuccessCallBackFun = _onSuccess;
        //{"userName":"名字","password":""}
        if (_param == null || EngineUtils.isEmptyObject(_param)) {
            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.autoLogin=_param.autoLogin||"";
        GlobalConfig.password = _param.password || "";
        GlobalConfig.hasCamera = (typeof  _param.hasCamera == "boolean") ? _param.hasCamera : false;
        GlobalConfig.hasMicrophone = (typeof  _param.hasMicrophone == "boolean") ? _param.hasMicrophone : false;

        loger.log("autoLoginMd5",GlobalConfig.classId,GlobalConfig.userId,GlobalConfig.userRole);
        let autoLoginMd5=MD5(""+GlobalConfig.classId+GlobalConfig.userId+GlobalConfig.userRole);
        loger.log("joinClass-GlobalConfig.autoLogin",GlobalConfig.autoLogin,"autoLoginMd5-",autoLoginMd5);
        if(GlobalConfig.autoLogin&&autoLoginMd5==GlobalConfig.autoLogin){
           // MD5(classId+userId+userRole)==m
            //自动登录，跳过验证流程
            loger.log("自动登录");
            this._sassJoinSuccessHandler();
        }else {
            //不能自动登录，开始校验
            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);
        //返回给客户端初始化成功的数据
        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;
        }

        this._emit(MessageTypes.CLASS_INIT_SUCCESS, initSuccessCallBackData);
    }

    // 通过SASS平台验证(密码和MD5)
    _sassJoinSuccessHandler(_data) {
        //返回值
        /* flag	数值型	无		True:成功
         Flag：失败
         h5_mcu_list	字符串			H5muc列表
         maxVideoChannels	数值型			最大视频路数
         maxAudioChannels	数值型			最大音频路数
         h5Module	数值型			H5开关
         ms	字符串			Ms列表
         mcu	字符串			Mcu列表
         rs	字符串			Rs列表
         doc	字符串			Doc列表*/
        //获取课堂最完整的数据
        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.h5Delay || 0;//mcu消息延迟的时间间隔，单位(秒)，结合客户端传的messageDelay的值使用
            GlobalConfig.className = _data.meetingName || "";
            GlobalConfig.classBeginTime = _data.beginTime || "";
            GlobalConfig.classEndTime = _data.endTime || "";
            GlobalConfig.userIp = _data.userIp || "";

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

            //视频质量相关设置
            GlobalConfig.fps = _data.fps||15;
            GlobalConfig.gop = _data.gop||3;;
            GlobalConfig.videoQuality = _data.videoQuality||2;

            //是否自动开始(身份是host的时候才用到的)
            GlobalConfig.isAutoStartClass= _data.autoRecord||0;

            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&&_data.mcuList.length>0) {
                //MCU地址默认使用第一个
                GlobalConfig.MCUServerIP = _data.mcuList[0].ip || "";
                GlobalConfig.MCUServerPort = _data.mcuList[0].port || "";
            }

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

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

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

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

        }

        if (_data.currentInfo) {
            //根据从Sass获取的数据信息,同步最后一次保存的课堂状态信息
            loger.log("本地同步最后一次保存过的课堂状态信息");
            try {
                GlobalConfig.setClassStatusInfo(JSON.parse(_data.currentInfo));
            }catch (err){
                GlobalConfig.setClassStatusInfo(_data.currentInfo);
            }
            loger.log(GlobalConfig.classStatusInfo);
        } else {
            loger.log("还没有保存过课堂状信息");
        }


        //录制回放不需要选点
        if(GlobalConfig.isRecordPlayBack){
            if (_parseBuf) {
                //开启录制回放流程
                loger.log("开启录制回放流程");
                _parseBuf.readyRecordPlay();
            }else {
                loger.warn("开启录制回放流程失败，还未创建模块");
            }
        }else {
            //根据用户的userIp获取信息
            this.getUserIpInfo();
        }
    }

    //根据UserIp获取ip信息
    getUserIpInfo() {
        if (_serverCheck) {
            _serverCheck.getUserIpInfo("", GlobalConfig.userIp);
        }
    }

    //MCU MS ip选点完成，开加入MCU
    _serverCheckBestIpSuccessHandler(_data) {
        loger.log("_serverCheckBestIpSuccessHandler,IP选点结束");
        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('保存课堂状态信息成功.');
        loger.log(_data);
    }

    _sassSaveClassRecordInfoSuccessHandler(_data) {
        loger.log('保存课堂录制信息成功.');
        loger.log(_data);
    }

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

    // MCU 课堂成功
    _mcuJoinMCUClassSuccessHandler(_data) {
        loger.log('MCU 课堂成功.');
        GlobalConfig.setCurrentStatus(GlobalConfig.statusCode_2);

        //返回给客户端初始化成功的数据
        let joinClassSuccessCallBackData = {};

        joinClassSuccessCallBackData.isRecordPlayBack=GlobalConfig.isRecordPlayBack;

        joinClassSuccessCallBackData.DOCServerIP = GlobalConfig.DOCServerIP;
        joinClassSuccessCallBackData.DOCServerPort = GlobalConfig.DOCServerPort;

        joinClassSuccessCallBackData.classId = GlobalConfig.classId;
        joinClassSuccessCallBackData.className = GlobalConfig.className;
        joinClassSuccessCallBackData.h5Module = GlobalConfig.h5Module;
        joinClassSuccessCallBackData.isHost = GlobalConfig.isHost;
        joinClassSuccessCallBackData.maxAudioChannels = GlobalConfig.maxAudioChannels;
        joinClassSuccessCallBackData.maxVideoChannels = GlobalConfig.maxVideoChannels;
        joinClassSuccessCallBackData.mcuDelay = GlobalConfig.mcuDelay;

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

        joinClassSuccessCallBackData.siteId = GlobalConfig.siteId;
        joinClassSuccessCallBackData.classId = GlobalConfig.classId;
        joinClassSuccessCallBackData.userRole = GlobalConfig.userRole;
        joinClassSuccessCallBackData.userId = GlobalConfig.userId;
        joinClassSuccessCallBackData.passwordRequired = GlobalConfig.passwordRequired;
        joinClassSuccessCallBackData.classType = GlobalConfig.classType || ApeConsts.CLASS_TYPE_INTERACT;

        joinClassSuccessCallBackData.country = GlobalConfig.country;//国家
        joinClassSuccessCallBackData.city = GlobalConfig.city;//城市
        joinClassSuccessCallBackData.province = GlobalConfig.province;//服务商
        joinClassSuccessCallBackData.isp = GlobalConfig.isp;//服务商

        joinClassSuccessCallBackData.classTimestamp=GlobalConfig.classTimestamp;//课堂进行的累积时间
        joinClassSuccessCallBackData.recordPlaybackMaxTime=GlobalConfig.recordPlaybackMaxTime;//录制回放的总时间

        joinClassSuccessCallBackData.fps=GlobalConfig.fps;
        joinClassSuccessCallBackData.gop=GlobalConfig.gop;
        joinClassSuccessCallBackData.videoQuality=GlobalConfig.videoQuality;

        loger.log('加入课堂成功');
        loger.log(joinClassSuccessCallBackData);

        //加入课堂成功，广播消息
        this._emit(MessageTypes.CLASS_JOIN_SUCCESS, joinClassSuccessCallBackData);
    }

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

    _getVideoAllChannelInfo(_param) {
        if (_video_ape) {
            return _video_ape.getAllChannelInfo(_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);
        }
    }

    _getAudioAllChannelInfo(_param) {
        if (_audio_ape) {
            return _audio_ape.getAllChannelInfo(_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 ->');
        loger.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);
        loger.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);
                }
            }
        }
    }

    //录制回放相关的处理------------------------------------------------
    //录制回放初始化
    _initRecordPlayback(_param){
        //{"classId":"1653304953","portal":"112.126.80.182:80","userRole":"normal","userId":0}
        if (_param == null) {
            loger.error('录制回放初始化失败,参数错误');
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_INIT_RECORD_PLAY_BACK_FAILED);
            return;
        }
        //判断必要的参数字段值
        if (_param.classId == null || isNaN(_param.classId) || _param.portal == null || _param.portal == "") {
            loger.error('录制回放初始化失败', _param);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_INIT_RECORD_PLAY_BACK_FAILED);
            return;
        }
        loger.log('录制回放', _param);

        //保存参数
        GlobalConfig.isRecordPlayBack=true;//设置为录制回放状态
        GlobalConfig.classId = parseInt(_param.classId);
        GlobalConfig.portal = _param.portal;
        GlobalConfig.userRole =ApeConsts.normal;//*************很重要，录制回放的时候，身份模式是普通人********
        GlobalConfig.userId = _param.userId || "0";
        GlobalConfig.userName = _param.userName || "";

        //获取课堂最完整的数据，录制回放需要获取课堂数据
        if (_sass) {
            _sass.getClassParam();
        }
    }

    //开始录制回放
    _startRecordPlayback(_param) {
        if (_parseBuf) {
            _parseBuf.startRecordPlayback(_param);
        }
    }
    //停止录制回放
    _stopRecordPlayback(_param) {
        if (_parseBuf) {
            _parseBuf.stopRecordPlayback(_param);
        }
    }
    //暂停录制回放
    _pauseRecordPlayback(_param) {
        if (_parseBuf) {
            _parseBuf.pauseRecordPlayback(_param);
        }
    }
    //seek录制回放
    _seekRecordPlayback(_param) {
        if (_parseBuf) {
            _parseBuf.seekRecordPlayback(_param);
        }
    }

    //录制回放加入 课堂成功
    _joinRecordPlaybackSuccessHandler(_data) {
        loger.log('加入录制回放成功.');
        GlobalConfig.setCurrentStatus(GlobalConfig.statusCode_2);

        //返回给客户端初始化成功的数据
        let joinClassSuccessCallBackData = {};

        joinClassSuccessCallBackData.isRecordPlayBack=GlobalConfig.isRecordPlayBack;

        joinClassSuccessCallBackData.DOCServerIP = GlobalConfig.DOCServerIP;
        joinClassSuccessCallBackData.DOCServerPort = GlobalConfig.DOCServerPort;

        joinClassSuccessCallBackData.classId = GlobalConfig.classId;
        joinClassSuccessCallBackData.className = GlobalConfig.className;
        joinClassSuccessCallBackData.h5Module = GlobalConfig.h5Module;
        joinClassSuccessCallBackData.isHost = GlobalConfig.isHost;//
        joinClassSuccessCallBackData.maxAudioChannels = GlobalConfig.maxAudioChannels;
        joinClassSuccessCallBackData.maxVideoChannels = GlobalConfig.maxVideoChannels;
        joinClassSuccessCallBackData.mcuDelay = GlobalConfig.mcuDelay;

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

        joinClassSuccessCallBackData.siteId = GlobalConfig.siteId;
        joinClassSuccessCallBackData.classId = GlobalConfig.classId;
        joinClassSuccessCallBackData.userRole = GlobalConfig.userRole;
        joinClassSuccessCallBackData.userId = GlobalConfig.userId;
        joinClassSuccessCallBackData.passwordRequired = GlobalConfig.passwordRequired;
        joinClassSuccessCallBackData.classType = GlobalConfig.classType || ApeConsts.CLASS_TYPE_INTERACT;

        joinClassSuccessCallBackData.country = GlobalConfig.country;//国家
        joinClassSuccessCallBackData.city = GlobalConfig.city;//城市
        joinClassSuccessCallBackData.province = GlobalConfig.province;//服务商
        joinClassSuccessCallBackData.isp = GlobalConfig.isp;//服务商

        joinClassSuccessCallBackData.classTimestamp=GlobalConfig.classTimestamp;//课堂进行的累积时间
        joinClassSuccessCallBackData.recordPlaybackMaxTime=GlobalConfig.recordPlaybackMaxTime;//录制回放的总时间

        joinClassSuccessCallBackData.fps=GlobalConfig.fps;
        joinClassSuccessCallBackData.gop=GlobalConfig.gop;
        joinClassSuccessCallBackData.videoQuality=GlobalConfig.videoQuality;

        loger.log(joinClassSuccessCallBackData);
        //和加入课堂成功使用同样的消息处理
        this._emit(MessageTypes.CLASS_JOIN_SUCCESS, joinClassSuccessCallBackData);
    }

}