import { STATUS } from '../../../consts/statusCode';
import { RoleModel } from './../../../db/Role';
import { CounterModel } from '../../../db/Counter';
import { HeroModel } from '../../../db/Hero';
import { EquipModel } from '../../../db/Equip';
import { calculateCE, resResult } from '../../../pubUtils/util';
import {Application, BackendSession, createTcpMailBox} from 'pinus';
import { COUNTER } from '../../../consts';
import { handleCost } from '../../../services/rewardService';
import { getTitle, getTeraph } from '../../../pubUtils/data';
import { SSL_OP_SSLEAY_080_CLIENT_DH_BUG } from 'constants';
import { getTeraphAttr } from '../../../consts/constModules/abilityConst'
const _ = require('underscore');

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

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

    async initEquips(roleId: string, roleName: string) {
        // const seqId = await CounterModel.getNewCounter(COUNTER.EID);
        // const equipInfo = {
        //     roleId,
        //     roleName,
        //     id: 1,
        //     name: '倚天剑',
        //     seqId,
        //     type: 1
        // }
        // const equip = await EquipModel.createEquip(equipInfo);
        // await HeroModel.addEquip(roleId, 12, 1, equip._id);
    }

    async initHeros(roleId: string, roleName: string) {

        const heroInfo = {
            roleId,
            roleName,
            hid: 1,
            hName: '曹操',
            quality: 1,
            job: 1,
            star: 0,
            serverId: 1,
            skins:[{id: 41001, enable: true}]
        }
        await HeroModel.createHero(heroInfo);
    }

    async initRole(msg: {content: string , target: string}, session: BackendSession) {
        let roleId = session.get('roleId');
        let roleName = session.get('roleName');
        console.log('role in initRole: ', roleId, roleName);

        let heros = await HeroModel.findByRole(roleId);
        if (!heros || heros.length === 0) {
            await this.initHeros(roleId, roleName);
        }

        // let equips = await EquipModel.findbyRole(roleId);
        // if (!equips || equips.length === 0) {
            await this.initEquips(roleId, roleName);
        // }

        console.log('initRole finish');
    }

    async getRoleInfo(msg: {targetRoleId: string}, session: BackendSession) {
        let { targetRoleId } = msg;
        let { roleId, roleName, headHid = 1, ce = 0, topFive, topFiveCe = 0 } = await RoleModel.findByRoleId(targetRoleId);
        return resResult(STATUS.SUCCESS, { roleId, roleName, headHid, ce, topFive, topFiveCe });
    }

    //爵位
    async roleTitleLevelUp(msg: {}, session: BackendSession){
        let roleId = session.get('roleId');
        let role = await RoleModel.findByRoleId(roleId);
        let sid: string = session.get('sid');
        let title = ++role.title;
        let titleInfo = getTitle(role.title);
        if (!titleInfo)
            return resResult(STATUS.DIC_DATA_NOT_FOUND)
        if (titleInfo.lvLimited > role.lv) 
            return resResult(STATUS.COM_BATTLE_LV_NOT_ENOUGH)
        let consumes = titleInfo.material;
        let result = await handleCost(roleId, sid, consumes);
        if (!result) 
            return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
        await RoleModel.updateRoleInfo(roleId, { title });
        return resResult(STATUS.SUCCESS, { roleId, title });
    }

    //神像强化
    async roleTeraphStrengthen(msg: {id: number, type: number}, session: BackendSession){
        let {id, type} = msg;
        let roleId = session.get('roleId');
        let role = await RoleModel.findByRoleId(roleId);
        let sid: string = session.get('sid');
        let index = _.findIndex(role.teraphs, {id});
        if (index < 0)
            return resResult(STATUS.WRONG_PARMS);
        let teraph = role.teraphs[index];
        let teraphInfo = getTeraph(id, teraph.grade);
        if (!teraphInfo)
            return resResult(STATUS.DIC_DATA_NOT_FOUND)
        let falg = true;
        for (let attrName in getTeraphAttr()) {
            if (teraph[attrName] != teraphInfo[attrName]) {
                falg = false;
                break;
            }
        }
        if (!!falg)
            return  resResult(STATUS.ROLE_TERAPH_NOT_STRENGTHEN);
        //TODO强化属性
        let consumes;
        if (type == 1) {
            consumes = teraphInfo.upMaterial;
        } else if (type == 2) {
            consumes = teraphInfo.upMaterial;
        } else {
            return resResult(STATUS.WRONG_PARMS); 
        }
        let result = await handleCost(roleId, sid, consumes);
        if (!result) 
            return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
        await RoleModel.updateRoleInfo(roleId, { teraphs: role.teraphs });
        return resResult(STATUS.SUCCESS, { roleId, teraphs: role.teraphs });
    }

    //神像进阶
    async roleTeraphQualityUp(msg: {id: number}, session: BackendSession){
        let {id} = msg;
        let roleId = session.get('roleId');
        let role = await RoleModel.findByRoleId(roleId);
        let sid: string = session.get('sid');
        let index = _.findIndex(role.teraphs, {id});
        if (index < 0)
            return resResult(STATUS.WRONG_PARMS);
        let teraph = role.teraphs[index];
        let teraphInfo = getTeraph(id, teraph.grade);
        if (!teraphInfo)
            return resResult(STATUS.DIC_DATA_NOT_FOUND)
        for (let attrName in getTeraphAttr()) {
            if (teraph[attrName] != teraphInfo[attrName])
                return resResult(STATUS.ROLE_TERAPH_NOT_QUILITY);
        }
        teraph.grade++;
        teraph.atk = 0;
        teraph.agi = 0;
        teraph.def = 0;
        teraph.hp = 0;
        teraph.luk = 0;
        teraph.mdef = 0;
        if (getTeraph(index, teraph.grade))
            return resResult(STATUS.DIC_DATA_NOT_FOUND)
        let consumes = teraphInfo.upGradeMaterial;
        let result = await handleCost(roleId, sid, consumes);
        if (!result) 
            return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
        await RoleModel.updateRoleInfo(roleId, { teraphs: role.teraphs });
        return resResult(STATUS.SUCCESS, { roleId, teraphs: role.teraphs });
    }
}