import { Application, BackendSession, pinus } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts/statusCode';
import { getRoleOnlineInfo } from '../../../services/redisService';
import { addItems, createHeroes } from '../../../services/rewardService';
import { RewardInter } from '../../../pubUtils/interface';
import { getExpByLv } from '../../../pubUtils/data';
import { RoleModel } from '../../../db/Role';
import { BLOCK_TYPE } from '../../../consts';
let timer: NodeJS.Timer;
export default function (app: Application) {
    return new GmRoleHandler(app);
}

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

    async addItems(msg: { roleId: string, roleName: string, serverId: number, values: { reward: RewardInter[], heroes: number[], lv: number }}, session: BackendSession) {
        let { roleId, roleName, serverId, values } = msg;

        let { reward, heroes, lv } = values;
        if (reward == undefined && heroes == undefined && lv == undefined) {
            return resResult(STATUS.WRONG_PARMS);
        }
        let connect = await getRoleOnlineInfo(roleId);
        let sid = connect.isOnline?connect.sid: null;

        if(reward &&reward.length > 0) {
            await addItems(roleId, roleName, sid, values.reward);
        }
        if(heroes && heroes.length > 0) {
            await createHeroes(roleId, roleName, sid, serverId, heroes.map(hid => { return { hid, count: 1 }}))
        }
        if(lv && lv > 0) {
            let exp = getExpByLv(lv - 1)?.sum||0;
            await RoleModel.updateRoleInfo(roleId, { lv, exp })
            let uids = [{ uid: roleId, sid }];
            pinus.app.get('channelService').pushMessageByUids('onPlayerExpChange', resResult(STATUS.SUCCESS, { 
                isLvUp: false, lv, exp
            }), uids);
        }
        return resResult(STATUS.SUCCESS);
    }

    async handleBlock(msg: { roleId: string, blockType: BLOCK_TYPE, blockReason: string }, session: BackendSession) {
        let { roleId, blockType, blockReason } = msg;
        if(roleId == undefined || blockType == undefined || blockReason == undefined) return resResult(STATUS.WRONG_PARMS);
        let role = await RoleModel.updateRoleInfo(roleId, { blockType, blockReason });
        if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
        let { isOnline, sid } = await getRoleOnlineInfo(roleId);
        if(isOnline) {
            await this.app.rpc.connector.connectorRemote.setOtherUseBlockTypeSession.toServer(sid,[{ roleId, blockType }]);
            if(blockType == BLOCK_TYPE.BLOCK) { // 踢走
                await this.app.rpc.connector.connectorRemote.remoteLogin.toServer(sid, roleId, STATUS.BLOCKED);
            }
        }
        return resResult(STATUS.SUCCESS);
    }
}