// 军团建筑物
import {readJsonFile, parseGoodStr, parseNumberList, decodeArrayListStr} from '../util'
import { FILENAME } from '../../consts'
import { RewardInter } from '../interface';
const _ = require('lodash');

type KeysEnum<T> = { [P in keyof Required<T>]: true };
// 中军大帐
export interface DicCentreBase {
    // id
    readonly id: number;
    // 等级
    readonly level: number;
    // 最大人数
    readonly peopleNum: number;
    // 管理员人数
    readonly managerNum: number;
}

const DicCenterKeys: KeysEnum<DicCentreBase> = {
    id: true,
    level: true,
    peopleNum: true,
    managerNum: true
};

// 炼器堂
export interface DicEquipProduceBase {
    // id
    readonly id: number;
    // 等级
    readonly level: number;
    // 开启炼器及研发等级
    readonly levelProduce: number;
    // 可研发的碎片的品质
    readonly qualityProduce: number[];
}

const DicEquipProduceKeys: KeysEnum<DicEquipProduceBase> = {
    id: true,
    level: true,
    levelProduce: true,
    qualityProduce: true
};

// 演武台
export interface DicBossBase {
    // id
    readonly id: number;
    // 等级
    readonly level: number;
    // boss等级
    readonly bossLevel: number;
    // 关卡id
    readonly wars: Array<{warId:number, bossHp:number}>;
    // 掉落的拍卖行奖励
    readonly reward: RewardInter[];

    readonly consume: number;
}

const DicBossKeys: KeysEnum<DicBossBase> = {
    id: true,
    level: true,
    bossLevel: true,
    wars: true,
    reward: true,
    consume: true
};

// 练兵场
export interface DicTrainBase {
    // id
    readonly id: number;
    // 等级
    readonly level: number;
    // 进阶等级
    readonly trainLevel: number;
    // 难度系数
    readonly difficultyRatio: number;
    // 据点奖励增长系数
    readonly judianRewardRatio: number;

    readonly shilianRewardRatio: number;
}

const DicTrainKeys: KeysEnum<DicTrainBase> = {
    id: true,
    level: true,
    trainLevel: true,
    difficultyRatio: true,
    judianRewardRatio: true,
    shilianRewardRatio: true
};

// 捐献所
export interface DicDonateBase {
    // id
    readonly id: number;
    // 等级
    readonly level: number;
    // 捐献值
    readonly donateValue: {type: number, count: number}[];
    // 捐献奖励
    readonly donateReward: {fund: number, active: number}[];
    // 今日捐献宝箱领取奖励系数
    readonly boxRewardRatio: number;
}

const DicDonateKeys: KeysEnum<DicDonateBase> = {
    id: true,
    level: true,
    donateValue: true,
    donateReward: true,
    boxRewardRatio: true
};

// 许愿池
export interface DicWishPoolBase {
    // id
    readonly id: number;
    // 等级
    readonly level: number;
    // 许愿物品
    readonly wishGoodsEquip: { quality: number, count: number }[];
    // 许愿将魂
    readonly wishGoodsHero: { quality: number, count: number }[];
}

const DicWishPoolKeys: KeysEnum<DicWishPoolBase> = {
    id: true,
    level: true,
    wishGoodsEquip: true,
    wishGoodsHero: true
};

// 商店
export interface DicStoreBase {
    // id
    readonly id: number;
    // 等级
    readonly level: number;
    // 许愿物品
    readonly storeGoods: {id: number, count: number, num: number}[];
}

const DicStoreKeys: KeysEnum<DicStoreBase> = {
    id: true,
    level: true,
    storeGoods: true
};

export const dicStructureConsume = new Map<number, Map<number, number>>(); // 升级消耗 structureId => level => consume
export const dicCenterBase = new Map<number, DicCentreBase>(); // 中军大帐
export const dicEquipPriduceBase = new Map<number, DicEquipProduceBase>(); // 炼器堂
export const dicBossBase = new Map<number, DicBossBase>(); // 演武台
export const dicTrainBase = new Map<number, DicTrainBase>(); // 练兵场
export const dicDonateBase = new Map<number, DicDonateBase>(); // 捐献所
export const dicWishPoolBase = new Map<number, DicWishPoolBase>(); // 许愿池
export const dicStoreBase = new Map<number, DicWishPoolBase>(); // 许愿池
export let maxMemberCnt = 0; // 满配最大人数

// 中军大帐
const strCenter = readJsonFile(FILENAME.DIC_GUILD_STRUCTURE_CENTER);
let arrCenter = JSON.parse(strCenter);
arrCenter.forEach(o => {
    setStructureConsume(o);
    if(o.peopleNum > maxMemberCnt) maxMemberCnt = o.peopleNum;
    dicCenterBase.set(o.level, _.pick(o, Object.keys(DicCenterKeys)));
});
arrCenter = undefined;

// 炼器堂
const strEquip = readJsonFile(FILENAME.DIC_GUILD_EQUIP_PRODUCE_BASE);
let arrEquip = JSON.parse(strEquip);
arrEquip.forEach(o => {
    setStructureConsume(o);
    o.qualityProduce = parseNumberList(o.qualityProduce);
    dicEquipPriduceBase.set(o.level, _.pick(o, Object.keys(DicEquipProduceKeys)));
});
arrEquip = undefined;

// 演武台
const strBoss = readJsonFile(FILENAME.DIC_GUILD_BOSS_BASE);
let arrBoss = JSON.parse(strBoss);
arrBoss.forEach(o => {
    setStructureConsume(o);
    o.reward = parseGoodStr(o.reward);
    o.wars = o.warIdHP.split('|').map((warStrs)=> {
        if (!warStrs) {
            return;
        }
        let warArr = warStrs.split('&');
        return { warId: parseInt(warArr[0]), bossHp: parseInt(warArr[1])}
    });
    dicBossBase.set(o.level, _.pick(o, Object.keys(DicBossKeys)));
});
arrBoss = undefined;

// 练兵场
const strTrain = readJsonFile(FILENAME.DIC_GUILD_TRAIN_BASE);
let arrTrain = JSON.parse(strTrain);
arrTrain.forEach(o => {
    setStructureConsume(o);

    dicTrainBase.set(o.level, _.pick(o, Object.keys(DicTrainKeys)));
});
arrTrain = undefined;

// 捐献所
const strDonate = readJsonFile(FILENAME.DIC_GUILD_DONATE_BASE);
let arrDonate = JSON.parse(strDonate);
arrDonate.forEach(o => {
    setStructureConsume(o);
    o.donateValue = parseDonateValue(o.donatevalue);
    o.donateReward = parseDonateReward(o.donateReward);
    dicDonateBase.set(o.level, _.pick(o, Object.keys(DicDonateKeys)));
});
arrDonate = undefined;

// 许愿池
const strWishPool = readJsonFile(FILENAME.DIC_GUILD_WISH_POOL_BASE);
let arrWishPool = JSON.parse(strWishPool);
arrWishPool.forEach(o => {
    setStructureConsume(o);
    o.wishGoodsEquip = parseWishGoods(o.wishgoodsEquip);
    o.wishGoodsHero = parseWishGoods(o.wishgoodsHero);
    dicWishPoolBase.set(o.level, _.pick(o, Object.keys(DicWishPoolKeys)));
});
arrWishPool = undefined;

// 商店
const strStore = readJsonFile(FILENAME.DIC_GUILD_STORE_BASE);
let arrStore = JSON.parse(strStore);
arrStore.forEach(o => {
    setStructureConsume(o);
    o.storeGoods = parseStoreGoods(o.storeGoods);
    dicStoreBase.set(o.level, _.pick(o, Object.keys(DicStoreKeys)));
});
arrStore = undefined;

// 升级消耗
function setStructureConsume(o) {
    let map = dicStructureConsume.get(o.structureId);
    if(!map) map = new Map<number, number>();
    map.set(o.level, o.consume);
    dicStructureConsume.set(o.structureId, map);
}

// {"type": number, "count": number} 
export function parseDonateValue(str: string) {
    let result = new Array<{ type: number, count: number }>();
    if (!str) return result;
    let decodeArr = decodeArrayListStr(str);
    for (let [type, count] of decodeArr) {
        if (isNaN(parseInt(type)) || isNaN(parseInt(count))) {
            throw new Error('data table format wrong');
        }
        result.push({ type: parseInt(type), count: parseInt(count) });
    }
    return result
}

// {"fund": number, "active": number} 
export function parseDonateReward(str: string) {
    let result = new Array<{ fund: number, active: number }>();
    if (!str) return result;
    let decodeArr = decodeArrayListStr(str);
    for (let [fund, active] of decodeArr) {
        if (isNaN(parseInt(fund)) || isNaN(parseInt(active))) {
            throw new Error('data table format wrong');
        }
        result.push({ fund: parseInt(fund), active: parseInt(active) });
    }
    return result
}

// { "quality": number, "count": number}
export function parseWishGoods(str: string) {
    let result = new Array<{ quality: number, count: number }>();
    if (!str) return result;
    let decodeArr = decodeArrayListStr(str);
    for (let [quality, count] of decodeArr) {
        if ( isNaN(parseInt(quality))|| isNaN(parseInt(count))) {
            throw new Error('data table format wrong');
        }
        result.push({ quality: parseInt(quality), count: parseInt(count) });
    }
    return result
}

// {"id": number, "count": number, "num": number}
export function parseStoreGoods(str: string) {
    let result = new Array<{ id: number, count: number, num: number }>();
    if (!str) return result;
    let decodeArr = decodeArrayListStr(str);
    for (let [id, count, num] of decodeArr) {
        if (isNaN(parseInt(id)) || isNaN(parseInt(count))|| isNaN(parseInt(num))) {
            throw new Error('data table format wrong');
        }
        result.push({ id: parseInt(id), count: parseInt(count), num: parseInt(num) });
    }
    return result
}