import { FriendPointModel } from './../db/FriendPoint';
import { STATUS } from './../consts/statusCode';
import { COM_BATTLE_ROBOT_ID_NAME, COM_TEAM_STATUS, CURRENCY_BY_TYPE, CURRENCY_TYPE, FRIEND_DROP_TYPE, COM_BTL_CONST, FRIEND_DROP_MAX } from './../consts';
import { RoleStatus, ComBattleTeamModel } from './../db/ComBattleTeam';
import { getBluePrtByQuality, getComBtlSetByQuality, getRewardByBlueprtId, getWarById, getWarIdByBlueprtId } from "../pubUtils/gamedata";
import { getRandEelm, getRandValue, resResult, ratioReward } from "../pubUtils/util";
import { getRandRobot } from "./battleService";

/**
 * 在给定的品质列表中随机返回一定数量的藏宝图Id
 * @param qualityArr 品质数组，在所有给定品质的藏宝图中筛选1
 * @param cnt 返回藏宝图数量
 */
export function getRandBlueprtId(qualityArr: Array<number>, cnt = 1) {
    if (!qualityArr || !qualityArr.length) return null;
    let blueprtIdArr = [];
    for (let q of qualityArr) {
        blueprtIdArr = blueprtIdArr.concat(getBluePrtByQuality(q));
    }
    if (blueprtIdArr.length === 0) return null;
    const res = getRandEelm(blueprtIdArr, cnt);
    return res;
}

export function getRandComBtlRobots(topFiveCe: number, lv: number, cnt: number) {
    let robotHeroes = getRandRobot(cnt); // 随机几个阵容
    // 创建并添加机器人
    let robotStArr = [], robotIdArr = [];
    for (let robot of robotHeroes) {
        const robotCe = getRandValue(topFiveCe || 0, COM_BTL_CONST.ROBOT_CE_RATIO, 0);
        const robotLv = getRandValue(lv, COM_BTL_CONST.ROBOT_CE_RATIO, 0);
        const imgHid = robot[Math.floor(Math.random() * robot.length)];
        const { robotRoleId, robotRoleName } = COM_BATTLE_ROBOT_ID_NAME[Math.floor(Math.random() * COM_BATTLE_ROBOT_ID_NAME.length)];
        let robotStatus = new RoleStatus(robotRoleId, robotRoleName, false, false, imgHid, imgHid, robotCe, robotLv, robot, true);
        robotStArr.push(robotStatus);
        robotIdArr.push(robotRoleId);
    }
    return {
        robotStArr, robotIdArr
    }
}

export function checkComBattleResult(teamStatus) {
    if (teamStatus.bossCurHp === 0) {
        return COM_TEAM_STATUS.WIN;
    } else {
        let allPlayerKilled = true;
        let robotRestHurt = 0;
        // 看看是否还有活人
        teamStatus.roleStatus.forEach(st => {
            // 设置了阵容，且阵容人数和阵亡人数一样，说明玩家战败
            if (!st.isRobot && st.heroes && ((st.heroes.length > 0 && st.killed.length < st.heroes.length) || st.heroes.length === 0)) {
                allPlayerKilled = false
            }
        });
        // 没有活人的话看看还有没有机器人没打完伤害
        if (allPlayerKilled && teamStatus.curRnd < COM_BTL_CONST.ROBOT_RND_LMT) {
            teamStatus.roleStatus.forEach(st => {
                if (st.isRobot) {
                    const deltaRnd = COM_BTL_CONST.ROBOT_RND_LMT - teamStatus.curRnd;
                    let hurtHp = getRandValue(teamStatus.bossHp / COM_BTL_CONST.ROBOT_RND_LMT * COM_BTL_CONST.ROBOT_HURT_RATIO, COM_BTL_CONST.ROBOT_HURT_CH_RATIO, 0) * deltaRnd; // 1 个机器人对 boss 造成的总伤害
                    robotRestHurt += hurtHp;
                }
            })
        }
        if (allPlayerKilled) {
            // 没有活人且机器人剩余伤害打不死 boss，战败
            if (teamStatus.bossCurHp > robotRestHurt) {
                return COM_TEAM_STATUS.LOOSE;
            } else {
                return COM_TEAM_STATUS.WIN;
            }
        }
    }
    return COM_TEAM_STATUS.FIGHTING;
}

/**
 * @description 计算寻宝结算-deprecated
 * @export
 * @param {string} roleId
 * @param {string} battleCode
 * @returns
 */
export async function checkComBattleDrop(roleId: string, battleCode: string) {
    let team = await ComBattleTeamModel.getTeamByRoleAndBattleCode(roleId, battleCode);
    if (team.status !== COM_TEAM_STATUS.WIN) return { status: -1, resResult: resResult(STATUS.COM_BATTLE_REWARD_ERR) };
    let roleSt = null;
    team.roleStatus.forEach(st => {
        if (st.roleId === roleId) {
            roleSt = st;
        }
    });
    if (!roleSt || roleSt.gotReward) return { status: -1, resResult: resResult(STATUS.COM_BATTLE_REWARD_ERR) };
    let fixReward = getRewardByBlueprtId(team.blueprtId);
    if (!roleSt.isCap) {
        if (roleSt.isFrd) {
            fixReward = '&';
        } else {
            fixReward = ratioReward(fixReward, COM_BTL_CONST.ASSIST_REWARD_RATIO);
        }
    }
    await ComBattleTeamModel.updateRewardSt(team.teamCode, roleId, true);
    return {status: 0, fixReward};
}

export function clearComBtlTimer(teamCode: string, timerMap: Map<string, NodeJS.Timer>) {
    let timer = timerMap.get(teamCode);
    if (timer) {
        clearTimeout(timer);
    }
}

export function setComBtlTimer(teamCode: string, timer: NodeJS.Timer, timerMap: Map<string, NodeJS.Timer>) {
    let preTimer = timerMap.get(teamCode);
    if (preTimer) {
        clearTimeout(preTimer);
    }
    timerMap.set(teamCode, timer);
}

export async function getRealReward(blueprtId: number, roleSt: RoleStatus) {
    let warInfo = getWarById(getWarIdByBlueprtId(blueprtId));
    let fixRewardStr = warInfo['fixReward'];
    if (!roleSt.isCap) {
        if (roleSt.isFrd) {
            let frdPointRec = await FriendPointModel.getFrdPointRecToday(roleSt.roleId, FRIEND_DROP_TYPE.COM_BATTLE);
            if (!frdPointRec || frdPointRec.cnt <= FRIEND_DROP_MAX.COM_BTL - COM_BTL_CONST.FRDCNT_DROP) {
                fixRewardStr = `${CURRENCY_BY_TYPE.get(CURRENCY_TYPE.FRIEND_POINT)}&${COM_BTL_CONST.FRDCNT_DROP}`;
            } else if (frdPointRec.cnt < FRIEND_DROP_MAX.COM_BTL) {
                fixRewardStr = `${CURRENCY_BY_TYPE.get(CURRENCY_TYPE.FRIEND_POINT)}&${COM_BTL_CONST.FRDCNT_DROP - frdPointRec.cnt}`;
            } else {
                fixRewardStr = '&';
            }
        } else {
            fixRewardStr = ratioReward(fixRewardStr, COM_BTL_CONST.ASSIST_REWARD_RATIO);
        }
    }
    return fixRewardStr;
}

export async function getAssistTimesByQuality(roleId: string, qualityArr?: Array<number>) {
    let teams = await ComBattleTeamModel.getAssistTeamsByTime(roleId, qualityArr, new Date(new Date().setHours(0, 0, 0, 0)), true);
    let cntMap = new Map<number, number>();
    teams.forEach(team => {
        if (team && team.quality && team.roleStatus) {
            for (let st of team.roleStatus) {
                if (st.roleId !== roleId || st.isFrd) {
                    continue;
                }
                let cnt = cntMap.get(team.quality) || 0;
                cntMap.set(team.quality, cnt + 1)
            }
        }
    });
    return cntMap;
}

export async function getFrd(roleId: string, quality: number) {
    let isFrd = false;
    let assistTimes = await getAssistTimesByQuality(roleId, [quality]);
    let assistTime = assistTimes.get(quality);
    let { assistanceTime } = getComBtlSetByQuality(quality);
    if (assistTime >= assistanceTime) isFrd = true;
    return isFrd;
}