/**
 * 体力系统
 */

import { scheduleJob, Job  } from 'node-schedule';
import { SystemConfigModel } from '../db/SystemConfig';
import PvpDefenseType,{ PvpDefenseModel } from '../db/PvpDefense';
import { PVP } from '../pubUtils/dicParam';
import { nowSeconds, getTodayZeroPoint } from '../pubUtils/timeUtil';
import { getPvpGkWarIds, getPvpRankRewards, getPvpHeroRewards } from '../pubUtils/data';
import { deepCopy, getRandomArr } from '../pubUtils/util';
import { getLvByScore } from './pvpService';
import { getMyRank, setRank, getRedis } from './redisService';
import { REDIS_KEY } from '../consts';
import { RankParam } from '../pubUtils/interface';
import { RoleModel } from '../db/Role';
import { MailModel, MailType } from '../db/Mail';
import { pinus } from 'pinus';
import { indexOf } from 'underscore';
import { JsxEmit } from 'typescript';
const PER_SECOND = 1 * 1000;
const PER_DAY = 24 * 60 * 60;
const SETTLE_DIFF = 29 * 60;
const LIMIT_NUM = 1000;
var seasonJobId;
var warJobId;
export async function init() {
    let seasonEndTime = 0;
    let systemConfig = await SystemConfigModel.findSystemConfig();
    if (!systemConfig) {
        let warIds = getPvpGkWarIds();
        let warId = warIds[0];//TODO随机地图
        seasonEndTime = PVP.PVP_SEASON_DAYS * PER_DAY + getTodayZeroPoint();
        systemConfig = await SystemConfigModel.createSystemConfig( seasonEndTime, warId );
    } else {    
        seasonEndTime = systemConfig.seasonEndTime;
        if (systemConfig.seasonEndTime - SETTLE_DIFF <= nowSeconds()) {
            await setPvpSeasonResult({name: 'simpleJobExample' + systemConfig.seasonNum, notSetNext: true });
            seasonEndTime = PVP.PVP_SEASON_DAYS * PER_DAY + getTodayZeroPoint();
            systemConfig.seasonNum++;
            await SystemConfigModel.updateSystemConfig({ seasonEndTime, seasonNum: systemConfig.seasonNum});
        }
    }
    let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
    seasonJobId = scheduleJob(settleTime, setPvpSeasonResult, { name: 'setPvpSeasonResult' });
    warJobId = scheduleJob("0 0 0 * * 3", resetPvpWarId);
}

export async function setPvpSeasonResult(obj:{ name:string, notSetNext?: boolean }) {
    console.log('exce setPvpSeasonResult'+ obj?.name);
    let { seasonNum, seasonEndTime } = await setNextPvpTime(obj?.notSetNext);
    for (let page = 0; page < 3; page++) {
        let pvpDefenses = await PvpDefenseModel.getPvpDef(500, page);
        let addMails = new Array<MailType>();
        let pushMessage = new Array<any>();
        for (let pvpDefense of pvpDefenses) {
            if (pvpDefense.seasonNum !== seasonNum) {
                await setPvpDefResultOnTime(pvpDefense, seasonNum, seasonEndTime, addMails, pushMessage);
            }
        }
        await MailModel.addMails(addMails);
        for (let message of pushMessage) {      
            pinus.app.rpc.connector.connectorRemote.pushMessage.toServer(message.sid, message.uid, message.route, message.data);
        }
    }
    return { seasonNum, seasonEndTime };
}

export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime:number, addMails: Array<MailType>, pushMessage:Array<any>) {
    let role = await RoleModel.findByRoleId(pvpDefense.roleId);
    if (!role) {
        return;
    }
    let {score, pLv, heroScores, winStreakNum, challengeCnt, challengeRefTime, goods } = await checkResult(pvpDefense, seasonNum, seasonEndTime);
    pvpDefense = await PvpDefenseModel.updateInfo(pvpDefense.roleId, {score:score, pLv, heroScores, winStreakNum, seasonNum, challengeCnt, challengeRefTime, seasonEndTime});
    let { roleName, lv, vLv, headHid, sHid, title  } = role;
    let params = new RankParam(roleName, lv, vLv, headHid, sHid, title);
    setRank(REDIS_KEY.PVP_RANK, 0, pvpDefense.roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), params);
    //下发邮件
    const doc = new MailModel();
    const mail = Object.assign(doc.toJSON(), {roleId: pvpDefense.roleId, goods, sendName: '系统', mailId: 1, sendTime: nowSeconds()});
    addMails.push(mail);
    let key = 'login_roleId_' + pvpDefense.roleId; 
    let sid = await getRedis(key);
    if (!!sid) {
        pushMessage.push({route: 'onMailsAdd', data:[mail], uid: pvpDefense.roleId, sid});
    }
    return pvpDefense;
}

export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime:number) {
    let pvpRankRewards = getPvpRankRewards();
    let pvpHeroRewards = getPvpHeroRewards();
    let goods = [];
    let rankLv = await getMyRank(REDIS_KEY.PVP_RANK, 0, pvpDefense.roleId);// 排行榜排名
    let pvpRankReward = getScore(pvpRankRewards, rankLv);
    if(pvpRankReward) {
        goods = goods.concat(pvpRankReward.reward);
    }
    let score = 0;
    for (let i = 0; i < pvpDefense.heroScores.length; i++) {
        let heroScore = pvpDefense.heroScores[i];
        let pvpHeroReward = getScore(pvpHeroRewards, heroScore.score);
        if(pvpHeroReward) {
            goods = goods.concat(pvpHeroReward.reward);
            heroScore.score = pvpHeroReward.heroscore;
        }
        score += heroScore.score; 
    }
    let pLv = getLvByScore(pvpDefense.heroScores);
    return {score, pLv, heroScores: pvpDefense.heroScores, winStreakNum:0, seasonNum, challengeCnt:PVP.PVP_CHALLENGE_COUNTS, challengeRefTime:0, seasonEndTime, goods};
}

export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime:number) {
    let role = await RoleModel.findByRoleId(pvpDefense.roleId);
    if (!role) {
        return;
    }
    let {score, pLv, heroScores, winStreakNum, challengeCnt, challengeRefTime, goods } = await checkResult(pvpDefense, seasonNum, seasonEndTime);
    pvpDefense = await PvpDefenseModel.updateInfo(pvpDefense.roleId, {score:score, pLv, heroScores, winStreakNum, seasonNum, challengeCnt, challengeRefTime, seasonEndTime});
    let { roleName, lv, vLv, headHid, sHid, title , roleId } = role;
    let params = new RankParam(roleName, lv, vLv, headHid, sHid, title);
    setRank(REDIS_KEY.PVP_RANK, 0, pvpDefense.roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), params);
    //下发邮件
    let sendTime = seasonEndTime -  PVP.PVP_SEASON_DAYS * PER_DAY + SETTLE_DIFF;
    let mail = await MailModel.addMail({roleId, goods, sendName: '系统', mailId: 1, sendTime: sendTime});
    let key = 'login_roleId_' + roleId; 
    let sid = await getRedis(key);
    if (!!sid) {
        pinus.app.rpc.connector.connectorRemote.pushMessage.toServer(sid, pvpDefense.roleId, 'onMailsAdd', [mail]);
    }
    return pvpDefense;
}

export async function resetPvpWarId() {
    console.log('resetPvpWarId');
    let systemConfig = await SystemConfigModel.findSystemConfig();
    let warIds = deepCopy(getPvpGkWarIds());
    let index = indexOf(warIds, systemConfig.warId);
    if (index != -1) {
        warIds.splice(index, 1);
    }
    let res = getRandomArr(warIds, 1);
    let warId = res[0];//TODO随机地图
    return await SystemConfigModel.updateSystemConfig({ warId });
}

async function setNextPvpTime(notSetNext: boolean) {
    if (!!notSetNext) {
        let systemConfig = await SystemConfigModel.findSystemConfig();
        return systemConfig;
    }
    let seasonEndTime = PVP.PVP_SEASON_DAYS * PER_DAY + getTodayZeroPoint();
    let systemConfig = await SystemConfigModel.updateSeason(seasonEndTime);
    let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
    seasonJobId = scheduleJob(settleTime, setPvpSeasonResult, { name: 'setPvpSeasonResult' });
    return systemConfig;
}

function getScore(arr, score) {
    for (let item of arr) {
        if ((item.max >= score||item.max == -1) && score >= item.min) {
            return item;
        }
    }
}

export async function resetPvpSeasonTime(hour: number) {
    if (!!seasonJobId) {
        seasonJobId.cancel();
    }
    let seasonEndTime = 0;
    let seasonNum = 1;
    
    let systemConfig = await SystemConfigModel.findSystemConfig();
    if (!systemConfig) {
        let warIds = getPvpGkWarIds();
        let warId = warIds[0];//TODO随机地图
        seasonEndTime = hour * 60 * 60 + getTodayZeroPoint();
        systemConfig = await SystemConfigModel.createSystemConfig( seasonEndTime, warId );
    } else {
        seasonEndTime = hour * 60 * 60 + getTodayZeroPoint();
        seasonNum = systemConfig.seasonNum + 1;
        await SystemConfigModel.updateSystemConfig({ seasonEndTime, seasonNum: seasonNum});
    }
    let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
    seasonJobId = scheduleJob(settleTime, setPvpSeasonResult, { name: 'setPvpSeasonResult' });
    return { seasonEndTime, seasonNum };
}