import { Application, BackendSession, pinus } from 'pinus';
import { UserGuildModel } from '../../../db/UserGuild';
import { resResult } from '../../../pubUtils/util';
import { STATUS, GUILD_OPERATE } from '../../../consts';
import { GuildRefineModel } from '../../../db/GuildRefine';
import { getArmyDevelopConsumeById, getGoodById } from '../../../pubUtils/data';
import { EquipModel } from '../../../db/Equip';
import { nowSeconds } from '../../../pubUtils/timeUtil';
import { handleCost, addItems } from '../../../services/rewardService';
import { GuildModel } from '../../../db/Guild';
import { findIndex, findWhere } from 'underscore';
import { lockData } from '../../../services/redLockService';
import { GUILD_DATA_NAME, GUILD_STRUCTURE } from '../../../consts/constModules/guildConst';
import { checkAuth } from '../../../services/guildService';
import { ARMY } from '../../../pubUtils/dicParam';
import { CURRENCY_BY_TYPE, CURRENCY_TYPE } from '../../../consts/constModules/itemConst';

export default function (app: Application) {
    return new GuildRefineHandler(app);
}

export class GuildRefineHandler {
    constructor(private app: Application) {

    }

    async getRefine(msg: {}, session: BackendSession) {
        const roleId = session.get('roleId');
        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
        if (!userGuild) 
            return resResult(STATUS.WRONG_PARMS); 
        const { guildCode: code } = userGuild;
        let { scienceTrees } = await GuildRefineModel.getRefine(code);
        return resResult(STATUS.SUCCESS, { scienceTrees }); 
    }   

    async refineEquip(msg: {eid: number}, session: BackendSession) {
        let { eid } = msg;
        const roleId: string = session.get('roleId');
        const sid: string = session.get('sid');
        const roleName: string = session.get('roleName');
        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
        if (!userGuild) 
            return resResult(STATUS.WRONG_PARMS); 
        let { guildCode: code } = userGuild;
        let equip = await EquipModel.findbySeqId(eid);
        if (!equip) return resResult(STATUS.EQUIP_NOT_FIND);
        let equpInfo = getGoodById(equip.id);
        let { scienceTrees } = await GuildRefineModel.getRefine(code);
        let findDevelopConsume;
        for (let scienceTree of scienceTrees) {
            if (scienceTree.endTime < nowSeconds()) {
                let developConsume = getArmyDevelopConsumeById(scienceTree.id);
                if (developConsume.quality && developConsume.levelMax >= equpInfo.lvLimited && equpInfo.lvLimited <= developConsume.levelMin) {
                    findDevelopConsume = developConsume;
                    break;
                }
            }
        }
        if (!findDevelopConsume) 
            return resResult(STATUS.GUILD_NOT_REFINE_THE_EQUIP);
      
        let result = await handleCost(roleId, sid, findDevelopConsume.honourConsume);
        if(!result) 
            return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
        let goods = await addItems(roleId, roleName, sid, [{id: eid, count: 1}]);
        return resResult(STATUS.SUCCESS, { goods }); 
    }   

    async lightUpTree(msg: {id: number}, session: BackendSession) {
        let { id } = msg;
        const roleId: string = session.get('roleId');
        const serverId: number = session.get('serverId');
        let userGuild = await UserGuildModel.getMyGuild(roleId, 'auth guildCode');
        if (!userGuild) 
            return resResult(STATUS.WRONG_PARMS); 
        const checkMyResult = await checkAuth(GUILD_OPERATE.EQUIP_PRODUCE, roleId, null, userGuild);
        if(!checkMyResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
        const { guildCode: code } = userGuild;
        let developConsume = getArmyDevelopConsumeById(id);
        if (!developConsume)
            return resResult(STATUS.WRONG_PARMS); 
        let res:any = await lockData(serverId, GUILD_DATA_NAME.GUILD_REFINE, code);//加锁
        if (!!res.err) 
            return resResult(STATUS.REDLOCK_ERR); 
        let guildRefine = await GuildRefineModel.getRefine(code);
        for (let scienceTree of  guildRefine.scienceTrees) {
            if (scienceTree.id == id) 
                return resResult(STATUS.GUILD_LIGHT_UP_THE_SCIENCETREE);
            
            if (scienceTree.endTime > nowSeconds()) 
                return resResult(STATUS.GUILD_SCIENCETREE_IS_RUNNING);
        }
        const costResult = await GuildModel.costFund(code, developConsume.fundConsume);
        if(!costResult) 
            return resResult(STATUS.GUILD_FUND_NOT_ENOUGH);
        let scienceTree = { id, endTime: nowSeconds() + developConsume.timeConsume, assistRoleIds: []}
        let { scienceTrees } = await GuildRefineModel.pushRefine(code, scienceTree);
        res.releaseCallback();
        return resResult(STATUS.SUCCESS, { scienceTrees }); 
    }

    async assistRefine(msg: {id: number}, session: BackendSession) {
        let { id } = msg;
        const roleId: string = session.get('roleId');
        const serverId: number = session.get('serverId');
        const sid: string = session.get('sid');

        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
        if (!userGuild) 
            return resResult(STATUS.WRONG_PARMS); 
        const { guildCode: code } = userGuild;
        let res:any = await lockData(serverId, GUILD_DATA_NAME.GUILD_ASSIST_REFINE, code);//加锁
        if (!!res.err) 
            return resResult(STATUS.REDLOCK_ERR); 
        let guildRefine = await GuildRefineModel.getRefine(code);
        
        let index = findIndex(guildRefine.scienceTrees, { id });
        if (index == -1) 
            return resResult(STATUS.WRONG_PARMS);
        let scienceTree = guildRefine.scienceTrees[index];
        if (!!scienceTree.assistRoleIds.indexOf(roleId)) 
            return resResult(STATUS.GUILD_IS_ASSISTED_SCIENCETREE); 
        if (scienceTree.assistRoleIds.length >= ARMY.ARMY_DEVELOPMENT_SPEEDTMES) 
            return resResult(STATUS.GUILD_REACH_MAX_ASSIST_COUNT); 

        let result = await handleCost(roleId, sid, [{id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: ARMY.ARMY_DEVELOPMENT_SPEEDCOST}]);
        if(!result) 
            return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);   
        scienceTree.assistRoleIds.push(roleId);
        scienceTree.endTime -= scienceTree.endTime - ARMY.ARMY_DEVELOPMENT_SPEED * 60;

        let { scienceTrees } = await GuildRefineModel.updateRefine(code, { scienceTrees: guildRefine.scienceTrees })
        res.releaseCallback();
        return resResult(STATUS.SUCCESS, { scienceTrees }); 
    }
}