// 存在激战期的内存数据

import { pinus } from "pinus";
import { GVG_PERIOD } from "../../consts";
import { GVGTeamModel, GVGTeamType } from "../../db/GVGTeam";
import { GVGTeamMem } from "../../domain/battleField/gvgBattle";
import { dispatch } from "../../pubUtils/dispatcher";
import { getGVGPeriodData } from "./gvgService";

// 积分点占领情况，groupId_serverType_cityId -> GVGBattleData
const gvgBattleMap: Map<string, GVGBattleData> = new Map();

class GVGBattleData {
    public groupId: number;     // 战区
    public serverType: number;  // 单服还是跨服

    private teams: Map<string, GVGTeamMem> = new Map(); // 队伍, teamCode => team
    private rolePoints: Map<string, number[]> = new Map(); // roleId => pointId[]，用于更新玩家的积分
    private roleToTeam: Map<string, string[]> = new Map(); // roleId => teamCode
    private areaToTeams: Map<number, Set<string>> = new Map(); // areaId => teamCode set，用于定时下发地图玩家数据
    private hasRobot: Map<number, boolean> = new Map(); // cityId => boolean
    
    constructor(groupId: number, serverType: number) {
        this.groupId = groupId;
        this.serverType = serverType;
    }

    public findTeamsByArea(areaId: number) {
        let teamCodes = this.areaToTeams.get(areaId)||new Set();
        let teams: GVGTeamMem[] = [];
        for(let teamCode of teamCodes) {
            let team = this.teams.get(teamCode);
            if(team) teams.push(team);
        }
        return teams.slice(0, 20);
    }

    public leaveCity(roleId: string) {
        let teamCodes = this.roleToTeam.get(roleId)||[];
        for(let teamCode of teamCodes) {
            let team = this.teams.get(teamCode);
            if(team) team.setCity(0);
        }
        this.rolePoints.delete(roleId);
    }

    public enterCity(teams: GVGTeamType[]) {
        for(let team of teams) {
            let fromAreaId = this.teams.get(team.teamCode)?.areaId||0;

            if(!this.teams.has(team.teamCode)) {
                this.teams.set(team.teamCode, new GVGTeamMem(team))
            }
            this.teams.get(team.teamCode).setCity(team.cityId, team.areaId, team.pointId);
            if(team.pointId > 0) {
                if(!this.rolePoints.has(team.roleId)) this.rolePoints.set(team.roleId, []);
                this.rolePoints.get(team.roleId).push(team.pointId);
            }
            let teamCodesOfRole = this.roleToTeam.get(team.roleId)||[];
            if(teamCodesOfRole.indexOf(team.teamCode) == -1) teamCodesOfRole.push(team.teamCode);
            this.roleToTeam.set(team.roleId, teamCodesOfRole);
            this.setAreaMap(team.teamCode, fromAreaId, team.areaId);

            if(team.isRobot) this.hasRobot.set(team.cityId, team.isRobot);
        }
    }

    private setAreaMap(teamCode: string, fromAreaId: number, toAreaId: number) {
        if(fromAreaId == toAreaId) return;
        let fromAreaSet = this.areaToTeams.get(fromAreaId);
        if(fromAreaSet && fromAreaSet.has(teamCode)) fromAreaSet.delete(teamCode);

        if(!this.areaToTeams.has(toAreaId)) {
            this.areaToTeams.set(toAreaId, new Set());
        }
        if(!this.areaToTeams.get(toAreaId).has(teamCode)) {
            this.areaToTeams.get(toAreaId).add(teamCode);
        }
    }

    public move(teamCode: string, areaId: number, fromAreaId: number, startMoveTime: number, stopMoveTime: number) {
        let team = this.teams.get(teamCode);
        if(!team) return;
        team.moveToArea(areaId, fromAreaId, startMoveTime, stopMoveTime);
        this.setAreaMap(teamCode, fromAreaId, areaId);
    }

    public setTime(teamCode: string, teamUpdate: GVGTeamType) {
        let team = this.teams.get(teamCode);
        if(!team) return;
        team.attackTime = teamUpdate.attackTime;
        team.defenseTime = teamUpdate.defenseTime;
    }

    // 队伍入驻积分点
    public teamSettle(teamCode: string, pointId: number) {
        let team = this.teams.get(teamCode);
        if(!team) return;
        team.pointId = pointId;
    }

    public checkHasRobot(cityId: number) {
        return this.hasRobot.get(cityId)||false;
    }
}

export function getGVGBattleData(groupId: number, serverType: number) {
    let key = `${groupId}_${serverType}`;
    if(!gvgBattleMap.has(key)) {
        gvgBattleMap.set(key, new GVGBattleData(groupId, serverType));
    }
    return gvgBattleMap.get(key);
}

export async function initTeamToMem() {
    let sid = pinus.app.getServerId();
    let servers = pinus.app.getServersByType('guild');
    let { configId, period } = getGVGPeriodData();
    if(period != GVG_PERIOD.BATTLE) return;
    let teams = await GVGTeamModel.findByConfigId(configId);
    for(let team of teams) {
        if(dispatch(team.cityId.toString(), servers)?.id == sid) {
            let teamObj = getGVGBattleData(team.groupId, team.serverType);
            teamObj.enterCity([team]);
        }
    }
}