/**
 * 体力系统
 */

import { scheduleJob } 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 { getRandomArr } from '../pubUtils/util';
import { getLvByScore } from './pvpService';
import { getMyRank, setRank } from './redisService';
import { REDIS_KEY } from '../consts';
import { RankParam } from '../pubUtils/interface';
import { RoleModel } from '../db/Role';
import { MailModel, MailType } from '../db/Mail';
const _ = require('underscore');
const PER_SECOND = 1 * 1000;
const PER_DAY = 24 * 60 * 60;
const SETTLE_DIFF = 29 * 60;
const LIMIT_NUM = 1000;
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});
            seasonEndTime = PVP.PVP_SEASON_DAYS * PER_DAY + getTodayZeroPoint();
            systemConfig.seasonNum++;
            await SystemConfigModel.updateSystemConfig({ seasonEndTime, seasonNum: systemConfig.seasonNum});
        }
    }
    let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
    scheduleJob(settleTime, setPvpSeasonResult)
    scheduleJob("0 0 0 * * 1", resetPvpWarId)
}

export async function setPvpSeasonResult(obj:{ name:string }) {
    console.log('exce setPvpSeasonResult'+ obj.name);
    let { seasonNum, seasonEndTime } = await setNextPvpTime();
    for (let page = 0; page < 3; page++) {
        let pvpDefenses = await PvpDefenseModel.getPvpDef(500, page);
        let addMails = new Array<MailType>();
        for (let pvpDefense of pvpDefenses) {
            if (pvpDefense.seasonNum !== seasonNum) {
                await setPvpDefResultOnTime(pvpDefense, seasonNum, seasonEndTime, addMails);
            }
        }
        await MailModel.addMails(addMails);
    }
}

export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime:number, addMails: Array<MailType>) {
    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(), { goods, sendName: '系统', mailId: 1, sendTime: nowSeconds()});
    addMails.push(mail);
    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  } = 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;
    await MailModel.addMail({ goods, sendName: '系统', mailId: 1, sendTime: sendTime});
    return pvpDefense;
}

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

async function setNextPvpTime() {
    let seasonEndTime = PVP.PVP_SEASON_DAYS * PER_DAY + getTodayZeroPoint();
    let systemConfig = await SystemConfigModel.updateSeason(seasonEndTime);
    let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
    scheduleJob(settleTime, setPvpSeasonResult);
    return systemConfig;
}

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