// //////////////////////////////////////////////////////////////////////////////
//视频模块
// //////////////////////////////////////////////////////////////////////////////

import Ape from './Ape';
import ApeConsts from './ApeConsts';
import pdu from 'pdus';
import Loger from 'Loger';
import MessageTypes from 'MessageTypes';
import GlobalConfig from 'GlobalConfig';
import EngineUtils from 'EngineUtils';
import MediaModule from "./MediaModule";
import  ShareApe from './ShareApe';
let loger = Loger.getLoger('VideoApe');

class VideoApe extends Ape {
  constructor() {
    super(
      ApeConsts.VIDEO_SESSION_ID,
      ApeConsts.VIDEO_SESSION_NAME,
      ApeConsts.VIDEO_SESSION_TAG
    );
    this.isLeave=false;
    this.mediaModule = new MediaModule();
    this.mediaModule.MEDIA_OBJ_TABLE_ID = ApeConsts.VIDEO_OBJ_TABLE_ID;
    this.mediaModule.mediaChannels = {};
    this.mediaModule.mediaType = ApeConsts.MEDIA_TYPE_VIDEO;
    this.shareApe = new ShareApe();
    this.shareApe.on(MessageTypes.PUBLISH_SCREEN_SHARE_SUCCESS, this.onPublishScreenShareSuccess.bind(this));
    this.shareApe.on(MessageTypes.PUBLISH_SCREEN_SHARE_FAILE, this.onPublishScreenShareFaile.bind(this));
    this.shareApe.on(MessageTypes.PUBLISH_SCREEN_SHARE_CLOSE, this.onPublishScreenShareClose.bind(this));
    this.shareApe.on(MessageTypes.PUBLISH_SCREEN_SHARE_DISCONNECT, this.onPublishScreenShareDisconnect.bind(this));
    this.shareApe.on(MessageTypes.PUBLISH_SCREEN_SHARE_CONNECTED, this.onPublishScreenShareConnected.bind(this));
    this.shareApe.on(MessageTypes.PUBLISH_SCREEN_MOVIE_INFO_CHANGE, this.onPublishScreenMovieInfoChange.bind(this));
    this.shareApe.on(MessageTypes.PUBLISH_SCREEN_VIDEO_INFO_CHANGE, this.onPublishScreenVideoInfoChange.bind(this));

    // Ape Models
    this.registerKey(this._session_id, this._session_name, this._session_tag, new ArrayBuffer);
    this.registerObj(pdu.RCPDU_REG_REGISTER_TABLE, ApeConsts.VIDEO_OBJ_TABLE_ID, ApeConsts.VIDEO_OBJ_TABLE_NAME, ApeConsts.VIDEO_OBJ_TABLE_TAG, 0, new ArrayBuffer);
    // videoApe 监听视频控制消息，用户之间的消息传递
    this.on(pdu.RCPDU_SEND_VIDEO_DATA_REQUEST, this.receiveVideoCommandHandler.bind(this));
  }

  //ape加入成功
  onJoinChannelHandlerSuccess() {
    //这个设置很重要，因为只有Sass流程完成之后，APE才能取得GlobalConfig中的数据
    loger.log('视频模块初始完成->');
    this.mediaModule.maxMediaChannel = GlobalConfig.maxVideoChannels;
  }

  /////////////发送数据操作////////////////////////////////////////////
  //获取播流地址
  getPlayVideoPath(_param) {
    //loger.log('getPlayVideoPath');
    return this.mediaModule.getMediaPlayPath(_param);
  }

  //获取推流地址
  getPublishVideoPath(_param) {
    //loger.log('获取推流地址->');
    if (!this.mcu.connected) {
      loger.warn(GlobalConfig.getCurrentStatus());
      return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
    }
    //监课比较特殊，不占用课堂内的音视频路数，额外创建
    if (GlobalConfig.userRole == ApeConsts.invisible) {
      let result = this.mediaModule.getMediaPublishPathForInVisible(_param);
      this._emit(MessageTypes.VIDEO_GET_PUBLISH_PATH, result);
      return result;
    }

    //非监课的身份，需要判断是否可以继续推流
    //需要判断当前已经使用的流路数
    let openChannel = 0;
    let allChannels = MediaModule.allMediaChannelsList;
    for (let i in allChannels) {
      let channel = allChannels[i];
      if (channel && channel.status == ApeConsts.CHANNEL_STATUS_OPENING &&
        channel.userRole != ApeConsts.invisible&&
        channel.userId!=GlobalConfig.userId) {
        //正在开启的才计数，监课开启的不计算在内
        openChannel++;
      }
    }

    //如果已经开启的数量大于等于最大允许开启的数量，不允许再推流
    if (openChannel >= GlobalConfig.maxMediaChannels) {
      loger.warn('不能再打开设备->当前开启的设备数量->', openChannel);
      return {"code": ApeConsts.RETURN_FAILED, "data": "不能再打开设备,当前开启的设备数量"};
    }

    let result = this.mediaModule.getMediaPublishPath(_param);
    this._emit(MessageTypes.VIDEO_GET_PUBLISH_PATH, result);
    return result;
  }

  //获取当前所有频道信息
  getAllChannelInfo(_param) {
    loger.log('获取当前所有频道信息->');
    return this.mediaModule.getAllMediaChannelInfo();
  }

  //推流
  publishVideo(_param) {
    if (!this.mcu.connected) {
      loger.warn(GlobalConfig.getCurrentStatus());
      this._emit(MessageTypes.VIDEO_PUBLISH_RESULT, {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接!", "mediaId": 0});
      return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
    }

    if (_param == null || _param.publishUrl == null) {
      loger.warn('推流->参数错误', _param);
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      this._emit(MessageTypes.VIDEO_PUBLISH_RESULT, {"code": ApeConsts.RETURN_FAILED, "data": "参数错误!", "mediaId": 0});
      return {"code": ApeConsts.RETURN_FAILED, "data": "参数错误"};
    }

    //获取可选参数,转换为JSON字符串
    try {
      GlobalConfig.optionJsonData = JSON.stringify(_param.optionJsonData)||""
    } catch (err) {
      GlobalConfig.optionJsonData = "";
    }

    //根据推流的地址获取对应的频道信息
    let needPublishChannelInfo = this.mediaModule.getNeedPublishMediaChannel(_param.publishUrl);
    if (needPublishChannelInfo == null) {
      loger.warn('推流->推流数据已经无效', _param);
      this._emit(MessageTypes.VIDEO_PUBLISH_RESULT, {
        "code": ApeConsts.RETURN_FAILED,
        "data": "推流数据已经无效!",
        "mediaId": 0
      });
      return {"code": ApeConsts.RETURN_FAILED, "data": "推流数据已经无效"};
    }

    //如果外部传入了流Id就使用外部的
    if(_param.streamId){
      needPublishChannelInfo.streamId=_param.streamId;
      loger.log("推流信息->使用外部传递的流ID",needPublishChannelInfo);
    }else {
      loger.log("推流信息->使用原始的流ID",needPublishChannelInfo);
    }

    //判断当前是否还有空闲的channle
    let freeChannel = this.mediaModule.getFreeMediaChannel();
    if (freeChannel == 0) {
      loger.warn("推流->不能再打开更多的设备 ");
      this._emit(MessageTypes.VIDEO_PUBLISH_RESULT, {
        "code": ApeConsts.RETURN_FAILED,
        "data": "不能再打开更多的设备!",
        "mediaId": 0
      });
      return {"code": ApeConsts.RETURN_FAILED, "data": "不能再打开更多的设备", "mediaChannels": this.mediaModule.mediaChannels};
    }


    //判断当前的频道是否已经占用
    if (this.mediaModule.checkChannelIsOpening(needPublishChannelInfo.channelId)) {
      if (needPublishChannelInfo.nodeId == GlobalConfig.nodeId) {
        loger.warn(needPublishChannelInfo.channelId, "已经推送过消息，不需要再次推送");
        this._emit(MessageTypes.VIDEO_PUBLISH_RESULT, {
          "code": ApeConsts.RETURN_SUCCESS,
          "data": "已经推送过消息，不需要再次推送!",
          "mediaId": needPublishChannelInfo.channelId
        });
        return {
          "code": ApeConsts.RETURN_SUCCESS,
          "data": "已经推送过消息，不需要再次推送!",
          "mediaId": needPublishChannelInfo.channelId
        };
      } else {
        loger.warn(needPublishChannelInfo.channelId, "频道已经被占用");
        this._emit(MessageTypes.VIDEO_PUBLISH_RESULT, {
          "code": ApeConsts.RETURN_FAILED,
          "data": "频道已经被占用!",
          "mediaId": 0
        });
        return {"code": ApeConsts.RETURN_FAILED, "data": "频道已经被占用!", "mediaChannels": this.mediaModule.mediaChannels};
      }
    }

    //每次推流的时候重置状态
    GlobalConfig.videoEnabled=true;
    GlobalConfig.audioEnabled=true;

    let channelInfo = this.mediaModule.getDefaultChannelInfo();
    channelInfo.owner = GlobalConfig.nodeId;
    channelInfo.status = ApeConsts.CHANNEL_STATUS_OPENING;
    channelInfo.channelId = needPublishChannelInfo.channelId;
    channelInfo.streamId = needPublishChannelInfo.streamId;//按规则拼接的流名称
    channelInfo.m3u8Url=_param.m3u8Url||"";
    channelInfo.rtmpUrl=_param.rtmpUrl||""
    channelInfo.timestamp = needPublishChannelInfo.timestamp;//时间戳
    channelInfo.mediaType = ApeConsts.MEDIA_TYPE_VIDEO;
    this.sendTableUpdateHandler(channelInfo);

    this._emit(MessageTypes.VIDEO_PUBLISH_RESULT, {
      "code": ApeConsts.RETURN_SUCCESS,
      "data": "推流成功!",
      "mediaId": needPublishChannelInfo.channelId
    });
    return {"code": ApeConsts.RETURN_SUCCESS, "data": "推流成功!", "mediaId": needPublishChannelInfo.channelId};
  }

  //停止推流，
  stopPublishVideo(_param) {
    loger.log('停止推流->', _param);
    if (!this.mcu.connected) {
      loger.warn(GlobalConfig.getCurrentStatus());
      return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
    }

    //默认为自己的nodeId，_param如果为空，那么默认就是当前自己的nodeId，否则用_param
    let nodeId = GlobalConfig.nodeId;
    if (_param && parseInt(_param.nodeId) > 0) {
      nodeId = parseInt(_param.nodeId);
    }

    //默认为0,如果releaseChannelId 存在就释放releaseChannelId通道
    let releaseChannelId = 0;
    if (_param && parseInt(_param.mediaId) > 0) {
      releaseChannelId = parseInt(_param.mediaId);
    }

    //释放channelId 的占用
    if (releaseChannelId > 0) {
      //第一种情况，释放nodeId占用的指定mediaId (channelId)
      this._releaseChannelForNodeId(nodeId, releaseChannelId);
    } else {
      //第二种情况，释放nodeId占用的所有channelId
      this._releaseNodeIdAllChannel(nodeId);
    }
  }
  //推流状态发生改变
  mediaPublishStatusChange(_data){
    //loger.log("推流状态发生改变->",_data);
    this.sendVideoBroadcastMsg({
      "actionType": ApeConsts.MEDIA_ACTION_PUBLISH_STATUS,
      "toNodeId": 0,
      "data":_data|| ""
    });

   /* //如果是老师或主讲人助教，推流需要同步
    if(GlobalConfig.isTeachOrAssistant){
      _data.nodeId=GlobalConfig.nodeId;
      if(_data.status==1){
        this.publishVideo(_data);
      }else if(_data.status==0){
        _data.nodeId=GlobalConfig.nodeId;
        this.stopPublishVideo(_data)
      }
    }*/

    //推流需要同步
      _data.nodeId=GlobalConfig.nodeId;
      if(_data.status==1){
        this.publishVideo(_data);
      }else if(_data.status==0){
        _data.nodeId=GlobalConfig.nodeId;
        this.stopPublishVideo(_data)
      }
  }
  //-----------------------屏幕共享-----------------------

  //屏幕共享连接打开
  onPublishScreenShareFaile() {
    loger.log('屏幕共享推流失败->');
    this._emit(MessageTypes.PUBLISH_SCREEN_SHARE_FAILE);
  }

  //屏幕共享连接关闭
  onPublishScreenShareClose() {
    loger.log('屏幕共享推流关闭->');
    this._emit(MessageTypes.PUBLISH_SCREEN_SHARE_CLOSE);
  }

  //屏幕共享连接失败
  onPublishScreenShareDisconnect() {
    loger.log('屏幕共享服务器连接失败->');
    this._emit(MessageTypes.PUBLISH_SCREEN_SHARE_DISCONNECT);
  }

  //屏幕共享连接失败
  onPublishScreenShareConnected() {
    loger.log('屏幕共享服务器连接成功->');
    this._emit(MessageTypes.PUBLISH_SCREEN_SHARE_CONNECTED);
  }

  onPublishScreenMovieInfoChange(data) {
    loger.log('屏幕共享MOVIE信息发生改变->');
    this._emit(MessageTypes.PUBLISH_SCREEN_MOVIE_INFO_CHANGE, data);
  }

  onPublishScreenVideoInfoChange(data) {
    loger.log('屏幕共享视频信息发生改变->');
    this._emit(MessageTypes.PUBLISH_SCREEN_VIDEO_INFO_CHANGE, data);
  }

  //监听屏幕共享发布成功
  onPublishScreenShareSuccess(data) {
    loger.log('屏幕共享推流成功之后才能更新同步消息->',data);
    //屏幕共享推流成功之后才能更新同步消息
    let channelInfo = this.shareApe.getPublishChannelInfo();
    this.sendTableUpdateHandler(channelInfo);
    this._emit(MessageTypes.PUBLISH_SCREEN_SHARE_SUCCESS, {
      "code": ApeConsts.RETURN_SUCCESS,
      "data": "桌面共享推流!",
      "mediaId": channelInfo.channelId
    });
    return {"code": ApeConsts.RETURN_SUCCESS, "data": "桌面共享推流!", "mediaId": channelInfo.channelId};
  }

  //桌面共享推流
  publishScreenShare(_param) {
    if (!this.mcu.connected) {
      loger.warn(GlobalConfig.getCurrentStatus());
      this._emit(MessageTypes.VIDEO_PUBLISH_RESULT, {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接!", "mediaId": 0});
      return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
    }
    let publishType = 'flash';
    if (_param && _param.type == 'live') {
      publishType = 'live';
    }
    //老师能开启屏幕共享
    if (GlobalConfig.isHost||GlobalConfig.isAssistant||GlobalConfig.isPresenter) {
      //获取屏幕共享推流的地址
      let shareResult = this.mediaModule.getMediaPublishPathForScreenShare(this.shareApe.channelId, publishType);
      shareResult.ip = _param.ip || "";//外部可以设置屏幕共享的IP
      shareResult.port = _param.port || "";//外部可以设置屏幕共享的端口
      this.shareApe.publish(shareResult);
    }
  }

  //停止桌面共享推流
  stopPublishScreenShare(_param) {
    loger.log('停止桌面共享推流->', _param);
    if (!this.mcu.connected) {
      loger.warn(GlobalConfig.getCurrentStatus());
      return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
    }
    //只有老师能停止屏幕共享
    if (GlobalConfig.isHost||GlobalConfig.isAssistant||GlobalConfig.isPresenter) {
      let channelInfo = this.shareApe.getDefaultChannelInfo();
      channelInfo.status = ApeConsts.CHANNEL_STATUS_RELEASED;
      this.sendTableUpdateHandler(channelInfo);
      this.shareApe.stopPublish();
    }
  }

  //-----------------------屏幕共享 end-----------------------

  //-----------------------推送和停止外部流地址----------------
  //推送外部流地址
  publishExternalLink(_param) {
    loger.log('推送外部流地址->',_param);
    //屏幕共享推流成功之后才能更新同步消息
    let channelInfo = this.shareApe.getPublishChannelInfo();
    channelInfo.mediaType = ApeConsts.MEDIA_TYPE_EXTERNAL_LINK;//外部推流地址
    //如果
    if(_param){
      channelInfo.publishUrl=_param.rtmpUrl||"";//推流拉流地址一样
      channelInfo.m3u8Url=_param.m3u8Url||"";
      channelInfo.rtmpUrl=_param.rtmpUrl||"";
      channelInfo.replay=_param.replay||"";
    }
    this.sendTableUpdateHandler(channelInfo);
  }

  //停止推送外部流地址
  stopPublishExternalLink(_param) {
    loger.log('停止推送外部流地址->', _param);
    if (!this.mcu.connected) {
      loger.warn(GlobalConfig.getCurrentStatus());
      return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
    }
    //只有老师能停止屏幕共享
    if (GlobalConfig.isHost||GlobalConfig.isAssistant||GlobalConfig.isPresenter) {
      let channelInfo = this.shareApe.getDefaultChannelInfo();
      channelInfo.status = ApeConsts.CHANNEL_STATUS_RELEASED;
      channelInfo.mediaType=ApeConsts.MEDIA_TYPE_EXTERNAL_LINK;
      this.sendTableUpdateHandler(channelInfo);
      //调用停止的时候自己的也要停止，同步的消息不会再发给自己
      this._emit(MessageTypes.SCREEN_SHARE_STOP, channelInfo);
    }
  }

  //-----------------------推送和停止外部流地址END-------------
  //释放nodeId占用的指定的channelId频道
  _releaseChannelForNodeId(nodeId, channelId) {
    loger.log(nodeId, "停止-->channelId", channelId);
    let channelInfo = this.mediaModule.mediaChannels[channelId];
    if (channelInfo && channelInfo.status == ApeConsts.CHANNEL_STATUS_OPENING) {
      if (channelInfo.fromNodeId == nodeId) {

        let channelInfo = this.mediaModule.getDefaultChannelInfo();
        channelInfo.status = ApeConsts.CHANNEL_STATUS_RELEASED;
        channelInfo.channelId = channelId;

        this.sendTableUpdateHandler(channelInfo);
      } else {
        loger.warn(channelId, "不属于nodeId", nodeId, "不能释放", channelInfo);
      }
    } else {
      loger.warn(nodeId, "要释放的channel不存在或者已经释放-->channelId", channelInfo);
    }
  }

  //释放nodeId占用的所有频道
  _releaseNodeIdAllChannel(nodeId) {
    if (!this.mcu.connected) {
      clearTimeout(this.releaseTimeId);
      loger.warn(GlobalConfig.getCurrentStatus());
      return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
    }
    clearTimeout(this.releaseTimeId);
    if(GlobalConfig.classType==ApeConsts.CLASS_TYPE_ZHIBO&&GlobalConfig.isH5){
      //直播时H5不处理
      return;
    }

    loger.log("释放nodeId占用的所有频道->", nodeId);
    let openingChannelInfo = this.mediaModule.getOpeningMediaChannelForNodeId(nodeId);
    if (openingChannelInfo.channelId == 0) {
      loger.warn(nodeId, "没有占用channel不需要处理");
      return {"code": ApeConsts.RETURN_FAILED, "data": "没有占用channel不需要处理"};
    }

    let channelInfo = this.mediaModule.getDefaultChannelInfo();
    channelInfo.status = ApeConsts.CHANNEL_STATUS_RELEASED;
    channelInfo.channelId = openingChannelInfo.channelId;
    channelInfo.nodeId = openingChannelInfo.fromNodeId;//发送消息的人员nodeId
    channelInfo.userRole = openingChannelInfo.userRole;
    channelInfo.userName = openingChannelInfo.userName;
    channelInfo.userId = openingChannelInfo.userId;

    this.sendTableUpdateHandler(channelInfo);
    //递归检查,800毫秒之后执行
    this.releaseTimeId = setTimeout(function () {
      loger.warn(nodeId, "检查频道是否占用");
      this._releaseNodeIdAllChannel(nodeId);
    }.bind(this), 800);
  }

  sendVideoBroadcastMsg(_param) {
    if (!this.mcu.connected) {
      loger.warn(GlobalConfig.getCurrentStatus());
      return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
    }
    if (this._classInfo ==null||EngineUtils.isEmptyObject(this._classInfo)){
      //还未加入频道成功，暂时不能发送消息
      return;
    }
  /*  if (this._classInfo ===null || EngineUtils.isEmptyObject(this._classInfo)) {
      loger.log('不能发送Video消息.McuClient还未初始化数据!');
      if (GlobalConfig.getCurrentStatus().code == 0 || GlobalConfig.getCurrentStatus().code == 1) {
        this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_SEND_FAILED_NO_JOIN);
        return {"code": 1, "data": "不能发送Video消息.McuClient还未初始化数据"};
      }
      return {"code": ApeConsts.RETURN_FAILED, "data": "不能发送Video消息.McuClient还未初始化数据"};
    }*/
    if (_param == null) {
      loger.warn('sendVideoCommandMsg失败,参数错误', _param);
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return {"code": ApeConsts.RETURN_FAILED, "data": "sendVideoCommandMsg失败,参数错误"};
    }
    // to, message
    loger.log('视频模块广播消息.', _param);
    //如果是控制开启摄像头推流，需要判断是否还有空闲频道
    if (_param.actionType != null && _param.actionType == ApeConsts.MEDIA_ACTION_OPEN_CAMERA) {
      //判断当前开启的视频数量是否已经是最大值,如果已经是最大值，不能再开启
      let freeChannel = this.mediaModule.getFreeMediaChannel();
      if (freeChannel == 0) {
        loger.warn('视频模块广播消息->不能再打开更多的设备', _param);
        return {"code": ApeConsts.RETURN_FAILED, "data": "不能再打开更多的设备", "mediaChannels": this.mediaModule.mediaChannels};
      }
    }

    let videoSendPdu = new pdu['RCVideoSendDataRequestPdu'];
    videoSendPdu.type = pdu.RCPDU_SEND_VIDEO_DATA_REQUEST;
    videoSendPdu.isPublic = true;

    videoSendPdu.fromNodeId = GlobalConfig.nodeId;//发起人
    videoSendPdu.toNodeId = parseInt(_param.toNodeId) || 0;//接收者，0就是所有人
    videoSendPdu.actionType = parseInt(_param.actionType) || ApeConsts.MEDIA_ACTION_DEFAULT;

    let dataStr = '';
    try {
      dataStr = JSON.stringify(_param.data);
    } catch (err) {
      loger.warn('控制消息->JSON转换失败');
      dataStr = _param.data;
    }
    videoSendPdu.data = this._rCArrayBufferUtil.strToUint8Array("h5" + dataStr);//开头两个字会乱码

    if (!videoSendPdu.isPublic && 0 != videoSendPdu.toNodeId) {
      //发送给制定的人
      this.send(videoSendPdu);
    } else {
      //发送给所有人
      this.sendChatUniform(videoSendPdu);
    }
    return {"code": ApeConsts.RETURN_SUCCESS, "data": ""};
  }

  //发送到mcu同步（更新数据）
  sendTableUpdateHandler(_channelInfo) {
    //loger.log("video===sendTableUpdateHandler ");
    if(GlobalConfig.classExit||this.isLeave){
      //已经离开课堂就不再做处理
      return;
    }
    if(GlobalConfig.classType==ApeConsts.CLASS_TYPE_ZHIBO&&GlobalConfig.isH5){
      //直播时H5不做处理
      return;
    }
    let updateModelPdu = this.packPdu(_channelInfo, _channelInfo.channelId);//let updateModelPdu=this.packPdu({},ApeConsts.VIDEO_OBJ_TABLE_ID+2);

    if (updateModelPdu == null) {
      loger.warn("sendTableUpdateHandler error,updateModelPdu=null");
      return;
    }

    let tableItemPdu = new pdu['RCRegistryTableItemPdu'];
    tableItemPdu.itemIdx = _channelInfo.channelId;//tableItemPdu.itemIdx=ApeConsts.VIDEO_OBJ_TABLE_ID+2;
    tableItemPdu.owner = _channelInfo.owner;//0收到flash的是这个值，MCU做了了用户掉线处理，30秒之后会清理owner为0
    tableItemPdu.itemData = updateModelPdu.toArrayBuffer();

    //insert
    let tableInsertItemPdu = new pdu['RCRegistryTableUpdateItemPdu'];
    tableInsertItemPdu.type = pdu.RCPDU_REG_TABLE_UPDATE_PDU;//
    tableInsertItemPdu.items.push(tableItemPdu);

    let updateObjPdu = new pdu['RCRegistryUpdateObjPdu'];
    updateObjPdu.objId = ApeConsts.VIDEO_OBJ_TABLE_ID;//
    updateObjPdu.subType = tableInsertItemPdu.type;
    updateObjPdu.userData = tableInsertItemPdu.toArrayBuffer();

    //同步
    let adapterItemPdu = new pdu['RCAdapterItemPdu'];
    adapterItemPdu.type = pdu.RCPDU_REG_UPDATE_OBJ;
    adapterItemPdu.itemData = updateObjPdu.toArrayBuffer();

    let adapterPdu = new pdu['RCAdapterPdu'];
    adapterPdu.type = pdu.RCPDU_REG_ADAPTER;
    adapterPdu.item.push(adapterItemPdu);

    loger.log("发送消息MCU更新VIDEO模块->channel:" + tableItemPdu.itemIdx);
    this.sendUniform(adapterPdu, true);
  }

  /////收到消息处理//////////////////////////////////////////////////
  // 视频消息处理,内部处理，不需要告诉应用层
  receiveVideoCommandHandler(_data,seek) {
    let videoReceivePdu = pdu['RCVideoSendDataRequestPdu'].decode(_data);
    if (videoReceivePdu == null) {
      loger.warn("视频控制消息处理,收到的消息为null,不做处理");
      return;
    }
    videoReceivePdu.data = this._rCArrayBufferUtil.uint8ArrayToStr(videoReceivePdu.data, 2);//开头两个字会乱码

    let dataObj = {};
    try {
      dataObj = JSON.parse(videoReceivePdu.data);
    } catch (err) {
      loger.warn('控制消息->JSON转换失败');
      dataObj = videoReceivePdu.data;
    }
    videoReceivePdu.data = dataObj;
    //录制回放和H5需要处理
    if(GlobalConfig.isRecordPlayBack){
      //录制回放的处理
     console.log("录制回放的处理视频模块控制消息->",videoReceivePdu);
      if (videoReceivePdu.toNodeId!=0){
        //只处理发送给所有人的消息，发给指定人的消息不处理
        return;
      }
      let data=videoReceivePdu.data;
      if(!data) return;
     /* "data": {
        "appId": "eb253cc7b40c4a8b82f0a5b6f93c2ce0",
          "channel": "markettest_1880101695",
          "channelKey": "",
          "uid": 886346081,
          "status": 1,
          "userId": "user_338621",
          "userName": "user_338621",
          "userRole": "normal",
          "timestamp": 1505886364100,
          "recordTimestamp": 27
      }*/
     switch (videoReceivePdu.actionType){
        case ApeConsts.MEDIA_ACTION_PUBLISH_STATUS:
          //webRtc的推流和停止推流的消息
          let videoInfo={};
          let videoData=data;
          if(data.status==1){
            loger.log("播放文件->", videoData);
            videoInfo=this.packVideoInfoAndSendToClient(videoData,seek);
            this._emit(MessageTypes.VIDEO_PLAY, videoInfo);
          }else if(data.status==0){
           // loger.log("停止播放文件->", videoData);
           // videoInfo=this.packVideoInfoAndSendToClient(videoData,seek);
           // this._emit(MessageTypes.VIDEO_STOP, videoInfo);
          }
          break;
        default:
          break
      }

    }else {
      //判断接收者的id,如果不是0，并且也不是自己的nodeId，那么消息不做处理
      if (videoReceivePdu.toNodeId != 0 && videoReceivePdu.toNodeId != GlobalConfig.nodeId) {
        loger.log('视频消息不处理->接收人ID:'+videoReceivePdu.toNodeId, "自己的ID:"+GlobalConfig.nodeId);
      } else {
        loger.log('视频控制消息处理 .', videoReceivePdu);
        this._emit(MessageTypes.VIDEO_BROADCAST, videoReceivePdu);
        let data=videoReceivePdu.data;
        if(data){
          switch (videoReceivePdu.actionType){
            case ApeConsts.MEDIA_ACTION_PUBLISH_STATUS:
              //webRtc的推流和停止推流的消息
              let videoInfo={};
              let videoData=data;
            /*  videoData.streamId=data.channel+"_"+data.userId+"_"+data.uid+"_"+(parseInt(parseInt(data.timestamp)/1000));
              if(data.status==1){
                loger.log("播放文件->", "userName",data.userName,"uid",data.uid,"时间:"+new Date(1505886364100).toString());
                videoInfo=this.packVideoInfoAndSendToClient(videoData,seek);
                this._emit(MessageTypes.VIDEO_PLAY, videoInfo);
              }else if(data.status==0){
                loger.log("停止播放文件->", "userName",data.userName,"uid",data.uid,"时间:"+new Date(1505886364100).toString());
                videoInfo=this.packVideoInfoAndSendToClient(videoData,seek);
                this._emit(MessageTypes.VIDEO_STOP, videoInfo);
              }*/
            /*  if(data.status==1){
                this.publishVideo(data);
              }else if(data.status==0){
                data.nodeId=videoReceivePdu.toNodeId;
                this.stopPublishVideo(data)
              }*/
              break;
            default:
              break
          }
        }
      }
    }

  }
  //切换了MS，重新更新一下当前正在播放的流地址
  changeMediaMs(){

  }
  tableUpdateHandler(owner, itemIdx, itemData, seek) {
    let unpackChannelInfo = this.unPackPdu(owner, itemIdx, itemData);
    loger.log("视频模块数据更新->channel:"+itemIdx+'  mediaType:'+unpackChannelInfo.mediaType+'  status->'+unpackChannelInfo.status+"  seek->", seek);
    //****很重要********
    //如果owner的值为0，代表的是这个歌频道已经被释放了(mcu服务端对于占用channel的掉线用户，就是把owner设置为0)
    if (owner == 0) {
      loger.log("MCU返回值owner=0->释放占用的频道,channel:"+itemIdx);
      unpackChannelInfo.status = ApeConsts.CHANNEL_STATUS_RELEASED;
      unpackChannelInfo.streamId = "";
    }
    //屏幕共享的流不保存
    if (unpackChannelInfo.mediaType != ApeConsts.MEDIA_TYPE_SHARE &&
      unpackChannelInfo.mediaType != ApeConsts.MEDIA_TYPE_EXTERNAL_LINK &&
      unpackChannelInfo.channelId > 0) {
      this.mediaModule.mediaChannels[itemIdx] = unpackChannelInfo;
    }

    //数据存在并且不是自己发送的消息,或者是外部设置的播放地址
    if (unpackChannelInfo && (unpackChannelInfo.fromNodeId != GlobalConfig.nodeId||unpackChannelInfo.mediaType== ApeConsts.MEDIA_TYPE_EXTERNAL_LINK)) {
      let receiveChannelInfo = {};
      receiveChannelInfo.mediaId = unpackChannelInfo.channelId;
      receiveChannelInfo.fromNodeId = unpackChannelInfo.fromNodeId;
      receiveChannelInfo.userName = unpackChannelInfo.userName || "";
      receiveChannelInfo.userRole = unpackChannelInfo.userRole || ApeConsts.normal;
      receiveChannelInfo.mediaType = unpackChannelInfo.mediaType || ApeConsts.MEDIA_TYPE_DEFAULT;
      receiveChannelInfo.screenWidth = unpackChannelInfo.screenWidth || GlobalConfig.screenWidth;
      receiveChannelInfo.screenHeight = unpackChannelInfo.screenHeight || GlobalConfig.screenHeight;
      receiveChannelInfo.deviceType = unpackChannelInfo.deviceType || GlobalConfig.devicePC;
      receiveChannelInfo.optionJsonData = unpackChannelInfo.optionJsonData || "";
      //消息不是自己同步的，需要处理
      if (unpackChannelInfo.status == ApeConsts.CHANNEL_STATUS_OPENING) {
        //正在推流
        receiveChannelInfo.m3u8Url = "";
        receiveChannelInfo.rtmpUrl = "";
        receiveChannelInfo.replay = "";

        receiveChannelInfo.seek = seek || 0;//这个是录制回放时使用的seek

        let m3u8Stream = this.mediaModule.getMediaPlayPath({"type": "m3u8", "streamId": unpackChannelInfo.streamId});
        let rtmpStream = this.mediaModule.getMediaPlayPath({"type": "rtmp", "streamId": unpackChannelInfo.streamId});
        let replay = this.mediaModule.getMediaRecordPlaybackPath({
          "type": "m3u8",
          "streamId": unpackChannelInfo.streamId
        });

        //如果接收的消息中已经有拉流地址，优先使用
        if(unpackChannelInfo.m3u8Url){
          m3u8Stream.playUrl=unpackChannelInfo.m3u8Url;
        }
        if(unpackChannelInfo.rtmpUrl){
          rtmpStream.playUrl=unpackChannelInfo.rtmpUrl;
        }
        if(unpackChannelInfo.replay){
          replay.playUrl=unpackChannelInfo.replay;
        }


        if (m3u8Stream.code == 0) {
          receiveChannelInfo.m3u8Url = m3u8Stream.playUrl;
        }
        if (rtmpStream.code == 0) {
          receiveChannelInfo.rtmpUrl = rtmpStream.playUrl;
        }
        if (replay.code == 0) {
          receiveChannelInfo.replay = replay.playUrl;
          receiveChannelInfo.seek=parseInt(parseInt(receiveChannelInfo.seek)+parseInt(replay.seek));
        }

        if (unpackChannelInfo.mediaType != ApeConsts.MEDIA_TYPE_SHARE&&
          unpackChannelInfo.mediaType != ApeConsts.MEDIA_TYPE_EXTERNAL_LINK
        ) {
          //广播播放视频的消息
          loger.log("VIDEO_PLAY", receiveChannelInfo);
          this._emit(MessageTypes.VIDEO_PLAY, receiveChannelInfo);
        } else {
          //播放屏幕共享
          loger.log("SCREEN_SHARE_PLAY", receiveChannelInfo);
          this._emit(MessageTypes.SCREEN_SHARE_PLAY, receiveChannelInfo);

        }
      } else {
        if (unpackChannelInfo.mediaType != ApeConsts.MEDIA_TYPE_SHARE&&
           unpackChannelInfo.mediaType != ApeConsts.MEDIA_TYPE_EXTERNAL_LINK
        ) {
          //停止播放视频
          loger.log("VIDEO_STOP", receiveChannelInfo);
          this._emit(MessageTypes.VIDEO_STOP, receiveChannelInfo);
        } else {
          //停止播放屏幕共享
          if (unpackChannelInfo.channelId != 0) {
            loger.log("SCREEN_SHARE_STOP", receiveChannelInfo);
            this._emit(MessageTypes.SCREEN_SHARE_STOP, receiveChannelInfo);
          } else {
            loger.log("停止播放视频->channelId=0->不合法的id", receiveChannelInfo);
          }
        }

      }
    } else {
      loger.warn("视频消息是自己发送的或者是视频消息无效，不需要处理，消息内容如下：");
      loger.log(unpackChannelInfo);
      if (unpackChannelInfo.status == ApeConsts.CHANNEL_STATUS_OPENING) {
        GlobalConfig.openCamera = EngineUtils.creatTimestamp();
        GlobalConfig.openMicrophones = GlobalConfig.openCamera;
        //GlobalConfig.videoEnabled=true;
        //GlobalConfig.audioEnabled=true;
      } else {
        GlobalConfig.openCamera = 0;
        GlobalConfig.openMicrophones = 0;
        GlobalConfig.videoEnabled=true;
        GlobalConfig.audioEnabled=true;
      }

      //更新用户的摄像头和麦克风状态
      if (unpackChannelInfo.mediaType != ApeConsts.MEDIA_TYPE_SHARE&&
        unpackChannelInfo.mediaType != ApeConsts.MEDIA_TYPE_EXTERNAL_LINK
      ) {
        //非屏幕共享的情况下才更新状态
        this._emit(MessageTypes.USER_DEVICE_STATUS_CHAANGE, {
          nodeId: GlobalConfig.nodeId,
          userRole: GlobalConfig.userRole,
          userName: GlobalConfig.userName,
          userId: GlobalConfig.userId,
          openCamera: GlobalConfig.openCamera,
          openMicrophones: GlobalConfig.openMicrophones
        });
      }
    }
    if (unpackChannelInfo.mediaType != ApeConsts.MEDIA_TYPE_SHARE&&
       unpackChannelInfo.mediaType != ApeConsts.MEDIA_TYPE_EXTERNAL_LINK
    ) {
      //非屏幕共享情况的处理
      MediaModule.allMediaChannelsList[itemIdx] = unpackChannelInfo;
      //console.log('MediaModule.allMediaChannelsList', MediaModule.allMediaChannelsList);
      this._emit(MessageTypes.VIDEO_UPDATE, unpackChannelInfo);
    }

  }

  /*
  * 组织视频数据发送给客户端
  * */
  packVideoInfoAndSendToClient(_param,seek){
    let mediaChannelInfo = {};
    mediaChannelInfo.mediaId = _param.channelId;
    mediaChannelInfo.fromNodeId = _param.fromNodeId||_param.nodeId||_param.uid;
    mediaChannelInfo.userName = _param.userName || "";
    mediaChannelInfo.userRole = _param.userRole || ApeConsts.normal;
    mediaChannelInfo.mediaType = _param.mediaType || ApeConsts.MEDIA_TYPE_DEFAULT;
    mediaChannelInfo.screenWidth = _param.screenWidth || GlobalConfig.screenWidth;
    mediaChannelInfo.screenHeight = _param.screenHeight || GlobalConfig.screenHeight;
    mediaChannelInfo.deviceType = _param.deviceType || GlobalConfig.devicePC;
    mediaChannelInfo.optionJsonData = _param.optionJsonData || "";
    mediaChannelInfo.m3u8Url = "";
    mediaChannelInfo.rtmpUrl = "";
    mediaChannelInfo.replay = "";
    mediaChannelInfo.seek = seek || 0;//这个是录制回放时使用的seek
    //消息不是自己同步的，需要处理
    if (_param.status == ApeConsts.CHANNEL_STATUS_OPENING) {
      let m3u8Stream = this.mediaModule.getMediaPlayPath({"type": "m3u8", "streamId": _param.streamId});
      let rtmpStream = this.mediaModule.getMediaPlayPath({"type": "rtmp", "streamId": _param.streamId});
      let replay = this.mediaModule.getMediaRecordPlaybackPath({
        "type": "m3u8",
        "streamId": _param.streamId
      });
      if (m3u8Stream.code == 0) {
        mediaChannelInfo.m3u8Url = m3u8Stream.playUrl;
      }
      if (rtmpStream.code == 0) {
        mediaChannelInfo.rtmpUrl = rtmpStream.playUrl;
      }
      if (replay.code == 0) {
        mediaChannelInfo.replay = replay.playUrl;
      }
    }
    return mediaChannelInfo;
  }

  //更新媒体文件模块的录制信息，每次开启录制的时候需要把当前媒体文件的信息更新一次
  updaterRecordApeStatus(_param) {
    loger.warn("录制状态发送改变->更新当前的状态->", this.mediaModule.mediaChannels);
    for (let i in this.mediaModule.mediaChannels) {
      let channelInfo = this.mediaModule.mediaChannels[i];
      if (channelInfo) {
        channelInfo.nodeId = channelInfo.fromNodeId;//发送消息的人员nodeId
        if (channelInfo.status == ApeConsts.CHANNEL_STATUS_RELEASED) {
          channelInfo.owner = 0;
        } else {
          channelInfo.owner = channelInfo.fromNodeId;
        }
        //owner为0就是没有使用
        if(channelInfo.owner==0){
          channelInfo.status = ApeConsts.CHANNEL_STATUS_RELEASED
        }
        this.sendTableUpdateHandler(channelInfo);
      }
    }
  }

  //清除当前模块的数据
  clearData() {
    loger.log("clearData->");
    MediaModule.allMediaChannelsList = {};
  }

  ///////数据的封包和解包/////////////////////////////////////////
  packPdu(_param, _itemIdx) {
    //验证坐标点集合数组是否合法
    if (_param == null || _itemIdx == null) {
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return null;
    }

    //判断type类型，根据type设置不同的参数
    let packPduModel = new pdu['RCVideoChannelInfoPdu'];
    packPduModel.status = _param.status || ApeConsts.CHANNEL_STATUS_RELEASED;
    packPduModel.channelId = _itemIdx;
    packPduModel.streamId = _param.streamId || "";
    packPduModel.m3u8Url=_param.m3u8Url || "";
    packPduModel.rtmpUrl=_param.rtmpUrl || "";
    packPduModel.replay=_param.replay || "";

    packPduModel.siteId = _param.siteId || GlobalConfig.siteId;//GlobalConfig.siteId;
    packPduModel.classId = parseInt(_param.classId) || parseInt(GlobalConfig.classId);
    packPduModel.userId = _param.userId || "0";
    packPduModel.mediaType = _param.mediaType || ApeConsts.MEDIA_TYPE_VIDEO;
    packPduModel.timestamp = _param.timestamp || 0;
    packPduModel.fromNodeId = _param.nodeId||_param.fromNodeId || GlobalConfig.nodeId;
    packPduModel.userName = _param.userName || GlobalConfig.userName;
    packPduModel.toNodeId = 0;
    packPduModel.userRole = _param.userRole || GlobalConfig.userRole;
    packPduModel.screenWidth = _param.screenWidth || GlobalConfig.screenWidth;
    packPduModel.screenHeight = _param.screenHeight || GlobalConfig.screenHeight;
    packPduModel.deviceType = _param.deviceType || GlobalConfig.deviceType;
    packPduModel.optionJsonData = GlobalConfig.optionJsonData;
    packPduModel.sendTimestamp =parseInt(EngineUtils.creatTimestamp()- GlobalConfig.serverAndLoacTimeDistanc);//当前时间减去服务器时间差
    loger.log('packPdu--------------->', packPduModel);
    return packPduModel;
  }

  unPackPdu(owner, itemIdx, itemData) {
    loger.log("unPackPdu-------------->owner:", owner, "itemIdx->", itemIdx);
    if (owner == null || itemIdx == null || itemData == null) {
      this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
      return null;
    }
    try {
      let videoChannelInfo = pdu['RCVideoChannelInfoPdu'].decode(itemData);
      loger.log(videoChannelInfo);
      return videoChannelInfo;
    } catch (err) {
      loger.log("unPackPdu error，itemIdx=" + itemIdx + "  err:" + err.message);
    }
    return null;
  }
  stopApe(){
    this.isLeave=true;
  }
}

export default VideoApe;