import { HangUpRecordModel } from './../db/HangUpRecord';
import { ChannelService } from 'pinus';
import { HANG_UP_CONSTS } from './../consts/consts';
import { BattleRecordModel } from './../db/BattleRecord';
import { TowerRecordModel } from './../db/TowerRecord';
import { RoleModel } from './../db/Role';
import { getTowerDataByLv } from "../util/gamedata"
import { decodeArrayStr } from '../util/util';
import { handleFixedReward } from './rewardService';

export async function checkTowerWar(roleId: string, battleId: number) {
    const battleIdStr = `${battleId}`;
    let { towerLv } = await RoleModel.findByRoleId(roleId);
    const towerInfo = getTowerDataByLv(towerLv);
    if (!towerInfo) {
        console.error(`天梯层数异常，lv ${towerLv} by ${roleId}`);
        return { status: -1, msg: '天梯层数异常' };
    }
    const warArray = decodeArrayStr(towerInfo.warArray) || [];
    if (warArray.indexOf(battleIdStr) === -1) {
        return { status: -1, msg: '战斗 Id 异常' };
    }

    let { heroes = [], warStatus = [] } = await TowerRecordModel.getRecordByLv(roleId, towerLv);
    const curWarStatus = warStatus.find(elem => elem.warId == battleId);
    if (curWarStatus.status) {
        return {status: -1, msg: '天梯关卡不能重复挑战'};
    }

    return { status: 0, data: {
        heroes, warStatus: curWarStatus
    }};
}

export async function towerBattleEnd(channelService: ChannelService, sid: string, roleId: string, battleCode: string, battleId: number, succeed: boolean, heroes: Array<number>) {
    if (succeed) {
        let battleRec = await BattleRecordModel.getBattleRecordByCode(battleCode);
        if (battleRec.battleId != battleId) {
            return { status: -1, msg: '战斗数据错误' };
        }
        let { towerLv, roleName } = await RoleModel.findByRoleId(roleId);
        let { warStatus, heroes: recHeroes } = await TowerRecordModel.getRecordByLv(roleId, towerLv);
        for (let hid of heroes) {
            if (recHeroes.indexOf(hid) !== -1) {
                return { status: -1, msg: '使用了重复的武将' };
            }
        }

        let inc = 1;
        warStatus.forEach(st => {
            if (st.warId !== battleId && st.status === false) {
                inc = 0;
            }
        })
        let newRec = await TowerRecordModel.updateRecord(roleId, towerLv, battleCode, battleId, heroes, inc);
        let bonusReward = null;
        if (inc === 1) {
            await RoleModel.towerLvUp(roleId);
            const nextTowerInfo = getTowerDataByLv(towerLv + 1);
            if (nextTowerInfo) {
                const { wars } = nextTowerInfo;
                const sts = wars.map(id => {
                    return {warId: id, status: false};
                });
                await TowerRecordModel.createRecord({roleId, lv: towerLv + 1, warStatus: sts});
            }
            const { bonus } = getTowerDataByLv(towerLv);
            if (bonus) {
                bonusReward = await handleFixedReward(roleId, roleName, bonus, 1);
            }
            if (towerLv + 1 >= HANG_UP_CONSTS.ENABLE_LV) {
                await startHangUp(roleId, roleName);
                channelService.pushMessageByUids('hangUpEnable', {code: 200, data: {enable: true}}, [{uid: roleId, sid}]);
            }
        }
        return {
            status: 0,
            data: {
                newRec,
                bonusReward,
                towerStatus: !!inc
            }
        };
    }
}

async function startHangUp(roleId: string, roleName: string) {
    await HangUpRecordModel.initRecord(roleId, roleName);
}

export async function calcuHangUpReward(roleId: string) {
    let { towerLv } = await RoleModel.findByRoleId(roleId);
    let { startLv, startTime} = await HangUpRecordModel.getCurRec(roleId);
    let towerInfo = getTowerDataByLv(towerLv - 1); // towerLv 是当前层，奖励计算按照已经通过的层，即上一层
    const curTime = new Date();
    let deltaTime = curTime.getTime() - startTime.getTime();
    if (deltaTime > HANG_UP_CONSTS.MAX_TIME) deltaTime = HANG_UP_CONSTS.MAX_TIME;
    const multi = Math.floor(deltaTime / HANG_UP_CONSTS.UNIT_TIME);
    return {
        endLv: towerLv - 1,
        endTime: new Date(startTime.getTime() + multi * HANG_UP_CONSTS.UNIT_TIME),
        timeReward: towerInfo.timeReward,
        multi
    };
}