// //////////////////////////////////////////////////////////////////////////////
//
//  媒体共享模块
// //////////////////////////////////////////////////////////////////////////////

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

let loger = Loger.getLoger('MediaSharedApe');

class MediaSharedApe extends Ape {
    constructor() {
        super(
            ApeConsts.MEDIA_SESSION_ID,
            ApeConsts.MEDIA_SESSION_NAME,
            ApeConsts.MEDIA_SESSION_TAG
        );
        
        this.mediaSharedList = {};//记录媒体数据
        // Ape Models
        this.registerKey(this._session_id, this._session_name, this._session_tag, new ArrayBuffer);
        this.registerObj(pdu.RCPDU_REG_REGISTER_TABLE, ApeConsts.MEDIA_OBJ_TABLE_ID, ApeConsts.MEDIA_OBJ_TABLE_NAME, ApeConsts.MEDIA_OBJ_TABLE_TAG, 0, new ArrayBuffer);
   }

    /////////////发送数据操作//////////////////////////////////////////////////////
    //上传媒体文件
    mediaSharedUpload(paramInfo) {
        if (paramInfo == null || EngineUtils.isEmptyObject(paramInfo)) {
            loger.warn('上传媒体文件->失败->参数错误->',paramInfo);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return;
        }
        //判断媒体文件是否已经存在，每个媒体文件都有唯一的fileId,如果已经同步的媒体文件中存在相同的fileId就不需要再同步
        if (this.checkMediaSharedId(paramInfo.fileId)) {
            //媒体文件已经存在相同的fileId，不需要同步上传
            loger.warn('上传媒体文件->失败->媒体文件档的fileId无效或已经存在相同的fileId不需要上传');
            return;
        }

        let itemIdx = EngineUtils.creatSoleNumberFromTimestamp();//
        let pduDataModel = this.packPdu(paramInfo, itemIdx);
        if (pduDataModel == null) {
            loger.log('上传媒体文件->失败->数据无效');
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return;
        }

        let tableItemPdu = new pdu['RCRegistryTableItemPdu'];
        tableItemPdu.itemIdx = itemIdx;//直接用时间戳作为id
        tableItemPdu.registerObjId = ApeConsts.MEDIA_OBJ_TABLE_ID;
        tableItemPdu.owner = 0;//收到flash的是这个值，不清楚先写固定
        tableItemPdu.itemData = pduDataModel.toArrayBuffer();

        //insert
        let tableInsertItemPdu = new pdu['RCRegistryTableInsertItemPdu'];
        //optional RCPduType_E type = 1 [default = RCPDU_REG_TABLE_UPDATE_PDU];
        //repeated RCRegistryTableItemPdu items = 2;
        tableInsertItemPdu.type = pdu.RCPDU_REG_TABLE_INSERT_PDU;//
        tableInsertItemPdu.items.push(tableItemPdu);

        let updateObjPdu = new pdu['RCRegistryUpdateObjPdu'];
        updateObjPdu.objId = ApeConsts.MEDIA_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("上传媒体文件->发送->itemIdx=" + tableItemPdu.itemIdx);
        this.sendUniform(adapterPdu, true);
    }


    //删除媒体文件
    mediaSharedDelete(paramInfo) {
        let tableDeleteItemPdu = new pdu['RCRegistryTableDeleteItemPdu'];
        tableDeleteItemPdu.type = pdu.RCPDU_REG_TABLE_DELETE_PDU;//
        tableDeleteItemPdu.itemIdx = parseInt(paramInfo.itemIdx);//这里需要设置要删除的数据的itemIdx，每条数据的这个id都不一样

        let updateObjPdu = new pdu['RCRegistryUpdateObjPdu'];
        updateObjPdu.objId = ApeConsts.MEDIA_OBJ_TABLE_ID;
        updateObjPdu.subType = tableDeleteItemPdu.type;
        updateObjPdu.userData = tableDeleteItemPdu.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("媒体文件发送删除数据=============>" + tableDeleteItemPdu.itemIdx);
        this.sendUniform(adapterPdu, true);
    }

    //更新
    updaterMediaShared(_pduDataModel, _itemIdx) {
        //验证坐标点集合数组是否合法
        if (_pduDataModel == null || _itemIdx == null) {
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return null;
        }
        loger.log("媒体文件->updaterMediaShared ", _pduDataModel);

        let pduDataModel = this.packPdu(_pduDataModel, _itemIdx);
        let tableItemPdu = new pdu['RCRegistryTableItemPdu'];
        tableItemPdu.itemIdx = _itemIdx;//直接用时间戳作为id
        tableItemPdu.owner = 0;//收到flash的是这个值，不清楚先写固定
        tableItemPdu.itemData = pduDataModel.toArrayBuffer();

        //insert
        let tableInsertItemPdu = new pdu['RCRegistryTableUpdateItemPdu'];
        //optional RCPduType_E type = 1 [default = RCPDU_REG_TABLE_UPDATE_PDU];
        //repeated RCRegistryTableItemPdu items = 2;
        tableInsertItemPdu.type = pdu.RCPDU_REG_TABLE_UPDATE_PDU;//
        tableInsertItemPdu.items.push(tableItemPdu);

        let updateObjPdu = new pdu['RCRegistryUpdateObjPdu'];
        updateObjPdu.objId = ApeConsts.MEDIA_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("发送更新媒体文件.itemIdx=" + tableItemPdu.itemIdx);
        this.sendUniform(adapterPdu, true);
    }
    
    //组织完整的媒体文件信息，包含上传时的信息和转换后的完整地址信息
    _mediaSharedPackFullInfo(_itemDataInfo){
        let itemDataInfo=_itemDataInfo;
        if(!itemDataInfo.seek){
            itemDataInfo.seek=1;
        }
        loger.log('mediaPackFullInfo->', itemDataInfo);
        return itemDataInfo;
    }
    //更新媒体文件模块的录制信息，每次开启录制的时候需要把当前媒体文件的信息更新一次
    updaterRecordApeStatus(_param){
        loger.warn("录制状态发送改变->更新当前的媒体文件数据->fileId:", GlobalConfig.activeMediaId, 'page:',GlobalConfig.activeMediaSeek);
        this.mediaSharedSeek({
            "itemIdx": GlobalConfig.activeMediaId,
            "seek":GlobalConfig.activeMediaSeek
        });
    }
    //清除当前媒体文件模块的数据
    clearData(){
        loger.log("clearData->")
        this.mediaSharedList={};
        GlobalConfig.activeMediaId=0;
        GlobalConfig.activeMediaSeek=1;

    }
    //更新媒体文件（播放，暂停，停止，seek）
    mediaSharedUpdate(_param){
        if (_param == null || _param.itemIdx == null) {
            loger.warn('媒体文件更新失败->参数错误', _param);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return;
        }

        //获取已经存在的数据
        let pduDataModel = this.mediaSharedList[_param.itemIdx];
        if (pduDataModel == null) {
            loger.warn('更新媒体文件->媒体文件不存在', _param);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return;
        }

        //更新当前选择的媒体文件数据的字段
        pduDataModel.status =parseInt(_param.status)||0;//默认是0
        pduDataModel.seek=parseInt(_param.seek)||1;
        //更新当前选择的媒体文件
        this.updaterMediaShared(pduDataModel, pduDataModel.itemIdx);
    }

    //播放媒体文件
    mediaSharedPlay(paramInfo) {
        loger.log('切换媒体文件->', paramInfo);
        if (GlobalConfig.isRecordPlayBack) {
            loger.warn('录制回放状态不允许切换媒体文件');
            return;
        }

        if (paramInfo == null || paramInfo.itemIdx == null) {
            loger.warn('切换媒体文件失败,参数错误', paramInfo);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return;
        }

       /* if (paramInfo.itemIdx == GlobalConfig.activeMediaId && GlobalConfig.activeMediaId != 0) {
            loger.warn('媒体文件已经显示', paramInfo.itemIdx, GlobalConfig.activeMediaId);
            return;
        }*/

        //更新切换之前的媒体文件的数据,要显示当前切换的媒体文件,上一个媒体文件需要隐藏
        let oldPduDataModel;
        if (GlobalConfig.activeMediaId != 0) {
            oldPduDataModel = this.mediaSharedList[GlobalConfig.activeMediaId];
            if (oldPduDataModel) {
                oldPduDataModel.status = 0;//设置为不可见
                oldPduDataModel.seek=0;
            }
        }

        //获取已经存在的数据
        let pduDataModel = this.mediaSharedList[paramInfo.itemIdx];
        if (pduDataModel == null) {
            loger.warn('切换媒体文件失败,媒体文件不存在', paramInfo);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return;
        }

        //更新当前选择的媒体文件数据的字段
        pduDataModel.status = paramInfo.status || 0;//默认是0
        pduDataModel.seek= paramInfo.seek || 1;
        //loger.log('切换媒体文件，当前媒体文件和上一个显示的媒体文件都需要更新状态');
        loger.log({"oldDoc": oldPduDataModel, "nowDoc": pduDataModel});
        //更新当前选择的媒体文件
        this.updaterMediaShared(pduDataModel, pduDataModel.itemIdx);

        //更新上一个媒体文件 隐藏
        if (oldPduDataModel&&oldPduDataModel.itemIdx!=pduDataModel.itemIdx) {
            this.updaterMediaShared(oldPduDataModel, oldPduDataModel.itemIdx);
        }
    }

    //停止媒体文件
    mediaSharedStop(paramInfo) {
        loger.log('停止媒体文件->', paramInfo);
        if (GlobalConfig.isRecordPlayBack) {
            loger.warn('录制回放状态不允许停止媒体文件');
            return;
        }

        if (paramInfo == null || paramInfo.itemIdx == null) {
            loger.warn('停止媒体文件,参数错误', paramInfo);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return;
        }

        //获取已经存在的数据
        let pduDataModel = this.mediaSharedList[paramInfo.itemIdx];
        if (pduDataModel == null) {
            loger.warn('停止媒体文件,媒体文件不存在', paramInfo);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return;
        }

        //更新当前选择的媒体文件数据的字段
        pduDataModel.status =  0;//默认是0
        pduDataModel.seek=0;
        //更新当前选择的媒体文件
        this.updaterMediaShared(pduDataModel, pduDataModel.itemIdx);
    }
    //暂停媒体文件
    mediaSharedPause(paramInfo) {
        loger.log('暂停媒体文件->', paramInfo);
        if (GlobalConfig.isRecordPlayBack) {
            loger.warn('录制回放-》暂停媒体文件');
            return;
        }

        if (paramInfo == null || paramInfo.itemIdx == null) {
            loger.warn('暂停媒体文件,参数错误', paramInfo);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return;
        }

        //获取已经存在的数据
        let pduDataModel = this.mediaSharedList[paramInfo.itemIdx];
        if (pduDataModel == null) {
            loger.warn('暂停媒体文件,媒体文件不存在', paramInfo);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return;
        }

        //更新当前选择的媒体文件数据的字段
        pduDataModel.status =  2;//默认是0
        //更新当前选择的媒体文件
        this.updaterMediaShared(pduDataModel, pduDataModel.itemIdx);
    }
    //媒体文件SEEK
    mediaSharedSeek(paramInfo) {
        loger.log('媒体文件SEEK->',paramInfo);
        //获取已经存在的数据
        let pduDataModel = this.mediaSharedList[paramInfo.itemIdx];
        if (pduDataModel == null) {
            loger.log('媒体文件SEEK->媒体文件不存在', paramInfo);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return;
        }
        //更新数据的字段
        pduDataModel.seek = parseInt(paramInfo.seek) || 1;
        if (pduDataModel.seek < 1) {
            pduDataModel.seek = 1;//默认值最小是1
        }
        this.updaterMediaShared(pduDataModel, pduDataModel.itemIdx);
    }


    /////收到消息处理/////////////////////////////////////////////////////////////////////////////////
    tableInsertHandler(owner, itemIdx, itemData) {

    }
    //添加媒体文件
    tableInsertApeHandler(_tableUpdateItems, _seekTime) {
        let tableInsertItems =_tableUpdateItems;
        let tableInsertItemsLen = tableInsertItems.length;
        loger.log('添加媒体文件->_seekTime:'+_seekTime, "activeMediaId->", GlobalConfig.activeMediaId, "tableUpdateItemsLen->", tableInsertItemsLen);
        for (let i = 0; i < tableInsertItemsLen; ++i) {
            let insertItem = tableInsertItems[i];
            //this.tableInsertHandler(insertItem.owner, insertItem.itemIdx, insertItem.itemData);
            let itemDataInfo = this.unPackPdu(insertItem.owner, insertItem.itemIdx, insertItem.itemData);
            if(itemDataInfo){
                itemDataInfo.seek=itemDataInfo.seek+parseInt(_seekTime);//seek是媒体文件自己的，_seekTime是录制回放时进度条换算的
                this.mediaSharedList[insertItem.itemIdx] = itemDataInfo;
                if (itemDataInfo.status == 1) {
                    GlobalConfig.activeMediaId = itemDataInfo.itemIdx;//当前激活的媒体文件ID
                    GlobalConfig.activeMediaSeek = itemDataInfo.seek;
                    loger.log('添加媒体文件->设置当前激活的媒体文件id');
                }
                let getMediaPackFullInfo= this._mediaSharedPackFullInfo(itemDataInfo);
                this._emit(MessageTypes.MEDIA_SHARED_UPDATE, getMediaPackFullInfo);
            }
        }
        //媒体文件数据更新完毕，如果当前没有显示的媒体文件，默认选择一个显示
        this._showDefaultMeida();
    }
    tableDeleteHandler(object_id, tableDeleteData) {
        loger.log('删除媒体文件数据->', object_id, tableDeleteData);//["tableDeleteHandler",1179649,{"type":231,"itemIdx":[1486301768]}]
        if (tableDeleteData && tableDeleteData.itemIdx) {
            let len = tableDeleteData.itemIdx.length;
            let itemIdxs = tableDeleteData.itemIdx;
            for (let i = 0; i < len; i++) {
                if (this.mediaSharedList[itemIdxs[i]]) {
                    loger.log("删除媒体文件数据:", itemIdxs[i]);
                    let itemDataInfo = this.mediaSharedList[itemIdxs[i]];
                    if (itemDataInfo && itemDataInfo.status ==1) {
                        GlobalConfig.activeMediaId = 0;//当前激活的媒体文件ID
                        GlobalConfig.activeMediaSeek = 1;//当前激活的媒体文件的当前页
                        loger.log('删除媒体文件数据->清除当前显示的媒体文件');
                    }
                    this._emit(MessageTypes.MEDIA_SHARED_DELETE, {"itemIdx": itemIdxs[i]});
                    delete this.mediaSharedList[itemIdxs[i]];
                }
            }
        }
    }

    tableUpdateHandler(owner, itemIdx, itemData) {

    }
    tableUpdateApeHandler(_tableUpdateItems, _seekTime) {
        let tableUpdateItemsLen = _tableUpdateItems.length;
        loger.log('更新媒体文件->_seekTime:'+_seekTime, "activeDocId->", GlobalConfig.activeMediaId, "更新的数量->", tableUpdateItemsLen);
        for (let i = 0; i < tableUpdateItemsLen; ++i) {
            let tableItem = _tableUpdateItems[i];
            let itemDataInfo = this.unPackPdu(tableItem.owner, tableItem.itemIdx, tableItem.itemData);
            if (itemDataInfo != null) {
                itemDataInfo.seek=itemDataInfo.seek+parseInt(_seekTime);
                this.mediaSharedList[tableItem.itemIdx] = itemDataInfo;
                if (itemDataInfo && itemDataInfo.status ==1) {
                    GlobalConfig.activeMediaId = itemDataInfo.itemIdx;//当前激活的媒体文件ID
                    GlobalConfig.activeMediaSeek = itemDataInfo.seek;
                    loger.log('更新媒体文件->设置当前激活的媒体文件id->', GlobalConfig.activeMediaId, "curPageNum->", GlobalConfig.activeMediaSeek);
                }
                let getMediaPackFullInfo= this._mediaSharedPackFullInfo(itemDataInfo);
                this._emit(MessageTypes.MEDIA_SHARED_UPDATE, getMediaPackFullInfo);
            } else {
                loger.log('更新媒体文件-> 数据无效--> itemIdx', itemIdx);
            }
        }
        this._showDefaultMeida();
    }

    //果当前没有显示的媒体文件，默认选择一个显示媒体文件
    _showDefaultMeida() {
        //显示默认媒体文件条件->1.非录制回放状态下 2.只有host有权限操作 3.当前激活的媒体文件id不为0
        if (GlobalConfig.isRecordPlayBack || !GlobalConfig.isHost || GlobalConfig.activeMediaId > 0) {
            return;
        }
        /*
        let tempDocItemIdx;//临时记录媒体文件数据，用于显示默认媒体文件
        for (let key in this.mediaSharedList) {
            tempDocItemIdx= this.mediaSharedList[key];
            if (tempDocItemIdx) {
                loger.log("选择一个媒体文件作为默认媒体文件显示->", tempDocItemIdx);
                let paramInfo = {
                    "itemIdx": tempDocItemIdx.itemIdx,
                    "status": 1
                };
                this.mediaSharedPlay(paramInfo);
                //选择完成就跳出循环
              return;
            }
        }*/
    }

    onJoinChannelHandlerSuccess() {
        loger.log(this._session_name + ' 媒体共享加入频道成功');
        if (this._apeDelayed) {
            setTimeout(() => {
                this._emit(MediaSharedApe.MEDIASHARED_JOIN_CHANNEL_SUCCESS);
            }, (GlobalConfig.mcuDelay + GlobalConfig.docDelay) || 12000 + GlobalConfig.docDelay);
        } else {
            setTimeout(() => {
                this._emit(MediaSharedApe.MEDIASHARED_JOIN_CHANNEL_SUCCESS);
            }, GlobalConfig.docDelay);
        }
    }

    //检查媒体文件是否已经存在，如果存在 返回true,否则返回false
    checkMediaSharedId(_fileId) {
        if (_fileId == null) {
            loger.warn('查找媒体文件->失败->参数为null');
            return true;
        }
        //遍历查找
        for (let key in this.mediaSharedList) {
            let item = this.mediaSharedList[key];
            if (item && item.fileId == _fileId) {
                loger.log('查找媒体文件->已经存在->',_fileId);
                return true;
            }
        }
        loger.log('查找媒体文件->没有查找到媒体文件->',_fileId);
        //储存的数据中没有查找到
        return false;
    }

    ///////数据的封包和解包/////////////////////////////////////////
    packPdu(_param, _itemIdx) {
        loger.log("媒体文件->packPdu");
        //验证坐标点集合数组是否合法
        if (_param == null || _itemIdx == null) {
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return null;
        }
       /* optional uint32 item_idx=1;//唯一标识
        optional uint32 owner=2;
        optional uint32 from=3;
        optional string file_type=4;
        optional string creat_user_id=5;//创建文件userid
        optional string url  =6;//文件地址
        optional uint32 status=7;//状态0停止  1播放 2暂停
        optional string fileId=8;//文件在服务器数据库中的唯一id
        optional string file_name=9;//文件的名字
        optional uint32 seek=10;//seek*/

        //判断type类型，根据type设置不同的参数
        let pduDataModel = new pdu['RCMediaSharedSendDataModelPdu'];
        pduDataModel.itemIdx = _itemIdx;
        pduDataModel.owner = GlobalConfig.nodeId;
        pduDataModel.from = GlobalConfig.nodeId;
        pduDataModel.fileType = _param.fileType || "";
        pduDataModel.creatUserId = _param.creatUserId || "0";
        pduDataModel.url = _param.url||"";//这个地址没用到，数据太长占用资源 暂停使用//"http://101.200.150.192/DocSharing/data/h5test/20170206-171100025/7e9c4178cac1133e0dd9d5b583439122.jpg";
        pduDataModel.status = _param.status || 0;
        pduDataModel.fileId = _param.fileId || "";//媒体文件在服务器数据库中的唯一id,必须有
        pduDataModel.fileName = _param.fileName || "media_" + _itemIdx;//媒体文件的名字
        pduDataModel.seek= parseInt(_param.seek) ||1;
        return pduDataModel;
    }

    unPackPdu(owner, itemIdx, itemData) {
        if (owner == null || itemIdx == null || itemData == null) {
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return null;
        }
        try {
            let pduDataModel = pdu['RCMediaSharedSendDataModelPdu'].decode(itemData);
            loger.log("媒体文件===>unPackPdu");
            return pduDataModel;
        } catch (err) {
            loger.log("媒体文件===>unPackPdu->Pdu解析错误->itemIdx=" + itemIdx + "->err:" + err.message);
        }
        return null;
    }
    
}
MediaSharedApe.prototype.MEDIASHARED_JOIN_CHANNEL_SUCCESS = MediaSharedApe.MEDIASHARED_JOIN_CHANNEL_SUCCESS = 'mediaShared_join_channel_success';
export default MediaSharedApe;