// 征战中原相关

import { GVG_PERIOD, STATUS, VESTIGE_OPP_STATUS, VESTIGE_STATUS } from "../../consts";
import { ArtifactModel } from "../../db/Artifact";
import { GVGVestigeModel } from "../../db/GVGVestige";
import { GVGVestigeLockModel } from "../../db/GVGVestigeLock";
import { GVGVestigeRankModel, GVGVestigeRankType, GVGVestigeRankUpdate } from "../../db/GVGVestigeRank";
import { GVGVestigeRecType } from "../../db/GVGVestigeRec";
import { HeroModel, HeroType } from "../../db/Hero";
import { RoleModel, RoleType } from "../../db/Role";
import { OppDetailData, OppDetailHeroData, OppPlayerHeroInfo, OppPlayerInfo } from "../../domain/gvgField/gvgDb";
import { GVGVestigeOppPlayer } from "../../domain/gvgField/returnData";
import { gameData, getGVGVestigeRange } from "../../pubUtils/data";
import { GVG } from "../../pubUtils/dicParam";
import { RewardInter } from "../../pubUtils/interface";
import { getTimeFun } from "../../pubUtils/timeUtil";
import { getRandEelm, getRandValueByMinMax, resResult } from "../../pubUtils/util";
import { getNumberArr, uniqueArr } from "../ladderService";
import { getHeroesAttributes } from "../playerCeService";
import { getAllServerName } from "../redisService";
import { combineItems } from "../role/util";
import { getGroupIdOfServer, getGVGServerType } from "./gvgService";

// 备战期的遗迹和激战期的开始结束战斗时间
export function getFightTimeByPeriod(period: GVG_PERIOD) {
    let dicPeriod = gameData.gvgPeriod.get(period);
    if(!dicPeriod) return { startFightTime: 0, endFightTime: 0 };

    return {
        startFightTime: <number>getTimeFun().getTimeWithHour(dicPeriod.startHour, dicPeriod.startMinute, dicPeriod.startSecond),
        endFightTime: <number>getTimeFun().getTimeWithHour(dicPeriod.endHour, dicPeriod.endMinute, dicPeriod.endSecond),
    }
}

// 征战中原每天随机的遗迹点
export async function getVestiges(serverId: number) {
    let groupId = await getGroupIdOfServer(serverId);
    let serverType = await getGVGServerType(serverId);
    let vestige = await GVGVestigeModel.getVestige(groupId);
    if(!vestige) {
        let dicGVGVestige = gameData.gvgVestigeByServerType.get(serverType)||[];
        let cnt = gameData.gvgVestigeCntByServerType.get(serverType)||0;
        let randResult = getRandEelm(dicGVGVestige, cnt);
        vestige = await GVGVestigeModel.initTodayVestige(groupId, serverType, randResult);
    }
    return vestige.vestiges||[];
}

export async function checkVestige(serverId: number, vestigeId: number) {
    let vestiges = await getVestiges(serverId);
    return !!vestiges.find(cur => cur.vestigeId == vestigeId);
}

// 根据自己排名随机出对手排名
export function refreshVestigeOppRanks(rank: number) {
    let dicRange = getGVGVestigeRange(rank);
    if(!dicRange) return [];
    
    let { rangeBeforeFrom, rangeBeforeTo, rangeBeforeNum, rangeAfterFrom, rangeAfterTo, rangeAfterNum } = dicRange;
    let beforeRanks = randomRank(rangeBeforeFrom == -1? rank: rangeBeforeFrom, rangeBeforeTo == -1? rank: rangeBeforeTo, rangeBeforeNum);
    let afterRanks = randomRank(rangeAfterFrom == -1? rank: rangeAfterFrom, rangeAfterTo == -1? rank: rangeAfterTo, rangeAfterNum);

    let topRanks = getNumberArr(dicRange.topChallengeFrom + 1, dicRange.topChallengeTo);
    let ranks = [...topRanks, ...beforeRanks, ...afterRanks];
    return uniqueArr(ranks.sort((a, b) => a - b));
}

function randomRank(min: number, max: number, len: number) {
    if(min == max || len == 0) return [];
    let arr = getNumberArr(min + 1, max);
    return getRandEelm(arr, len);
}

// 根据ranks获取oppPlayer显示数据
export async function getOppPlayerByRanks(serverId: number, groupId: number, vestigeId: number, ranks: number[]) {
    let serverNames = await getAllServerName();
    let opps = await GVGVestigeRankModel.findByRanks(groupId, vestigeId, ranks);
    let dicRankMap = gameData.gvgVestige.get(vestigeId);
    if(!dicRankMap) return [];
    let result: GVGVestigeOppPlayer[] = [];
    for(let rank of ranks) {
        let obj = new GVGVestigeOppPlayer(rank);
        let opp = opps.find(cur => cur.rank == rank);
        let dicCurRank = dicRankMap.get(rank);
        if(opp) {
            let role = <RoleType>opp.role;
            let lineupce = opp.lineup.reduce((pre, cur) => pre + cur.ce, 0);
            obj.setByRole(role, serverNames, lineupce, dicCurRank?.score||0);
        } else {
            obj.setByDic(dicCurRank, serverNames[serverId]);
        }
        result.push(obj);
    }
    
    return result;
}

// 获取其他遗迹里使用过的武将
export async function getVestigeUsedHeroes(roleId: string, curVestigeId: number) {
    let myDatas = await GVGVestigeRankModel.findAllByRole(roleId);
    let result: number[] = [];
    for(let { vestigeId, lineup = [] } of myDatas) {
        if(vestigeId == curVestigeId) continue;
        result.push(...lineup.map(cur => cur.actorId));
    }
    return result;
}

// 是否在其他遗迹中使用过这个武将
export async function checkHeroIsUsedInOtherVestige(roleId: string, curVestigeId: number, heroes: { actorId: number }[]) {
    let usedHeroes = await getVestigeUsedHeroes(roleId, curVestigeId);
    for(let { actorId } of heroes) {
        if(usedHeroes.indexOf(actorId) != -1) return true;
    }
    return false;
}

// 检查我的排名是否可以挑战对方的排名
export function checkVestigeRank(myRank: number, targetRank: number) {
    let dicRange = getGVGVestigeRange(myRank);
    if(!dicRange) return false;
    if(myRank == targetRank || targetRank == 0) return false;

    // 是否可以挑战最前的几个排名
    if(dicRange.topChallengeFrom <= targetRank && dicRange.topChallengeTo >= targetRank) return true;
    if(dicRange.rangeBeforeTo == -1) {
        if(dicRange.rangeBeforeFrom < targetRank && myRank > targetRank) return true;
    } else {
        if(dicRange.rangeBeforeFrom < targetRank && dicRange.rangeBeforeTo >= targetRank) return true;
    }
    if(dicRange.rangeAfterTo == -1) {
        if(dicRange.rangeAfterFrom < targetRank && myRank > targetRank) return true;
    } else {
        if(dicRange.rangeAfterFrom < targetRank && dicRange.rangeAfterTo >= targetRank) return true;
    }

    return false;
}

export function isRobot(roleId: string) {
    if(!roleId) roleId = '';
    return roleId.startsWith('robot');
}

export async function checkVestigeOppStatus(configId: number, groupId: number, vestigeId: number, roleId: string, myRank: number, targetRoleId: string, rank: number) {
    
    let myData = await GVGVestigeRankModel.findByRole(vestigeId, roleId);
    if(!myData) {
        let role = await RoleModel.findByRoleId(roleId, 'roleId');
        let oppRanks = refreshVestigeOppRanks(-1);
        myData = await GVGVestigeRankModel.initRank(configId, vestigeId, groupId, role, oppRanks );
    }
    if(myData?.rank != myRank) return VESTIGE_OPP_STATUS.MY_RANK_CHANGE;

    if(isRobot(targetRoleId)) {
        let targetData = await GVGVestigeRankModel.findByRank(vestigeId, rank);
        if(targetData) return VESTIGE_OPP_STATUS.OPP_RANK_CHANGE;
    } else {
        let targetData = await GVGVestigeRankModel.findByRole(vestigeId, targetRoleId);
        if(targetData?.rank != rank) return VESTIGE_OPP_STATUS.OPP_RANK_CHANGE;
    }
    let lockResult = await GVGVestigeLockModel.chooseOppLock(groupId, vestigeId, rank, configId, roleId, targetRoleId);
    if(!lockResult) return VESTIGE_OPP_STATUS.OPP_IS_LOCKED;

    return VESTIGE_OPP_STATUS.BATTLE;
}

// 生成防守数据
export async function generateDefenseInfo(roleId: string, vestigeId: number, rank: number) {
    if(isRobot(roleId)) {
        let dicRank = gameData.gvgVestige.get(vestigeId)?.get(rank); // 调用之前已经验证过了
        let dicWar = gameData.war.get(dicRank?.warId);
        let dicWarJson = gameData.warJson.get(dicWar?.dispatchJsonId);
        if(!dicWarJson) return new OppPlayerInfo();

        let heroes: OppPlayerHeroInfo[] = [];
        for(let json of dicWarJson) {
            if(json.relation == 2) {
                let hero = new OppPlayerHeroInfo();
                hero.setByWarJson(json);
                heroes.push(hero);
            }
        }
        let info = new OppPlayerInfo();
        info.initByRobot(dicRank, heroes, true);
        return info;
    } else {
        let playerVestigeData = await GVGVestigeRankModel.findByRole(vestigeId, roleId);
        if(!playerVestigeData) return null;
        let lineup = playerVestigeData.lineup||[];
        let hids = lineup.map(cur => cur.actorId);
        let role = await RoleModel.findByRoleId(playerVestigeData.roleId, 'roleId roleName heads head frames frame spines spine title lv');
        let heroes = await HeroModel.findByHidRange(hids, playerVestigeData.roleId, 'hid skinId lv star colorStar quality ce');

        let info = new OppPlayerInfo();
        info.initByPlayer(playerVestigeData.rank, role, true);
        info.setPlayerHeroes(heroes, lineup);
        return info;
    }
}

export async function generateAttackInfo(roleId: string, rank: number) {
    let role = await RoleModel.findByRoleId(roleId, 'roleId roleName heads head frames frame spines spine title lv');
    let info = new OppPlayerInfo();
    info.initByPlayer(rank, role, false);
    return info;
}

export async function generateAttackHeroInfo(lineup: { actorId: number, dataId: number, order: number }[], dbHeroes: HeroType[]) {
    let info = new OppPlayerInfo();
    info.setPlayerHeroes(dbHeroes, lineup);
    return info;
}

export async function getOppDetailData(rec: GVGVestigeRecType) {
    let isRobot = rec.defenseInfo.isRobot;
    let dicLadderDifficultRatio = gameData.ladderDifficultRatio.get(rec.defenseInfo.oldRank);
    let result = new OppDetailData(rec, getVestigeRecStatus(rec));
    if(!isRobot) {
        const dicWar = gameData.war.get(dicLadderDifficultRatio.gkId);
        const dicWarJson = gameData.warJson.get(dicWar.dispatchJsonId);
        const defenseInfo = rec.defenseInfo.heroes||[];
        const hids = defenseInfo.map(cur => cur.hid);
        const heroes = await HeroModel.findByHidRange(hids, rec.defenseRoleId, 'hid lv quality star colorStar');
        const artifactSeids = heroes.map(hero => hero.artifact);
        const artifacts = await ArtifactModel.findbySeqIds(rec.defenseRoleId, artifactSeids);
        result.setByPlayer(dicWarJson, defenseInfo, heroes, artifacts);
        let attrByHid = await getHeroesAttributes(rec.defenseRoleId);
        for(let [hid, attribute] of attrByHid) {
            result.setAttribute(hid, attribute.getAttributesToString());
        }
    }

    return result;

}

// 根据记录里的时间判断当前状态
export function getVestigeRecStatus(rec: GVGVestigeRecType) {
    let { checkTime = 0, battleTime = 0, endTime = 0, cancel } = rec;
    if(cancel) return { status: VESTIGE_STATUS.COMPLETE, time: endTime };
    if(endTime > 0 && endTime <= Date.now()) return { status: VESTIGE_STATUS.COMPLETE, time: endTime };
    if(battleTime > 0 && battleTime <= Date.now() && battleTime + GVG.GVG_VESTIGE_BATTLE_COUNTDOWN * 1000 > Date.now()) return { status: VESTIGE_STATUS.BATTLE, time: battleTime + GVG.GVG_VESTIGE_BATTLE_COUNTDOWN * 1000 };
    if(checkTime > 0 && checkTime <= Date.now() && checkTime + GVG.GVG_VESTIGE_PREPARE_COUNTDOWN * 1000 > Date.now()) return { status: VESTIGE_STATUS.CHECK, time: checkTime + GVG.GVG_VESTIGE_PREPARE_COUNTDOWN * 1000 };
    // 超时的
    if(battleTime > 0 && endTime == 0 && battleTime + GVG.GVG_VESTIGE_BATTLE_COUNTDOWN * 1000 <= Date.now()) return { status: VESTIGE_STATUS.COMPLETE, time: battleTime + GVG.GVG_VESTIGE_BATTLE_COUNTDOWN };
    if(checkTime > 0 && battleTime == 0 && checkTime + GVG.GVG_VESTIGE_PREPARE_COUNTDOWN * 1000 <= Date.now()) return { status: VESTIGE_STATUS.COMPLETE, time: checkTime + GVG.GVG_VESTIGE_PREPARE_COUNTDOWN };
    return { status: VESTIGE_STATUS.NO, time: 0 };
}

// 将开始战斗时候的阵容存到防守阵容
export async function updateMyVestigeRank(isChange: boolean, atkData: GVGVestigeRankType, historyRank: number, rec: GVGVestigeRecType) {
    let update: GVGVestigeRankUpdate = {}, needUpdate = false;
    if(isChange) {
        if(atkData && !atkData.hasDefense) { // 只有第一次挑战且自己没有主动保存过阵容的时候才会这么保存
            let heroes = rec.attackInfo.heroes||[];
            let lineup = heroes.map(hero => ({ actorId: hero.hid, dataId: hero.dataId, order: hero.order, ce: hero.ce }));
            update.lineup = lineup;
            update.hasDefense = true;
            needUpdate = true;
        }
        if(atkData && atkData.rank > historyRank) { // 更新历史最高排名
            update.historyRank = atkData.rank;
            needUpdate = true;
        }
        if(atkData) { // 排名变化时刷新对手
            let oppRanks = refreshVestigeOppRanks(atkData.rank);
            update.oppRanks = oppRanks;
            needUpdate = true;
        }
    }
    if(needUpdate) {
        atkData = await GVGVestigeRankModel.updateByRoleId(atkData.vestigeId, atkData.roleId, update);
    }
    return atkData
}

export function calBreakGoods(vestige: number, historyRank: number, rank: number) {
    let dicRankMap = gameData.gvgVestige.get(vestige);
    if(!dicRankMap) return { rewards: [], leagueRewards: [] };
    let rewards: RewardInter[] = [], leagueRewards: RewardInter[] = [];
    for(let i = historyRank + 1; i <= rank; i++) {
        let dicRank = dicRankMap.get(i);
        if(!dicRank) continue;
        for(let { id, count } of dicRank.onceReward) {
            let obj = rewards.find(obj => obj.id == id);
            if(!obj) {
                rewards.push({ id, count });
            } else {
                obj.count += count;
            }
        }
        for(let { id, count } of dicRank.onceLeagueReward) {
            let obj = leagueRewards.find(obj => obj.id == id);
            if(!obj) {
                leagueRewards.push({ id, count });
            } else {
                obj.count += count;
            }
        }
    }
    return { rewards, leagueRewards }
}