/**
 * 体力系统
 */
import { PvpDefenseModel, Heroes, OppPlayers, Robot } from '../db/pvpDefense';
import { RoleType } from '../db/Role';
import { PVP_PLAYER_POS, PVP_HERO_POS, ROBOT_NAME } from '../consts';

import { dicPvpOpponent } from "../pubUtils/dictionary/DicPvpOpponent";
import { getRandomIndexByLen, genCode, getRandomByLen } from '../pubUtils/util';
import { gameData } from "../pubUtils/data";


export async function initPvpInfo(role: RoleType) {
    let heroes: Array<Heroes> = [];
    //初始化最强5人阵容
    for (let i = 0; i < role.topFive.length; i++) {
        let item = role.topFive[i];
        if (item.hid) {
            heroes.push({
                actorId: item.hid,
                hero: item.hero,
                ce: item.ce,
                dataId: PVP_HERO_POS.START + i,
                order: i + 1,
            });
        }
    }
    //初始化对手人阵容TODO
    let oppPlayers: Array<OppPlayers> = await refreshEnemies(role, 0, 1);
    
    let result = await PvpDefenseModel.createPvpDefense({ roleId: role.roleId, roleName: role.roleName, heroes, oppPlayers, defCe: role.topFiveCe });
    //加入排行榜 TODO
    return result;
}

export async function checkPvp(role: RoleType) {
    let result = await PvpDefenseModel.findByRoleId(role.roleId);
    if (!!result)
        return result;
    result = await initPvpInfo(role);
    return result;
}



// 刷新对手
export async function refreshEnemies(role: RoleType, score: number, pLv: number) {
    let { roleId, topFiveCe } = role;
    let oppPlayers = new Array<OppPlayers>();
    let opp = dicPvpOpponent.values()
    for(let { id, maxLv, minLv, ratio } of opp) {
        let flag = false; // 是否筛选成功
        if(score > 3000) { // TODO 将这个放到const
            flag = await matchPlayer(oppPlayers,  id, roleId, pLv + minLv, pLv + maxLv);
            // TODO 当前后分数段没有时，返回前一名的玩家
            if(!flag) flag = matchRobot(oppPlayers, id, topFiveCe, ratio);
        } else {
            flag = matchRobot(oppPlayers, id, topFiveCe, ratio);
        }
        if(!flag) continue;
    }
    
    return oppPlayers;
}

async function matchPlayer(oppPlayers: OppPlayers[], pos: number, roleId: string, minLv: number, maxLv: number ) {
    let range = await PvpDefenseModel.findByTeamLv(minLv, maxLv);
    if(range.length <= 0) return false;

    let index = getRandomIndexByLen(range.length);
    let result = range[index];
    if(!result) return false;
    if(result.roleId == roleId) {
        range.splice(index, 1);
        if(range.length <= 0) return false;
        index = getRandomIndexByLen(range.length);
        result = range[range.length];
    }
    
    oppPlayers.push({
        oppDef: result._id,
        pos,
        isRobot: false,
        robot: null
    });
    return true;
}

function matchRobot(oppPlayers: OppPlayers[], pos: number, myCe: number, ratio: number) {
    let range = gameData.pvpWar;
    if(range.length <= 0) return false;

    let index = getRandomIndexByLen(range.length);
    let result = range[index];
    if(!result) return false;

    let roleId = generateRobotRoleId();
    let roleName = getRandomByLen(ROBOT_NAME);
    let robot = new Robot(roleId, roleName, Math.floor(myCe * ratio), result.war_id)
    oppPlayers.push({
        oppDef: null,
        pos,
        isRobot: true,
        robot
    });
    return true
}

function generateRobotRoleId() {
    return `${genCode(10)}_r`;
}

export function checkRoleIsRobot(roleId: string) {
    return !!roleId.match(/_r/);
}