import { BackendSession } from "pinus";
import { GVG_ACTIVE_TYPE, GVG_ITEM, GVG_RESOURCE_TYPE, GVG_SEED_TYPE, GVG_TECH_TYPE, ITEM_CHANGE_REASON, LEAGUE_JOB } from "../../consts";
import { GVGLeagueFarmModel, GVGLeagueFarmType } from "../../db/GVGLeagueFarm";
import { GVGLeaguePrepareModel, GVGLeaguePrepareType, Tech } from "../../db/GVGLeaguePrepare";
import { GVGUserDailyDataModel, GVGUserDailyDataType } from "../../db/GVGUserDailyData";
import { GVGUserDataModel, GVGUserDataType } from "../../db/GVGUserData";
import { GVGUserItemModel } from "../../db/GVGUserItem";
import { LeagueField } from "../../domain/gvgField/returnData";
import { calLeagueLv, gameData, getFieldMaxAddType } from "../../pubUtils/data";
import { GVG } from "../../pubUtils/dicParam";
import { RewardInter } from "../../pubUtils/interface";
import { nowSeconds } from "../../pubUtils/timeUtil";
import { getArrayOfNumber, getRandEelm, getRandValueByMinMax, parseGoodStr, sortArrRandom } from "../../pubUtils/util";
import { addGVGReward } from "./gvgItemService";
import { getGVGConfig } from "./gvgService";
import { getProduceCoinCnt } from "./gvgItemService";
import { GVGLeagueType } from "../../db/GVGLeague";
import { getCities } from "../guildActivity/guildActivityService";
import { getGVGCities } from "./gvgBattleService";

export function checkPreTech(techId: number, activeQueue: number[], techQueue: Tech[]) {
    const dicTech = gameData.gvgTech.get(techId);
    if(!dicTech) return false;

    let hasOrUnlock = dicTech.prepositionId.length == 0;
    for(let andArr of dicTech.prepositionId) { // or关系
        let hasAndUnlock = true;
        for(let id of andArr) { // and关系
            if(!checkTechIsIng(id, activeQueue, techQueue)) {
                hasAndUnlock = false; break;
            }
        }
        if(hasAndUnlock) hasOrUnlock = true;
    }
    return hasOrUnlock;
}

export function checkTechIsIng(techId: number, activeQueue: number[], techQueue: Tech[]) {
    return techQueue.findIndex(cur => cur.id == techId) != -1 || activeQueue.indexOf(techId) != -1
}

export function calProduce(obj: { food: number, mineral: number, wood: number }) {
    let { food = 0, mineral = 0, wood = 0 } = obj||{};
    return food + mineral + wood;
}

/**
 * 获得活跃
 * @param leagueCode 
 * @param roleId 
 * @param type GVG_ACTIVE_TYPE
 * @returns 
 */
export async function addGVGActive(leagueCode: string, roleId: string, type: GVG_ACTIVE_TYPE, count = 1) {
    let { configId } = getGVGConfig();

    let add = gameData.gvgActive.get(type)||0;
    let result = await GVGUserDataModel.addActive(configId, leagueCode, roleId, type, add * count);
    return result.active;
}

export async function addGVGTechActive(leagueCode: string, roleId: string) {
    let { configId } = getGVGConfig();
    let check = await GVGUserDailyDataModel.checkGetTechActive(configId, leagueCode, roleId);
    if(!check) {
        await GVGUserDailyDataModel.setHasGetTechActive(configId, leagueCode, roleId);
        return await addGVGActive(leagueCode, roleId, GVG_ACTIVE_TYPE.TECH_ACTIVATE);
    } else {
        const data = await GVGUserDataModel.findByRole(configId, leagueCode, roleId);
        return data?.active||0;
    }
}

export function getGVGDailyItems(job: number) {
    return job == LEAGUE_JOB.PRODUCER? parseGoodStr(GVG.GVG_PRODUCER_GET): parseGoodStr(GVG.GVG_FIGHTER_GET);
}

export async function getDailyLoginReward(roleId: string, roleName: string, sid: string, leagueCode: string, job: number) {
    let { configId } = getGVGConfig();
    if(job && !await GVGUserDailyDataModel.checkHasLogin(configId, leagueCode, roleId)) {
        // 发每日奖励
        await GVGUserDailyDataModel.setHasLogin(configId, leagueCode, roleId);
        let leagueGoods = await addGVGReward(roleId, roleName, leagueCode, sid, getGVGDailyItems(job), [], ITEM_CHANGE_REASON.GVG_LOGIN)
        let active = await addGVGActive(leagueCode, roleId, GVG_ACTIVE_TYPE.LOGIN);
        return { active, reward: leagueGoods }
    }
    return null;
}

export function getMyDistribute(userDailyData: GVGUserDailyDataType) {
    return {
        food: userDailyData?.food||0,
        mineral: userDailyData?.mineral||0,
        wood: userDailyData?.wood||0,
        score: userDailyData?.score||0,
    }
}

/**
 * 资源
 * @param leagueCode 联军id 
 * @param roleId 玩家id
 * @param resourceType 资源类型
 * @param count 数量
 * @returns 
 */
export async function addResource(leagueCode: string, roleId: string, resourceType: GVG_RESOURCE_TYPE, count: number) {
    let { configId } = getGVGConfig();
    let resources = getResourceCnt(resourceType, count);
    if(!resources) return false;
    let { food = 0, mineral = 0, wood = 0 } = resources;

    // 联军更新资源
    let league = await GVGLeaguePrepareModel.addResource(configId, leagueCode, food, mineral, wood);
    // 联军升级
    let lv = calLeagueLv(league.resources);
    league = await GVGLeaguePrepareModel.setLv(configId, leagueCode, lv);
    // 个人贡献更新
    await GVGUserDataModel.addResource(configId, leagueCode, roleId, food, mineral, wood);
    // 个人今日贡献更新
    let userDailyData = await GVGUserDailyDataModel.addResource(configId, leagueCode, roleId, food, mineral, wood);

    let myDistribute = getMyDistribute(userDailyData);

    return { resource: league.resources, lv: league.lv, myDistribute }
}

function getResourceCnt(resourceType: GVG_RESOURCE_TYPE, count: number) {
    switch(resourceType) {
        case GVG_RESOURCE_TYPE.FOOD: 
            return { food: count };
        case GVG_RESOURCE_TYPE.MINERAL:
            return { mineral: count };
        case GVG_RESOURCE_TYPE.WOOD:
            return { wood: count };
    }
}

export async function unlockField(leagueCode: string, roleId: string, farmId: number) {
    let { configId } = getGVGConfig(); 
    const produceCoinCnt = await getLockFieldCnt(leagueCode, roleId);
    if(produceCoinCnt == 0) return
    const leagueFarms = await GVGLeagueFarmModel.findByFarmId(configId, leagueCode, farmId);       
    // 查询现有的田
    let { maxAddTypeCntMap, myAddTypeCntMap, allLands, myFieldCnt, myLockField } = calCntFromFarms(farmId, leagueFarms, roleId);
    if(allLands.length <= 0 || myLockField >= produceCoinCnt) return; // 田数量不足 or 已经锁过了

    let allAdd = calAddType(myFieldCnt, myAddTypeCntMap, maxAddTypeCntMap, produceCoinCnt - myLockField);
    let randLand = sortArrRandom(getRandEelm(allLands, produceCoinCnt - myLockField));
    let lands: { fieldId: number, addType: number }[] = [];
    for(let fieldId of randLand) {
        let addType = 0;
        for(let [_addType, addCnt] of allAdd) {
            if(addCnt > 0) {
                addType = _addType; 
                allAdd.set(_addType, addCnt - 1);
                break;
            }
        }
        lands.push({ fieldId, addType });
    }
    // 更新田
    let result = await GVGLeagueFarmModel.lockFields(configId, leagueCode, farmId, roleId, lands);
    return await GVGLeagueFarmModel.findByFarmIdAndRoleId(configId, leagueCode, farmId, roleId);
}

function calCntFromFarms(farmId: number, leagueFarms: GVGLeagueFarmType[], roleId: string) {
    let maxAddTypeCntMap = getFieldMaxAddType(farmId); // 加成田最大数量
    let myAddTypeCntMap = new Map<number, number>();
    let myFieldCnt = 0; // 玩家已有的田有
    let myLockField = 0; // 玩家没有种只是锁住了的田
    let allLands = getArrayOfNumber(gameData.gvgResource.get(farmId)?.sum??0); // 全部可使用的田
    for(let leagueFarm of leagueFarms) {
        // 全联军
        if(leagueFarm.addType) maxAddTypeCntMap.set(leagueFarm.addType, maxAddTypeCntMap.get(leagueFarm.addType) - 1);
        if(leagueFarm.unlockTime >= nowSeconds()) {
            let index = allLands.indexOf(leagueFarm.fieldId);
            if(index > -1) allLands.splice(index);
        }

        // 玩家数据
        if(leagueFarm.lockRoleId == roleId && leagueFarm.unlockTime >= nowSeconds()) {
            if(leagueFarm.addType) {
                if(!myAddTypeCntMap.has(leagueFarm.addType)) myAddTypeCntMap.set(leagueFarm.addType, 0);
                myAddTypeCntMap.set(leagueFarm.addType, myAddTypeCntMap.get(leagueFarm.addType) + 1);
            }
            myFieldCnt++;
            if(leagueFarm.harvestTime == 0) myLockField++;
        }
    }
    return { maxAddTypeCntMap, myAddTypeCntMap, allLands, myFieldCnt, myLockField }
}

/**
 * 
 * @param myFieldCnt 我已种的田的数量
 * @param myAddTypeCntMap 我已种的田的有加成的田分别的数量
 * @param maxAddTypeCntMap 联军最多可以加成田的数量
 * @param count 本次可以加的田
 * @returns 
 */
function calAddType(myFieldCnt: number, myAddTypeCntMap: Map<number, number>, maxAddTypeCntMap: Map<number, number>, count: number) {
    let result = new Map<number, number>(); // 加成类型, 数量  
    let minSpField = Math.floor((myFieldCnt + count) * gameData.gvgSpFieldRatio.min / 100); // 最少需要这么多个特殊田
    let maxSpField = Math.floor((myFieldCnt + count) * gameData.gvgSpFieldRatio.max / 100); // 最多可以有这么多个特殊田
    let myAllAddFieldCnt = 0;
    for(let [_, cnt] of myAddTypeCntMap) myAllAddFieldCnt += cnt;
    if(myAllAddFieldCnt >= maxSpField) return result;

    let randCnt = getRandValueByMinMax(minSpField, maxSpField);

    for(let [addType, ratio] of gameData.gvgFieldAddType) { // 按比例加田
        let maxCnt = maxAddTypeCntMap.get(addType)||0;
        if(maxCnt == 0) continue;
        let cnt = Math.ceil(randCnt * ratio / 100);
        let resultCnt = maxCnt > cnt? cnt: maxCnt;
        myAllAddFieldCnt += resultCnt;
        maxAddTypeCntMap.set(addType, maxAddTypeCntMap.get(addType) - 1);
        result.set(addType, resultCnt);
    }
    if(myAllAddFieldCnt < minSpField) {
        for(let [addType, addCnt] of result) { // 如果还有多的塞一塞
            let maxCnt = maxAddTypeCntMap.get(addType)||0;
            if(maxCnt > addCnt) {
                let inc = maxCnt - addCnt > minSpField - myAllAddFieldCnt? minSpField - myAllAddFieldCnt: maxCnt - addCnt;
                result.set(addType, count + inc);
                myAllAddFieldCnt += inc;
                if(myAllAddFieldCnt >= minSpField) break;
            } else {
                break;
            }
        }
    }
    return result;
}

export async function rollbackUnPlantFields(cost: RewardInter[], plantResult: GVGLeagueFarmType[], session: BackendSession, leagueCode: string) {
    const roleId = session.get('roleId');
    const roleName = session.get('roleName');
    const sid = session.get('sid');
    let add: RewardInter[] = [];
    for(let { id, count } of cost) add.push({ id, count });
    for(let { seedType } of plantResult) {
        let index = add.findIndex(({ id }) => id == getItemIdOfSeedType(seedType));
        console.log('#### index', index);
        if(index != -1) {
            add[index].count --;
            if(add[index].count <= 0) add.splice(index);
        }
    }
    console.log('rollbackUnPlantFields', add, 'plantResult', plantResult)
    await addGVGReward(roleId, roleName, leagueCode, sid, add, [], ITEM_CHANGE_REASON.PLANT_ROLLBACK);
    return add;
}

// 计算实际消耗的种子
export function getCostSeedReward(plantResult: GVGLeagueFarmType[]) {
    const reward: RewardInter[] = [], leagueReward: RewardInter[] = [];
    for(let { seedType } of plantResult) {
        let itemId = getItemIdOfSeedType(seedType);
        let dicGVGItem = gameData.gvgItem.get(itemId);
        if(!dicGVGItem) continue;
        for(let { id, count } of dicGVGItem.reward) {
            let rewardObj = reward.find(({ id }) => id == id);
            rewardObj? rewardObj.count += count: reward.push({ id, count: count });
        }
        for(let { id, count } of dicGVGItem.leagueReward) {
            let rewardObj = leagueReward.find(({ id }) => id == id);
            rewardObj? rewardObj.count += count: leagueReward.push({ id, count: count });
        }
    }
    return { reward, leagueReward }
}

export function getItemIdOfSeedType(seedType: GVG_SEED_TYPE) {
    switch(seedType) {
        case GVG_SEED_TYPE.WHEAT:
            return GVG_ITEM.WHEAT;
        case GVG_SEED_TYPE.CORN:
            return GVG_ITEM.CORN;
        case GVG_SEED_TYPE.RICE:
            return GVG_ITEM.RICE;
    }
}

export async function getLockFieldCnt(leagueCode: string, roleId: string) {
    let { configId } = getGVGConfig();
    const itemIds = [GVG_ITEM.WHEAT, GVG_ITEM.CORN, GVG_ITEM.RICE, GVG_ITEM.PRODUCE_COIN];
    const items = await GVGUserItemModel.findByRoleAndIds(configId, leagueCode, roleId, itemIds);
    return items.reduce((pre, cur) => pre + cur.count, 0);
}

export async function getmyDistributeRank(leagueCode: string, members: { roleId: string }[], targetRoleId: string) {
    let { configId } = getGVGConfig();
    
    const roleIds = members.map(member => member.roleId);
    const userDatas = await GVGUserDataModel.findByRoles(configId, leagueCode, roleIds);
    userDatas.sort((a, b) => calProduce(b.distribute) - calProduce(a.distribute));
    for(let i = 0; i < userDatas.length; i++) {
        if(userDatas[i].roleId == targetRoleId) return i + 1;
    }
    return 0
}

export async function getLeagueFarmShowResult(leagueCode: string, roleId: string, farmId: number, needField = true) {
    let { configId } = getGVGConfig();
    const leagueFarms = await GVGLeagueFarmModel.findLockedByFarmId(configId, leagueCode, farmId);
    if(!needField) return { farmId, count: leagueFarms.length };
    
    const fields = await GVGLeagueFarmModel.findByFarmIdAndRoleId(configId, leagueCode, farmId, roleId);
    const result = fields.map(field => new LeagueField(field));
    return { farmId, count: leagueFarms.length, fields: result }
}

export async function calFarmOutputs(myResultFields: GVGLeagueFarmType[], league: GVGLeagueType, leaguePrepare: GVGLeaguePrepareType) {
    let cities = await getGVGCities(league);
    let [foodSum = 0, rewardSum = new Array<RewardInter>(), leagueRewardSum = new Array<RewardInter>(), activeSum = 0] = [];
    for(let { seedType, addType, farmId } of myResultFields) {
        let { food, reward, leagueReward, active } = calResourceResult(seedType, addType, farmId, cities||[], leaguePrepare?.activeTech||[]);
        foodSum += food;
        for(let { id, count } of reward) {
            let rewardObj = rewardSum.find(cur => cur.id == id);
            rewardObj? rewardObj.count += count: rewardSum.push({id, count});
        }
        for(let { id, count } of leagueReward) {
            let rewardObj = leagueRewardSum.find(cur => cur.id == id);
            rewardObj? rewardObj.count += count: leagueRewardSum.push({id, count});
        }
        activeSum += active;
    }
    return { foodSum, rewardSum, leagueRewardSum, activeSum }
}

function calResourceResult(seedType: number, addType: number, farmId: number, cities: number[], activeTech: number[]) {
    // 种子基础产量 * ( 1 + 格子加成 + 农庄等级加成 + 战力城池加成 + 科技树加成)
    let itemId = getItemIdOfSeedType(seedType);
    let dicGVGItem = gameData.gvgItem.get(itemId);
    let dicFarm = gameData.gvgResource.get(farmId);
    if(!dicGVGItem || !dicFarm) return {};
    let { value: foodBase, reward, leagueReward, leagueConsume } = dicGVGItem;
    let addRatio = seedType == addType? GVG.GVG_SP_FIELD_ADD: 0;
    let farmRatio = dicFarm.fieldAdd;
    let cityRatio = getCitiesAdd(cities);
    let techRatio = getTechAdd(activeTech);
    let produceCoin = getProduceCoinCnt(leagueConsume);

    return {
        food: Math.floor(foodBase * (1 + (addRatio + farmRatio + cityRatio + techRatio)/100)),
        reward, leagueReward, 
        active: produceCoin
    }
}

// TODO 城池加成，多城池取最大加成
function getCitiesAdd(cities: number[]) {
    return 0
}

// 科技树加成 叠加
function getTechAdd(activeTech: number[]) {
    let ratio = 0;
    for(let techId of activeTech) {
        let dicTech = gameData.gvgTech.get(techId);
        if(dicTech.type == GVG_TECH_TYPE.PRODUCE_UP) {
            ratio += dicTech.param[0];
        }
    }
    return ratio;
}