/**
 * 战场奖励发放 对象
 * 支持战场相关的奖励格式，目前包括fixedReward, randomReward, conditionReward
 */

import { BattleDropModel } from '../db/BattleDrop';
import { getWarById } from '../pubUtils/gamedata';
import { decodeStr } from '../pubUtils/util';
import { BATTLE_REWARD_TYPE } from '../consts/consts';
import { handleReward } from './rewardService';

export class WarReward {
    roleId: string;
    roleName: string;
    battleId: number;
    condition: Map<number, boolean>;
    warInfo: any;
    isSuccess: boolean;
    rewards: Array<{type: number, gid: number, count: number, times: number}>;
    fixReward: string;
    conditionReward: string;
    randomReward: string;

    constructor(roleId: string, roleName: string, battleId: number, isSuccess: boolean) {
        this.roleId = roleId;
        this.roleName = roleName;
        this.battleId = battleId;
        this.condition = new Map();
        this.warInfo = getWarById(battleId);

        let {fixReward = '', conditionReward = '', RandomReward = ''} = this.warInfo;
        this.fixReward = fixReward;
        this.conditionReward = conditionReward;
        this.randomReward = RandomReward;

        this.isSuccess = isSuccess;
    }

    public setCondition(id: number, isOk: boolean) {
        this.condition.set(id, isOk);
    }

    public setFixReward(reward: string) {
        let str = this.fixReward;
        let last = str.substr(str.length-1, 1);
        if(last == '&') str = str.substr(0, str.length - 1);
        if(str.length) {
            this.fixReward += '|' + reward;
        } else {
            this.fixReward += reward;
        }
    }

    public setConditionReward(reward: string) {
        let str = this.conditionReward;
        let last = str.substr(str.length-1, 1);
        if(last == '&') str = str.substr(0, str.length - 1);
        if(str.length) {
            this.conditionReward += reward;
        } else {
            this.conditionReward += '|' + reward;
        }
    }

    public setRandomReward(reward: string) {
        let str = this.randomReward;
        let last = str.substr(str.length-1, 1);
        if(last == '&') str = str.substr(0, str.length - 1);
        if(str.length) {
            this.randomReward += reward;
        } else {
            this.randomReward += '|' + reward;
        }
    }

    private handleFixReward(num: number, fixReward: string) {
        let reward = decodeStr('fixReward', fixReward);
        for(let i = 0; i < num; i++) {
            for(let obj of reward) {
                this.rewards.push({type: BATTLE_REWARD_TYPE.FIX_REWARD, times: i +1, ...obj, count: obj.count });
            }
        }
    }
    private handleConditionReward(num: number, conditionReward: string) {
        let reward = decodeStr('conditionReward', conditionReward);
        for(let i = 0; i < num; i++) {
            for(let obj of reward) {
                if(this.condition.get(obj.condition)) {
                    this.rewards.push({type: BATTLE_REWARD_TYPE.CONDITION_REWARD, times: i +1, ...obj, count: obj.count});
                }
            }
        }
    }

    private async handleRandomReward(num: number, randomReward: string) {

            let reward = decodeStr('randomReward', randomReward);
            for(let obj of reward) {
                let { gid, frequency } = obj;
                let dropHistory = await BattleDropModel.findByGid(this.roleId, this.battleId, gid);
                let { getNum = 0, allNum = 0, getSum = 0, allSum = 0 } = dropHistory;
                for(let i = 0; i < num; i ++) {
                    let flag = false; // 是否可以获得
                    if(allNum + 1 > frequency) {
                        allNum = 0; getNum = 0;
                    }
                    allNum++; allSum++;
                    if(getNum == 0) {
                        let r = Math.random();
                        if(r <= 1/frequency*allNum || (allNum >= frequency) ) {
                            flag = true; // 独立概率随机
                        }
                    }
                    if(flag) {
                        getNum ++; getSum++;
                        this.rewards.push({type: BATTLE_REWARD_TYPE.RANDOM_REWARD, times: i +1, ...obj});
                    }
                }
                await BattleDropModel.updateByGid(this.roleId, this.battleId, gid, {
                    getNum, allNum, getSum, allSum
                });
            }
    }

    public async saveReward(num: number) {
        this.rewards = new Array();
        // let warType = this.warInfo.warType;
        
        if(this.isSuccess) { // 成功了才给固定奖励
            if(this.fixReward) this.handleFixReward(num, this.fixReward);
            if(this.conditionReward) this.handleConditionReward(num, this.conditionReward);
            if(this.randomReward) await this.handleRandomReward(num, this.randomReward);
        }

        let returnGoods = await handleReward(this.roleId, this.roleName, this.rewards);
        return returnGoods;
    }

}