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, getResultMaxRank } from '../pubUtils/data';
import { deepCopy, getRandomArr } from '../pubUtils/util';
import { getLvByScore } from './pvpService';
import { getMyRank, setRank, getRedis, resetPvpRanks } from './redisService';
import { REDIS_KEY } from '../consts';
import { RankParam } from '../domain/rank';
import { RoleModel } from '../db/Role';
import { MailModel, MailType } from '../db/Mail';
import { pinus } from 'pinus';
import { indexOf } from 'underscore';
import { PvpSeasonResultModel } from '../db/PvpSeasonResult';
import { settleGuildWeekly } from './guildService';
const PER_SECOND = 1 * 1000;
const PER_DAY = 24 * 60 * 60;
const SETTLE_DIFF = 29 * 60;
const LIMIT_NUM = 1000;
const pageNum = 500;
const PER_MINUTE = 1 * 60;
var seasonJobId;
var warJobId;
var seasonEndTimeJobId;
let guildWeeklyJobId
export async function init() {
    let seasonEndTime = 0;
    let systemConfig = await SystemConfigModel.findSystemConfig();
    if (!systemConfig) {
        console.log('create season seasonNum = '+ systemConfig.seasonNum);
        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()) {
            seasonEndTime = PVP.PVP_SEASON_DAYS * PER_DAY + getTodayZeroPoint();
            console.log('update season seasonNum = '+ systemConfig.seasonNum);
            systemConfig.seasonNum++;
            await SystemConfigModel.updateSystemConfig({ seasonEndTime, seasonNum: systemConfig.seasonNum, oldSeasonEndTime: systemConfig.seasonEndTime});
            await setPvpSeasonResult({name: 'simpleJobExample' + systemConfig.seasonNum, notSetNext: true, notPush: true });
        } 
    }
    let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
    console.log(' settleTime = ' + settleTime);
    seasonJobId = scheduleJob(settleTime, setPvpSeasonResult, { name: 'setPvpSeasonResult' });
    console.log(' settleTime111111 = ' + (seasonEndTime -  PER_MINUTE)* PER_SECOND);

    seasonEndTimeJobId = scheduleJob((seasonEndTime -  PER_MINUTE)* PER_SECOND, resetPvpRanks, { name: 'resetRank' });
    warJobId = scheduleJob("0 0 0 * * 3", resetPvpWarId);
    console.log('execute season resetPvpRanks');
    await resetPvpRanks();

    // 周功勋结算任务
    guildWeeklyJobId = scheduleJob('0 0 0 * * 1', settleGuildWeekly, { name: 'settleGuildWeekly' });

}

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

export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNum: number, oldSeasonEndTime: number, addMails: Array<MailType>, pushMessage:Array<any>) {

    let { score, pLv, heroScores, challengeCnt, challengeRefTime, goods } = await checkResult(pvpDefense, seasonNum, oldSeasonEndTime);
    pvpDefense = await PvpDefenseModel.updateInfo(pvpDefense.roleId, {score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime});

    //下发邮件
    const doc = new MailModel();
    const mail = Object.assign(doc.toJSON(), {roleId: pvpDefense.roleId, goods, sendName: '系统', mailId: 1, sendTime: oldSeasonEndTime});
    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, oldSeasonEndTime:number, rankLv?:number) {
    let pvpRankRewards = getPvpRankRewards();
    let pvpHeroRewards = getPvpHeroRewards();
    let goods = [];
    if (!rankLv) {
        rankLv = await getMyRank(REDIS_KEY.PVP_RANK, 0, pvpDefense.roleId);// 排行榜排名
    }
    let oldPLv = getLvByScore(pvpDefense.heroScores);
    let { challengeCnt, challengeRefTime } = pvpDefense;
    let pvpRankReward;
    if (!!rankLv) {
        pvpRankReward = getScore(pvpRankRewards, rankLv);
    } else {
        pvpRankReward = getResultMaxRank();
    }
    let rankGoods = [];
    if(pvpRankReward) {
        goods = goods.concat(pvpRankReward.reward);
        rankGoods = pvpRankReward.reward;
    }
    let heroGoods = [];
    let score = 0;
    let oldHeroScores = deepCopy(pvpDefense.heroScores)
    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;
            if (!!pvpHeroReward.reward[0]) {
                heroGoods.push({
                    hid: heroScore.hid,
                    id: pvpHeroReward.reward[0].id,
                    count: pvpHeroReward.reward[0].count,
                });
            }
        }
        score += heroScore.score; 
    }
    let pLv = getLvByScore(pvpDefense.heroScores);
    await PvpSeasonResultModel.updatePvpSeasonResult(pvpDefense.roleId, { 
        oldSeasonData:{refOppCnt: pvpDefense.refOppCnt, rankLv, score: pvpDefense.score, pLv: oldPLv, heroScores: oldHeroScores, 
            seasonNum: pvpDefense.seasonNum, challengeCnt, challengeRefTime, seasonEndTime: oldSeasonEndTime
        }, heroGoods, rankGoods, show: true});
    return { rankLv, score, pLv, heroScores: pvpDefense.heroScores, seasonNum, challengeCnt:PVP.PVP_CHALLENGE_COUNTS, challengeRefTime:0, oldSeasonEndTime, goods};
}

export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: number, oldSeasonEndTime:number) {
    let role = await RoleModel.findByRoleId(pvpDefense.roleId);
    if (!role) {
        return;
    }
    let resultMaxRank = getResultMaxRank();
    let rankLv = resultMaxRank.min;    
    let {score, pLv, heroScores, challengeCnt, challengeRefTime, goods } = await checkResult(pvpDefense, seasonNum, oldSeasonEndTime, rankLv);
    pvpDefense = await PvpDefenseModel.updateInfoAndInclude(pvpDefense.roleId, {score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime});
    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 mail = await MailModel.addMail({roleId, goods, sendName: '系统', mailId: 1, sendTime: oldSeasonEndTime});
    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) {
    let {seasonEndTime, seasonNum} = await SystemConfigModel.findSystemConfig();
    if (!!notSetNext) {
        return { seasonEndTime, seasonNum , oldSeasonEndTime: 0};
    }
    let oldSeasonEndTime = seasonEndTime;
    seasonEndTime = (PVP.PVP_SEASON_DAYS + 1) * PER_DAY + getTodayZeroPoint();
    await SystemConfigModel.updateSeason(seasonEndTime, oldSeasonEndTime);
    let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
    seasonJobId = scheduleJob(settleTime, setPvpSeasonResult, { name: 'setPvpSeasonResult' });
    seasonEndTimeJobId = scheduleJob((seasonEndTime -  PER_MINUTE)* PER_SECOND, resetPvpRanks, { name: 'resetRank' });
    return { seasonEndTime, seasonNum: seasonNum + 1, oldSeasonEndTime };
}

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;
    if (!!seasonEndTimeJobId) {
        seasonEndTimeJobId.cancel();
    }
    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, oldSeasonEndTime: 0});
        await setPvpSeasonResult({name: 'simpleJobExample' + systemConfig.seasonNum, notSetNext: true });
        await resetPvpRanks();
    }
    let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
    console.log('settleTime = ' + settleTime)
    seasonJobId = scheduleJob(settleTime, setPvpSeasonResult, { name: 'setPvpSeasonResult' });
    return { seasonEndTime, seasonNum };
}