import { Application, ChannelService, HandlerService, } from 'pinus';
// import { sendRolesMails } from '../../../services/mailService';
import { reloadResources } from '../../../pubUtils/data';
import { HeroUpdate } from '../../../db/Hero';
import { RoleUpdate } from '../../../db/Role';
import { SkinUpdate } from '../../../db/Skin';
import { RankFirstModel, RankFirstType } from '../../../db/RankFirst';
import { getInitRoleInfo } from '../../../pubUtils/roleUtil';
import { DEFAULT_HEROES } from '../../../consts';
import { Figure } from '../../../domain/dbGeneral';
import { getDefaultRoleInfo } from '../../../services/roleService';
import { PVPConfigModel, PVPConfigType } from '../../../db/SystemConfig';
import { treatRoleName, taflush } from '../../../services/sdkService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { errlogger } from '../../../util/logger';

export default function (app: Application) {
    new HandlerService(app, {});
    return new RoleRemote(app);
}

export class RoleRemote {

    constructor(private app: Application) {
        this.app = app;
        this.channelService = app.get('channelService');
        this.setInitRole();
        this.loadRankFirst();
        this.initPvpSeasonNum();
    }
    private channelService: ChannelService;
    private initHeroes: Map<number, HeroUpdate> = new Map(); // hid => hero
    private initRole: RoleUpdate = {};
    private initSkins: Map<number, SkinUpdate> = new Map(); // hid => skin
    private figureInfo: {heads: Figure[], frames: Figure[], spines: Figure[]};
    private rankFirstRewards: Map<number, Map<number, RankFirstType>> = new Map();

    private async loadRankFirst() {
        let rankFirstRewards = await RankFirstModel.findAllRankRewards();
        for(let rank of rankFirstRewards) {
            if(!this.rankFirstRewards.has(rank.serverId)) {
                this.rankFirstRewards.set(rank.serverId, new Map());
            }
            this.rankFirstRewards.get(rank.serverId).set(rank.id, rank);
        }
        this.app.set('rankFirstRewards', this.rankFirstRewards);
    }

    public setRankFirst(rank: RankFirstType) {
        try {
            // console.log('****** setRankFirst', rank.serverId, rank.id, rank)
            if(!this.rankFirstRewards.has(rank.serverId)) {
                this.rankFirstRewards.set(rank.serverId, new Map());
            }
            this.rankFirstRewards.get(rank.serverId).set(rank.id, rank);
            this.app.set('rankFirstRewards', this.rankFirstRewards);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }

    }

    public getRankFirstById(serverId: number, id: number) {
        try {
            return this.rankFirstRewards.get(serverId)?.get(id);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public setInitRole() {
        try {
            let result = getInitRoleInfo();
            let { role, heroes, skins, figureInfo } = result;
            for(let hero of heroes) {
                this.initHeroes.set(hero.hid, hero);
            }
            for(let skin of skins) {
                this.initSkins.set(skin.hid, skin);
            }
            this.initRole = role;
            this.figureInfo = figureInfo;
            const initRoleInfos = getDefaultRoleInfo(this.initHeroes, this.initSkins, this.initRole, this.figureInfo);
            this.app.set('initRoleInfos', initRoleInfos);
            this.app.set('initHeroes', this.initHeroes);
            this.app.set('initSkins', this.initSkins);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public getInitRoleInfos() {
        try {
            let initRoleInfos = this.app.get('initRoleInfos');
            if (!initRoleInfos) {
                initRoleInfos = getDefaultRoleInfo(this.initHeroes, this.initSkins, this.initRole, this.figureInfo);
                this.app.set('initRoleInfos', initRoleInfos);
            }
            return initRoleInfos;
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public getInitHeroes() {
        try {
            let result: HeroUpdate[] = [];
            for(let hid of DEFAULT_HEROES) {
                result.push(this.initHeroes.get(hid));
            }
            return result;
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public getInitSkins() {
        try {
            let result: SkinUpdate[] = [];
            for(let hid of DEFAULT_HEROES) {
                result.push(this.initSkins.get(hid));
            }
            return result;
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public getInitHeroById(hid: number) {
        try {
            return {
                heroInfo: this.initHeroes.get(hid),
                skinInfo: this.initSkins.get(hid)
            }
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }


    /**
     * 重载json资源
     */
    public async reloadResources() {
        try {
            reloadResources();
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }


    public setPvpSeasonNum(pvpConfig: PVPConfigType) {
        try {
            if(pvpConfig) {
                this.app.set('pvpSeasonNum', pvpConfig.seasonNum);
                this.app.set('pvpSeasonEndTime', pvpConfig.seasonEndTime);
            }
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public async initPvpSeasonNum() {
        try {
            let pvpConfig = await PVPConfigModel.findCurPVPConfig();
            this.setPvpSeasonNum(pvpConfig);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public async treatRoleName(roleId: string) {
        try {
            await treatRoleName(roleId);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public setServerMainten(serverIds: number[], startTime: number, endTime: number) {
        try {
            setServerMainten(serverIds, startTime, endTime);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public stopServerMainten(serverIds: number[]) {
        try {
            stopServerMainten(serverIds);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public getServerMainten(serverId: number) {
        try {
            return getServerMainten(serverId);
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }

    public taflush() {
        try {
            return taflush();
        } catch(e) {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }
}