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';


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

    this.on(MessageTypes.MCU_ERROR,this._mcuErrorHandler.bind(this));
    this.on(MessageTypes.DOC_SHOW, this.docShowHandler.bind(this));

    // Sass平台层
    _sass = Sass;
    _sass.on('*', (type, data) => this._emit(type, data));
    _sass.on(_sass.SUCCESS, this._sassVerifySuccessHandler.bind(this));
    _sass.on(_sass.CLASS_INIT_SUCCESS, this._sassInitSuccessHandler.bind(this));
    _sass.on(_sass.CLASS_GET_CLASS_DETAIL, this._h5SassGetClassDetailSuccessHandler.bind(this));
    _sass.on(_sass.CLASS_GET_MEETING_PARAM,this._h5SassGetMeetingParaSuccessHandler);

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


    // 注册所有应用Ape
    _confer_ape = new ConferApe();
    _confer_ape.on('*', (type, data) => this._emit(type, data));
    _confer_ape.on(MessageTypes.DOC_SWITCH, this.docSwitchHandler.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));

    _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));


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


    //公开外部调用的方法
    //class
    this.init=this._init;
    this.joinClass=this._joinClass;
    this.leaveClass=this._leaveClass;
    this.mcuClientStatus=this._mcuClientStatus;

    //chatApe
    this.sendChatMsg=this._sendChatMsg;

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


    //whiteBoradApe
    this.sendInsertAnnotaion=this._sendInsertAnnotaion;
    //this.sendUpdaterAnnotaion=this._sendUpdaterAnnotaion;//暂时关闭更新接口
    this.sendDeleteAnnotaion=this._sendDeleteAnnotaion;
    this.sendDeleteAllAnnotation=this._sendDeleteAllAnnotation;

    //DocApe
    this.sendDocumentUpload= this._sendDocumentUpload;//上传文档
    this.sendDocumentSwitch=  this._sendDocumentSwitch; //切换文档
    this.sendDocumentDelete= this. _sendDocumentDelete;//删除文档
    this.sendDocumentDeleteAll= this._documentDeleteAll;//删除所有文档
    this.sendDocumentCommand= this._sendDocumentCommand;//操作文档(翻页、缩放、滚动...)

    //debug
    //this.setDebugData=this._setDebugData;
  }


  //mcu异常监听
  _mcuErrorHandler(_data){
    if(_mcuErrorCallBackFun){
      let errorMessage={"code":_data,"reson":""};
      loger.log("MCU_ERROR",errorMessage);
      _mcuErrorCallBackFun(errorMessage);
    }
  }

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

  //初始化
  _init(_param,_onSuccess,_mcuErrorCallBack){
    _initSuccessCallBackFun=_onSuccess;
   // _initFailureCallBackFun=_onFailure;
    _mcuErrorCallBackFun=_mcuErrorCallBack;
    //{"meetingNumber":"1653304953","portal":"112.126.80.182:80","userRole":"normal","userId":0}
    //判断传入的参数是否存在
    if(_param==null||EngineUtils.isEmptyObject(_param)||_onSuccess==null||_mcuErrorCallBack==null){
      loger.log('init初始化失败,参数错误');
      this._emit(MessageTypes.MCU_ERROR,MessageTypes.ERR_CLASS_INIT_PAEAM);
      return ;
    }
    //判断必要的参数字段值
    if(_param.meetingNumber==null||isNaN(_param.meetingNumber)||_param.portal==null||_param.portal==""){
      loger.log('init初始化失败',_param);
      this._emit(MessageTypes.MCU_ERROR,MessageTypes.ERR_CLASS_INIT_PAEAM);
      return ;
    }
    loger.log('init',_param);
    //保存参数
    GlobalConfig.confId=_param.meetingNumber;
    GlobalConfig.portal=_param.portal;
    GlobalConfig.userRole=_param.userRole||"normal";
    GlobalConfig.userId=_param.userId||"0";

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

  //外部请求加入会议
  _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 ;
    }

    GlobalConfig.userName=_param.userName;
    GlobalConfig.password=_param.password||"";

    //开始校验
    if(_sass){
      _sass.passwordAndMd5Checking(GlobalConfig.getConfInfo());
    }
  }
  // 离开会议
  _leaveClass() {
    if(_confer_ape){
      _confer_ape.leaveClass();
    }
    if(_mcu){
      _mcu.leaveMCU();
      GlobalConfig.setCurrentStatus(GlobalConfig.statusCode_3);
    }
  }

  // 用meetingNumber向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.classType||"";

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

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

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

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

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

      _initSuccessCallBackFun(initSuccessCallBackData);
    }
  }

  //// 用meetingNumber向SASS平台获取入会验证信息失败
  //_sassInitFailedHandler(_data) {
  //  loger.log('向SASS平台获取入会验证信息失败.');
  //  //this._emit(MessageTypes.CLASS_INIT_FAILED);
  //  let callBackObj={"code":_data,"message":""};
  //  if(_initFailureCallBackFun){
  //    _initFailureCallBackFun(callBackObj);
  //  }
  //}

  //使用固定的假数据
  _setDebugData(_data){
    loger.log("setDebugData "+_data);
    //GlobalConfig.setDebugData(_data);
  }

  // 通过SASS平台验证
  _sassVerifySuccessHandler(_data) {

    //返回值
   /* flag	数值型	无		True:成功
    Flag：失败
    h5_mcu_list	字符串			H5muc列表
    maxVideoChannels	数值型			最大视频路数
    maxAudioChannels	数值型			最大音频路数
    h5Module	数值型			H5开关
    ms	字符串			Ms列表
    mcu	字符串			Mcu列表
    rs	字符串			Rs列表
    doc	字符串			Doc列表*/

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


    loger.log('加入底层MCU会议.');
    if(_mcu){
      _mcu.joinMCU(GlobalConfig.getConfInfo());
    }
  }

  //获取会议所有参数
  _h5SassGetClassDetailSuccessHandler(_data){
    loger.log('获取getClassDetail完成.');
    GlobalConfig.classDetail=_data;
    loger.log(GlobalConfig.classDetail);
    this._emit(MessageTypes.CLASS_SHOW_DETAIL, _data);
  }

  //获取会议所有参数
  _h5SassGetMeetingParaSuccessHandler(_data){
    loger.log('获取getMeetingParam完成.');
    GlobalConfig.meetingParam=_data;
   // loger.log(GlobalConfig.meetingParam);
  }

  // MCU 会议成功
  _joinClassSuccessHandler(_data) {
    loger.log('MCU 会议成功.');
    GlobalConfig.setCurrentStatus(GlobalConfig.statusCode_2);
    if(_sass){
      _sass.getClassDetail();//会议信息
      _sass.getMeetingParam();//会议参数大全
    }

    //储存数据

    GlobalConfig.MCUServerIP=_data.MCUServerIP;
    GlobalConfig.MCUServerPort=_data.MCUServerPort;
    GlobalConfig.classRole=_data.classRole;
    GlobalConfig.confId=_data.confId;
    GlobalConfig.h5Module=_data.h5Module;
    GlobalConfig.isHost=_data.isHost;
    GlobalConfig.maxAudioChannels=_data.maxAudioChannels;
    GlobalConfig.maxVideoChannels=_data.maxVideoChannels;
    GlobalConfig.maxMediaChannels=_data.maxMediaChannels;
    GlobalConfig.mcuConfInfo=_data.mcuConfInfo;
    GlobalConfig.mcuDelay=_data.mcuDelay;
    GlobalConfig.md5=_data.md5;
    GlobalConfig.msType=_data.msType;
    GlobalConfig.nodeId=_data.nodeId;
    GlobalConfig.password=_data.password;
    //GlobalConfig.passwordRequired  老师的默认是true
    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.doc=GlobalConfig.doc;//文档服务器地址
      initSuccessCallBackData.classRole=GlobalConfig.classRole;
      initSuccessCallBackData.confId=GlobalConfig.confId;
      initSuccessCallBackData.h5Module=GlobalConfig.h5Module;
      initSuccessCallBackData.isHost=GlobalConfig.isHost;
      initSuccessCallBackData.maxAudioChannels=GlobalConfig.maxAudioChannels;
      initSuccessCallBackData.maxVideoChannels=GlobalConfig.maxVideoChannels;
      initSuccessCallBackData.maxMediaChannels=GlobalConfig.maxMediaChannels;
     // GlobalConfig.mcuConfInfo=_data.mcuConfInfo;
      initSuccessCallBackData.mcuDelay=GlobalConfig.mcuDelay;
      //GlobalConfig.md5=_data.md5;
      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.meetingNumber=GlobalConfig.confId;
      initSuccessCallBackData.userRole=GlobalConfig.userRole;
      initSuccessCallBackData.userId=GlobalConfig.userId;
      initSuccessCallBackData.passwordRequired=GlobalConfig.passwordRequired;
      initSuccessCallBackData.classType=GlobalConfig.classType;
      loger.log('加入会议成功',initSuccessCallBackData);
      _joinClassSuccessCallBackFun(initSuccessCallBackData);
    }
  }
  //// MCU 会议失败
  //_joinClassFailureHandler(_data){
  //  GlobalConfig.setCurrentStatus(GlobalConfig.statusCode_1);
  //  loger.log("_joinClassFailureHandler",_data);
  //  if(_joinClassFailureCallBackFun){
  //    let callBackObj={"code":_data,"message":""};
  //    _joinClassFailureCallBackFun(callBackObj);
  //  }
  //}

  // 参会处理
  conferenceHandler(msg_type) {
    var msg = {
      type: msg_type,
      data: null
    };
    this._emit(msg.type, msg);
  }

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

  //VidoeApe
  _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);
    }
  }
  //更新标注，发送信息
  _sendUpdaterAnnotaion(_param){
    if(_whiteboard_ape){
      _whiteboard_ape.sendUpdaterAnnotaion(_param);
    }
  }
  //删除标注，发送信息
  _sendDeleteAnnotaion(_param){
    if(_whiteboard_ape){
      _whiteboard_ape.sendDeleteAnnotaion(_param);
    }
  }
//删除所有标注
  _sendDeleteAllAnnotation(_param){
    if(_whiteboard_ape){
      _whiteboard_ape.sendDeleteAllAnnotation(_param);
    }
  }

  //DocApe
  //上传文档
  _sendDocumentUpload(_param){
    if(_doc_ape){
      _doc_ape.documentUpload(_param);
    }
  }
  //切换文档
  _sendDocumentSwitch(_param){
    if(_doc_ape){
      _doc_ape.documentSwitch(_param);
    }
  }
  //删除文档
  _sendDocumentDelete(_param){
    if(_doc_ape){
      _doc_ape.documentDelete(_param);
    }
  }
  //删除所有文档
  _documentDeleteAll(_param){
    if(_doc_ape){
      _doc_ape.documentDeleteAll(_param);
    }
  }

  //操作文档(翻页、缩放、滚动...)
  _sendDocumentCommand(_param){
    if(_doc_ape){
      _doc_ape.documentCommand(_param);
    }
  }

  // 白板笔记更新(svg)
  annoUpdateHandler(annoInfo) {
    const activeDocId = _confer_ape.activeDocId;
    const docItem = _doc_ape.docList[activeDocId];
    if (docItem && annoInfo.id == docItem.wbid) {
      this._emit(MessageTypes.DOC_ANNOTATION, annoInfo);
    }
  }

  // 文档变更-笔记处理
  docShowHandler(docItem) {
    loger.log('Doc Show ->' + docItem.id + '|' + docItem.curPageNo);
    const annoInfo = _whiteboard_ape.annoInfos[docItem.wbid];
    if (annoInfo) {
      this._emit(MessageTypes.DOC_ANNOTATION, annoInfo);
    } else {
      this._emit(MessageTypes.DOC_ANNOTATION);

    }
  }

  // 文档切换
  docSwitchHandler() {
    const activeDocId = _confer_ape.activeDocId;
    loger.log('Switch Doc Active -> ' + activeDocId);
    const docItem = _doc_ape.docList[activeDocId];
    if (docItem) {
      this._emit(MessageTypes.DOC_SHOW, docItem);
    }
  }

  // 文档变更
  docUpdateHandler(docItem) {
    loger.log('Doc UpdateId ->' + docItem.id + '| activeDocId ->' + _confer_ape.activeDocId);
    if (docItem.id == _confer_ape.activeDocId) {
      this._emit(MessageTypes.DOC_SHOW, docItem);
    }
  }

  //文档删除
    docDeleteHandler(docItem){
        if (docItem.id == _confer_ape.activeDocId) {
            this._emit(MessageTypes.DOC_DELETE, docItem);
        }
    }
}