import { GVGTeamMem } from "../../domain/battleField/gvgBattle";
import { GVGLeagueType } from "../../db/GVGLeague";
import { GVGTeamModel, GVGTeamType, GVGTeamUpdate } from "../../db/GVGTeam";
import { GVGCityModel, GVGCityType } from "../../db/GVGCity";
import { gameData, getGVGBattleRankReward } from "../../pubUtils/data";
import { GVG_AREA_TYPE, GVG_BATTLE_RANK_TYPE, GVG_TECH_TYPE, MAIL_TYPE, PUSH_ROUTE, REDIS_KEY, STATUS } from "../../consts";
import { nowSeconds } from "../../pubUtils/timeUtil";
import { DicGVGAreaPoint } from "../../pubUtils/dictionary/DicGVGAreaPoint";
import { getGVGBattleData, getGVGBattleMap } from "./gvgBattleMemory";
import { GVGCityMapInfo, GVGTeamInList, GVGTeamInListOnPoint, GVGTeamSpineInMap } from "../../domain/gvgField/returnData";
import { GVG } from "../../pubUtils/dicParam";
import { GVGHeroInfo, PvpEnemies, PvpHeroInfo } from "../../domain/dbGeneral";
import { getGVGConfig } from "./gvgService";
import { GVGLeaguePrepareModel } from "../../db/GVGLeaguePrepare";
import { pinus } from "pinus";
import { dispatch } from "../../pubUtils/dispatcher";
import { Rank } from "../rankService";
import { LeagueRankInfo, RoleRankInfo } from "../../domain/rank";
import { findKeys, getAllServerName } from "../redisService";
import { sendMessageToChannel, sendMessageToCityWithSuc, sendMessageToGVGAreaByTeamWithSuc, sendMessageToGVGAreaWithSuc, sendMessageToGVGCityWithSuc } from "../pushService";
import { sendMailToLeagueByContent } from "../mailService";


/**
 * TODO 检查上周是否有占领城池
 * @param league 
 * @returns boolean 是否占领
 */
export async function checkHasCities(league: GVGLeagueType) {
    return false
}

/**
 * TODO 获取本联军上周占领的城池
 * @param league 
 * @returns number[] 城池id
 */
export async function getGVGCities(league: GVGLeagueType) {
    return []
}

/**
 * 获取当前城池状态
 * @returns [{cityId: number, guardLeagueCode: string, guardLeagueName: string, teamCnt: number }]
 */
export async function getGVGCitiesInfo(configId: number, groupId: number, serverType: number, league: GVGLeagueType): Promise<{cityId: number, guardLeagueName: string, teamCnt: number }[]> {
    let cities = await GVGCityModel.findGuardCityByLeague(configId, groupId, serverType);
    let result: GVGCityMapInfo[] = [];
    for(let city of cities) {
        let players = (city.players||[]).filter(cur => cur.leagueCode == league.leagueCode);
        let obj = new GVGCityMapInfo(city, players.length);
        result.push(obj);
    }
    return result;
}

/**
 * 获取内存中队伍的数据结构
 */
export function getGVGTeamMemInfo(team: GVGTeamType): GVGTeamMem {
    const teamMem = new GVGTeamMem(team);
    teamMem.isMoving = false;
    teamMem.startMoveTime = 0;
    teamMem.stopMoveTime = 0;
    return teamMem;
}

export function getBirthAreaOfCity(city: GVGCityType, leagueCode: string) {
    let isGuard = city.guardLeague == leagueCode;
    let dicGVGCity = gameData.gvgCity.get(city.cityId);
    return isGuard? dicGVGCity.defenseBirth: dicGVGCity.attackBirth;
}

// guild.gvgBattleHandler.startMove 检测
export function checkMoveStatus(team: GVGTeamType, cityId: number, areaId: number) {
    if(!team) return STATUS.GVG_BATTLE_TEAM_NOT_FOUND;
    if(team.cityId != cityId) return STATUS.GVG_BATTLE_IS_NOT_IN_CITY;
    if(team.pointId > 0) return STATUS.GVG_BATTLE_TEAM_IS_SELLTED;
    if(team.stopMoveTime > nowSeconds()) return STATUS.GVG_BATTLE_IS_MOVING;
    let dicArea = gameData.gvgArea.get(areaId);
    if(!dicArea) return STATUS.DIC_DATA_NOT_FOUND;
    if(dicArea.relateArea.indexOf(team.areaId) == -1) return STATUS.GVG_BATTLE_AREA_NOT_RELATE;
    return STATUS.SUCCESS;
}

export async function initRobots(configId: number, groupId: number, serverType: number, cityId: number) {
    let robotTeams = await GVGTeamModel.findRobotTeams(groupId, serverType, cityId);
    let updateDicPoints: DicGVGAreaPoint[] = [];
    let { areaIds = []} = gameData.gvgCity.get(cityId);
    for(let [_, point] of gameData.gvgAreaPoint) {
        if(areaIds.indexOf(point.areaId) == -1) continue;
        let robotTeam = robotTeams.find(team => team.pointId == point.pointId);
        if(!robotTeam || (!robotTeam.isBroken && robotTeam.configId != configId) ) {
            updateDicPoints.push(point);
        }
    }
    if(updateDicPoints.length > 0) {
        robotTeams = await GVGTeamModel.initRobots(configId, groupId, serverType, cityId, updateDicPoints);
        // 存入内存
        let teamObj = getGVGBattleData(groupId, serverType);
        teamObj.enterCity(...robotTeams);
    }
    return robotTeams;
}

export function checkAreaIsInCity(cityId: number, areaIds: number[]) {
    let dicCity = gameData.gvgCity.get(cityId);
    if(!dicCity) return false;
    for(let areaId of areaIds) {
        if(dicCity.areaIds.indexOf(areaId) == -1) return false;
    }
    return true;
}

export function calBattleScoreByCe(isSuccess: boolean, lineupCe: number) {
    let winScore = Math.floor(lineupCe/GVG.GVG_BATTLE_SCORE);
    if(winScore <= 0) winScore = 1;
    return isSuccess? winScore: 0;
}

export async function teamBreak(city: GVGCityType, team: GVGTeamType) {
    if(team.durability > 0) return team
    let areaId = getBirthAreaOfCity(city, team.leagueCode);
    team = await GVGTeamModel.teamBreak(team.teamCode, team.isRobot, team.maxDurability, areaId);
    return team;
}

export function getGVGWarId(defenseTeam: GVGTeamType) {
    if(!defenseTeam.isRobot) return GVG.GVG_CITY_BGMAP_GKID; // 玩家防守地图
    if(!defenseTeam.isCatapult) return GVG.GVG_CATAPULT_WARJSON; // 投石车使用
    return GVG.GVG_ROBOT_WARJSON; // 据点守卫使用
}

// guild.gvgBattleHandler.battleStart 里的heroes返回
export function getOppHeroes(warId: number, isRobot: boolean, lineup: GVGHeroInfo[]) {
    let heroes: PvpEnemies[] = [];
    const dicWar = gameData.war.get(warId);
    if(!dicWar) { console.error(`warId ${warId} not found`); return [] }
    const dicWarJson = gameData.warJson.get(dicWar.dispatchJsonId)||[];
    for(let warJson of dicWarJson) {
        if(!isRobot) {
            let heroInfo = lineup.find(cur => cur.dataId == warJson.dataId);
            if(!heroInfo) continue;
            let hero = new PvpEnemies(warJson, heroInfo);
            heroes.push(hero);
        } else {
            if(warJson.relation == 2) {
                let dicHero = gameData.hero.get(warJson.actorId);
                if(!dicHero) continue;
                let heroInfo = new PvpHeroInfo();
                heroInfo.setRobotInfo(dicHero, warJson.lv);
                let hero = new PvpEnemies(warJson, heroInfo);
                heroes.push(hero);
            }
        }
    }
    return heroes
}

// guild.gvgBattleHandler.battleStart 检测
export function checkGVGBattleStart(roleId: string, attackTeam: GVGTeamType, defenseTeam: GVGTeamType) {

    if(!attackTeam || !defenseTeam) return STATUS.GVG_BATTLE_TEAM_INVALID;
    if(attackTeam.roleId != roleId) return STATUS.GVG_TEAM_IS_NOT_MINE;
    if(attackTeam.leagueCode == defenseTeam.leagueCode) return STATUS.GVG_SAME_LEAGUE_CANNOT_ATTACK;
    if(attackTeam.areaId != defenseTeam.areaId) return STATUS.GVG_TEAM_NOT_SAME_AREA;

    if(attackTeam.attackTime > nowSeconds()) return STATUS.GVG_TEAM_ATTACKING;
    if(defenseTeam.defenseTime > nowSeconds() || defenseTeam.lockTime > nowSeconds()) return STATUS.GVG_TEAM_DEFENSEING;
    if(attackTeam.durability <= 0) return STATUS.GVG_ATTACK_TEAM_BROKEN;
    if(defenseTeam.durability <= 0) return STATUS.GVG_DEFENSE_TEAM_BROKEN;
    
    return STATUS.SUCCESS;
}

// ——————————  定时器相关  —————————— //
// gvg激战期开始定时器
export async function gvgBattleStart() {
    let servers = pinus.app.getServersByType('guild');

    let { configId } = getGVGConfig();
    let guardCities = await GVGCityModel.findAllGuardCities(configId);
    for(let { cityId, groupId, serverType, guardLeague, guardLeagueName } of guardCities) {
        let sid = dispatch(cityId.toString(), servers)?.id;
        await pinus.app.rpc.guild.guildRemote.initCatapult.toServer(sid, cityId, groupId, serverType, guardLeague, guardLeagueName);
    }
}

// 每次活动开始初始化投石车
export async function initCatapult(cityId: number, groupId: number, serverType: number, leagueCode: string, leagueName: string) {
    let { configId } = getGVGConfig();

    let leaguePrepare = await GVGLeaguePrepareModel.findByLeague(configId, leagueCode);
    let activeTech = leaguePrepare?.activeTech||[];
    let hasCatapult = false, atk = 0, durability = 0;
    for(let techId of activeTech) {
        let dicTech = gameData.gvgTech.get(techId);
        if(dicTech && dicTech.type == GVG_TECH_TYPE.BATTLE_ITEM_CATAPULT) {
            hasCatapult = true, atk = dicTech.param[0]; durability = dicTech.param[1];
        }
    }
    if(hasCatapult) {
        let dicCity = gameData.gvgCity.get(cityId);
        let areaIds = (dicCity?.areaIds||[]).filter(areaId => {
            let dicArea = gameData.gvgArea.get(areaId);
            return dicArea && dicArea.areaType == GVG_AREA_TYPE.CATAPULT;
        });
        let teams = await GVGTeamModel.initCatapult(configId, groupId, serverType, cityId, leagueCode, leagueName, areaIds, atk, durability);
        // 处理内存
        let teamObj = getGVGBattleData(groupId, serverType);
        teamObj.enterCity(...teams);
    }
}

// 投石车投伤害
export async function catapultHurt() {
    for(let [_key, teamObj] of getGVGBattleMap()) {
        let teams = teamObj.findCatapult();
        for(let catapult of teams) {
            if(catapult.isBroken) continue;
            let dicArea = gameData.gvgArea.get(catapult.areaId);
            let relateArea = dicArea?.relateArea||[];
            let teamCodes = teamObj.findCatapultAttackTeam(relateArea, catapult.leagueCode);
            let dicGVGCity = gameData.gvgCity.get(catapult.cityId);
            let teams = await GVGTeamModel.attackByCatapult(teamCodes, catapult.captapultAtk, dicGVGCity.attackBirth)
            teamObj.battleEnd(teams);
            await sendMessageToGVGAreaByTeamWithSuc(teamObj.groupId, teamObj.serverType, catapult.areaId, PUSH_ROUTE.GVG_TEAM_ATTACKED, { 
                cityId: catapult.cityId, areaId: catapult.areaId, attackType: 1, teams: teams.map(team => new GVGTeamInList(team))
            });
            for(let team of teams) {
                await pushTeamBeHurtMessage(team);
            }
        }
    }
}

// 排行榜积分更新
export async function addBattleRankScore(gvgTeam: GVGTeamType, incScore: number) {
    let { configId, groupId, serverType, cityId, roleId, leagueCode, isRobot } = gvgTeam;
    if(isRobot) return;

    let r1 = new Rank(REDIS_KEY.GVG_BATTLE_RANK, { configId, groupId, serverType, cityId });
    r1.setRankWithRoleInfo(roleId, incScore, Date.now(), null, true);

    let r2 = new Rank(REDIS_KEY.GVG_BATTLE_LEAGUE_RANK, { configId, groupId, serverType, cityId });
    r2.setRankWithLeagueInfo(leagueCode, incScore, Date.now(), null, true);
}

// 获取排行榜
export async function getBattleRanks(configId: number, groupId: number, serverType: number, cityId: number, myLeague: GVGLeagueType) {
    let r = new Rank(REDIS_KEY.GVG_BATTLE_LEAGUE_RANK, { configId, groupId, serverType, cityId });
    r.setGenerFieldsFun((obj => {
        if(obj instanceof LeagueRankInfo) {
            return { rank: obj.rank, leagueCode: obj.code, leagueName: obj.name, score: obj.num }   
        }
        return obj
    }));

    let { ranks, myRank } = await r.getRankListWithMyRank({ leagueCode: myLeague.leagueCode });
    if (!myRank) {
        myRank = await r.generMyRankWithLeague(myLeague.leagueCode, 0, 0, myLeague);
    }
    return { ranks, myRank }
}

// 每5秒一次结算
export async function gvgBattleSeconds() {
    const { configId } = getGVGConfig();
    const serverNames = await getAllServerName();
    let keys: { groupId: number, serverType: number, cityId: number }[] = []
    for(let [_key, teamObj] of getGVGBattleMap()) {
        // 每5秒给据点上的人加积分
        let teams = teamObj.findSettledPoint();
        for(let teamMem of teams) {
            if(teamMem.isBroken || teamMem.durability <= 0) continue;
            let addScore = gameData.gvgAreaPoint.get(teamMem.pointId)?.score||0;
            let team = await GVGTeamModel.addScore(teamMem.teamCode, addScore);
            await addBattleRankScore(team, addScore);
        }
        // 向下推送区域数据
        for(let areaId of teamObj.findAreas()) {
            let dicArea = gameData.gvgArea.get(areaId);
            let teams = teamObj.findTeamsByArea(areaId);
            let result = teams.map(team => new GVGTeamSpineInMap(team, serverNames));
            await sendMessageToGVGAreaWithSuc(teamObj.groupId, teamObj.serverType, areaId, PUSH_ROUTE.GVG_AREA_SPINE_CHANGE, { cityId: dicArea.cityId, areaId, spines: result });
            
            let index = keys.findIndex(cur => cur.cityId == dicArea.cityId && cur.groupId == teamObj.groupId && cur.serverType == teamObj.serverType);
            if(index == -1) keys.push({ groupId: teamObj.groupId, serverType: teamObj.serverType, cityId: dicArea.cityId });
        }

    }

    for(let { groupId, serverType, cityId } of keys) {
        let r = new Rank(REDIS_KEY.GVG_BATTLE_LEAGUE_RANK, { configId, groupId, serverType, cityId });
        let rawRanks = await r.getRankByRange();
        let ranks = rawRanks.map(obj => {
            if(obj instanceof LeagueRankInfo) {
                return { rank: obj.rank, leagueCode: obj.code, leagueName: obj.name, score: obj.num }   
            }
            return obj
        })
        await sendMessageToGVGCityWithSuc(groupId, serverType, cityId, PUSH_ROUTE.GVG_CITY_RANK_UPDATE, { cityId, ranks });
    
    }

}

export async function gvgBattleEnd() {
    let { configId } = getGVGConfig();
    let guardLeagueCnt = new Map<string, number>();

    // 城池占领情况
    let keys = await findKeys(`${REDIS_KEY.GVG_BATTLE_LEAGUE_RANK}:${configId}:`);
    let rankKeys = keys.map(key => {
        let [,, _groupId, _serverType, _cityId] = key.split(':');
        return { groupId: parseInt(_groupId), serverType: parseInt(_serverType), cityId: parseInt(_cityId) };
    }).sort((a, b) => b.cityId - a.cityId);

    for(let { groupId, serverType, cityId } of rankKeys) {
        let r = new Rank(REDIS_KEY.GVG_BATTLE_LEAGUE_RANK, { configId, groupId, serverType, cityId });
        let ranks = await r.getRankByRange();
        // 排名最高占领城池
        for(let obj of ranks) { 
            let rank = <LeagueRankInfo>obj;
            let cnt = guardLeagueCnt.get(rank.code)||0;
            if(cnt < GVG.GVG_CITY_OCCUPIED_NUMBER) {
                await GVGCityModel.guardCity(configId, groupId, serverType, cityId, rank);
                guardLeagueCnt.set(rank.code, cnt + 1);
                break;
            }
        }
        // 联军排行榜发放奖励
        for(let _obj of ranks) {
            let obj = <LeagueRankInfo>_obj;
            let dicRank = getGVGBattleRankReward(GVG_BATTLE_RANK_TYPE.LEAGUE, obj.rank);
            await sendMailToLeagueByContent(MAIL_TYPE.GVG_BATTLE_LEAGUE_RANK_REWARD, obj.code, { params: [`${obj.rank}`], goods: dicRank.reward });
        }
    }

    // 个人排行榜发放奖励
    let playerKeys = await findKeys(`${REDIS_KEY.GVG_BATTLE_RANK}:${configId}:`);
    for(let key of playerKeys) {
        let [,, _groupId, _serverType, _cityId] = key.split(':');
        let groupId = parseInt(_groupId);
        let serverType = parseInt(_serverType);
        let cityId = parseInt(_cityId);
        let r = new Rank(REDIS_KEY.GVG_BATTLE_LEAGUE_RANK, { configId, groupId, serverType, cityId });
        let ranks = await r.getRankByRange();

        for(let _obj of ranks) {
            let obj = <RoleRankInfo>_obj;
            let dicRank = getGVGBattleRankReward(GVG_BATTLE_RANK_TYPE.PLAYER, obj.rank);
            await sendMailToLeagueByContent(MAIL_TYPE.GVG_BATTLE_PLAYER_RANK_REWARD, obj.roleId, { params: [`${obj.rank}`], goods: dicRank.reward });
        }
    }

}

// ——————————  定时器相关 end  —————————— //

// ——————————  推送相关  —————————— //
// 推送
export async function battleEndSendMessage(groupId: number, serverType: number, cityId: number, defenseTeam: GVGTeamType, attackTeam: GVGTeamType) {
    // 推送伤害
    await sendMessageToGVGAreaByTeamWithSuc(groupId, serverType, defenseTeam.areaId, PUSH_ROUTE.GVG_TEAM_ATTACKED, { 
        cityId, areaId: defenseTeam.areaId, attackType: 3, teams: [new GVGTeamInList(defenseTeam), new GVGTeamInList(attackTeam)] 
    });
    await pushTeamBeHurtMessage(defenseTeam, attackTeam);
    await pushTeamBeHurtMessage(attackTeam);
}

// 队伍移动
export async function pushTeamBeHurtMessage(team: GVGTeamType, replaceTeam?: GVGTeamType) {

    if(team.curTeamBreak && team.originPointId > 0) {
        await sendMessageToGVGAreaByTeamWithSuc(team.groupId, team.serverType, team.originPointId, PUSH_ROUTE.GVG_AREA_POINT_CHANGE, { 
            cityId: team.cityId, areaId: team.originPointId, point: new GVGTeamInListOnPoint(team.originPointId, replaceTeam && !replaceTeam.curTeamBreak, replaceTeam)
        });
    }

    await pushTeamMoveMessage(team);
    if(team.isRobot && team.isBroken) {
        await sendMessageToGVGAreaByTeamWithSuc(team.groupId, team.serverType, team.fromAreaId, PUSH_ROUTE.GVG_PLAYER_LEAVE_AREA, { 
            cityId: team.cityId, areaId: team.areaId, teamCode: team.teamCode
        });
    }
}

export async function pushTeamMoveMessage(team: GVGTeamType) {
    if(team.fromAreaId != team.areaId) {
        if(team.fromAreaId > 0) {
            await sendMessageToGVGAreaByTeamWithSuc(team.groupId, team.serverType, team.fromAreaId, PUSH_ROUTE.GVG_PLAYER_LEAVE_AREA, { 
                cityId: team.cityId, areaId: team.fromAreaId, teamCode: team.teamCode
            });
        }
        if(team.areaId > 0) {
            await sendMessageToGVGAreaByTeamWithSuc(team.groupId, team.serverType, team.fromAreaId, PUSH_ROUTE.GVG_PLAYER_AREA_ADD, { 
                cityId: team.cityId, areaId: team.fromAreaId, player: new GVGTeamInList(team)
            });
        }
    }
}
// ——————————  推送相关 end  —————————— //