// //////////////////////////////////////////////////////////////////////////////
//答题卡模块+点名模块 (点名的时候创建单选项的题型即可，type=100)
// //////////////////////////////////////////////////////////////////////////////

import Ape from './Ape';
import ApeConsts from './ApeConsts';
import ThirdMessage from './ThirdMessage';
import MessageTypes from 'MessageTypes';
import pdu from 'pdus';
import UTF8 from 'utf-8';
import Loger from 'Loger';
import GlobalConfig from 'GlobalConfig';
import EngineUtils from 'EngineUtils';
import TimerCounter from "TimerCounter";
import Sass from 'Sass';

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

class QuestionApe extends Ape {
    constructor() {
        super(
            ApeConsts.QUESTION_SESSION_ID,
            ApeConsts.QUESTION_SESSION_NAME,
            ApeConsts.QUESTION_SESSION_TAG
        );
        this.questionList={};//MCU同步的题目数据
        this.questionDataList={};//Sass保存的题目内容数据

        //监听Sass事件
        this._sass=Sass;
        //创建答题卡
        this._sass.on(Sass.SASS_CREAT_QUESTION_SUCCESS,this._sassCreatQuestionSuccessHandler.bind(this));
        this._sass.on(Sass.SASS_CREAT_QUESTION_FAILED,this._sassCreatQuestionFailedHandler.bind(this));
        //获取题目数据
        this._sass.on(Sass.SASS_GET_QUESTION_SUCCESS,this._sassGetQuestionSuccessHandler.bind(this));
        this._sass.on(Sass.SASS_GET_QUESTION_FAILED,this._sassGetQuestionFailedHandler.bind(this));
        //获取答题结果
        this._sass.on(Sass.SASS_GET_QUESTION_RESULT_SUCCESS,this._sassGetQuestionResultSuccessHandler.bind(this));
        this._sass.on(Sass.SASS_GET_QUESTION_RESULT_FAILED,this._sassGetQuestionResultFailedHandler.bind(this));
        //保存答题数据
        this._sass.on(Sass.SASS_SEND_ANSWER_SUCCESS,this._sassSendAnswerSuccessHandler.bind(this));
        this._sass.on(Sass.SASS_SEND_ANSWER_FAILED,this._sassSendAnswerFailedHandler.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.CONFERENCE_OBJ_QUESTION_ID,
            ApeConsts.CONFERENCE_OBJ_QUESTION_NAME, ApeConsts.CONFERENCE_OBJ_QUESTION_TAG, 0, new ArrayBuffer);
    }

    //更新信息
    sendUpdaterTable(_param) {
        loger.log('答题卡->发送更新信息->');
        if (_param == null || EngineUtils.isEmptyObject(_param)) {
            loger.log('答题卡->发送更新信息->参数错误');
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return;
        }
        let itemIdx =_param.itemIdx;
        let modelPdu = this.packPdu(_param, itemIdx);

        if (modelPdu == null) {
            loger.log('答题卡->发送更新信息->参数错误');
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return;
        }
        console.log("modelPdu",modelPdu);
        let tableItemPdu = new pdu['RCRegistryTableItemPdu'];
        tableItemPdu.itemIdx = itemIdx;
        tableItemPdu.owner = 0;//收到flash的是这个值，不清楚先写固定
        tableItemPdu.registerObjId = ApeConsts.CONFERENCE_OBJ_QUESTION_ID;
        loger.log('答题卡->发送更新信息->1aaaaaa');
        tableItemPdu.itemData = modelPdu.toArrayBuffer();

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

        let updateObjPdu = new pdu['RCRegistryUpdateObjPdu'];
        updateObjPdu.objId = ApeConsts.CONFERENCE_OBJ_QUESTION_ID;
        updateObjPdu.subType = tableUpdateItem.type;
        updateObjPdu.userData = tableUpdateItem.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);
        this.sendUniform(adapterPdu, true);
    }

    //删除
    tableDelete(_param) {
        if(!_param){
            loger.warn('答题卡->删除数据失败->参数错误',_param);
            return;
        }
        let tableDeleteItemPdu = new pdu['RCRegistryTableDeleteItemPdu'];
        tableDeleteItemPdu.type = pdu.RCPDU_REG_TABLE_DELETE_PDU;//
        tableDeleteItemPdu.itemIdx = parseInt(_param.itemIdx);//这里需要设置要删除的数据的itemIdx，每条数据的这个id都不一样

        let updateObjPdu = new pdu['RCRegistryUpdateObjPdu'];
        updateObjPdu.objId = ApeConsts.CONFERENCE_OBJ_QUESTION_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);
    }

    /////收到消息处理/////////////////////////////////////////////////////////////////////////////////
    //答题卡更新数据
    tableUpdateHandler(owner, itemIdx, itemData) {
        try {
            let model = this.unPackPdu(owner, itemIdx, itemData);
            loger.log('答题卡更新数据->',model);
            this.questionList[itemIdx]=model;
            console.log('this.questionList',this.questionList);
            if(model){
                switch (model.type){
                    case 1:
                    case 2:
                    case 3:
                    case 4:
                    case 100:
                        //停止答题
                        loger.log("更新答题数据");
                        if(GlobalConfig.isHost){
                            //老师，只统计数据，不答题
                            //先判断时间是否超时
                            let timeDistance=EngineUtils.creatTimestamp()-model.timestamp;
                            loger.log("答题卡显示倒计时->timeDistance:"+timeDistance);
                            timeDistance=model.timeLimit-timeDistance;
                            if(timeDistance<=0){
                                //答题卡时间到，需要停止
                                loger.log("答题卡时间到->需要停止");
                                this.stopQuestion(model);
                            }else {
                                this.getQuestionResult(model);
                            }

                        }else if(GlobalConfig.isNormal) {
                            //学生->如果自己已经提交过答案就不需要再显示
                            if(model.totalUserList.indexOf(GlobalConfig.userId)>=0){
                                loger.log("已经提交过答案-不需要显示答题卡->userId:"+GlobalConfig.userId);
                            }else {
                                //显示答题卡数据
                                this._emit(MessageTypes.START_ANSWER_QUESTION,model);
                            }
                        }
                        break;
                    //case 4:
                    //    //停止点名
                    //    loger.log("更新点名数据");
                    //    this._emit(MessageTypes.UPDATE_CALL_THE_ROLL,model);
                    //    break;
                    default :
                        break;
                }
            }

        } catch (err) {
            loger.warn('答题卡更新数据->解析失败->err', err.message);
        }
    }
    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.questionList[itemIdxs[i]]) {
                    loger.log("答题卡删除数据:", itemIdxs[i]);
                    let itemDataInfo = this.questionList[itemIdxs[i]];
                    if(itemDataInfo){
                        switch (itemDataInfo.type){
                            case 1:
                            case 2:
                            case 3:
                                //停止答题
                                loger.log("停止答题->",itemDataInfo);
                                this._emit(MessageTypes.STOP_ANSWER_QUESTION,itemDataInfo);
                                break;
                            case 4:
                                //停止点名
                                loger.log("停止点名");
                                this._emit(MessageTypes.STOP_CALL_THE_ROLL,itemDataInfo);
                                break;
                            default :
                                break;
                        }
                    }
                    delete this.questionList[itemIdxs[i]];
                }
            }
        }
    }
    
    ///////数据的封包和解包/////////////////////////////////////////
    packPdu(_param, _itemIdx) {
        //验证坐标点集合数组是否合法
        if (_param == null || _itemIdx == null) {
            loger.log("答题卡->packPdu->参数错误",_itemIdx,_param);
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return null;
        }
        /*optional uint32 item_idx=1;
        optional uint32 from=2;
        optional uint32 owner=3;
        optional uint32 type=4;//类型
        optional uint32 questionId=5;//题目id
        optional uint32 timeLimit=6;//有效时间
        optional uint32 timestamp=7;//创建的时间
        repeated string totalUserList=8;//参与的人员userId列表*/
        
        let modelPdu = new pdu['RCQuestionDataModelPdu'];
        modelPdu.itemIdx = _itemIdx;
        modelPdu.from = _param.nodeId||GlobalConfig.nodeId;
        modelPdu.owner = _param.owner||GlobalConfig.nodeId;
        modelPdu.type = parseInt(_param.type)||0;
        modelPdu.questionId= parseInt(_param.questionId)||0;
        modelPdu.timeLimit= parseInt(_param.timeLimit)||1;//有效时间
        modelPdu.timestamp= parseInt(_param.timestamp)||EngineUtils.creatTimestamp();//创建的时间
        modelPdu.content= _param.content||[];//题干
        modelPdu.options= _param.options||[];//选项列表
        modelPdu.answer= _param.answer||[];//用户选择的选项索引
        modelPdu.correct= _param.correct||[];//正确答案索引
        modelPdu.totalUserList=_param.totalUserList||[];//参加的人员userId列表
        loger.log("答题卡->packPdu",modelPdu);
        return modelPdu;
    }

    unPackPdu(owner, itemIdx, itemData) {
        loger.log("答题卡->unPackPdu ");
        if (owner == null || itemIdx == null || itemData == null) {
            this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
            return null;
        }

        try {
            let modelPdu = pdu['RCQuestionDataModelPdu'].decode(itemData);
            return modelPdu;
        } catch (err) {
            loger.log("答题卡->Pdu解析错误，itemIdx=" + itemIdx + "  err:" + err.message);
        }
        return null;
    }

    //答题卡接口-------------------------------------------------------------------
    creatQuestion(_param){
        if(!_param){
            loger.warn("创建答题卡->参数错误",_param);
            return;
        }
        loger.log("创建答题卡->",_param);
        if(this._sass){
            /*{
                "type": 1,//1单选，2多选，3判断，4点名
                "content": "题目",//没有就传""
                "timeLimit": 88,//有效时间（秒）
                "correct": "[]",//正确答案，没有就传[]
                "options": [],//选项数组，没有就传[]
                "answer": []//学生选择的答案，没有就传[]
            }*/
            let paramObj=_param;
            paramObj.classId=GlobalConfig.classId;
            this._sass.creatQuestion(paramObj);
        }
    }
    getQuestion(_param){
        if(!_param){
            loger.warn("获取答题卡数据->参数错误",_param);
            return;
        }
        loger.log("获取答题卡数据->.",_param);
        if(this.questionList[_param.itemIdx]){
            this._emit(MessageTypes.START_ANSWER_QUESTION,this.questionList[_param.itemIdx]);
        }else {
            if(this._sass){
                this._sass.getQuestion(_param);
            }
        }

    }
    getQuestionResult(_param){
        if(!_param){
            loger.warn("获取答题卡结果->参数错误",_param);
            return;
        }
        loger.log("获取答题卡结果->",_param);
        if(this._sass){
            this._sass.getQuestionResult(_param);
        }
    }
    sendAnswer(_param){
        if(!_param){
            loger.warn("保存答题答案->参数错误",_param);
            return;
        }
        //检查是否已经提交过答案
        let questionItem=this.questionList[_param.itemIdx];
        if(questionItem){
            if(questionItem.totalUserList.indexOf(GlobalConfig.userId)>=0){
                loger.warn("保存答题答案->已经提交过答案不能再次提交");
                return;
            }else {
                if(this._sass){
                    if(questionItem.questionId==parseInt(_param.questionId)){
                        loger.log("保存答题答案->",_param);
                        let paramObj=_param;
                        paramObj.classId=GlobalConfig.classId;
                        paramObj.userId = GlobalConfig.userId;
                        paramObj.userName = GlobalConfig.userName;
                        this._sass.sendAnswer(paramObj);
                    }else {
                        loger.log("保存答题答案->questionId不存在",_param);
                        console.log("questionList",this.questionList);
                    }
                }
            }
        }else {
            loger.warn("保存答题答案->数据不存在",_param);
        }
    }
    stopQuestion(_param){
        if(!_param){
            loger.warn("停止答题->参数错误",_param);
            return;
        }
        if(this.questionList[_param.itemIdx]){
            loger.log("停止答题->",_param);
            this.tableDelete(_param);
        }else {
            loger.warn("停止答题->数据不存在",_param);
        }
    }
    //Sass 事件监听
    _sassCreatQuestionSuccessHandler(_data){
        //loger.log("创建答题卡成功",_data);
        if(_data){
            //this.questionDataList[_data.questionId]=_data;//保存题目数据

            let questionItem=_data;
           /* //判断是答题还是点名，type=100的时候是点名
            if(questionItem.type==100){
                questionItem.itemIdx=ApeConsts.CONFERENCE_OBJ_QUESTION_ID+1;
            }else {
                questionItem.itemIdx=ApeConsts.CONFERENCE_OBJ_QUESTION_ID;
            }*/
            questionItem.itemIdx=EngineUtils.creatTimestamp();
            this.sendUpdaterTable(questionItem);
        }

    }
    _sassCreatQuestionFailedHandler(_data){
        loger.warn("创建答题卡失败",_data);
    }
    _sassGetQuestionSuccessHandler(_data){
        loger.log("获取答题卡数据成功",_data);
    }
    _sassGetQuestionFailedHandler(_data){
        loger.warn("获取答题卡数据失败",_data);
    }
    _sassGetQuestionResultSuccessHandler(_data){
        loger.log("获取答题卡结果成功",_data);
        //返回值结构
        /* {
         "questionId": 11,
         "list": [
         {
         "answer": "",
         "userName": "visitor_995083397",
         "userId": "0"
         },
         {
         "answer": "0",
         "userName": "visitor_995083397",
         "userId": "0"
         }
         ]
         }*/
        if(_data){
            let resultObj= this.questionList[_data.itemIdx];
            /* {
             "type": 1,//1 单选、2多选、3判断、4点名
             "questionId": 15,
             "content": "题目",
             "timeLimit": 88,
             "totalUser":5,//当前参与的总人数
             "correct": "[]",//正确答案
             "options": ["A","B","C"],
             //各个选项参与人数的百分比和参与人的名字
             "answers":[
             {"percent":40,"userNames":"张三、asdas"},
             {"percent":40,"userNames":"历史、asdas"},
             {"percent":20,"userNames":"bdb"},
             ]
             }*/
            if(resultObj){
                let list=_data.list||[];
                let listLen=list.length;
                resultObj.totalUser=listLen;
                resultObj.answers=[];

                //根据选项的个数，把选项分开
                let options=resultObj.options;
                for(let i=0;i<options.length;i++){
                    let optionObj=new Object();
                    optionObj.percent=0;//百分比  选择的人数和总参与人数的比
                    optionObj.userNames=[];
                    resultObj.answers.push(optionObj)
                }

                //把list选择的答案和人员分配到各个选项数组
                for(let k=0;k<listLen;k++){
                    let listItem=list[k];
                    if(listItem){
                        let answerIndex=parseInt(listItem.answer);
                        let optionObj=resultObj.answers[answerIndex];
                        if(optionObj){
                            optionObj.userNames.push(listItem.userName);
                            optionObj.percent=parseInt(optionObj.userNames.length/listLen*100);
                        }
                    }
                }
                loger.log("获取答题卡结果统计->",resultObj);
                this._emit(MessageTypes.UPDATE_ANSWER_QUESTION,resultObj);
            }
        }
    }
    _sassGetQuestionResultFailedHandler(_data){
        loger.warn("获取答题卡结果失败",_data);
    }
    _sassSendAnswerSuccessHandler(_data){
        loger.log("保存答案成功",_data);
        let questionItem=this.questionList[_data.itemIdx];
        if(questionItem){
            if(questionItem.totalUserList.indexOf(GlobalConfig.userId)<0){
                questionItem.totalUserList.push(""+GlobalConfig.userId);
            }
            this.sendUpdaterTable(questionItem);
        }
    }
    _sassSendAnswerFailedHandler(_data){
        loger.warn("保存答案失败",_data);
    }

}

export default QuestionApe;