import {Application, BackendSession, ChannelService} from 'pinus';
import { handleCost, addItems } from '../../../services/rewardService';
import { calPlayerCeAndSave } from '../../../services/playerCeService';
import { resResult, returnHeroCeRatio, getAllAttrStage } from '../../../pubUtils/util';
import { STATUS } from '../../../consts/statusCode';
import {HeroModel} from '../../../db/Hero';
import {CURRENCY_BY_TYPE, CURRENCY_TYPE, CONSUME_TYPE, HERO_GROW_MAX, HERO_SYSTEM_TYPE, ITID, ABI_STAGE, HERO_CE_RATIO} from '../../../consts';
import { RoleModel } from '../../../db/Role';
import { ItemModel } from '../../../db/Item';
import { gameData, getHeroExpByLv, getHeroStarByQuality, getHeroWakeByQuality, getHeroLvByExp, getMaxGradeByjobClass, getJobByGradeAndClass, getFriendShipById } from '../../../pubUtils/data';
import { RewardInter } from '../../../pubUtils/interface';
import { getDropItems } from '../../../consts/constModules/itemConst'
export default function(app: Application) {
    return new HeroHandler(app);
}

export class HeroHandler {
    constructor(private app: Application) {
    }

    private channelService: ChannelService = this.app.get('channelService');

    public async test(msg: { items:Array<{id: number, count: number, seqId:number, type:number}>}, session: BackendSession) {
        let roleId: string = session.get('roleId');
        let roleName: string = session.get('roleName');
        let sid: string = session.get('sid');

        let {items} = msg;

        let result = await handleCost(roleId, sid, items );
        //let result = await addItems(roleId, roleName, sid, [{id, count}] );
        if(!result) {
            return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
        }
        return resResult(STATUS.SUCCESS,{result});

    }

    public async addItem(msg: { id: number, count: number}, session: BackendSession) {
        let roleId: string = session.get('roleId');
        let roleName: string = session.get('roleName');
        let sid: string = session.get('sid');

        let {id, count} = msg;

        //let result = await handleCost(roleId, sid, [{id, count}] );
        let items = [{id, count}];
        let role = await RoleModel.findByRoleId(roleId);
        if (id == 999999) {
            items = getDropItems();
            if (role.lv < 60) {
                role.lv = 60;
                let roleLvInfo = gameData.kingexp.get(role.lv - 1);
                role.exp = roleLvInfo.sum;
                await RoleModel.updateRoleInfo(roleId, role);
            }
        } 
        let result = await addItems(roleId, roleName, sid, items );
        if(!result) {
            return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
        }
        return resResult(STATUS.SUCCESS,{goods: result, lv: role.lv, exp: role.exp});

    }

    // 武将碎片合成
    public async compose(msg: { hid: number}, session: BackendSession) {
        let roleId: string = session.get('roleId');
        let roleName: string = session.get('roleName');
        let sid: string = session.get('sid');
        let serverId: number = session.get('serverId');

        let {hid} = msg;

        // 检查是否存在武将
        let hasHero = await HeroModel.findByHidAndRole(hid, roleId);
        if(hasHero) return resResult(STATUS.ROLE_HERO_EXISTS);
        // 根据dic_hero 获得 1. 碎片id 2. 碎片数量 3. 初始武将星级 4. 初始品质
        let dicHero = gameData.hero.get(hid);
        if(!dicHero) return resResult(STATUS.DIC_DATA_NOT_FOUND);
        let {pieceId, quality, initialStars: star, pieceCount, jobid: job, name: hName, initialSkin} = dicHero;
        // 碎片数量是否足够
        let costResult = await handleCost(roleId, sid, [{id: pieceId, count: pieceCount}]);
        if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
        // createHero
        let curHero = await HeroModel.createHero({
            roleId, serverId, roleName, hid, hName, star, quality, job, skins:[{id: initialSkin, enable: true}]
        });
        await calPlayerCeAndSave(sid, roleId, [curHero], HERO_SYSTEM_TYPE.INIT);
        return resResult(STATUS.SUCCESS, {curHero: returnHeroCeRatio(curHero)});
    }

    // 武将升级
    public async lvUp(msg: { hid: number, type: number}, session: BackendSession) {
        let roleId: string = session.get('roleId');
        let sid: string = session.get('sid');

        let { hid, type } = msg;

        let addLv = 0;
        if(type == 1) {
            addLv = 1;
        } else if(type == 5) {
            addLv = 5;
        } else {
            return resResult(STATUS.ROLE_HERO_LV_TYPE_ERROR);
        }
        // 计算武将可以升的级数
        let hero = await HeroModel.findByHidAndRole(hid, roleId);
        if(!hero) return resResult(STATUS.ROLE_HERO_NOT_EXISTS);
        let {lv: playerLv} = await RoleModel.findByRoleId(roleId);
        let {lv: oldLv, exp: oldExp} = hero;
        if(oldLv >= playerLv ) return resResult(STATUS.ROLE_HERO_LV_OVER);
        if(oldLv + addLv > playerLv ) addLv = playerLv - oldLv;

        let nextExp = getHeroExpByLv(oldLv + addLv - 1);
        let needExp = nextExp - oldExp;
        let newExp = oldExp;

        // 计算得材料可转换的经验
        let originalConsumes = await ItemModel.findByRoleAndType(roleId, CONSUME_TYPE.EXP);
        let material = new Array<RewardInter>();
        for(let {id, count} of originalConsumes) {
            let dicGoods = gameData.goods.get(id);
            if(!dicGoods) return resResult(STATUS.DIC_DATA_NOT_FOUND);
            let _count = Math.ceil(needExp/dicGoods.value);
            if(_count < count) {
                material.push({id, count: _count});
                newExp += dicGoods.value * _count; 
                break;
            } else {
                material.push({id, count});
                newExp += dicGoods.value * count;
            }
        }

        if (newExp == oldExp) {
            return resResult(STATUS.ROLE_EXP_NOT_ENOUGH);
        }

        let newLv = getHeroLvByExp(newExp);
        
        let costResult = await handleCost(roleId, sid, material);
        if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);

        hero.lv = playerLv > newLv?newLv: playerLv;
        hero.exp = newExp;

        let heros = await calPlayerCeAndSave(sid, roleId, [hero], HERO_SYSTEM_TYPE.LVUP, [hid]);
        const curHero = { 
            hid, lv : heros[0].lv, exp : heros[0].exp
        }
        return resResult(STATUS.SUCCESS, { curHero });

    }

    // 武将升星
    public async starUp(msg: { hid: number, star: number, starStage: number}, session: BackendSession) {
        let roleId: string = session.get('roleId');
        let sid: string = session.get('sid');

        let {hid, star, starStage} = msg;
        // 根据dic_hero 获得 1. 碎片id 2. 碎片数量 3. 初始武将星级 4. 初始品质
        let dicHero = gameData.hero.get(hid);
        if(!dicHero) return resResult(STATUS.DIC_DATA_NOT_FOUND);
        let {pieceId} = dicHero;
        
        let hero = await HeroModel.findByHidAndRole(hid, roleId);
        if(!hero) return resResult(STATUS.ROLE_HERO_NOT_EXISTS);

        let {star: oldStar, starStage: oldStarStage, quality} = hero;
        if(oldStar != star || oldStarStage != starStage) {
            return resResult(STATUS.WRONG_PARMS);
        }
        if(oldStar == HERO_GROW_MAX.STAR) {
            return resResult(STATUS.ROLE_STAR_REACH_MAX);
        }
        // 根据dic_zyz_hero_star 计算需要花的碎片并检查碎片数量
        const curDicHeroStar = getHeroStarByQuality(quality, oldStar);
        if(!curDicHeroStar) return resResult(STATUS.DIC_DATA_NOT_FOUND);

        let costResult = await handleCost(roleId, sid, [{id: pieceId, count: curDicHeroStar.advanceUpFragmentNum}]);
        if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
        
        let isUpStar = oldStarStage + 1 == ABI_STAGE.END;
        hero.star = isUpStar? oldStar + 1: oldStar;
        hero.starStage = isUpStar? ABI_STAGE.START: oldStarStage + 1;

        let heros = await calPlayerCeAndSave(sid, roleId, [hero], HERO_SYSTEM_TYPE.STAR, [hid, isUpStar?1:0]);
        const curHero = { 
            hid, 
            star : heros[0].star, 
            starStage : heros[0].starStage, 
            colorStar: heros[0].colorStar, 
            colorStarStage: heros[0].colorStarStage
        }
        return resResult(STATUS.SUCCESS, {isUpStar, curHero});
    }

    // 武将升品
    public async qualityUp(msg: { hid: number, quality: number }, session: BackendSession) {
        let roleId: string = session.get('roleId');
        let sid: string = session.get('sid');

        let {hid, quality} = msg;
        let dicHero = gameData.hero.get(hid);
        if(!dicHero) return resResult(STATUS.DIC_DATA_NOT_FOUND);
        // 根据dic_hero 获得 碎片id
        let {pieceId} = dicHero;
        
        let hero = await HeroModel.findByHidAndRole(hid, roleId);
        if(!hero) return resResult(STATUS.ROLE_HERO_NOT_EXISTS);
        let {quality: oldQuality, star} = hero;
        if(quality != oldQuality) {
            return resResult(STATUS.WRONG_PARMS);
        }
        if(oldQuality == HERO_GROW_MAX.QUALITY) {
            return resResult(STATUS.ROLE_QUALITY_REACH_MAX);
        }
        if(star != HERO_GROW_MAX.STAR ) {
            return resResult(STATUS.ROLE_STAR_NOT_ENOUGH);
        }

        // 根据dic_zyz_hero_quality_up 获得需要的材料
        const curDicHeroQualityUp = gameData.heroQualityUp.get(quality);
        if(!curDicHeroQualityUp) return resResult(STATUS.DIC_DATA_NOT_FOUND);
        let {fragmentNum} = curDicHeroQualityUp;

        let costResult = await handleCost(roleId, sid, [{id: pieceId, count: fragmentNum}]);
        if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
        
        hero.quality ++;
        let heros = await calPlayerCeAndSave(sid, roleId, [hero], HERO_SYSTEM_TYPE.QUALITY, [hid]);
        const curHero = { 
            hid, 
            quality : heros[0].quality
        }
        return resResult(STATUS.SUCCESS, {curHero});
    }

    // 武将觉醒
    public async wakeUp(msg: { hid: number, colorStar: number, colorStarStage: number}, session: BackendSession) {

        let roleId: string = session.get('roleId');
        let sid: string = session.get('sid');

        let {hid, colorStar, colorStarStage} = msg;
        // 根据dic_hero 获得 1. 碎片id 2. 碎片数量 3. 初始武将星级 4. 初始品质
        let dicHero = gameData.hero.get(hid);
        if(!dicHero) return resResult(STATUS.DIC_DATA_NOT_FOUND);
        let {pieceId} = dicHero;
        
        let hero = await HeroModel.findByHidAndRole(hid, roleId);
        if(!hero) return resResult(STATUS.ROLE_HERO_NOT_EXISTS);

        let {colorStar: oldColorStar, colorStarStage: oldColorStarStage, star, quality} = hero;
        if(colorStar != oldColorStar || colorStarStage != oldColorStarStage) {
            return resResult(STATUS.WRONG_PARMS);
        }
        if(star != HERO_GROW_MAX.STAR) {
            return resResult(STATUS.ROLE_WAKE_STAR_NOT_ENOUGH);
        }
        if(quality != HERO_GROW_MAX.QUALITY) {
            return resResult(STATUS.ROLE_QUALITY_NOT_ENOUGH);
        }
        // 根据dic_zyz_hero_wake 计算需要花的碎片并检查碎片数量
        const curDicHeroStar = getHeroWakeByQuality(dicHero.quality, oldColorStar)
        if(!curDicHeroStar) return resResult(STATUS.DIC_DATA_NOT_FOUND);

        let {fragmentNum, consume} = curDicHeroStar;

        // console.log(JSON.stringify([{id: pieceId, count: fragmentNum}, ...consumeArr]))
        let costResult = await handleCost(roleId, sid, [{id: pieceId, count: fragmentNum}, ...consume]);
        if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
        
        let isWakeUp = oldColorStar == 0;
        let isUpStar = isWakeUp || oldColorStarStage + 1 == ABI_STAGE.END;
        hero.colorStar = isUpStar? oldColorStar + 1: oldColorStar;
        hero.colorStarStage = isUpStar? ABI_STAGE.START: oldColorStarStage + 1;

        let heros = await calPlayerCeAndSave(sid, roleId, [hero], HERO_SYSTEM_TYPE.COLORSTAR, [hid, isUpStar?1:0, isWakeUp?1:0]);
        const curHero = { 
            hid, 
            star : heros[0].star, 
            starStage : heros[0].starStage, 
            colorStar: heros[0].colorStar, 
            colorStarStage: heros[0].colorStarStage
        }
        return resResult(STATUS.SUCCESS, {isUpStar, curHero});
    }

    //训练
    async heroJobTrain (msg: {hid:number}, session: BackendSession) {
        let roleId: string  = session.get('roleId');
        let sid: string = session.get('sid');
        let { hid } = msg;
        let hero = await HeroModel.findByHidAndRole(hid, roleId);
        if (!hero) 
            return resResult(STATUS.HERO_NOT_FIND);
        let heroJob = gameData.job.get(hero.job);
        if (hero.jobStage >= 6) 
            return resResult(STATUS.HERO_JOB_STAGE_REACH_MAX_STAGE);
        if (hero.job >= getMaxGradeByjobClass(heroJob.job_class))
            return resResult(STATUS.HERO_JOB_REACH_MAX_STAGE);
        
        let consume = new Array<RewardInter>();
        if(heroJob.trainingConsume[hero.jobStage]) {
            consume.push(heroJob.trainingConsume[hero.jobStage]);
        }
        let result = await handleCost(roleId, sid, consume);
        if(!result) {
            return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
        }
        hero.jobStage = hero.jobStage +1;
        //重算战力并下发
        let heros = await calPlayerCeAndSave(sid, roleId, [hero], HERO_SYSTEM_TYPE.TRAIN);
        return resResult(STATUS.SUCCESS, { curHero: {hid : heros[0].hid, job : heros[0].job, jobStage: heros[0].jobStage}});
    }   

    //进阶 
    async heroJobStageUp(msg: {hid:number}, session: BackendSession) {
        let roleId: string = session.get('roleId');
        let sid: string = session.get('sid');
        let { hid } = msg;
        let hero = await HeroModel.findByHidAndRole(hid, roleId);
        if (!hero) 
            return resResult(STATUS.HERO_NOT_FIND);
        let curJob = hero.job;
        let heroJob = gameData.job.get(curJob);
        if (heroJob.unlockLevel > hero.lv) 
            return resResult(STATUS.NOT_REACH_UNLOCK_LEVEL);
        if (curJob >= getMaxGradeByjobClass(heroJob.job_class))
            return resResult(STATUS.HERO_JOB_REACH_MAX_STAGE);
        let result = await handleCost(roleId, sid, heroJob.upGradeConsume);
        if(!result) {
            return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
        }
        let nextHeroJob = getJobByGradeAndClass(heroJob.job_class, heroJob.grade + 1);
        hero.job = nextHeroJob.jobid;
        hero.jobStage = 0;
        //重算战力并下发
        let heros = await calPlayerCeAndSave(sid, roleId, [hero], HERO_SYSTEM_TYPE.STAGEUP, [curJob]);
        return resResult(STATUS.SUCCESS, { curHero: {hid : heros[0].hid, job : heros[0].job, jobStage : heros[0].jobStage}});
    }

    //激活羁绊 
    async heroConectionActivate(msg: {shipId: number}, session: BackendSession) {
        let roleId: string = session.get('roleId');
        let sid: string = session.get('sid');
        let { shipId } = msg;
        let shipHidAndLevel = gameData.friendShipHidAandIds.get(shipId);
        if (!shipHidAndLevel)
            return resResult(STATUS.HERO_CONECTION_IS_NOT_EXIT);
        let hero = await HeroModel.findByHidAndRole(shipHidAndLevel.actorId, roleId);
        if (!hero) 
            return resResult(STATUS.HERO_NOT_FIND);
        let flag = true;
        let level = 1;
        for (let conection of hero.connections) {
            if (conection.shipId == shipId ) {
                if (conection.level >= shipHidAndLevel.level) {
                    return resResult(STATUS.HERO_CONECTION_IS_MAX_LEVEL);
                } else {
                    flag = false;
                    conection.level++;
                    level = conection.level;
                }
            }
        }
        if (!!flag) {
            hero.connections.push({shipId, level});
        }
        let friendShip = getFriendShipById(shipId, level);
        if (hero.star < friendShip.level)
            return resResult(STATUS.NOT_REACH_UNLOCK_LEVEL);
        let hids = friendShip.hids;
        for (let hid of hids) {
            if (hid == shipHidAndLevel.actorId)
                continue;
            let member = await HeroModel.findByHidAndRole(hid, roleId);
            if (!member)
                return resResult(STATUS.ROLE_SHORT_HERO_CONECTION);
            if (member.star < friendShip.level)
                return resResult(STATUS.NOT_REACH_UNLOCK_LEVEL);
        }
        let result = await handleCost(roleId, sid, [{id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN), count: friendShip.costCoin}]);
        if(!result) {
            return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
        }
        //重算战力并下发
        let heros = await calPlayerCeAndSave(sid, roleId, [hero], HERO_SYSTEM_TYPE.CONNECT, [shipId, level]);
        return resResult(STATUS.SUCCESS, { curHero: {hid : heros[0].hid, connections : heros[0].connections}});
    }

    //赠送（包括一键赠送）
    async heroGiveFavor(msg: {hid:number, items:Array<{id : number,count : number}>}, session: BackendSession) {
        let roleId: string = session.get('roleId');
        let sid: string = session.get('sid');
        let { hid, items } = msg;
        let hero = await HeroModel.findByHidAndRole(hid, roleId);
        let lastLv = hero.favourLv;
        if (!hero) 
            return resResult(STATUS.HERO_NOT_FIND);
        let friendShipLevels = gameData.friendShipLevel;
        if (friendShipLevels[friendShipLevels.length - 1].level <= hero.favourLv) 
            return resResult(STATUS.HERO_FAVOUR_LEVEL_REACH_MAXT);
        //计算消耗物品转化的经验
        let exp:number = 0;
        for (let item of items) {
            let itemInfo = gameData.goods.get(item.id);
            if (!itemInfo)
                return resResult(STATUS.DIC_DATA_NOT_FOUND)
            let dicItid = ITID.get(itemInfo.itid);
            if (dicItid.type == CONSUME_TYPE.FAVOUR) {
                exp += itemInfo.value;
            } else {
                return resResult(STATUS.WRONG_PARMS); 
            }
        }
        hero.favour += exp;
        for (let friendShipLevel of friendShipLevels) {
            if (friendShipLevel.level < hero.favourLv) 
                continue;
            if (friendShipLevel.exp > hero.favour)
                break;
            hero.favour -= friendShipLevel.exp;
            hero.favourLv++;
        }
        let result = await handleCost(roleId, sid, items);
        if(!result) {
            return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
        }
        //重算战力并下发
        if (lastLv != hero.favourLv) {
            await calPlayerCeAndSave(sid, roleId, [hero], HERO_SYSTEM_TYPE.FAVOUR, [lastLv]);
        } else {
            await HeroModel.updateHeroInfo(roleId, hero.hid, hero);
        }
        return resResult(STATUS.SUCCESS, { curHero: {hid : hero.hid, favour : hero.favour, favourLv : hero.favourLv}});
    }

    //穿带时装
    async heroWearSkin(msg: {id:number}, session: BackendSession) {
        let roleId: string = session.get('roleId');
        let sid: string = session.get('sid');
        let { id } = msg;
        let skinInfo = gameData.fashion.get(id);
        if (!skinInfo) 
            return resResult(STATUS.HERO_SKIN_NOT_FIND);
        let hero = await HeroModel.findByHidAndRole(skinInfo.actorId, roleId);
        if (!hero)
            return resResult(STATUS.HERO_NOT_FIND);
        let result = false;    
        let lastSkinId: number;
        for (let skin of hero.skins) {
            if (skin.id == id) {
                if (!!skin.enable) {
                    return resResult(STATUS.HERO_SKIN_IS_EQUIPED);
                }
                skin.enable = true;
                result = true;
            } else {
                if (!!skin.enable) {
                    lastSkinId = skin.id;
                } 
                skin.enable = false;
            }
        }
        if (!result) {
            return resResult(STATUS.HERO_SKIN_NOT_FIND);
        }
        await calPlayerCeAndSave(sid, roleId, [hero], HERO_SYSTEM_TYPE.SKIN, [id, lastSkinId]);
        return resResult(STATUS.SUCCESS, {curHero: {hid : hero.hid, skins : hero.skins} });
    }
}