import { ITID, CONSUME_TYPE, ITEM_TABLE, CURRENCY_TYPE, MAIL_TYPE, HANDLE_REWARD_TYPE, HERO_SYSTEM_TYPE, CURRENCY_BY_TYPE, ITEM_CHANGE_REASON, TA_USERSET_TYPE, TA_EVENT, POP_UP_SHOP_CONDITION_TYPE, ROLE_SELECT, FIGURE_UNLOCK_CONDITION, PUSH_ROUTE, ACTIVITY_TYPE } from '../../consts';
import { getDecimalCnt, getRandEelm, getRandEelmWithWeight, getRandValueByMinMax, } from '../../pubUtils/util';
import { RoleModel, RoleType } from '../../db/Role';
import { setAp } from '../actionPointService';
import { ItemModel, } from '../../db/Item';
import { ItemInter, } from '../../pubUtils/interface';
import { gameData, getDefArtifactByGid } from '../../pubUtils/data';
import { uniq } from 'underscore';
import { EPlace, HeroModel, HeroType, } from '../../db/Hero';
import { Figure } from '../../domain/dbGeneral';
import { ArtifactParam, JewelParam } from '../../domain/roleField/hero';
import { HeroSkin } from '../../db/Hero';
import { BAG } from '../../pubUtils/dicParam';
import { sendMailByContent } from '../mailService';
import { SkinModel, } from '../../db/Skin';
import { reportTAEvent, reportTAUserSet } from '../sdkService';
import { saveCoinChangeLog, saveFigureInfoLog, saveGoldChangeLog, saveItemChangeLog } from '../../pubUtils/logUtil';
import { JewelModel, JewelType, jewelUpdate, RandSe } from '../../db/Jewel';
import { updateEplaces } from '../equipService';
import { combineItems, getCoinEventProperties, getGoldEventProperties, sortItems } from './util';
import { nowSeconds } from '../../pubUtils/timeUtil';
import { calculateCeWithHero, calculateCeWithRole } from '../playerCeService';
import { sendMessageToUserWithSuc } from '../pushService';
import { filterGoods } from '../dataService';
import { ArtifactModel, ArtifactModelType, ArtifactModelUpdate } from '../../db/Artifact';
import { ActivityItemModel } from '../../db/ActivityItem';
import { getActivitiesByType } from '../activity/activityService';
import { ActivityModelType } from '../../db/Activity';
import { ForgeData } from '../../domain/activityField/forgeField';
import { getRoleCreateTime, getServerCreateTime } from '../redisService';

export async function handleCost(roleId: string, sid: string, goods: Array<ItemInter>, reason: ITEM_CHANGE_REASON) {

    let { items, jewels, gold, coin, artifacts, activityItems } = sortItems(goods, HANDLE_REWARD_TYPE.COST);
    let jewelSeqIds = jewels.map(cur => cur.seqId);
    let resJewels: JewelType[] = [];
    let artifactSeqIds = artifacts.map(cur => cur.seqId);
    let resArtifacts: ArtifactModelType[] = [];

    // 检查货币是否充足
    let role = await RoleModel.findByRoleId(roleId);
    if (gold.length > 0 || coin.length > 0) {
        let { gold: originGold, coin: originCoin } = role;
        for(let {count} of gold) { originGold -= count };
        for(let count of coin) { originCoin -= count };
        if(originGold < 0 || originCoin < 0) return false;
    }
    //检查装备是否存在
    if (jewels.length > 0) {
        resJewels = await JewelModel.findbySeqIds(jewelSeqIds);
        if (resJewels.length < jewels.length)
            return false;
    }
    //检查宝物是否存在
    if (artifacts.length > 0) {
        resArtifacts = await ArtifactModel.findbySeqIds(roleId, artifactSeqIds);
        if (resArtifacts.length < artifacts.length)
            return false;
    }
    //检查并修改道具
    if (items.length > 0) {
        let { hasError, result } = await ItemModel.decreaseItems(roleId, items);
        if (hasError) return false;
        sendMessageToUserWithSuc(roleId, PUSH_ROUTE.ITEM_UPDATE, { goods: result.map(cur => ({...cur, reason })) }, sid);
        saveItemChangeLog(roleId, result, reason);
    }
    //检查并修改道具
    if (activityItems.length > 0) {
        let { hasError, result } = await ActivityItemModel.decreaseActivityItems(roleId, activityItems);
        if (hasError) return false;
        sendMessageToUserWithSuc(roleId, PUSH_ROUTE.ACTIVITY_ITEM_UPDATE, { goods: result.map(cur => ({...cur, reason })) }, sid);
        saveItemChangeLog(roleId, result, reason);
    }

    //删除装备
    if (resJewels.length > 0) {
        let heroMap = new Map<number, { hero: HeroType, jewels: JewelType[]}>();
        for(let jewel of resJewels) {
            if(jewel.hid > 0) {
                if(!heroMap.has(jewel.hid))  {
                    let hero = await HeroModel.findByHidAndRole(jewel.hid, roleId);
                    heroMap.set(jewel.hid, { hero, jewels: [] });
                }
                heroMap.get(jewel.hid).jewels.push(jewel);
            }
        }
        for(let [hid, {hero, jewels} ] of heroMap) {
            // 脱下天晶石
            let update = new Map<number, Partial<EPlace>>();
            for(let jewel of jewels) {
                await JewelModel.putOnOrOff(jewel.id, 0, 0);
                let curEquip = hero.ePlace.find(cur => cur.jewel == jewel.id);
                if(!!curEquip) {
                    update.set(curEquip.id, { jewel: 0 });
                }
            }
            let { newEplace } = updateEplaces(hero.ePlace, update);
            await calculateCeWithHero(HERO_SYSTEM_TYPE.EQUIP_STRENGTH, roleId, role.serverId, sid, hid, { ePlace: newEplace }, { ePlaceIds: [...update.keys()] });
        }


        let jewels = await JewelModel.deleteBySeqIds(roleId, jewelSeqIds);
        saveItemChangeLog(roleId, jewels.map(jewel => ({ id: jewel.id, count: 1, inc: -1 })), reason);
        sendMessageToUserWithSuc(roleId, PUSH_ROUTE.JEWEL_DEL, { jewels: jewels.map(jewel => ({ seqId: jewel.seqId, id: jewel.id, inc: -1, reason })) }, sid);
    }

    //删除宝物
    if (resArtifacts.length > 0) {
        let heroMap = new Map<number, { artifact: ArtifactModelType}>();
        for(let artifact of resArtifacts) {
            if(artifact.hid > 0) {
                heroMap.set(artifact.hid, { artifact });
            }
        }
        for(let [hid, { artifact } ] of heroMap) {
            // 脱下天晶石
            await ArtifactModel.putOnOrOff(roleId, artifact.id, 0);
            await calculateCeWithHero(HERO_SYSTEM_TYPE.PUT_ARTIFACT, roleId, role.serverId, sid, hid, { artifact: 0 });
        }

        let artifacts = await ArtifactModel.deleteBySeqIds(roleId, artifactSeqIds);
        saveItemChangeLog(roleId, artifacts.map(artifact => ({ id: artifact.id, count: 1, inc: -1 })), reason);
        sendMessageToUserWithSuc(roleId, PUSH_ROUTE.ARTIFACT_DEL, { artifacts: artifacts.map(artifact => ({ seqId: artifact.seqId, id: artifact.id, inc: -1, reason })) }, sid);
    }

    //消耗玩家货币
    if (gold.length > 0 || coin.length > 0) {
        let costGold = gold.reduce((pre, cur) => pre + cur.count, 0);
        let costCoin = coin.reduce((pre, cur) => pre + cur, 0);
        role = await RoleModel.decreaseGoldAndCoin(roleId, gold, costCoin);
        sendMessageToUserWithSuc(roleId, PUSH_ROUTE.PLAYER_DATA_CHANGE, { gold: role.gold, coin: role.coin, totalCost: role.totalCost }, sid);

        if(costGold > 0) {
            reportTAEvent(roleId, TA_EVENT.ITEM_CONSUME, getGoldEventProperties(costGold, role.gold, reason));
            reportTAUserSet(TA_USERSET_TYPE.SET, roleId, { current_gold: role.gold });
            saveGoldChangeLog(roleId, role.gold, -1 * costGold, reason);
        }
        if(costCoin > 0) {
            reportTAEvent(roleId, TA_EVENT.ITEM_CONSUME, getCoinEventProperties(costCoin, role.coin, reason));
            reportTAUserSet(TA_USERSET_TYPE.SET, roleId, { current_coin: role.coin });
            saveCoinChangeLog(roleId, role.coin, -1 * costCoin, reason);
        }

    }

    return true;
}

export async function addItems(roleId: string, roleName: string, sid: string, goods: Array<ItemInter>, reason: ITEM_CHANGE_REASON) {
    goods = filterGoods(goods, obj => obj.id, roleId, reason);
    let { items, jewels, gold, coin, ap, skins, figures, artifacts, activityItems } = sortItems(goods, HANDLE_REWARD_TYPE.RECEIVE);
    let showItems: { id: number, seqId?: number|string, count: number, isBag?: boolean, expireTime?: number }[] = [];
    let role = await RoleModel.findByRoleId(roleId, '-warCount -topLineup');
    // 1. 装备处理
    if(jewels.length > 0) {
        let { jewelCount = 0 } = role;
        let incJewels = jewels, mailJewels: { id?: number, hid?: number, seqId?: number }[] = [];
        if(jewels.length + jewelCount > BAG.BAG_EQUIP_UPLIMITED) { // 装备上限
            let inc = BAG.BAG_EQUIP_UPLIMITED - jewelCount;
            if(inc < 0) inc = 0;
            incJewels = jewels.slice(0, inc);
            mailJewels = jewels.slice(inc);
        }

        // 直接加的
        let { jewels: jewelInfos } = await addJewels(roleId, roleName, <{id: number }[]>incJewels, reason);
        for (let jewel of jewelInfos) {
            showItems.push({ seqId: jewel.seqId, id: jewel.id, count: 1, isBag: true });
        }
        for(let jewel of combineItems(mailJewels)) {
            showItems.push({ id: jewel.id, count: jewel.count, isBag: false });
        }
        //装备推送
        if (!!jewelInfos.length)
            sendMessageToUserWithSuc(roleId, PUSH_ROUTE.JEWEL_ADD, { jewelInfos }, sid);
        //统计装备
        if (jewelInfos.length > 0) {
            saveItemChangeLog(roleId, jewelInfos, reason);
        }
        // 发邮件的
        if(mailJewels.length > 0) {
            await sendMailByContent(MAIL_TYPE.EQUIP_OVER, roleId, { goods: combineItems(mailJewels) });
        }
    }

    // 2. 道具处理
    if(items.length > 0) {
        let { items: itemInfos } = await addBags(roleId, roleName, items, reason);
        for (let item of items) {
            showItems.push({ id: item.id, count: item.count });
        }
        //背包除去装备推送 
        if (!!itemInfos.length) {
            sendMessageToUserWithSuc(roleId, PUSH_ROUTE.ITEM_UPDATE, { goods: itemInfos }, sid);
            saveItemChangeLog(roleId, itemInfos, reason);
        }   
        
    }

    // 3. 货币推送
    if(gold.length > 0 || coin.length > 0 || ap > 0) {
        await setAp(role.serverId, roleId, null, role.lv, ap, sid, reason);
        let incCoin = coin.reduce((pre, cur) => pre + cur, 0);
        let incGold = gold.reduce((pre, cur) => pre + cur.count, 0);
        role = await RoleModel.increaseGoldAndCoin(roleId, gold, incCoin);
        sendMessageToUserWithSuc(roleId, PUSH_ROUTE.PLAYER_DATA_CHANGE, { gold: role.gold, coin: role.coin }, sid);

        if(gold.length > 0) {
            gold.forEach(({ count }) => {
                showItems.push(getGoldObject(count));
            });
            reportTAEvent(roleId, TA_EVENT.ITEM_GET, getGoldEventProperties(incGold, role.gold, reason));
            reportTAUserSet(TA_USERSET_TYPE.SET, roleId, { current_gold: role.gold });
            saveGoldChangeLog(roleId, role.gold, incGold, reason );
        }
        if(coin.length > 0) {
            coin.forEach(count => {
                showItems.push(getCoinObject(count));
            });
            reportTAEvent(roleId, TA_EVENT.ITEM_GET, getCoinEventProperties(incCoin, role.coin, reason));
            reportTAUserSet(TA_USERSET_TYPE.SET, roleId, { current_coin: role.coin });
            saveCoinChangeLog(roleId, role.coin, incCoin, reason);
        }
        if(ap > 0) {
            showItems.push(getApObject(ap));
        }
    }

    // 4. 皮肤处理
    let figureInfos:{ heads: Figure[], frames: Figure[], spines: Figure[] }[] = []; // 头像变化推送信息
    if(skins.length > 0) {
        let heroskins: {skins: HeroSkin[], hid: number}[] = []; // 皮肤推送信息
        let skinInfos: {id: number, hid: number, count: number, inc: number, reason: number }[] = [];
        let calAllHeroResult = undefined; // 全局战力变化推送
    
        for (let skinId of skins) {//皮肤推送
            let hero = await addSkin(roleId, roleName, role.serverId, sid, skinId, false);
            skinInfos.push({ id: skinId, hid: hero? hero.hid: 0, count: 1, inc: 1, reason })
            showItems.push({ id: skinId, count: 1 });
            if(hero) heroskins.push({ skins: hero.skins, hid: hero.hid });
        }
        if (!!skinInfos.length) {
            pushHeroSkinMsg(heroskins, skinInfos, roleId, sid);  // 推送onHeroSkinChange
            saveItemChangeLog(roleId, skinInfos, reason);
        }
    } 

    // 5. 获得头像和相框等
    if(figures.length > 0) {
        let figureInfo = await addFigure(roleId, figures, reason);
        if(figureInfo) figureInfos.push(figureInfo);
        for (let id of figures) {//皮肤推送        
            showItems.push({ id, count: 1 });
        }
    }

    // 获得头像或相框或形象推送
    if(!!figureInfos && figureInfos.length > 0) {
        for(let figureInfo of figureInfos) {
            sendMessageToUserWithSuc(roleId, PUSH_ROUTE.HEAD_CHANGE, { ...figureInfo }, sid);
            saveFigureInfoLog(roleId, figureInfo, reason)
        }
    }

    // 6. 宝物处理
    
    if(artifacts.length > 0) {
        let { artifactCount = 0 } = role;
        let incArtifacts = artifacts, mailArtifacts: { id?: number, seqId?: number|string }[] = [];
        if(artifacts.length + artifactCount > BAG.BAG_ARTIFACT_UPLIMITED) { // 装备上限
            let inc = BAG.BAG_ARTIFACT_UPLIMITED - artifactCount;
            if(inc < 0) inc = 0;
            incArtifacts = artifacts.slice(0, inc);
            mailArtifacts = artifacts.slice(inc);
        }

        // 直接加的
        let { artifacts: artifactInfos } = await addArtifacts(roleId, roleName, <{id: number}[]>incArtifacts, reason);
        for (let artifact of artifactInfos) {
            showItems.push({ seqId: artifact.seqId, id: artifact.id, count: 1, isBag: true });
        }
        for(let artifact of combineItems(mailArtifacts)) {
            showItems.push({ id: artifact.id, count: artifact.count, isBag: false });
        }
        //装备推送
        if (!!artifactInfos.length)
            sendMessageToUserWithSuc(roleId, PUSH_ROUTE.ARTIFACT_ADD, { artifacts: artifactInfos }, sid);
        //统计装备
        if (artifactInfos.length > 0) {
            saveItemChangeLog(roleId, artifactInfos, reason);
        }
        // 发邮件的
        if(mailArtifacts.length > 0) {
            await sendMailByContent(MAIL_TYPE.ARTIFACT_OVER, roleId, { goods: combineItems(mailArtifacts) });
        }
    }

    // 7. 活动道具处理
    if(activityItems.length > 0) {
        let { items: itemInfos } = await addActivityItems(role, activityItems, reason);
        for (let item of itemInfos) {
            showItems.push({ id: item.id, count: item.inc, expireTime: item.expireTime });
        }
        //背包除去装备推送 
        if (!!itemInfos.length) {
            sendMessageToUserWithSuc(roleId, PUSH_ROUTE.ACTIVITY_ITEM_UPDATE, { goods: itemInfos }, sid);
            saveItemChangeLog(roleId, itemInfos, reason);
        }   
        
    }
    return showItems;
}


export async function checkGoods(roleId: string, goodIds: Array<number>) {
    let jewelSeqIds: Array<number> = [];
    let itemIds: Array<number> = [];
    let hids: Array<number> = [];
    goodIds = uniq(goodIds);
    for (let goodId of goodIds) {
        let goodInfo = gameData.goods.get(goodId);
        if (!!goodInfo) {
            let { table } = ITID.get(goodInfo.itid);
            if (table == ITEM_TABLE.EQUIP) {
                jewelSeqIds.push(goodId);
            } else if (table == ITEM_TABLE.ITEM) {
                itemIds.push(goodId);
            }
        }
    }

    //检查装备是否存在
    if (!!jewelSeqIds.length) {
        let resJewels = await JewelModel.findbySeqIds(jewelSeqIds);
        resJewels = uniq(resJewels, function (resEquip) {
            return resEquip.id;
        });
        if (resJewels.length < jewelSeqIds.length)
            return false;
    }
    //检查并修改道具
    if (itemIds.length > 0) {
        let items = await ItemModel.findbyRoleAndIds(roleId, itemIds);
        if (items.length < itemIds.length)
            return false;
    }
    return true;
}

export async function checkHeroes(roleId: string, hids: number[]) {
    if (!!hids.length) {
        let heros = await HeroModel.findByHidRange(hids, roleId);
        if (heros.length < hids.length)
            return false;
    }
    return true
}

export async function checkHeroEquips(roleId: string, quality: number) {
    return await HeroModel.checkEquipByQuality(roleId, quality);
}

/**
 * 解锁头像/相框
 * @param roleId 玩家id
 * @param conditions 解锁条件
 * @param role 如果已查询过role表就直接可以使用
 */
export async function unlockFigure(sid: string, roleId: string, conditions: { type: number, paramHid?: number, paramFavourLv?: number, paramSkinId?: number, paramWinStreakNum?: number }[], role?: RoleType) {
    if (!role || !role.heads || !role.frames) {
        role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.GET_HEADS);
    }
    let { figureInfo, heads, frames, spines } = unlockFigureWithoutSave(conditions, role);
    role = await RoleModel.updateRoleInfo(roleId, { heads, frames, spines });
    if (!!figureInfo && (figureInfo.heads.length > 0 || figureInfo.frames.length > 0 || figureInfo.spines.length > 0)) {
        sendMessageToUserWithSuc(roleId, PUSH_ROUTE.HEAD_CHANGE, { ...figureInfo }, sid);
    }
}


/**
 * 皮肤数据变化去重、推送
 * @param heroskins 推送的皮肤
 * @param roleId 玩家
 */
function pushHeroSkinMsg(heroskins: {skins: HeroSkin[], hid: number}[],  skinInfos: {id: number, hid: number }[], roleId: string, sid: string) {
    let pushSkinInfos: {skins: HeroSkin[], hid: number}[] = []; // 可能会有重复的
    for(let { skins, hid } of heroskins) {
        let index = pushSkinInfos.findIndex(cur => cur.hid == hid);
        if(index == -1) {
            pushSkinInfos.push({skins, hid});
        } else {
            if(skins.length > pushSkinInfos[index].skins.length) {
                pushSkinInfos[index] = {skins, hid};
            }
        }
    }
    if(pushSkinInfos.length > 0 || skinInfos.length > 0) {
        sendMessageToUserWithSuc(roleId, PUSH_ROUTE.HERO_SKIN_CHANGE, { heros: heroskins, skins: skinInfos }, sid);
    }
}


/**
 * 只插入皮肤，不管那么多的
 * @param roleId 
 * @param roleName 
 * @param skinId 
 * @returns 
 */
 export async function increaseSkin(roleId:string, roleName: string, skinId: number) {
    let dicSkin = gameData.fashion.get(skinId);
    if (!dicSkin) return false;

    let skin = await SkinModel.increaseSkin(roleId, skinId, { roleId, roleName, id: skinId, skinName: dicSkin.name, hid: dicSkin.actorId, skinId: dicSkin.heroId });
    if(!skin) return false; // 插入失败
    return skin
}

/**
 * 添加皮肤
 * @param roleId 玩家id 
 * @param roleName 玩家名
 * @param id 皮肤id
 * @param hero 武将，如果已经查询过这个武将就不用再查询一次，主意要select skins字段
 * @returns {{ hero, figureInfo, calAllHeroResult }} hero：添加皮肤后的武将 figureInfo: 触发头像添加信息 calAllHeroResult：全局战力加成后结果
 */
export async function addSkin(roleId: string, roleName: string, serverId: number, sid: string, skinId: number, enable: boolean, hero?: HeroType) {
    let skin = await increaseSkin(roleId, roleName, skinId);
    if(!skin) return false;

    if(skin.hid && !hero) hero = await HeroModel.findByHidAndRole(skin.hid, roleId);
    let condition = { type: FIGURE_UNLOCK_CONDITION.GET_SKIN, paramSkinId: skinId };
    await unlockFigure(sid, roleId, [condition]); // 解锁头像
    await calculateCeWithRole(HERO_SYSTEM_TYPE.ADD_SKIN, roleId, serverId, sid, {}, { skinId }); // 全局加成

    if (hero) { // 有武将的，将皮肤链接到武将上
        let curSkin = hero.skins.find(cur => cur.id == skinId);
        if (!curSkin) {
            hero.skins.push(new HeroSkin(skin, enable));
            await HeroModel.updateHeroInfo(roleId, hero.hid, hero);
        }
        return hero;
    } else {
        return null
    }
}

export async function addBags(roleId: string, roleName: string, datas: { id: number, count: number }[], reason: number) {
    let items: { id: number, count: number, inc: number }[] = [];
    for(let data of datas) {
        let item = await addBag(roleId, roleName, data, reason);
        items.push(item)
    }
    return { items }
}

export async function addBag(roleId: string, roleName: string, data: { id: number, count: number }, reason: number) {
    let { id, count } = data;
    let { name: itemName, itid, hid } = gameData.goods.get(id);
    let { type } = ITID.get(itid);

    let item = await ItemModel.increaseItem(roleId, id, count, { roleId, roleName, itemName, id, type, hid });
    return { id: item.id, count: item.count, inc: count, reason };
}

export async function addActivityItems(role: RoleType, datas: { id: number, count: number }[], reason: number) {
    let serverTime = await getServerCreateTime(role.serverId);
    let createTime = await getRoleCreateTime(role.roleId, role);
    let items: { id: number, count: number, inc: number, expireTime: number }[] = [];
    for(let data of datas) {
        let item = await addActivityItem(role.serverId, role.roleId, role.roleName, data, reason, createTime, serverTime);
        if(item) items.push(item)
    }
    return { items }
}

export async function addActivityItem(serverId: number, roleId: string, roleName: string, data: { id: number, count: number }, reason: number, createTime: number, serverTime: number) {
    let { id, count } = data;
    let { name: itemName, activityType } = gameData.goods.get(id);
    let activities = await getActivitiesByType(serverId, activityType);
    for(let activity of activities) {
        let activityData = getActivityData(activity, createTime, serverTime);
        if(!activityData || !activityData.canShow()) continue;
        let item = await ActivityItemModel.increaseActivityItem(roleId, id, count, { roleId, roleName, itemName, id, expireTime: Math.floor(activityData.nextRefreshTime/1000) });
        return { id: item.id, count: item.count, inc: count, expireTime: item.expireTime, reason };
    }
}

function getActivityData(activity: ActivityModelType, createTime: number, serverTime: number) {
    switch(activity.type) {
        case ACTIVITY_TYPE.FORGE:
            return new ForgeData(activity, createTime, serverTime)      
        default:
            return null
    }
}

export async function addJewels(roleId: string, roleName: string, jewels: { id: number, }[], reason: number) {
    let jewelInfo: jewelUpdate[] = [];
    for(let jewel of jewels) {
        let info = await getAddJewelInfo(roleId, roleName, jewel);
        jewelInfo.push(info);
    }

    const jewelResult = await JewelModel.createJewels(roleId, jewelInfo);
    return { jewels: jewelResult.map(jewel => new JewelParam(jewel, true, reason))}
}

export async function getAddJewelInfo(roleId: string, roleName: string, jewel: { id: number, }) {
    let { id, } = jewel;
    let { name, randomEffect, effectCount, rareEffect } = gameData.jewel.get(id);

    // 随机属性
    let randomResult: number[] = getRandEelm(randomEffect, effectCount);
    let rareResult: number[] = getRandEelm(rareEffect, 1);

    let randSe: Array<RandSe> = randomResult.map((id: number, index: number) => {
        return getJewelRandSe(index + 1, id);
    });
    let rareSe: Array<RandSe> = rareResult.map((id: number, index: number) => {
        return getJewelRandSe(index + 1, id);
    });

    return { roleId, roleName, id, name, randSe, rareSe };
}

/**
 * 天晶石已知词条随机值
 * @param id 词条位置，第几条
 * @param seid 词条id
 * @returns 
 */
export function getJewelRandSe(id: number, seid: number) {
    let dicRandom = gameData.randomEffectPool.get(seid)
    // console.log('#### dicRandom', dicRandom)
    let rand = 0;
    let planPool = gameData.randomEffectPoolPlan.get(dicRandom.planId);
    if(planPool && planPool.length > 0) {
        let result = getRandEelmWithWeight(planPool);
        if(result) rand = Math.round(result.dic.num * 100)/100;
    } else {
        let randResult = getRandValueByMinMax(dicRandom.Min, dicRandom.Max, getDecimalCnt(dicRandom.gap));
        let n = Math.floor((randResult - dicRandom.Min)/dicRandom.gap);
        rand = Math.round(dicRandom.Min + n * dicRandom.gap * 100)/100;
    }
    return new RandSe(id, dicRandom.id, rand);
}

export async function addArtifacts(roleId: string, roleName: string, artifacts: { id: number, }[], reason: number) {
    let artifactInfos: ArtifactModelUpdate[] = [];
    for(let { id } of artifacts) {
        let dicArtifact = getDefArtifactByGid(id);
        if(dicArtifact) {
            let { goodId, artifactId, quality, qualityStage } = dicArtifact;
            artifactInfos.push({ roleId, roleName, id: goodId, artifactId, quality, qualityStage });
        }
    }

    const artifactResult = await ArtifactModel.createArtifacts(roleId, artifactInfos);
    return { artifacts: artifactResult.map(artifact => new ArtifactParam(artifact, true, reason))}
}

export function getGoldId() {
    return CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD);
}

/**
 * @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 getCoinObject(count: number) {
    return { id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN), count };
}

/**
 * @description 获取体力物品 { id, count }
 * @param count 体力数量
 */
 export function getApObject(count: number) {
    return { id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.ACTION_POINT), 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 };
}

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

export function getVoucherCoinObject(count: number) {
    return { id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.VOUCHER_COIN), count };
}

export function checkVoucherId(id: number) {
    let voucher = CURRENCY_BY_TYPE.get(CURRENCY_TYPE.VOUCHER);
    let voucherCoin = CURRENCY_BY_TYPE.get(CURRENCY_TYPE.VOUCHER_COIN);
    return id == voucher || id == voucherCoin;
}

/**
 * 返回 解锁头像/相框
 * @param conditions 解锁条件
 * @param role 如果已查询过role表就直接可以使用
 */
 export function unlockFigureWithoutSave(conditions: { type: number, paramHid?: number, paramFavourLv?: number, paramSkinId?: number, paramWinStreakNum?: number }[], role: RoleType) {

    let { heads, frames, spines, roleId } = role;
    let figureInfo = { heads: new Array<Figure>(), frames: new Array<Figure>(), spines: new Array<Figure>() };
    for (let { type, paramHid, paramFavourLv, paramSkinId, paramWinStreakNum } of conditions) {
        let canUnLockList = gameData.figureCondition.get(type);
        if (canUnLockList) {
            canUnLockList = filterGoods(canUnLockList, obj => obj.gid, roleId, ITEM_CHANGE_REASON.GET_HERO_UNLOCK_FIGURE);
            let reason = 0;

            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;
                    reason = ITEM_CHANGE_REASON.GET_HERO_UNLOCK_FIGURE;
                } else if (type == FIGURE_UNLOCK_CONDITION.HERO_FAVOR) {
                    let [hid, favourLv] = params;
                    if (paramHid == hid && paramFavourLv >= favourLv) flag = true;
                    reason = ITEM_CHANGE_REASON.HERO_FAVOR_UNLOCK_FIGURE;
                } else if (type == FIGURE_UNLOCK_CONDITION.GET_SKIN) {
                    let [id] = params;
                    if (paramSkinId == id) flag = true;
                    reason = ITEM_CHANGE_REASON.ADD_SKIN_UNLOCK_FIGURE;
                } else if (type == FIGURE_UNLOCK_CONDITION.PVP_WIN_SERIES) {
                    let [winStreakNum] = params;
                    if (paramWinStreakNum >= winStreakNum) flag = true;
                    reason = ITEM_CHANGE_REASON.PVP_SERIES_UNLOCK_FIGURE;
                }
                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, reason, false, id);
                    if (figure && figure.unlocked) figureInfo.heads.push(figure);
                } else if (dicItid.type == CONSUME_TYPE.FRAME) {
                    let figure = unlockSingleFigure(frames, gid, reason, false, id);
                    if (figure && figure.unlocked) figureInfo.frames.push(figure);
                } else if (dicItid.type == CONSUME_TYPE.SPINE) {
                    let figure = unlockSingleFigure(spines, gid, reason, false, id);
                    if (figure && figure.unlocked) figureInfo.spines.push(figure);
                } else {
                    continue;
                }

            }

        }
    }
    return { figureInfo, heads, frames, spines };
}



// 直接获得形象/相框
export async function addFigure(roleId: string, ids: number[], reason: 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, reason, true);
            if (figure && figure.unlocked) figureInfo.heads.push(figure);
        } else if (dicItid.type == CONSUME_TYPE.FRAME) {
            let figure = unlockSingleFigure(frames, gid, reason, true);
            if (figure && figure.unlocked) figureInfo.frames.push(figure);
        } else if (dicItid.type == CONSUME_TYPE.SPINE) {
            let figure = unlockSingleFigure(spines, gid, reason, 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, reason: number, unlockDirect = false, conditionId?: number) {
    let index = dbFigures.findIndex(cur => cur.id == id);
    let figure = dbFigures[index];
    if (index == -1) {
        figure = new Figure(id, false);
        dbFigures.push(figure);
        index = dbFigures.length - 1;
    }
    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 = nowSeconds() + dicGoods.timeLimit * 86400
        }
    }

    figure.inc = 1;
    figure.reason = reason;
    dbFigures[index] = figure;
    return figure
}

// async function getSkinsOfThisHero(roleId: string, roleName: string, hid: number, initialSkin: number, allSkins?: SkinType[]) {
//     if(!allSkins) allSkins = await SkinModel.findbyRoleAndHid(roleId, hid);
//     let skin = await increaseSkin(roleId, roleName, initialSkin);
//     if(skin) allSkins.push(skin);
//     let skins: { id: number, skin: string, enable: boolean }[] = [];
//     for(let skin of allSkins) {
//         skins.push({ id: skin.id, skin: skin._id, enable: skin.id == initialSkin });
//     }

//     return skins
// }

export function combineFigureInfo(figureInfos: { heads: Figure[], frames: Figure[], spines: Figure[] }[]) {
    let figureInfo = { heads: new Array<Figure>(), frames: new Array<Figure>(), spines: new Array<Figure>() };
    for(let {heads, frames, spines} of figureInfos) {
        for(let head of heads) {
            figureInfo.heads.push(head);
        }
        for(let frame of frames) {
            figureInfo.frames.push(frame);
        }
        for(let spine of spines) {
            figureInfo.spines.push(spine);
        }
    }
    return figureInfo;
}

// export class CreateHero {
//     roleId: string;
//     roleName: string;
//     serverId: number;

//     constructor(roleId: string, roleName: string, serverId: number) {

//     }
// }