import { dicHero } from "./dictionary/DicHero";
import { dicGoods, blueprt, dicJewel } from "./dictionary/DicGoods";
import { dicBlueprtCompose } from "./dictionary/DicBlueprtCompose";
import { dicBlueprtPossibility } from "./dictionary/DicBlueprtPossibility";
import { dicDaily } from "./dictionary/DicDaily";
import { dicEvent } from "./dictionary/DicEvent";
import { dicExpedition } from "./dictionary/DicExpedition";
import { dicExpeditionPoint } from "./dictionary/DicExpeditionPoint";
import { dicFuncSwitch } from "./dictionary/DicFuncSwitch";
import { dicHeroSkill } from "./dictionary/DicHeroSkill";
import { dicJob, jobClassAndgrades, jobClassMaxGrades } from "./dictionary/DicJob";
import { dicKingExp, maxPlayerLv } from "./dictionary/DicKingExp";
import { dicCharExp } from "./dictionary/DicCharExp";
import { dicQuestion } from "./dictionary/DicQuestion";
import { dicSe } from "./dictionary/DicSe";
import { dicTower } from "./dictionary/DicTower";
import { dicTowerTask } from "./dictionary/DicTowerTask";
import { dicWar, dicWarPvp } from "./dictionary/DicWar";
import { dicWarJson } from "./dictionary/DicWarJson";
import { dicXunbao } from "./dictionary/DicXunbao";
import { SPECIAL_ATTR } from "../consts/consts";
import { dicFashions } from "./dictionary/DicFashions";
import { friendShips, friendShipHidAandIds } from "./dictionary/DicFriendShip";
import { dicFriendShipLevel, dicFriendShipLevelMap } from "./dictionary/DicFriendShipLevel";
import { dicHeroQualityUp } from "./dictionary/DicHeroQualityUp";
import { dicHeroStar } from "./dictionary/DicHeroStar";
import { dicHeroWake } from "./dictionary/DicHeroWake";
import { dicRandomEffectPool } from './dictionary/DicRandomEffectPool';
import { dicStrengthenCost } from './dictionary/DicStrengthenCost';
import { dicRefine } from './dictionary/DicRefine';
import { dicHeroEquip } from './dictionary/DicHeroEquip';
import { dicSuit } from './dictionary/DicSuit';
import { dicTitle } from './dictionary/DicTitle';
import { dicTeraph } from './dictionary/DicTeraph';
import { dicSchool } from './dictionary/DicSchool';
import { dicSchoolRate } from './dictionary/DicSchoolRate';
import { dicHeroScroll, preHeroScroll } from './dictionary/DicHeroScroll';
import { ABI_TYPE_TO_STAGE } from "../consts";
import { dicPvpOpponent } from './dictionary/DicPvpOpponent';
import { dicPvpTeamLevel } from './dictionary/DicPvpTeamLevel';
import { dicPvpRefreshConsume, maxPvpRefreshCnt } from './dictionary/DicPvpRefreshConsume';
import { dicGkPvp, dicGkPvps }  from './dictionary/DicGkPvp';
import { dicHeroRewads }  from './dictionary/DicPvpHeroReward';
import { dicRankRewads, dicRankMax }  from './dictionary/DicPvpRankReward';
import { dicPvpBoxs }  from './dictionary/DicPvpBox';
import { dicGuildAuth } from './dictionary/DicGuildAuth';
import { dicCenterBase, dicEquipPriduceBase, dicBossBase, dicTrainBase, dicDonateBase, dicWishPoolBase, dicStoreBase, dicStructureConsume } from "./dictionary/DicStructure";
import { dicGuildActiveDayReward } from './dictionary/DicGuildActiveDayReward';
import { dicGuildActiveWeekReward } from './dictionary/DicGuildActiveWeekReward';
import { dicGuildActiveWays } from './dictionary/DicGuildActiveWays';
import { dicGuildPosition } from "./dictionary/DicGuildPosition";
import { dicMail } from "./dictionary/DicMail";
import { dicArmyTrainJuDian } from './dictionary/DicArmyTrainJuDian';
import { dicTrainSoloReward } from './dictionary/DicTrainSoloReward';
import { RewardInter } from "./interface";
import { dicArmyDevelopConsume } from '../pubUtils/dictionary/DicArmyDevelopConsume';
import { dicArmyBossRank } from '../pubUtils/dictionary/DicArmyBossRank';
import { dicArmyDonate } from '../pubUtils/dictionary/DicArmyDonateBoxReward';
import { dicRoleFriend } from "./dictionary/DicRoleFriend";
import { dicRoleFriendLv } from "./dictionary/DicRoleFriendLv";

export const gameData = {
    blurprtCompose: dicBlueprtCompose,
    blueprtPossibility: dicBlueprtPossibility,
    daily: dicDaily,
    event: dicEvent,
    expedition: dicExpedition,
    expeditionPoint: dicExpeditionPoint,
    funcsSwitch: dicFuncSwitch,
    goods: dicGoods,
    hero: dicHero,
    heroQualityUp: dicHeroQualityUp,
    heroSkill: dicHeroSkill,
    heroStar: dicHeroStar,
    heroWake: dicHeroWake,
    job: dicJob,
    jobClassMaxGrades: jobClassMaxGrades,
    jobClassAndgrades: jobClassAndgrades,
    kingexp: dicKingExp,
    maxPlayerLv: maxPlayerLv,
    charexp: dicCharExp,
    question: dicQuestion,
    se: dicSe,
    tower: dicTower,
    towerTask: dicTowerTask,
    war: dicWar,
    warJson: dicWarJson,
    xunbao: dicXunbao,
    btlBossHpSum: new Map<number, number>(),
    btlBossHp: new Map<number, Array<{dataId: number, hp: number, actorId: number}>>(),
    blueprtToWar: new Map<number, number>(),
    blueprt: blueprt,
    fashion: dicFashions,
    friendShips: friendShips,
    friendShipHidAandIds: friendShipHidAandIds,
    friendShipLevel: dicFriendShipLevel,
    friendShipLevelMap: dicFriendShipLevelMap,
    randomEffectPool: dicRandomEffectPool,
    strengthenCost: dicStrengthenCost,
    refine: dicRefine,
    jewels: dicJewel,
    dicHeroEquip: dicHeroEquip,
    suit: dicSuit,
    title: dicTitle,
    teraphs: dicTeraph,
    school: dicSchool,
    schoolRate: dicSchoolRate,
    heroScroll: dicHeroScroll,
    preHeroScroll: preHeroScroll,
    pvpOpponent: dicPvpOpponent,
    pvpTeamLevel: dicPvpTeamLevel,
    pvpWar: dicWarPvp,
    pvpRefreshConsume: dicPvpRefreshConsume,
    maxPvpRefreshCnt: maxPvpRefreshCnt,
    pvpGk: dicGkPvp,
    pvpGks: dicGkPvps,
    pvpHeroRewards: dicHeroRewads,
    pvpRankRewards: dicRankRewads,
    pvpBoxs: dicPvpBoxs,
    pvpRankMax: dicRankMax,
    guildAuth: dicGuildAuth,
    centerBase: dicCenterBase,
    equipProduceBase: dicEquipPriduceBase,
    bossBase: dicBossBase,
    trainBase: dicTrainBase,
    donateBase: dicDonateBase,
    armyWishPool: dicWishPoolBase,
    storeBase: dicStoreBase,
    structureConsume: dicStructureConsume,
    guildActiveDayReward: dicGuildActiveDayReward,
    guildActiveWeekReward: dicGuildActiveWeekReward,
    guildPosition: dicGuildPosition,
    armyTrainJuDian: dicArmyTrainJuDian,
    trainSoloReward: dicTrainSoloReward,
    mail: dicMail,
    guildActiveWays: dicGuildActiveWays,
    armyDevelopConsume: dicArmyDevelopConsume,
    armyBossRank: dicArmyBossRank,
    armyDonateBox: dicArmyDonate,
    roleFriend: dicRoleFriend,
    roleFriendLv: dicRoleFriendLv,
};

// 在此提供一些原先在gamedata中提供的方法，以便更方便获取gameData数据

/**
 * 根据主公当前经验获得当前等级
 * @param exp 累积经验
 */
export function getLvByExp(exp: number) {
    let curLv = 0;
    let entries = gameData.kingexp.entries();
    for (let [lv, {sum}] of entries) {
        curLv = lv;
        if(exp < sum) break;
    }

    return curLv;
}

/**
 * 根据主公当前等级，获得累积经验，1=> 1级满经验
 * @param lv 等级
 */
export function getExpByLv(lv: number) {
    return gameData.kingexp.get(lv);
}

/**
 * 根据武将当前经验获得当前等级
 * @param exp 累积经验
 */
export function getHeroLvByExp(exp: number) {
    let curLv = 0;
    let entries = gameData.charexp.entries();
    for (let [lv, sum] of entries) {
        curLv = lv;
        if(exp < sum) break;
    }

    return curLv;
}

/**
 * 根据武将当前等级，获得累积经验，1=> 1级满经验
 * @param lv 
 */
export function getHeroExpByLv(lv: number) {
    return gameData.charexp.get(lv);
}


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


export function getWarIdByBlueprtId(blueprtId: number) {
    let warId = gameData.blueprtToWar.get(blueprtId);
    if (!warId) {
        let blueprt = gameData.goods.get(blueprtId);
        if(blueprt) {
            const { specialAttr } = blueprt;
            warId = specialAttr.get(SPECIAL_ATTR.WAR_ID);
            if(warId)
                gameData.blueprtToWar.set(blueprtId, warId);
        }
    }
    return warId;
}

export function getHeroStarByQuality(quality: number, star: number) {
    return gameData.heroStar.get(`${quality}_${star}`);
}

export function getHeroWakeByQuality(quality: number, star: number) {
    return gameData.heroWake.get(`${quality}_${star}`);
}

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

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

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

export function getGoodById(gid:number) {
    return gameData.goods.get(gid);
}

export function getJewelById(gid:number) {
    return gameData.jewels.get(gid);
}

export function getHeroEquipByClassId(classId:number) {
    return gameData.dicHeroEquip.get(classId);
}

export function getHeroJob(jobId: number) {
    const job = gameData.job.get(jobId);
    return job;
}

export function getTitle(titleLv: number) {
    const titleInfo = gameData.title.get(titleLv);
    return titleInfo;
}

export function getTeraph(id: number, grade: number) {
    const teraphInfo = gameData.teraphs.get(id +'_'+ grade);
    return teraphInfo;
}

export function getSchoolRateByStar(star: number, colorStar: number, quality: number) {
    const schoolRate = gameData.schoolRate.get(`${star}_${colorStar}_${quality}`);
    return schoolRate;
}

export function getScollByStar(quality: number, star: number, curQuality: number, colorStar: number) {
    const heroScroll = gameData.heroScroll.get(`${quality}_${star}_${curQuality}_${colorStar}`);
    return heroScroll;
}

// 根据存在升星表等的stage字段的id对应17维id
export function getFieldByStage(stage: number, jobid: number) {
    let targetAttrId = ABI_TYPE_TO_STAGE.get(stage);
    if(typeof targetAttrId === 'number') {
        return targetAttrId
    } else {
        const dicJob = gameData.job.get(jobid);
        return targetAttrId(dicJob.type);
    }
}

export function getSuit(id: number) {
    const suitInfo = gameData.suit.get(id);
    return suitInfo;
}

export function getFuncsSwitch(id:number) {
    const funcInfo = gameData.funcsSwitch.get(id);
    return funcInfo;
}

export function getPLvByScore(score: number) {
    let lv = 0;
    for(let {teamLv, topFiveMin, topFiveMax} of gameData.pvpTeamLevel) {
        if(score >= topFiveMin) lv = teamLv;
        if(score < topFiveMax) break;
    }
    return lv;
}

export function getPvpGkByWarId (warId: number) {
    return gameData.pvpGk.get(warId);
}

export function getPvpGkWarIds() {
    let warIds = gameData.pvpGks;
    return warIds;
}

export function getPvpHeroRewards() {
    return gameData.pvpHeroRewards;
}

export function getPvpRankRewards() {
    return gameData.pvpRankRewards;
}

export function getPvpBoxs() {
    return gameData.pvpBoxs;
}

export function getResultMaxRank() {
    return gameData.pvpRankMax;
}

export function getStructureConsume(structureId: number, level: number) {
    return gameData.structureConsume.get(structureId).get(level);
}

export function hasStructureConsume(structureId: number, level: number) {
    return gameData.structureConsume.get(structureId).has(level);
}

export function getBossByLv(lv: number) {
    return gameData.bossBase.get(lv);
}

export function getArmyTrainJuDian(trainId: number) {
    return gameData.armyTrainJuDian.get(trainId);
}

export function getTrainSoloReward(id: number) {
    return gameData.trainSoloReward.get(id);
}

export function getTrainBaseByLv(lv: number) {
    return gameData.trainBase.get(lv);
}

export function getGuildActiveWeekReward(rank: number) {
    let result = gameData.guildActiveWeekReward.find(cur => {
        let {rankMax, rankMin} = cur;
        return rank >= rankMin && rank <= (rankMax || rankMax == -1);
    });
    let reward = new Array<RewardInter>();
    if(result) reward = result.reward;
    return reward;
}

export function getGuildActiveByIdAndType(id: number, type: number) {
    let dicWay = gameData.guildActiveWays.get(id);
    if(!dicWay) return 0;
    return dicWay.activePoint.get(type.toString());
}
export function getArmyDevelopConsumeById(id: number) {
    let result = gameData.armyDevelopConsume.get(id);
    return result;
}

export function getArmyDevelopConsume() {
    return gameData.armyDevelopConsume;
}

export function getArmyBossRank() {
    return gameData.armyBossRank;
}

export function getArmyDonateBaseByLv(lv: number) {
    return gameData.donateBase.get(lv);
}

export function getArmyDonateBoxBaseById(id: number) {
    return gameData.armyDonateBox.get(id);
}
export function getArmyWishPoolBaseByLv(lv: number) {
    return gameData.armyWishPool.get(lv);
}

export function getFriendLvByExp(exp: number) {
    let resultLv = 1;
    for(let [lv, {value}] of gameData.roleFriendLv) {
        resultLv = lv;
        if(exp < value) break;
    }
    return resultLv;
}