import { BossInstanceType, BossInstanceModel } from '../db/BossInstance';
import { getTodayZeroPoint, nowSeconds } from '../pubUtils/timeUtil';
import { lockData } from '../services/redLockService';
import { findIndex, indexBy, values } from 'underscore';
import { MailModel, MailType } from '../db/Mail';
import { getRedis, sismemberAsync, smembersAsync, saddAsync, delAsync, sremAsync } from '../services/redisService';
import { pinus } from 'pinus';
import { STATUS } from '../consts/statusCode';
import { deepCopy, resResult } from '../pubUtils/util';
import { BattleRecordModel } from '../db/BattleRecord';
import { getArmyBossRank } from '../pubUtils/data';
import { getMailContent } from '../services/mailService';
import { pushMail } from '../pubUtils/interface';
/**
 * 
 * @param bossInstance 
 * @param roleId 
 */
export async function getBossInstanceInfo(bossInstance: BossInstanceType, roleId:string) {
    let { warId, ranks,  bossHp, bossLv, winWarId, winTime, roleIdRecords, guildCode } = bossInstance;
    ranks.sort(function(a, b) {
        return b.score - a.score + a.time - b.time;
    });
    let result:any = {};
    //1：等待团长开启，2：今日已开启，且boss通关，3：开启中
    if ( bossInstance.bossHp <= 0 ) {
        if (!!winWarId && winTime > getTodayZeroPoint() && roleIdRecords.indexOf(roleId) == -1) {
            result = { winWarId };
            await BossInstanceModel.recordRoleIdWhenCheck(guildCode, roleId);
        }
        if (bossInstance.startTime < getTodayZeroPoint()) {
            result.status = 1;
            return result;
        } else {
            result.status = 2;
            return result;
        }
    }
    let isBattled = false;
    let myRank = {};
    
    let lastRanks = ranks.map(({roleId: battleRoleId, score, time}, index) => {
        if (roleId == battleRoleId) {
            myRank = {roleId, score, rankLv: index + 1};
            if (time >= getTodayZeroPoint())
                isBattled = true;
        }
        return {roleId, score, rankLv: index + 1};
    });
    return {warId, ranks: lastRanks, myRank, bossHp, status: 3, isBattled, bossLv};
}
/**
 * 战斗结束返回
 * @param bossInstance 
 * @param roleId 
 * @param battleNum 
 */
export async function getBossInstanceWhenEnd(bossInstance: BossInstanceType, roleId:string, battleNum:number) {
    let { warId, ranks, bossHp, winWarId, guildCode, recordRanks, winNum, bossLv } = bossInstance;
    let pushRanks;
    let result:any = {};
    if (battleNum == winNum) {
        pushRanks = deepCopy(recordRanks);
        result = {warId: winWarId, bossHp: 0, bossLv, status: 3};
        await BossInstanceModel.recordRoleIdWhenCheck(guildCode, roleId);
    } else {
        pushRanks = deepCopy(ranks);
        result = {warId, bossHp, bossLv, status: 3};
    }
    pushRanks.sort(function(a, b) {
        return b.score - a.score + a.time - b.time;
    });
    let isBattled = false;
    let myRank = {};
    pushRanks.forEach(({roleId: battleRoleId, score, time}, index) => {
        if (roleId == battleRoleId) {
            myRank = {roleId, score, rankLv: index + 1};
            if (time >= getTodayZeroPoint())
                isBattled = true;
        }
        return {roleId, score, rankLv: index + 1};
    });
    result.myRank = myRank;
    result.ranks = pushRanks;
    result.isBattled = isBattled;
    return result;
}

/**
 * 结算战斗
 * @param code 
 * @param serverId 
 * @param dataName 
 * @param damage 
 * @param roleId 
 */
export async function bossResult(code: string, serverId: number, dataName: string, roleId: string, damage: number) {
    let res:any = await lockData(serverId, dataName, code);//加锁
    if (!!res.err) 
        return true;
    let {winSettled, ranks, num, warId, bossHp} = await BossInstanceModel.findBossInstance(code);//锁定关卡信息
    if (winSettled) {
        res.releaseCallback();//解锁
        await BossInstanceModel.recordRoleIdWhenCheck(code, roleId);
        return true;
    } 
    let index = findIndex(ranks, {roleId});
    if (index == -1) {
        res.releaseCallback();//解锁
        return false;
    }
    ranks[index].score += bossHp; 
    if (bossHp > damage) {
        res.releaseCallback();//解锁
        return true;
    }
    let { recordRanks } = await BossInstanceModel.updateBossInstance(code, { bossHp: 0, winSettled: true, ranks,  recordRanks: ranks, winNum: num, winWarId: warId, roleIdRecords:[roleId]}, );
    await pushBossHpMessage(code, serverId, 0, true);
    res.releaseCallback();//数据修改解锁
    recordRanks.sort(function(a, b) {
        return b.score - a.score + a.time - b.time;
    });
    let mails = new Array<MailType>();
    let pushMessage = new Array<pushMail>();
    recordRanks.forEach(async function({roleId, score}, index){
        let rankLv = index + 1;
        let goods = getArmyBossRankReward(rankLv);
        if (!goods || !goods.length)
            return;
        await getMailContent(roleId, 1, [JSON.stringify(rankLv)], goods, mails, pushMessage);
    });
    await MailModel.addMails(mails);
    pushMessage.forEach(({route, data, uids })=>{
        pinus.app.channelService.pushMessageByUids(route, resResult(STATUS.SUCCESS, { mails:data }), uids);
    });
    return true;
}

export function getArmyBossRankReward(rankLv: number) {
    let armybossRankReward = getArmyBossRank();
    for (let item of armybossRankReward) {
        if (item.rankMin <= rankLv && (rankLv <= item.rankMax || item.rankMax == -1)) {
            return item.reward;
        }
    }
}
 
export async function addBossInstance(code: string, serverId:number, roleId: string) {
    let loginKey = 'login_roleId_' + roleId; 
    let sid = await getRedis(loginKey);
    let key = 'serverId_' + serverId + 'guildCode_' + code;
    let value = roleId+ '|' + sid;
    saddAsync(key, [value]);
}

export async function pushBossHpMessage(code: string, serverId:number, bossHp:number, isDelKey?: boolean ) {
    let key = 'serverId_' + serverId + 'guildCode_' + code;
    let members = await smembersAsync(key);
    let uids = members.map(member=>{
        let arr = member.split('|');
        let uid = arr[0];
        let sid = arr[1];
        return {uid, sid};
    });
    pinus.app.channelService.pushMessageByUids('onBossHpUpdate', resResult(STATUS.SUCCESS, {bossHp}), uids);
    if (isDelKey) {
        delAsync(key);
    }
}

export async function checkMemberExists(code: string, serverId:number, roleId: string, battleCode:string ) {
    let loginKey = 'login_roleId_' + roleId; 
    let sid = await getRedis(loginKey);
    let key = 'serverId_' + serverId + 'guildCode_' + code ;
    let value = roleId+ '|' + sid;
    let flag = await sismemberAsync(key, value);
    if (!flag) {
        const battleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode, true);
        if(!battleRecord || battleRecord.status != 0 || roleId != battleRecord.roleId) {
            return false;
        } 
        addBossInstance(code, serverId, roleId);
        flag = true;
    }
    return flag;
}