import GameModel from "../ts/core/GameModel";
import SKDataUtil from "../ts/gear_2.3.4/util/SKDataUtil";

let CPubFunction = require('./PubFunction');
let EEventType =
{
    PlayerTalkNpc: 1,
    PlayerKillNpc: 2,
    PlayerGatherNpc: 3,
    PlayerDoAction: 4,
    PlayerArriveArea: 5,
    PlayerGiveNpcItem: 6,
    FailEventPlayerDead: 11,
    FailEventTimeOut: 12,
};

let ETaskKind =
{
    EStory: 1,
    EDaily: 2,
    EFuBen: 3,
};

let EState =
{
    ELock: 0,
    EDoing: 1,
    EDone: 2,
    EFaild: 3,
};



class CEventBase {
    constructor() {
        this.nEventType = 0;
        this.strTip = '';
        this.vecPrize = [];

    }

}



//--------------------- 對話 ---------------//



class CEventTalkNpc extends CEventBase {
    constructor() {
        super();
        this.vecCreateNpc = [];
        this.nNpcConfigID = 0;
        this.vecSpeak = [];
        this.bAutoTrigle = 0;
    }

}


//--------------------- 採集Npc ---------------//

class CGatherNpc extends CEventBase {
    constructor() {
        super();
        this.vecCreateNpc = [];
        this.vecNpc = [];
    }
}


//--------------------- 在指定區域做動作 ---------------//

class CDoActionInArea extends CEventBase {
    constructor() {
        super();
        this.nMap = 0;
        this.nX = 0;
        this.nY = 0;
        this.strAction;
        this.strTalk = '';
    }
}

//--------------------- 到達區域 ---------------//

class CArriveArea extends CEventBase {
    constructor() {
        super();
        this.nMap = 0;
        this.nX = 0;
        this.nY = 0;
    }
}


//--------------------- 給Npc物品 ---------------//

class CGiveNpcItem extends CEventBase {
    constructor() {
        super();
        this.nItemID = 0;
        this.nNum = 0;
        this.nFromNpc;
        this.nNpcConfigID;
    }
}

//--------------------- 殺死Npc ---------------//

class CKillDynamicNpc extends CEventBase {
    constructor() {
        super();
        this.vecCreateNpc = [];
        this.vecNpc = [];
        this.bAutoTrigle = 0;
    }
}


//--------------------- 失敗事件：玩家死亡 ---------------//

class CFailEventPlayerDead extends CEventBase {

    constructor() {
        super();
        this.nEventType = EEventType.FailEventPlayerDead;
        this.nDeadCnt = 1;
    }
}


//--------------------- 失敗事件：超時 ---------------//

class CFailEventTimeOut extends CEventBase {
    constructor() {
        super();
        this.nEventType = EEventType.FailEventTimeOut;
        this.nMaxTime = 60;
    }
}


/**********************************************************************/

class CTask {
    constructor() {
        this.nTaskID = 0;
        this.nKind = 0;
        this.nTaskGrop = 0;
        this.nDailyCnt = 0;
        this.strTaskName = '';
        this.vecLimit = [];
this.vecEvent = []; //事件列表
        this.vecFailEvent = [];
    }


}


/*********************************** 任務配置信息 ***********************************/

class CConfigTaskMgr {
    constructor() {
        this.mapConfigTask = {};
        //    this.InitAllTask();
    }


    GetTaskEventCreateNpc(vecString) {
        let vecData = [];
        if(!vecString){
            return vecData;
        }
        if(SKDataUtil.isArray(vecString)){
            for(let item of vecString){
                if(typeof(item)!="string"){
                    continue;
                }
                let vecTmp = item.split(",");
                if (vecTmp.length != 4){
                    continue;
                }
                vecData.push({ nNpc: vecTmp[0], nMap: vecTmp[1], nX: vecTmp[2], nY: vecTmp[3] });
            }
        }else{
cc.log(`$警告:${vecString}不是數組!`);
        }
        return vecData;
    }


    GetDailyMaxCnt(nGrop) {
        if (nGrop == 2 || nGrop == 3)
            return 20;

        if (nGrop == 4)
            return 15;

        if (nGrop == 5)
            return 5;

        if (nGrop == 6)
            return 120;

        if (nGrop == 7)
            return 40;

        return 0;

    }

    StringVecorToDataVector(vecString) {
        let vecData = [];
        if(!vecString){
            return vecData;
        }
        if(SKDataUtil.isArray(vecString)){
            for (let item of vecString){
                if(typeof(item) != "string"){
cc.warn(`$警告:解析錯誤非字符串:${item}`);
                    continue;
                }
                let vecTmp = item.split(":");
                if (vecTmp.length < 2){
cc.warn(`$警告:解析錯誤缺少:號${item}`);
                    continue;
                }
                vecData.push({ nKey: vecTmp[0], nValue: vecTmp[1] });
            }
        }else{
cc.log(`$警告:${vecString}不是數組!`);
        }
        return vecData;
    }

    AddTask(nKind, stTask) {
        if (this.mapConfigTask.hasOwnProperty(nKind) == false)
            this.mapConfigTask[nKind] = [];
        this.mapConfigTask[nKind].push(stTask);
    }

    InitAllTask() {
        for (const itTask in GameModel.conf_task) {
            if (itTask == 'datatype')
                continue;
            const stData = GameModel.conf_task[itTask];
            let stTask = new CTask();
            stTask.nTaskID = parseInt(itTask);
            stTask.nKind = stData.nKind;
            stTask.strTaskName = stData.strName;
            stTask.nTaskGrop = CPubFunction.GetDefault(stData.nTaskGrop, 0);
            stTask.nDailyCnt = CPubFunction.GetDefault(stData.nDailyCnt, 0);
            for (let nIndex in stData.vecEvent) {
if (stData.vecEvent[nIndex].nEventType == EEventType.PlayerTalkNpc) //對話
                {
                    let stTalk = new CEventTalkNpc();
                    stTalk.nEventType = EEventType.PlayerTalkNpc;
                    stTalk.vecPrize = this.StringVecorToDataVector(stData.vecEvent[nIndex].vecPrize);
                    stTalk.strTip = stData.vecEvent[nIndex].strTip;
                    stTalk.vecCreateNpc = this.GetTaskEventCreateNpc(stData.vecEvent[nIndex].vecCreateNpc);
                    stTalk.vecNpc = stData.vecEvent[nIndex].vecNpc.slice(0);
                    stTalk.vecSpeak = this.StringVecorToDataVector(stData.vecEvent[nIndex].vecSpeak);
                    stTalk.bAutoTrigle = CPubFunction.GetDefault(stData.vecEvent[nIndex].bAutoTrigle, 0);
                    stTask.vecEvent.push(stTalk);
                }

                if (stData.vecEvent[nIndex].nEventType == EEventType.PlayerGatherNpc) {
                    let stGather = new CGatherNpc();
                    stGather.nEventType = EEventType.PlayerGatherNpc;
                    stGather.strTip = stData.vecEvent[nIndex].strTip;
                    stGather.vecPrize = this.StringVecorToDataVector(stData.vecEvent[nIndex].vecPrize);
                    stGather.vecCreateNpc = this.GetTaskEventCreateNpc(stData.vecEvent[nIndex].vecCreateNpc);
                    stGather.vecNpc = stData.vecEvent[nIndex].vecNpc.slice(0);
                    stTask.vecEvent.push(stGather);
                }

                if (stData.vecEvent[nIndex].nEventType == EEventType.PlayerDoAction) {
                    let stAction = new CDoActionInArea();
                    stAction.nEventType = EEventType.PlayerDoAction;
                    stAction.vecPrize = this.StringVecorToDataVector(stData.vecEvent[nIndex].vecPrize);
                    stAction.strTip = stData.vecEvent[nIndex].strTip;
                    stAction.nMap = stData.vecEvent[nIndex].nMap;
                    stAction.nX = stData.vecEvent[nIndex].nX;
                    stAction.nY = stData.vecEvent[nIndex].nY;
                    stAction.strAction = stData.vecEvent[nIndex].strAction;
                    stAction.strTalk = stData.vecEvent[nIndex].strTalk;
                    stTask.vecEvent.push(stAction);
                }

                if (stData.vecEvent[nIndex].nEventType == EEventType.PlayerArriveArea) {
                    let stAction = new CArriveArea();
                    stAction.nEventType = EEventType.PlayerArriveArea;
                    stAction.vecPrize = this.StringVecorToDataVector(stData.vecEvent[nIndex].vecPrize);
                    stAction.strTip = stData.vecEvent[nIndex].strTip;
                    stAction.nMap = stData.vecEvent[nIndex].nMap;
                    stAction.nX = stData.vecEvent[nIndex].nX;
                    stAction.nY = stData.vecEvent[nIndex].nY;
                    stTask.vecEvent.push(stAction);
                }

                if (stData.vecEvent[nIndex].nEventType == EEventType.PlayerGiveNpcItem) {
                    let stAction = new CGiveNpcItem();
                    stAction.nEventType = EEventType.PlayerGiveNpcItem;
                    stAction.vecPrize = this.StringVecorToDataVector(stData.vecEvent[nIndex].vecPrize);
                    stAction.strTip = stData.vecEvent[nIndex].strTip;
                    stAction.nItemID = stData.vecEvent[nIndex].nItemID;
                    stAction.nNum = stData.vecEvent[nIndex].nNum;
                    stAction.nFromNpc = stData.vecEvent[nIndex].nFromNpc;
                    stAction.nNpcConfigID = stData.vecEvent[nIndex].nToNpc;
                    stAction.strTip2 = stData.vecEvent[nIndex].strTip2;
                    stTask.vecEvent.push(stAction);
                }

                if (stData.vecEvent[nIndex].nEventType == EEventType.PlayerKillNpc) {
                    let stEvent = new CKillDynamicNpc();
                    stEvent.nEventType = EEventType.PlayerKillNpc;
                    stEvent.vecPrize = this.StringVecorToDataVector(stData.vecEvent[nIndex].vecPrize);
                    stEvent.strTip = stData.vecEvent[nIndex].strTip;
                    stEvent.vecCreateNpc = this.GetTaskEventCreateNpc(stData.vecEvent[nIndex].vecCreateNpc);
                    stEvent.vecNpc = stData.vecEvent[nIndex].vecNpc.slice(0);
                    stEvent.bAutoTrigle = stData.vecEvent[nIndex].bAutoTrigle;
                    stTask.vecEvent.push(stEvent);
                }
            }

            for (let nIndex in stData.vecFailEvent) {
                if (stData.vecFailEvent[nIndex].nEventType == EEventType.FailEventPlayerDead) {
                    let stEvent = new CFailEventPlayerDead();
                    stTask.vecFailEvent.push(stEvent);
                }

                if (stData.vecFailEvent[nIndex].nEventType == EEventType.FailEventTimeOut) {
                    let stEvent = new CFailEventTimeOut();
                    stTask.vecFailEvent.push(stEvent);
                }
            }
            stTask.vecLimit = this.StringVecorToDataVector(stData.vecLimit);
            this.AddTask(stTask.nKind, stTask);
        }
    }

    GetTaskInfo(nTaskID) {
        if (CPubFunction.GetMapLen(this.mapConfigTask) <= 0) {
            this.InitAllTask();
        }
        for (let nKind in this.mapConfigTask) {
            let vecTask = this.mapConfigTask[nKind];

            for (let nIndex in vecTask) {
                if (vecTask[nIndex].nTaskID == nTaskID)
                    return vecTask[nIndex];
            }
        }
        return null;
    }


    GetTaskStepInfo(nTaskID, nStep) {
        let stTaskConfig = this.GetTaskInfo(nTaskID);
        if (null == stTaskConfig)
            return null;

        if (nStep < 0 || nStep >= stTaskConfig.vecEvent.length)
            return null;

        return stTaskConfig.vecEvent[nStep];
    }


    GetFailEventInfo(nTaskID, nStep) {
        let stTaskConfig = this.GetTaskInfo(nTaskID);
        if (null == stTaskConfig)
            return null;

        if (nStep < 0 || nStep >= stTaskConfig.vecFailEvent.length)
            return null;

        return stTaskConfig.vecFailEvent[nStep];
    }


    IsTeamTask(nTaskID) {

        if (nTaskID >= 500)
            return true;

        return false;
    }
}

let g_pTaskConfigMgr = null;

module.exports = (() => {
    if (g_pTaskConfigMgr == null) {
        g_pTaskConfigMgr = new CConfigTaskMgr();
    }
    return { g_pTaskConfigMgr, CTask, CGatherNpc, CEventTalkNpc, EEventType, ETaskKind, EState };
})();