import { HeroModel, HeroUpdate } from '../db/Hero';
import { ItemModel } from '../db/Item';
import { EquipModel, RandSe, Holes } from './../db/Equip';
import { BagInter, EquipInter } from './interface';
import { gameData } from './data';
import { RANDOM_SE_COUNT, FIX_ATTRIBUTES_RAN, ITID, CURRENCY_BY_TYPE, CURRENCY_TYPE, ROLE_SELECT, FIGURE_UNLOCK_CONDITION, CONSUME_TYPE, HERO_SYSTEM_TYPE, TASK_TYPE } from '../consts';
import { getRandValueByMinMax, getRandEelm } from './util';

import { findWhere } from 'underscore';
import { RoleModel, RoleType } from '../db/Role';
import { Figure } from '../domain/dbGeneral';
import { getBeforeDaySeconds, nowSeconds } from './timeUtil';
import { calPlayerCeAndSave, reCalAllHeroCe } from './playerCe';
import { checkTask, checkTaskWithHeroes, checkTaskWithEquip } from './taskUtil';

export async function addSkins(roleId: string, id: number) {
    let skinInfo = gameData.fashion.get(id);
    if (!skinInfo)
        return false;
    let hero = await HeroModel.findByHidAndRole(skinInfo.actorId, roleId);
    if (!hero)
        return false;
    if (!!findWhere(hero.skins, { id }))
        return false;
    hero.skins.push({ id, enable: false });
    await HeroModel.updateHeroInfo(roleId, hero.hid, hero);
    return { skins: hero.skins, hid: hero.hid };
}

export async function addBags(roleId: string, roleName: string, data: BagInter) {
    let { id, count, itemName, type, hid } = data;
    let item = await ItemModel.increaseItem(roleId, id, count, { roleId, roleName, itemName, id, type, hid });
    return { id: item.id, count: item.count };
}

export async function addEquips(roleId: string, roleName: string, weapon: EquipInter) {
    let { id, name, quality, suitId, hole, randomEffect, itid, hid } = weapon;
    let {type} = ITID.get(itid);

    let randomNum = RANDOM_SE_COUNT.get(quality);
    let randomResult: number[] = getRandEelm(randomEffect, randomNum);

    let randSe: Array<RandSe> = randomResult.map((id: number, i: number) => {
        let random = gameData.randomEffectPool.get(id)
        let rand = 0;
        if(random.id > 0) rand = getRandValueByMinMax(random.Min, random.Max, 0);
        return {
            id: i + 1,
            seid: random.id,
            rand,
            locked: false
        };
    });
    
    let randRange = getRandValueByMinMax(0 - FIX_ATTRIBUTES_RAN, FIX_ATTRIBUTES_RAN, 0);
    
    let holes = new Array<Holes>();
    for(let i = 0; i < hole; i++) {
        holes.push({id: i+1, isOpen: false, jewel: 0})
    }

    const equip = await EquipModel.createEquip({roleId, roleName, id, name, quality, suitId, randRange, ePlaceId: type, randSe, holes, hid});
    
    // 任务
    let pushMessage = await checkTaskWithEquip(roleId, TASK_TYPE.EQUIP_SUIT, equip);

    return { equipInfo: equip, pushMessage }
}

/**
 * @description 获取元宝物品 { id, count }
 * @param count 元宝数量
 */
export function getGoldObject(count: number) {
    return { id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count};
}

/**
 * @description 获取友情点物品 { id, count }
 * @param count 友情点数量
 */
export function getFriendPointObject(count: number) {
    return { id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.FRIEND_POINT), count};
}

/**
 * @description 获取功勋物品 { id, count }
 * @param count 功勋数量
 */
export function getHonourObject(count: number) {
    return { id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.HONOUR), count};
}
/**
 * 解锁头像/相框
 * @param roleId 玩家id
 * @param conditions 解锁条件
 * @param role 如果已查询过role表就直接可以使用
 */
export async function unlockFigure(roleId: string, conditions: { type: number, paramHid?: number, paramFavourLv?: number, paramSkinId?: number }[], role?: RoleType) {
    if(!role || !role.heads || !role.frames) {
        role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.GET_HEADS);
    }
    let { heads, frames, spines } = role;
    let figureInfo = { heads: new Array<Figure>(), frames: new Array<Figure>(), spines: new Array<Figure>() };
    for(let {type, paramHid, paramFavourLv, paramSkinId } of conditions) {
        let canUnLockList = gameData.figureCondition.get(type);
        if(canUnLockList) {
            for(let {id, params, gid} of canUnLockList) {
                let flag = false; // 是否达成条件
                if(type == FIGURE_UNLOCK_CONDITION.GET_HERO) {
                    let [ hid ] = params;
                    if(paramHid == hid) flag = true;
                } else if (type == FIGURE_UNLOCK_CONDITION.HERO_FAVOR) {
                    let [ hid, favourLv ] = params;
                    if(paramHid == hid && paramFavourLv >= favourLv) flag = true;
                } else if ( type == FIGURE_UNLOCK_CONDITION.GET_SKIN) {
                    let [ id ] = params;
                    if(paramSkinId == id) flag = true;
                }
                if(!flag) continue;
                let dicGood = gameData.goods.get(gid);
                if(!dicGood) continue;
                let dicItid = ITID.get(dicGood.itid);
                if(!dicItid) continue;
    
                if(dicItid.type == CONSUME_TYPE.HEAD) {
                    let figure = unlockSingleFigure(heads, gid, false, id);
                    if(figure && figure.unlocked) figureInfo.heads.push(figure);
                } else if (dicItid.type == CONSUME_TYPE.FRAME) {
                    let figure = unlockSingleFigure(frames, gid, false, id);
                    if(figure && figure.unlocked) figureInfo.frames.push(figure);
                } else if (dicItid.type == CONSUME_TYPE.SPINE) {
                    let figure = unlockSingleFigure(spines, gid, false, id);
                    if(figure && figure.unlocked) figureInfo.spines.push(figure);
                } else {
                    continue;
                }
    
            }
    
        }
    }
    role = await RoleModel.updateRoleInfo(roleId, { heads, frames, spines });
    return figureInfo;
}


// 直接获得形象/相框
export async function addFigure(roleId: string, ids: number[]) {
    let role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.GET_HEADS);

    if(!role) return false;
    let { heads, frames, spines } = role;

    let figureInfo = { heads: [], frames: [], spines: [] };
    for(let gid of ids) {
        let dicGoods = gameData.goods.get(gid);
        if(!dicGoods) continue;
        let dicItid = ITID.get(dicGoods.itid);
        if(!dicItid) continue;
    
        if(dicItid.type == CONSUME_TYPE.HEAD) {
            let figure = unlockSingleFigure(heads, gid, true);
            if(figure && figure.unlocked) figureInfo.heads.push(figure);
        } else if (dicItid.type == CONSUME_TYPE.FRAME) {
            let figure = unlockSingleFigure(frames, gid, true);
            if(figure && figure.unlocked) figureInfo.frames.push(figure);
        } else if (dicItid.type == CONSUME_TYPE.SPINE) {
            let figure = unlockSingleFigure(spines, gid, true);
            if(figure && figure.unlocked) figureInfo.spines.push(figure);
        } else {
            continue;
        }
    }
    
    role = await RoleModel.updateRoleInfo(roleId, { heads, frames, spines });
    return figureInfo;
}

/**
 * 根据物品id解锁/获得玩家数据
 * @param dbFigures 数据库内字段
 * @param id 物品id
 * @param unlockDirect 是否不计算解锁条件直接解锁
 * @param conditionId 条件id
 */
function unlockSingleFigure(dbFigures: Figure[], id: number, unlockDirect = false, conditionId?: number) {
    let figure = dbFigures.find(cur => cur.id == id);
    if(!figure) {
        figure = new Figure(id, false);
        dbFigures.push(figure);
    }
    if(figure.unlocked) return; // 已解锁过
    if(!figure.unlockedId) figure.unlockedId = new Array<number>();

    let dicGoods = gameData.goods.get(id);

    let hasUnlockedAll = true;
    if(!unlockDirect) { // 不能直接获得，需要通过type解锁
        if(figure.unlockedId.includes(conditionId)) return;

        figure.unlockedId.push(conditionId);
    
        for(let { id: cid } of dicGoods.condition) {
            if(!figure.unlockedId.includes(cid)) {
                hasUnlockedAll = false; break;
            }
        }
    }
    if(hasUnlockedAll) {
        figure.unlocked = true;
        delete figure.unlockedId;

        if(dicGoods.timeLimit) {
            figure.time = getBeforeDaySeconds(-1 * dicGoods.timeLimit); // timeLimit天以后 
        }
    }

    return figure
}

export async function createHero(roleId: string, heroInfo: HeroUpdate) {
    let { role, figureInfo, heroes, calHeroResults, calAllHeroResults, taskPushMessage } = await createHeroes(roleId, [heroInfo])
    return { hero: heroes[0], role, figureInfo, calHeroResult: calHeroResults[0], calAllHeroResult: calAllHeroResults[0], taskPushMessage }
}

export async function createHeroes(roleId: string, heroInfos: HeroUpdate[]) {
    
    let heroNum = 0;
    let skinIds = new Array<number>();
    let conditions = new Array<{type: number, paramHid?: number, paramFavourLv?: number, paramSkinId?: number }>();
    let heroes = [], calHeroResults = [], calAllHeroResults = [];

    for(let heroInfo of heroInfos) {
        let curHero = await HeroModel.createHero(heroInfo); heroes.push(curHero);
        let calHeroResult = await calPlayerCeAndSave(HERO_SYSTEM_TYPE.INIT, roleId, curHero, {}); calHeroResults.push(calHeroResult);
        let calAllHeroResult = await reCalAllHeroCe(HERO_SYSTEM_TYPE.ADD_SKIN, roleId, {}, skinIds); calAllHeroResults.push(calAllHeroResult);

        conditions.push({ type: FIGURE_UNLOCK_CONDITION.GET_HERO, paramHid: heroInfo.hid });
        heroInfo.skins.forEach(cur => {
            skinIds.push(cur.id);
            conditions.push({type: FIGURE_UNLOCK_CONDITION.GET_SKIN, paramSkinId: cur.id});
        });
        heroNum ++;
    }
    let figureInfo = await unlockFigure(roleId, conditions); // 解锁头像

    let role = await RoleModel.incRoleInfo(roleId, { heroNum }, { heroNumUpdatedAt: nowSeconds() });
    // 任务
    let m1 = await checkTask(roleId, TASK_TYPE.HERO_NUM, heroNum, true, {});
    let m2 = await checkTaskWithHeroes(roleId, TASK_TYPE.HERO_QUALITY, heroes);
    let m3 = await checkTaskWithHeroes(roleId, TASK_TYPE.HERO_QUALITY_STAR_UP, heroes);
    let m4 = await checkTaskWithHeroes(roleId, TASK_TYPE.HERO_LV, heroes);
    let taskPushMessage = m1.concat(m2, m3, m4);
    return { role, figureInfo, heroes, calHeroResults, calAllHeroResults, taskPushMessage }
}