import { STATUS } from '../../../consts/statusCode';
import { RoleModel } from './../../../db/Role';
import { HeroModel } from '../../../db/Hero';
import { resResult, decodeIdCntArrayStr, parseGoodStr, reduceCe } from '../../../pubUtils/util';
import {Application, BackendSession} from 'pinus';
import { handleCost } from '../../../services/rewardService';
import { getTitle, getTeraph, gameData, getScollByStar } from '../../../pubUtils/data';
import { SCHOOL, SCROLL } from '../../../pubUtils/dicParam';
import { getTeraphAttr, getAtrrNameById } from '../../../consts/constModules/abilityConst'
import { findIndex } from 'underscore';
import { SclResultInter, SclPosInter } from '../../../pubUtils/interface';
import { SchoolModel } from '../../../db/School';
import { checkMaterialEnough } from '../../../services/roleService'
import { calPlayerCeAndSave, calAllHeroCe } from '../../../services/playerCeService';
import { HERO_SYSTEM_TYPE } from '../../../consts';

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 oldCe = role.ce;
        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 });
        let {ce} = await calAllHeroCe( sid, roleId, HERO_SYSTEM_TYPE.TITLE, [title]);
        return resResult(STATUS.SUCCESS, { roleId, title, oldCe: reduceCe(oldCe), incRoleCe: ce - reduceCe(oldCe)});
    }

    //神像强化
    async roleTeraphStrengthen(msg: {id: number, count: number}, session: BackendSession){
        let {id, count} = 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 attrs = [];
        for (let attrName in getTeraphAttr()) {
            let attrNameMax = attrName+'Max';
            if (teraph[attrName] < teraphInfo[attrNameMax]) {
                attrs.push(attrName);
            }
        }
        if (!attrs.length)
            return  resResult(STATUS.ROLE_TERAPH_NOT_STRENGTHEN);
        let {attr, consumes} = checkMaterialEnough(count, attrs, teraphInfo, teraph);
        for (let key in attr) {
            teraph[key] += attr[key];
            role.globalCeAttr[key].fixUp += attr[key];
        }
        let result = await handleCost(roleId, sid, consumes);
        if (!result) 
            return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
        await RoleModel.updateRoleInfo(roleId, { teraphs: role.teraphs,  globalCeAttr: role.globalCeAttr});
        await calAllHeroCe( sid, roleId);
        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 +'Max'])
                return resResult(STATUS.ROLE_TERAPH_NOT_QUILITY);
            teraph[attrName] = 0;
        }
        teraph.grade++; 
        let nextTeraphInfo = getTeraph(id, teraph.grade)
        if (!nextTeraphInfo)
            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);
        for (let {id, number} of nextTeraphInfo.assiAttrValue) {
            let attrName = getAtrrNameById(id);
            role.globalCeAttr[attrName].ratioUp += number;
        }
        await RoleModel.updateRoleInfo(roleId, { teraphs: role.teraphs,  globalCeAttr: role.globalCeAttr});
        await calAllHeroCe(sid, roleId);
        return resResult(STATUS.SUCCESS, { roleId, teraphs: role.teraphs });
    }
   
    // 获得百家学宫
    async getSchoolList(msg: {}, session: BackendSession) {
        let roleId = session.get('roleId');

        const dicPosition = decodeIdCntArrayStr(SCHOOL.SCHOOL_POSITION, 1); // id=>isOpen

        const userSchoolList = await SchoolModel.findByRoleId(roleId);

        let school = new Array<SclResultInter>();
        gameData.school.forEach((dicSchool) => {
            let position = new Array<SclPosInter>();
            dicPosition.forEach((isOpen, id) => {
                id = parseInt(id);

                let userSchool = userSchoolList.find(cur => cur.schoolId == dicSchool.id && cur.positionId == id);
                if (userSchool) {
                    position.push({
                        id,
                        hid: userSchool.hid,
                        isOpen: userSchool.isOpen
                    });
                } else {
                    position.push({
                        id,
                        hid: 0,
                        isOpen: !!isOpen
                    });
                }
            });

            school.push({
                id: dicSchool.id,
                position
            });
        });

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

    }

    // 摆放/替换/卸下武将
    async changeSchoolHero(msg: { schoolId: number, positionId: number, hid: number }, session: BackendSession) {
        let roleId = session.get('roleId');
        let sid = session.get('sid');

        let { schoolId, positionId, hid } = msg;
        if (!gameData.school.has(schoolId)) {
            return resResult(STATUS.DIC_DATA_NOT_FOUND);
        }
        const dicPosition = decodeIdCntArrayStr(SCHOOL.SCHOOL_POSITION, 1); // id(str) => isOpen
        if (!dicPosition.has(positionId.toString())) {
            return resResult(STATUS.DIC_DATA_NOT_FOUND);
        }
        let isOpen = !!dicPosition.get(positionId.toString()); // 该位置是否解锁

        if(hid > 0) {
            let findHero = await SchoolModel.findByHid(roleId, hid);
            if (!!findHero) {
                return resResult(STATUS.ROLE_SCHOOL_HERO_USED);
            }

            let curHero = await HeroModel.findByHidAndRole(hid, roleId);
            if (!curHero) return resResult(STATUS.HERO_NOT_FIND);
        }
        
        let curSchool = await SchoolModel.findBySclAndPos(roleId, schoolId, positionId);
        let preHid = 0; // 原先在该位置上的武将
        if (curSchool) {
            isOpen = curSchool.isOpen;
            preHid = curSchool.hid;
        }


        if (!isOpen) {
            return resResult(STATUS.ROLE_SCHOOL_POSITION_LOCKED);
        }

        await SchoolModel.updateBySclAndPos(roleId, schoolId, positionId, { hid, isOpen })
        await calPlayerCeAndSave(sid, roleId, [], HERO_SYSTEM_TYPE.SCHOOL, [schoolId, hid, preHid]);

        return resResult(STATUS.SUCCESS, {
            schoolId, positionId, hid, preHid, isOpen
        });

    }

    // 解锁位置
    async unlockSchoolPosition(msg: { schoolId: number, positionId: number }, session: BackendSession) {
        let roleId = session.get('roleId');
        let sid = session.get('sid');

        let { schoolId, positionId } = msg;
        if (!gameData.school.has(schoolId)) {
            return resResult(STATUS.DIC_DATA_NOT_FOUND);
        }
        const dicPosition = decodeIdCntArrayStr(SCHOOL.SCHOOL_POSITION, 1); // id(str) => isOpen
        if (!dicPosition.has(positionId.toString())) {
            return resResult(STATUS.DIC_DATA_NOT_FOUND);
        }
        let isOpen = !!dicPosition.get(positionId.toString()); // 该位置是否解锁
        if (isOpen) {
            return resResult(STATUS.ROLE_SCHOOL_POSITION_UNLOCK_NOT_NEED);
        }
        let curSchool = await SchoolModel.findBySclAndPos(roleId, schoolId, positionId);
        if (curSchool && curSchool.isOpen) {
            return resResult(STATUS.ROLE_SCHOOL_POSITION_UNLOCK_NOT_NEED);
        }

        const cost = parseGoodStr(SCHOOL.SCHOOL_UNLOCK_COIN);
        const costResult = await handleCost(roleId, sid, cost);
        if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);

        curSchool = await SchoolModel.updateBySclAndPos(roleId, schoolId, positionId, { isOpen: true })

        return resResult(STATUS.SUCCESS, {
            schoolId, positionId, hid: curSchool.hid, isOpen: curSchool.isOpen
        });
    }

    // 激活/升级名将谱
    async activeHeroScroll(msg: { hid: number }, session: BackendSession) {
        let roleId = session.get('roleId');
        let sid = session.get('sid');

        let { hid } = msg;

        let curHero = await HeroModel.findByHidAndRole(hid, roleId, 'star colorStar quality scrollId scrollActive scrollStar scrollColorStar scrollQuality favour favourLv');
        if (!curHero) return resResult(STATUS.HERO_NOT_FIND);

        let dicHero = gameData.hero.get(hid);
        if (!dicHero) return resResult(STATUS.DIC_DATA_NOT_FOUND);

        let { star, colorStar, quality, scrollId, scrollActive, scrollStar, scrollColorStar, scrollQuality, favour, favourLv } = curHero;

        let update = {
            scrollActive, scrollId, scrollStar, scrollColorStar, scrollQuality, favour, favourLv
        };
        if (!scrollActive) { // 初次激活
            update.scrollActive = true;
            update.scrollStar = dicHero.initialStars;
            update.scrollQuality = dicHero.quality;
            update.scrollColorStar = 0;

            // 获取一定好感度
            let friendShipLevels = gameData.friendShipLevel;
            if (friendShipLevels[friendShipLevels.length - 1].level > favourLv) {

                update.favour += SCROLL.SCROLL_ACTIVE_FAVOUR;
                for (let friendShipLevel of friendShipLevels) {
                    if (friendShipLevel.level < update.favourLv) 
                        continue;
                    if (friendShipLevel.exp > update.favour)
                        break;
                    update.favour -= friendShipLevel.exp;
                    update.favourLv++;
                }
            
            }
        } else {
            if (star > scrollStar) { // 可以升星
                update.scrollStar++;
            } else if (quality > scrollQuality ) { // 可以升品
                update.scrollQuality++;
            } else if (colorStar > scrollColorStar) { // 可以升彩星
                update.scrollColorStar++;
            } else {
                return resResult(STATUS.ROLE_SCROLL_REACH_MAX);
            }

        }

        let dicHeroScroll = getScollByStar(dicHero.quality, update.scrollStar, update.scrollQuality, update.scrollColorStar);
        update.scrollId = dicHeroScroll?dicHeroScroll.id: 0;

        curHero = await HeroModel.updateHeroInfo(roleId, hid, update, 'hid scrollActive scrollId scrollStar scrollColorStar scrollQuality favour favourLv');
        await calPlayerCeAndSave(sid, roleId, [], HERO_SYSTEM_TYPE.SCROLL, [hid, favourLv]);

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

}