import { STATUS } from './../../../consts/statusCode';
import { EquipModel } from './../../../db/Equip';
import { RoleModel } from './../../../db/Role';
import { UserModel } from '../../../db/User';
import { GMUserModel  } from '../../../db/GMUser';
import { Application } from 'pinus';
import {FrontendSession} from 'pinus';
import { HeroModel } from './../../../db/Hero';
import { resResult, returnHeroCeRatio, reduceCe } from '../../../pubUtils/util';
import { COM_BTL_QUALITY } from '../../../consts';
import { getAp } from '../../../services/actionPointService';
import { ItemModel } from '../../../db/Item';
import { chackFunOpenWhenLogin } from '../../../services/funcSwitchService';
import { loginRefresh } from '../../../services/playerEventService';
import { nowSeconds } from '../../../pubUtils/timeUtil';
import { getRedis, setRedis, delRedis, rmRoleFromQueue } from '../../../services/redisService';

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

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

    /**
     * New client entry chat server.
     *
     * @param  {Object}   msg     request message
     * @param  {Object}   session current session object
     */
    async enter(msg: { token: string, serverId: number }, session: FrontendSession) {
        let self = this;
        let serverId = msg.serverId;

        let user = await UserModel.findUserByToken(msg.token);
        if (!user) {
            console.log('user token not found');
            return resResult(STATUS.TOKEN_ERR);
        }

        let role = await RoleModel.findByUid(user.uid, serverId);
        if (!role) {
            return resResult(STATUS.ROLE_NOT_FOUND);
        }
        let key = 'login_roleId_' + role.roleId; 
        let connect = await getRedis(key);
        if (!!connect) {
            await self.app.rpc.connector.connectorRemote.remoteLogin.toServer(connect, role.roleId);
        }
        let serverName =  this.app.getServerId();
        setRedis(key, serverName);
        await session.abind(role.roleId);
        session.set('uid', role.roleId);
        session.set('roleId', role.roleId);
        session.set('roleName', role.roleName);
        session.set('eventStatus', role.eventStatus);
        session.set('sid', self.app.get('serverId'));
        session.set('serverId', role.serverId);
        session.set('funcs', role.funcs||[]);
        session.push('sid', () => {});
        session.push('roleId', () => {});
        session.push('roleName', () => {});
        session.push('eventStatus', () => {});
        session.push('serverId', () => {});
        session.push('funcs', () => {});
        // session.push('rid', function (err) {
        //     if (err) {
        //         console.error('set rid for session service failed! error is : %j', err.stack);
        //     }
        // });
        session.on('closed', this.onUserLeave.bind(this));

        let channelService = self.app.get('channelService');
        let channel = channelService.getChannel(role.roleId, true);
        if (channel.getMembers().indexOf(role.roleId) === -1) {
            channel.add(role.roleId, self.app.get('serverId'));
        }

        // put user into channel
        // console.log(JSON.stringify(self.app.rpc.battle))
        // await self.app.rpc.battle.battleRemote.add.route(session)(role.roleId, self.app.get('serverId'), role.serverId, true);

        await self.app.rpc.chat.chatRemote.addWorldChannel.route(session)(role.roleId, serverId, self.app.get('serverId'));
        await self.app.rpc.chat.guildRemote.enterMyChannel.route(session)(role.roleId, self.app.get('serverId'));
        let heros = await HeroModel.findByRole(role.roleId);
        let equips = await EquipModel.findbyRole(role.roleId);
        let items = await ItemModel.findbyRole(role.roleId);

        await chackFunOpenWhenLogin(role, session);
        await loginRefresh(role.roleId);

        role['heros'] = heros.map(cur => returnHeroCeRatio(cur));
        role['equips'] = equips;
        role['consumeGoods'] = items;
        let apJson = await getAp(Date.now(), role.roleId);
        role['apJson'] = apJson;
        role['ce'] = reduceCe(role.ce);
        role['topFiveCe'] = reduceCe(role.topFiveCe);


        return resResult(STATUS.SUCCESS, { role });
    }

    /**
     * User log out handler
     *
     * @param {Object} app current application
     * @param {Object} session current session object
     *
     */
    onUserLeave(session: FrontendSession, reason: string) {
        if (!session || !session.uid) {
            return;
        }

        let roleId = session.get('roleId');
        let sid = session.get('sid');
        let serverId = session.get('serverId');
        let key = 'login_roleId_' + roleId; 
        delRedis(key);
        rmRoleFromQueue(roleId, sid, COM_BTL_QUALITY, null); // 删除redis中寻宝的匹配记录
        let channelService = this.app.get('channelService');
        let channel = channelService.getChannel(roleId, true);
        channel.leave(roleId, sid);
        // this.app.rpc.battle.battleRemote.kick.route(session)(roleId, this.app.get('serverId'), serverId);
        this.app.rpc.chat.chatRemote.kickWorldChannel.route(session, true)(roleId, sid, serverId);
        this.app.rpc.chat.guildRemote.leaveMyChannel.route(session)(roleId, sid);
        RoleModel.updateRoleInfo(roleId, { quitTime: nowSeconds() });
    }


    /**
     * New client entry chat server.
     *
     * @param  {Object}   msg     request message
     * @param  {Object}   session current session object
     */
    async gmEnter(msg: { token: string, serverId: number }, session: FrontendSession) {
        
        let self = this;

        let user = await GMUserModel.getGmAccountByToken(msg.token);
        if (!user) {
            console.log('user token not found');
            return resResult(STATUS.TOKEN_ERR);
        }

        console.log(self.app.get('serverId'));
        await session.abind(user.username);
        session.set('uid', user.uid);
        session.set('roleId', user.username);
        session.set('roleName', user.name);
        session.set('eventStatus', 0);
        session.set('sid', self.app.get('serverId'));
        session.push('sid', () => {});
        session.push('roleId', () => {});
        session.push('roleName', () => {});
        session.push('eventStatus', () => {});
        // session.push('rid', function (err) {
        //     if (err) {
        //         console.error('set rid for session service failed! error is : %j', err.stack);
        //     }
        // });
        session.on('closed', this.onUserLeave.bind(this));

        // put user into channel
        return resResult(STATUS.SUCCESS);
    }
}