import fs = require('fs');
import path = require('path');
import { ABI_TYPE, ABI_STAGE } from '../consts';
import { decodeIdCntArrayStr, getRandEelm } from './util';
import { IT_TYPE } from '../consts';

let gamedata = {};
const wars = ['dic_zyz_gk_main', 'dic_zyz_gk_mainElite', 'dic_zyz_gk_daily', 'dic_zyz_gk_event', 'dic_zyz_gk_tower', 'dic_zyz_gk_expedition', 'dic_zyz_gk_dungeon','dic_zyz_gk_dungeonElite', 'dic_zyz_gk_Treasure','dic_zyz_gk_branch']; // 关卡相关的表
const allWarInfos = new Map<number, any>();
const towerInfos = new Map<number, any>();
const towerTaskInfos = new Map<number, any>();
const heroInfos = new Map<number, any>();
const jobInfos = new Map<number, any>();
const jobClassMaxGrades = new Map<number, {grade:number, jobid:number}>();
const jobClassAndgrades = new Map<string, {jobid:number, unlockLevel:number}>();
const levelInfos = new Map<number, {sum: number, cur: number}>();
const heroLevelInfo = new Map<number, number>();
const starRatioInfo = new Map<number, number>();
const heroSkillInfo = new Map<number, any>()
const seidInfo = new Map<number, any>();
const olySeidInfo = new Map<number, any>();
const expeditionInfo = new Map<number, any> ();
const comBtlInfo = new Map<number, {quality: number, name: string, assistanceTime: number, assistanceLevel: number}>();
const btlBossHpSum = new Map<number, number>();
const btlBossHp = new Map<number, Array<{dataId: number, hp: number, actorId: number}>>();
const blueprtToWar = new Map<number, number>();
const goodInfo = new Map<number, any>();
const blueprt = new Map<number, Array<number>>();
const blueprtCompose = new Map<number, any>();
const fiendShips = new Map<string, any>();
const fashions = new Map<number, any>();
const fiendShipHidAandIds = new Map<number, {actorId: number, level:number}>();
const fiendShipLevelMaps = new Map<number, any>();

interface dicStar {
    id: number;
    quality: number;
    star: number;
    advanceUpFragmentNum: number;
    ceAttr: Map<number, number>
}
const heroStarList = new Map<string, dicStar>();
interface dicWake {
    id: number;
    quality: number;
    star: number;
    fragmentNum: number;
    consume: string;
    ceAttr: Map<number, number>
}
const heroWakeList = new Map<string, dicWake>();

function parseWarData() {
    let result = null;
    for (let filename of wars) {
        let warInfo = gamedata['jsons'][filename]||[];
        for(let war of warInfo) {
            if(war.war_id) {
                allWarInfos.set(war.war_id, war);
            }
        }
    }
    return result;
}

function parseTowerData() {
    const towerFile = 'dic_zyz_tower';
    const towerData = gamedata['jsons'][towerFile] || [];
    towerData.forEach(elem => {
        if (elem.towerFloor) {
            towerInfos.set(elem.towerFloor, elem);
        }
    });
}

function parseTowerTaskData() {
    const towerTaskFile = 'dic_zyz_search';
    const towerTaskData = gamedata['jsons'][towerTaskFile] || [];
    towerTaskData.forEach(elem => {
        if (elem && elem.taskId) {
            towerTaskInfos.set(elem.taskId, elem);
        }
    });
}

function parseHeroData() {
    const heroFile = 'dic_zyz_hero';
    const heroesData = gamedata['jsons'][heroFile] || [];
    heroesData.forEach(elem => {
        if (elem && elem.heroId) {
            elem.baseAbilityArr = new Array<number>();
            elem.baseAbilityUpArr = new Array<number>();


            elem.baseAbilityArr[ABI_TYPE.ABI_HP] = elem.hp||0;
            elem.baseAbilityArr[ABI_TYPE.ABI_ATK] = elem.atk||0;
            elem.baseAbilityArr[ABI_TYPE.ABI_MATK] = elem.matk||0;
            elem.baseAbilityArr[ABI_TYPE.ABI_DEF] = elem.def||0;
            elem.baseAbilityArr[ABI_TYPE.ABI_MDEF] = elem.mdef||0;
            elem.baseAbilityArr[ABI_TYPE.ABI_AGI] = elem.agi||0;
            elem.baseAbilityArr[ABI_TYPE.ABI_LUK] = elem.luk||0;
            elem.baseAbilityArr[ABI_TYPE.ABI_SPEED] = elem.speed||0;

            elem.baseAbilityUpArr[ABI_TYPE.ABI_HP] = elem.hp_up||0;
            elem.baseAbilityUpArr[ABI_TYPE.ABI_ATK] = elem.atk_up||0;
            elem.baseAbilityUpArr[ABI_TYPE.ABI_MATK] = elem.matk_up||0;
            elem.baseAbilityUpArr[ABI_TYPE.ABI_DEF] = elem.def_up||0;
            elem.baseAbilityUpArr[ABI_TYPE.ABI_MDEF] = elem.mdef_up||0;
            elem.baseAbilityUpArr[ABI_TYPE.ABI_AGI] = elem.agi_up||0;
            elem.baseAbilityUpArr[ABI_TYPE.ABI_LUK] = elem.luk_up||0;
            elem.baseAbilityUpArr[ABI_TYPE.ABI_SPEED] = elem.speed_up||0;

            heroInfos.set(elem.heroId, elem);
        }
    });
}

function parseJobData() {
    const jobFile = 'dic_zyz_job';
    const jobsData = gamedata['jsons'][jobFile] || [];
    jobsData.forEach(elem => {
        if (elem && elem.jobid) {
            elem.seids = elem.seid.split('&');
            delete elem.seid;
            jobInfos.set(elem.jobid, elem);
            let jobClass = jobClassMaxGrades.get(elem.job_class);
            if (!!jobClass && jobClass.grade < elem.grade) {
                jobClassMaxGrades.set(elem.job_class, {grade: elem.grade,jobid: elem.jobid});
            }
            jobClassAndgrades.set(elem.job_class+'_'+elem.grade,{unlockLevel:elem.unlockLevel, jobid:elem.jobid});
        }
    });
}


function parseLevelInfo() {
    const jobFile = 'dic_zyz_kingexp';
    const levelData = gamedata['jsons'][jobFile] || [];
    let exp = 0;
    levelData.forEach(elem => {
        if (elem && elem.level) {
            exp += elem.exp;
            levelInfos.set(elem.level, { sum: exp, cur: elem.exp });
        }
    });
}

function parseHeroLevelInfo() {
    const jobFile = 'dic_zyz_charexp';
    const levelData = gamedata['jsons'][jobFile] || [];
    let exp = 0;
    levelData.forEach(elem => {
        if (elem && elem.level) {
            exp += elem.exp;
            heroLevelInfo.set(elem.level, exp);
        }
    });
}

function parseStarRatio() {
    const file = 'dic_star_ratio';
    const data = gamedata['jsons'][file] || [];
    data.forEach(elem => {
        if (elem && elem.star) {
            starRatioInfo.set(elem.star, elem.ratio);
        }
    });
}

function parseHeroSkill() {
    const file = 'dic_zyz_heroskill';
    const data = gamedata['jsons'][file] || [];
    data.forEach(elem => {
        if (elem && elem.skillid) {
            let starSeidArr = new Array<{star: number, value: number}>();
            let colorStarSeidArr = new Array<{star: number, value: number}>();
            
            (elem.starSeid as string).split('|').forEach(cur => {
                if(cur) {
                    let a = cur.split('&');
                    starSeidArr.push({star: parseInt(a[0]), value: parseInt(a[1])});
                }
            });
            (elem.colorStarSeid as string).split('|').forEach(cur => {
                if(cur) {
                    let a = cur.split('&');
                    colorStarSeidArr.push({star: parseInt(a[0]), value: parseInt(a[1])});
                }
            });

            heroSkillInfo.set(elem.skillid, {starSeidArr, colorStarSeidArr});
        }
    });
}

function parseSeidList() {
    const file = 'dic_zyz_se';
    const data = gamedata['jsons'][file] || [];
    data.forEach(elem => {
        if (elem && elem.id) {
            let {gainvalue} = elem;
            let gainValueArr = (gainvalue as string).split('&');
            elem.gainValueArr = new Array();
            for(let g of gainValueArr) {
                if(g === "") continue;
                elem.gainValueArr.push(parseInt(g));
            }
            seidInfo.set(elem.id, elem);
        }
    });
}

function parseOlySeidList() {
    const file = 'dic_zyz_se_add';
    const data = gamedata['jsons'][file] || [];
    data.forEach(elem => {
        if (elem && elem.type) {
            olySeidInfo.set(elem.type, elem);
        }
    });
}

function parseExpedition() {
    const file = 'dic_expedition';
    const data = gamedata['jsons'][file] || [];
    data.forEach(elem => {
        if (elem && elem.id) {
            expeditionInfo.set(elem.id, elem);
        }
    });
    
}

function parseComBtlData() {
    const file = 'dic_zyz_xunbao';
    const data = gamedata['jsons'][file] || [];
    data.forEach(elem => {
        if (elem && elem.quality) {
            comBtlInfo.set(elem.quality, elem);
        }
    });
}

function parseGood() {
    const file = 'dic_goods';
    const data = gamedata['jsons'][file] || [];
    data.forEach(elem => {
        if (elem && elem.good_id) {
            goodInfo.set(elem.good_id, elem);
            if(elem.itid == IT_TYPE.BLUEPRT) {
                let arr = blueprt.get(elem.quality)||new Array();
                arr.push(elem.good_id);
                blueprt.set(elem.quality, arr);
            }
        }
    });
}

function parseBlueprtCompose() {
    const file = 'dic_blueprt_compose';
    const data = gamedata['jsons'][file] || [];
    data.forEach(elem => {
        if (elem && elem.quality) {
            blueprtCompose.set(elem.quality, elem);
        }
    });
}

function parseFashions() {
    const file = 'dic_zyz_fashions';
    const data = gamedata['jsons'][file] || [];
    data.forEach(elem => {
        if (elem && elem.id) {
            elem.actorAttrs = [];
            let actorAttrs = elem.actorAttr.split('|');
            for (let attr of actorAttrs) {
                let attrArr = attr.split('&');
                elem.actorAttrs.push({
                    id: parseInt(attrArr[0]),
                    number: parseInt(attrArr[1]),
                });
            }
            fashions.set(elem.id, elem);
        }
    });
}

function parseFiendShips() {
    const file = 'dic_zyz_friend_ship';
    const data = gamedata['jsons'][file] || [];
    data.forEach(elem => {
        if (elem && elem.id) {
            elem.attributes = [];
            elem.hids = elem.memberId.split('&');
            let attributes = elem.attribute.split('|');
            for (let attr of attributes) {
                let attrArr = attr.split('&');
                elem.attributes.push({
                    id: parseInt(attrArr[0]),
                    number: parseInt(attrArr[1]),
                });
            }
            delete elem.memberId;
            fiendShips.set(elem.shipId + '_' + elem.level, elem);
            let fiendShipHidAandId = fiendShipHidAandIds.get(elem.shipId);
            if (!fiendShipHidAandId || fiendShipHidAandId.level < elem.level)
                fiendShipHidAandIds.set(elem.shipId, {actorId: elem.actorId, level: elem.level});
        }
    });
}

function parseFiendShipLevels() {
    const file = 'dic_zyz_friend_ship_level';
    const data = gamedata['jsons'][file] || [];
    data.sort(function(a, b) {
        return a.level - b.level;
    });
}

function parseFiendShipLevelMaps() {
    const file = 'dic_zyz_friend_ship_level';
    const data = gamedata['jsons'][file] || [];
    data.forEach(elem => {
        if (elem && elem.level) {
            fiendShipLevelMaps.set(elem.level, elem);
        }
    });
}

function initData (folder: string) {
    if(!gamedata.hasOwnProperty(folder)) {
        gamedata[folder] = {};
    }
    fs.readdirSync(__dirname + '/../resource/' + folder)
    .filter(function(file) {
        return (file.indexOf(".") !== 0) && (file !== "index.js");
    })
    //筛选有文件名且不是index进行遍历
    .forEach(function(file) {
        var name = file.split('.')[0];
        try {
            gamedata[folder][name] = JSON.parse(
                fs.readFileSync(path.resolve(__dirname, "../resource/" + folder + "/" + file)).toString('utf8').replace(/^\uFEFF/, '')
            );
        } catch(e) {
            console.error(e);
            console.error('【文件错误】：' + file);
            gamedata[folder][name] = [];
        }

    });
}

function parseHeroStar() {
    const file = 'dic_zyz_hero_star';
    const data = gamedata['jsons'][file] || [];
    data.forEach(elem => {
        if (elem.id) {
            let ceAttr = new Map<number, number>();
            ceAttr.set(ABI_STAGE.HP, elem.hp_up);
            ceAttr.set(ABI_STAGE.ATK, elem.atk_up);
            ceAttr.set(ABI_STAGE.DEF, elem.def_up);
            ceAttr.set(ABI_STAGE.MDEF, elem.mdef_up);
            ceAttr.set(ABI_STAGE.AGI, elem.agi_up);
            ceAttr.set(ABI_STAGE.LUK, elem.luk_up);

            heroStarList.set(`${elem.quality}_${elem.star}`,{ceAttr, ...elem});
        }
    });
}


function parseHeroWake() {
    const file = 'dic_zyz_hero_wake';
    const data = gamedata['jsons'][file] || [];
    data.forEach(elem => {
        if (elem.id) {
            let ceAttr = new Map<number, number>();
            ceAttr.set(ABI_STAGE.HP, elem.hp_up);
            ceAttr.set(ABI_STAGE.ATK, elem.atk_up);
            ceAttr.set(ABI_STAGE.DEF, elem.def_up);
            ceAttr.set(ABI_STAGE.MDEF, elem.mdef_up);
            ceAttr.set(ABI_STAGE.AGI, elem.agi_up);
            ceAttr.set(ABI_STAGE.LUK, elem.luk_up);

            heroWakeList.set(`${elem.quality}_${elem.star}`,{ceAttr, ...elem});
        }
    });
}

function parseData() {
    parseWarData();
    parseTowerData();
    parseTowerTaskData();
    parseHeroData();
    parseJobData();
    parseLevelInfo();
    parseHeroLevelInfo();
    parseStarRatio();
    parseHeroSkill();
    parseSeidList();
    parseOlySeidList();
    parseExpedition();
    parseComBtlData();
    parseGood();
    parseBlueprtCompose();
    parseFashions();
    parseFiendShips();
    parseFiendShipLevels();
    parseFiendShipLevelMaps();
    parseHeroStar();
    parseHeroWake();
}

initData('jsons'); // 加载一般json
initData('warJsons'); // 加载出兵表
parseData();

export function getGamedata(key) {
    return gamedata['jsons'][key];
}

// 获取出兵表
export function getWarJsons(key: any) {
    key = key + '';
    let arr = key.split('&');
    let index = Math.floor(Math.random() * arr.length);
    key = arr[index];
    return {
        json: gamedata['warJsons'][key],
        fileName: key
    }
}

export function getWarById(warid: number) {
    return allWarInfos.get(warid);
}

export function getTowerDataByLv(lv: number) {
    return towerInfos.get(lv);
}

export function getGoodById(gid) {
    return goodInfo.get(gid);
}

export function getBluePrtByQuality(quality: number) {
    return blueprt.get(quality)|| new Array<number>();
}

export function getTaskById(tid: number) {
    const taskInfo = towerTaskInfos.get(tid);
    return taskInfo;
}

export function getHeroInfoById(hid: number) {
    const heroInfo = heroInfos.get(hid);
    return heroInfo;
}

export function getJobInfoById(jid: number) {
    const jobInfo = jobInfos.get(jid);
    return jobInfo;
}

export function getMaxGradeByjobClass(jobClass: number) {
    const job = jobClassMaxGrades.get(jobClass);
    return job?.jobid;
}

export function getLvByExp(exp: number) {
    let curLv = 0;
    let entries = levelInfos.entries();
    for (let [lv, {sum}] of entries) {
        curLv = lv;
        if(exp < sum) break;
    }

    return curLv;
}

export function getExpByLv(lv: number) {
    return levelInfos.get(lv);
}

export function getHeroLvByExp(exp: number) {
    let curLv = 0;
    let entries = heroLevelInfo.entries();
    for (let [lv, sum] of entries) {
        curLv = lv;
        if(exp < sum) break;
    }

    return curLv;
}

export function getHeroExpByLv(lv: number) {
    return heroLevelInfo.get(lv);
}

export function getStarRatio(star: number) {
    return starRatioInfo.get(star);
}

export function getHeroSkillById(skillId: number) {
    return heroSkillInfo.get(skillId);
}

export function getSeidById(id: number) {
    return seidInfo.get(id);
}

export function getOlySeidByType(type: number) {
    return olySeidInfo.get(type);
}

export function getExpeditionById(id: number) {
    return expeditionInfo.get(id);
}

export function getRandExpedition(cnt = 1) {
    const file = 'dic_expedition';
    const data = gamedata['jsons'][file] || [];
    return getRandEelm(data, cnt);
}

export function getComBtlSetByQuality(quality: number) {
    return comBtlInfo.get(quality);
}

export function getBossHpByWarId(warId: number) {
    let bossHpSum = btlBossHpSum.get(warId) || 0;
    let bossHpArr = btlBossHp.get(warId) || [];
    if (!bossHpSum || !bossHpArr) {
        const warInfo = getWarJsons(warId).json;
        if (warInfo && warInfo.length) {
            warInfo.forEach(hero => {
                let { attribute, dataId, relation, actorId } = hero;
                if (relation === 2) {
                    let attriData = decodeIdCntArrayStr(attribute, 1);
                    const hp = parseInt(attriData.get('1'));
                    if (hp > 0) {
                        bossHpArr.push({dataId, hp, actorId});
                        bossHpSum += hp;
                    }
                }
            })
            btlBossHp.set(warId, bossHpArr);
            btlBossHpSum.set(warId, bossHpSum);
        }
    }
    return { bossHpSum, bossHpArr };
}

export function getWarIdByBlueprtId(blueprtId: number) {
    let warId = blueprtToWar.get(blueprtId);
    if (!warId) {
        const { specialAttr } = getGoodById(blueprtId);
        const attrData = decodeIdCntArrayStr(specialAttr, 1);
        warId = parseInt(attrData.get('1'));
        blueprtToWar.set(blueprtId, warId);
    }
    return warId;
}

export function getBossHpByBlueprtId(blueprtId: number) {
    let warId = getWarIdByBlueprtId(blueprtId);
    let { dispatchJsonId } = getWarById(warId);
    let bossHpInfo = getBossHpByWarId(dispatchJsonId);
    return bossHpInfo;
}

export function getRewardByBlueprtId(blueprtId: number) {
    let warId = getWarIdByBlueprtId(blueprtId);
    let { fixReward } = getWarById(warId);
    return fixReward;
}

export function hasExpeditionById(id: number) {
    return expeditionInfo.has(id);
}

export function getBlueprtComposeByQuality(quality: number) {
    return blueprtCompose.get(quality);
}

export function getFashionsById(id:number) {
    return fashions.get(id);
}

export function getFriendShipById(shipId: number, level: number) {
    return fiendShips.get(shipId +'_' + level);
}

export function getHidAndLevelByShipId(shipId: number) {
    return fiendShipHidAandIds.get(shipId);
}

export function getFriendShipLevels() {
    const file = 'dic_zyz_friend_ship_level';
    return gamedata['jsons'][file] || [];
}

export function getJobByGradeAndClass(jobClass: number, grade: number) {
    return jobClassAndgrades.get(jobClass +'_' + grade);
}

export function getHeroStar(quality: number, star: number) {
    return heroStarList.get(`${quality}_${star}`);
}

export function getHeroWake(quality: number, star: number) {
    return heroWakeList.get(`${quality}_${star}`);
}

export function getFiendShipLevel(level: number) {
    return fiendShipLevelMaps.get(level);
}