import GameUtil from "../core/GameUtil";
import PetPracticeMgr from "../object/PetPracticeMgr";
import ChangeCard from "../object/ChangeCard";
import PlayerMgr from "../object/PlayerMgr";
import World from "../object/World";
import SKDataUtil from "../gear/SKDataUtil";
import SKLogger from "../gear/SKLogger";
import FivePhases from "../object/FivePhases";
import {EAttrCalType, Operate} from "../role/EEnum";
import SKCxfUtil from "../gear/SKCxfUtil";
import DB from "../utils/DB";
import Player from "../object/Player";

export default class GoodsMgr {
    static shared = new GoodsMgr();

    petrate: any;
    petSkillItem: any;
    cardItem: any;
    itemData: any;

    constructor() {
    }

    // 获得物品列表 type=-1 全部
    static getItemList(type: number = -1): any[] {
        let itemList = this.shared.itemData;
        if (!itemList) {
            this.shared.launch();
            itemList = this.shared.itemData;
        }
        let result: any = [];
        for (let key in itemList) {
            let info = itemList[key];
            result.push({id: info.id, name: info.name, type: info.type});
        }
        return result;
    }

    launch() {
        let conf = GameUtil.game_conf;
        if (!conf) {
            console.error("必须先初始化配置");
            return;
        }
        let data = conf.item;
        this.petrate = {} // 宠物吃元气丹成长率
        this.petSkillItem = [[], [], [], []]; // level 0 不被计算在内
        this.cardItem = [[], [], [], []]; // level 0 不被计算在内
        for (let itemid in data) {
            if (data.hasOwnProperty(itemid)) {
                let iteminfo = data[itemid];
                if (iteminfo.json != '' && iteminfo.json != null) {
                    iteminfo.json = SKDataUtil.jsonBy(iteminfo.json);
                    if (Math.floor(Number(itemid) / 100) == 105 && iteminfo.json.pet && iteminfo.json.rate) {
                        this.petrate[iteminfo.json.pet] = iteminfo.json.rate;
                    }
                }
                if (iteminfo.type == 10) {// 技能书
                    this.petSkillItem[iteminfo.level].push(itemid);
                }
                if (iteminfo.type == 15){ //变身卡
                    if(iteminfo.level == 1000){
                        continue
                    }
                    let level = iteminfo.level;
                    if(level == 1003){
                        level = 3
                    } else if(level == 1002){
                        level = 2
                    } else if(level == 1001){
                        level = 1
                    }
                    this.cardItem[level].push(itemid);
                }
            }
        }
        this.itemData = data;
    }

    // 使用物品
    useItem(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player == null) {
            return false;
        }
        let itemData = this.getItemInfo(data.itemid);
        if (itemData == null) {
            return false;
        }

        if (player.bag_list[data.itemid] <= 0 ){
            player.send_notice("您背包无此道具！")
            return false
        }

        SKLogger.debug(`玩家[${player.name}(${player.roleid})]使用物品[${itemData.name}]`);
        if (GameUtil.firstLevelCode.indexOf(data.itemid) != -1){
            this.firstLevelFairyDevice(player,itemData);
            return true;
        } else if (GameUtil.isDataInVecter(data.itemid, [50001, 50002, 50003])) { //藏宝图类型
            let stData = itemData.json;
            if (stData.hasOwnProperty('money')) {
                player.addMoney(0, stData.money, '藏宝图');
            }
            if (stData.hasOwnProperty('item')) {
                player.addItem(stData.item, 1, true, '藏宝图');
            }
            if (stData.hasOwnProperty('monster')) {
                World.shared.worldMonsterMgr.ReliveWorldMonster(player.roleid, stData.monster);
                // DWorld.shared.worldMonsterMgr.ReliveWorldMonster(player.roleid, stData.monster);
            }
            let r = GameUtil.random(0, 10000);
            if (r < 5000) {
                // 藏宝图赠送一个神兽丹
                player.addItem(10114, 1, true, '藏宝图赠送');
            }
            if(player){
                SKCxfUtil.getCxfRecordOperate({
                    roleId: player.roleid,
                    roleName: player.name,
                    operateType: Operate.ITEM,
                    operateDepict: "使用藏宝图",
                    operateResSerial: itemData.id,
                    operateResName: itemData.name,
                    operateContent: SKDataUtil.toJson(player.bag_list, "{}")
                })
            }
            return true;
        } else if (data.itemid == 50004) { //高级藏宝图
            return false;
        } else if (data.itemid == 80001) { //银两物品
            let iteminfo = this.itemData[data.itemid];
            let num = iteminfo.num * data.count;
            player.addMoney(0, num, `使用物品[${iteminfo.name}]`);
            if(player){
                SKCxfUtil.getCxfRecordOperate({
                    roleId: player.roleid,
                    roleName: player.name,
                    operateType: Operate.ITEM,
                    operateDepict: "银两",
                    operateResSerial: itemData.id,
                    operateResName: itemData.name,
                    operateContent: player.money
                })
            }
            return true;
        } else if (data.itemid == 80002) { //帮派书简
            let iteminfo = this.itemData[data.itemid];
            let num = iteminfo.num * data.count;
            player.addMoney(GameUtil.goldKind.bang_Score, num, `使用物品:${iteminfo.name}`);
            return true;
        } else if (GameUtil.isDataInVecter(data.itemid, [10301, 10302, 10303])) { //见闻录
            return false;
        } else if ([10101, 10102, 10103].indexOf(data.itemid) != -1) { // 技能书残卷
            let n = player.getBagItemNum(data.itemid);
            if (n < itemData.num) {
                return false;
            }
            let sitem = this.getRandomPetSkill(itemData.level);
            if (sitem) {
                // pPlayer.AddBagItem(data.itemid, -pItemInfo.num, false);
                data.count = itemData.num;
                player.addBagItem(sitem, 1, true);
                if(player){
                    SKCxfUtil.getCxfRecordOperate({
                        roleId: player.roleid,
                        roleName: player.name,
                        operateType: Operate.ITEM,
                        operateDepict: "合成技能书",
                        operateResSerial: itemData.id,
                        operateResName: itemData.name,
                        operateContent: SKDataUtil.toJson(player.bag_list, "{}")
                    })
                }
                return true;
            }
            return false;
        } else if([100311, 100313, 100315].indexOf(data.itemid) != -1){ // 变身卡
            if (player.getBagItemAllKindNum() >= player.bagKindNum) {
                player.send('s2c_notice', {
                    strRichText: `背包已满`
                });
                return false;
            }
            let n = player.getBagItemNum(data.itemid);
            if (n < (itemData.num * data.count)) {
                player.send_notice("碎片数量不足！")
                return false;
            }
            let count = 0;
            for(let i = 0; i < data.count; i++){
                // 合成变身卡 随机获得卡片
                let card = this.getRandomCard(itemData.level);
                if (!card) {
                    return false;
                }
                // pPlayer.AddBagItem(data.itemid, -pItemInfo.num, false);
                count += itemData.num;
                player.addBagItem(card, 1, true);
            }
            data.count = count;
            if(player){
                SKCxfUtil.getCxfRecordOperate({
                    roleId: player.roleid,
                    roleName: player.name,
                    operateType: Operate.ITEM,
                    operateDepict: "合成变身卡",
                    operateResSerial: itemData.id,
                    operateResName: itemData.name,
                    operateContent: SKDataUtil.toJson(player.bag_list, "{}")
                })
            }
            return true;
        } else if (data.itemid == 10202 || data.itemid == 10204) { //经验书
            return player.partnerMgr.addPartnerExp(data.operateid, this.itemData[data.itemid].num);
        } else if (data.itemid == 10203) { //超级星梦石
            let broleinfo = player.toObj();
            player.resetPoint();
            if(player){
                SKCxfUtil.getCxfRecordOperate({
                    roleId: player.roleid,
                    roleName: player.name,
                    operateType: Operate.ITEM,
                    operateDepict: "超级星梦石",
                    operateResSerial: itemData.id,
                    operateResName: itemData.name,
                    operateContent: SKDataUtil.toJson({attr1:player.attr1,addattr1:player.addattr1,addattr2:player.addattr2}, "{}")
                })
            }
            return true;
        } else if (data.itemid == 10001 || data.itemid == 10004) { //引妖香
            if(player){
                SKCxfUtil.getCxfRecordOperate({
                    roleId: player.roleid,
                    roleName: player.name,
                    operateType: Operate.ITEM,
                    operateDepict: "引妖香",
                    operateResSerial: itemData.id,
                    operateResName: itemData.name,
                    operateContent: SKDataUtil.toJson(player.bag_list, "{}")
                })
            }
            return player.useIncense(this.itemData[data.itemid].num);
        } else if (data.itemid == 10110 || (data.itemid >= 10112 && data.itemid <= 10114)) {
            let pet = player.getPetByID(data.operateid);
            if (!pet) {
                return false;
            }
            if(player){
                SKCxfUtil.getCxfRecordOperate({
                    roleId: player.roleid,
                    roleName: player.name,
                    operateType: Operate.ITEM,
                    operateDepict: "宠物经验丹",
                    operateResSerial: pet.petid,
                    operateResName: pet.name,
                    operateContent: SKDataUtil.toJson(pet.toObj(), "{}")
                })
            }
            return pet.addExp(this.itemData[data.itemid].num)
        } else if (data.itemid == 10116) {
            let pet = player.getPetByID(data.operateid);
            if (pet == null) {
                return false;
            }
            let maxxlevel = PetPracticeMgr.shared.GetMaxPriactiveLevel(pet.relive);
            let upexp = PetPracticeMgr.shared.GetUpdateHunPo(pet.xlevel);
            if (pet.xlevel >= maxxlevel && pet.xexp >= upexp) {
                return false;
            }
            pet.xexp += this.itemData[data.itemid].num;
            while (pet.xexp >= upexp) {
                pet.xexp -= upexp;
                pet.xlevel++;
                upexp = PetPracticeMgr.shared.GetUpdateHunPo(pet.xlevel);
            }
            if (pet.xlevel > maxxlevel) {
                pet.xlevel = maxxlevel;
                pet.xexp = PetPracticeMgr.shared.GetUpdateHunPo(pet.xlevel);
            }
            if(player){
                SKCxfUtil.getCxfRecordOperate({
                    roleId: player.roleid,
                    roleName: player.name,
                    operateType: Operate.ITEM,
                    operateDepict: "凝魂丹；宠物抗性",
                    operateResSerial: pet.petid,
                    operateResName: pet.name,
                    operateContent: SKDataUtil.toJson(pet.toObj(), "{}")
                })
            }
            player.send('s2c_update_pet', {
                info: pet.toObj()
            });
            return true;
        } else if (data.itemid == 10117) { //龙之骨
            let pet = player.getPetByID(data.operateid);
            if (pet == null) {
                return false;
            }
            if(player){
                SKCxfUtil.getCxfRecordOperate({
                    roleId: player.roleid,
                    roleName: player.name,
                    operateType: Operate.ITEM,
                    operateDepict: "龙之骨",
                    operateResSerial: pet.petid,
                    operateResName: pet.name,
                    operateContent: SKDataUtil.toJson(pet.toObj(), "{}")
                })
            }
            return pet.useLongGu();
        } else if (data.itemid == 90001) { //经验转魂魄
            let pet = player.getPetByID(data.operateid);
            if (pet == null) {
                return false;
            }
            let maxLevel = PetPracticeMgr.shared.GetMaxPriactiveLevel(pet.relive);
            let upexp = PetPracticeMgr.shared.GetUpdateHunPo(pet.xlevel);
            if (pet.xlevel >= maxLevel && pet.xexp >= upexp) {
                return false;
            }
            let count = this.itemData[data.itemid].num;
            pet.xexp += Math.floor(pet.exp / count);
            pet.exp = pet.exp % count;
            while (pet.xexp >= upexp) {
                pet.xexp -= upexp;
                pet.xlevel++;
                upexp = PetPracticeMgr.shared.GetUpdateHunPo(pet.xlevel);
            }
            if (pet.xlevel > maxLevel) {
                pet.exp += (pet.xlevel - maxLevel) * count; //返还剩余经验
                pet.xlevel = maxLevel;
                pet.xexp = PetPracticeMgr.shared.GetUpdateHunPo(pet.xlevel);
            }
            player.send('s2c_update_pet', {
                info: pet.toObj()
            });
            return true;
        } else if (itemData.typedetail == "元气丹" && itemData.num != 0) { // 宠物元气丹
            let pet = player.getPetByID(data.operateid);
            if (pet == null || itemData.num != pet.dataid) {
                return false;
            }
            return pet.useYuanqi();
        } else if (data.itemid == 10111 || data.itemid == 10120) { // 宠物亲密丹
            let pet = player.getPetByID(data.operateid);
            if (!pet) {
                return false;
            }
            if (typeof (itemData.num) == 'number' && itemData.num > 0) {
                return pet.addqinmi(itemData.num);
            }
            return false;
        } else if (itemData.type == 15) {//使用变身卡
            // 检测使用等级
            if (player.relive >= 1 && player.level > 80) {
                // 检测使用五行等级
                let fp = FivePhases.shared.getFivePhasesByRoleid(player.roleid);
                if(fp == undefined || fp == null){
                    let text = `没有达到等级，不能使用哦！`;
                    player.send_notice(text)
                    return false;
                }
                //检查玩家是否使用变身卡如果使用直接删除替换
                ChangeCard.shared.selectUseList(player.roleid);
                // 获取当前使用的变身卡数据
                let card = ChangeCard.shared.getCard(data.itemid);
                if(fp.fplevel < card.fplevel){
                    // 使用等级不达标通知
                    let text = `五行等级等级需要达到[color=#ff0000]${card.fplevel}级[/color][color=#ffffff]才能使用[/color][color=#ff0000]${card.cardname}变身卡[/color]`;
                    player.send_notice(text)
                    return false;
                }
                if (card) {
                    ChangeCard.shared.dataTS(player, card);
                    let gain = SKDataUtil.jsonBy(card.gain);
                    let fpmarkup = FivePhases.shared.getfpMarkup(player.roleid,card);
                    for (let key in gain) {
                        let key1 = Number(key);
                        let value = 0;
                        if(key1 < 75 && key1 > 69){
                            value = gain[key];  //五行属性没有加成
                        }else{
                            value = Math.floor(gain[key] + (gain[key] * (fpmarkup / 100)));
                        }
                        let addattr = GameUtil.attrToBaseAttr[key1];
                        if (addattr != null) {
                            let target_attr = addattr.target;
                            if (addattr.cal == EAttrCalType.ADD_PERCENT) {
                                player.attr1[target_attr] = Math.floor((1 + value / 100) * player.attr1[target_attr]);
                                if(target_attr == 30 || target_attr == 32){
                                    let attr = target_attr += 1;
                                    player.attr1[attr] = Math.floor((1 + value / 100) * player.attr1[target_attr]);
                                }
                            }
                        } else {
                            player.attr1[key1] += value;
                        }
                    }
                    let pdata = player.getData();
                    pdata.resid = player.resid;
                    pdata.changeid = card.resid;
                    player.send('s2c_player_data', pdata);
                    let text = `您使用了[color=#ff0000]${card.cardname}变身卡 [/color]。变得更强大了！`;
                    player.send_notice(text)
                    if(player){
                        SKCxfUtil.getCxfRecordOperate({
                            roleId: player.roleid,
                            roleName: player.name,
                            operateType: Operate.ITEM,
                            operateDepict: "使用变身卡",
                            operateResSerial: itemData.id,
                            operateResName: itemData.name,
                            operateContent: SKDataUtil.toJson({attr1:player.attr1,addattr1:player.addattr1,addattr2:player.addattr2}, "{}")
                        })
                    }
                    return true;
                }
            }else {
                let card = ChangeCard.shared.getCard(data.itemid);
                // 使用等级不达标通知
                let text = `[color=#ffffff]等级需要达到[/color][color=#ff0000]${player.relive}转${player.level}级[/color][color=#ffffff]才能使用[/color][color=#ff0000]${card.cardname}变身卡[/color]`;
                player.send_notice(text)
                return false;
            }

        } else if(data.itemid == 1003010 || data.itemid == 1003020){
            FivePhases.shared.addJinExp(data.roleid,this.itemData[data.itemid].num);
            return true
        } else if(data.itemid == 1003030 || data.itemid == 1003040){
            FivePhases.shared.addMuExp(data.roleid,this.itemData[data.itemid].num);
            return true
        } else if(data.itemid == 1003050 || data.itemid == 1003060){
            FivePhases.shared.addShuiExp(data.roleid,this.itemData[data.itemid].num);
            return true
        } else if(data.itemid == 1003070 || data.itemid == 1003080){
            FivePhases.shared.addHuoExp(data.roleid,this.itemData[data.itemid].num);
            return true
        } else if(data.itemid == 1003090 || data.itemid == 1003100){
            FivePhases.shared.addTuExp(data.roleid,this.itemData[data.itemid].num);
            return true
        }
        if (itemData.type == 10) { // 技能书
            if (Math.floor(itemData.id / 1000) == 60) { // 宠物技能书
                // if (player.curPet == null) {
                //     console.warn(`玩家[${player.roleid}:${player.name}]使用技能书[${itemData.name}]无参战宠物!`);
                //     return false;
                // }
                for (let i = 0; i < player.petList.length; i++) {
                    let spet = player.petList[i];
                    if (spet.petid == data.operateid) {
                        if(player){
                            SKCxfUtil.getCxfRecordOperate({
                                roleId: player.roleid,
                                roleName: player.name,
                                operateType: Operate.ITEM,
                                operateDepict: "技能书",
                                operateResSerial: itemData.id,
                                operateResName: itemData.name,
                                operateContent: SKDataUtil.toJson(spet.toObj(), "{}")
                            })
                        }
                        return spet.learnSkill(itemData.num);
                    }
                }
            }
        }

        if(itemData.type == 19) {// 宝宝道具
            if(itemData.id == 9652){
                return player.BabyEatCandy(data.operateid)
            }

            if(itemData.id == 9653){
                return player.ReadingBook(data.operateid)
            }
        }
        return false;
    }

    getItemInfo(nConfigID: any) {
        if (this.itemData.hasOwnProperty(nConfigID) == false)
            return null;

        return this.itemData[nConfigID];
    }

    firstLevelFairyDevice(player: Player, item: any){
        player.addEquip({type: 3, index: item.json.index, roleid: player.roleid, is: 1, grade: item.json.level});
    }

    getItemInfoByName(itemname: any) {
        for (const itemid in this.itemData) {
            if (this.itemData.hasOwnProperty(itemid)) {
                const item = this.itemData[itemid];
                if (item.name == itemname) {
                    return item;
                }
            }
        }
        return null;
    }

    /*
     * 获取宠物吃元气丹成长的概率
     * @param petid 宠物id
     */
    getPetUseYuanqiRate(petid: any) {
        let rate = this.petrate[petid];
        if (rate == null) {
            SKLogger.debug(`宠物元气丹[${petid}]成长概率未找到`);
            return 0;
        }
        return rate;
    }

    getMedicineEffect(itemid: any) {
        let retEffect = {
            addhp: 0,
            addmp: 0,
            mulhp: 0,
            mulmp: 0,
            huoyan: 0,
        };
        let medicine = this.getItemInfo(itemid);
        if (medicine == null) {
            return retEffect;
        }
        if (itemid == 40017) {
            retEffect.huoyan = 1;
            return retEffect;
        }

        let stData = medicine.json;
        if (stData == null || stData.hm == null) {
            return retEffect;
        }
        let hpc = stData.hm.indexOf('h');
        let mpc = stData.hm.indexOf('m');
        if (hpc != -1) {
            if (stData.jc == 'j') {
                retEffect.addhp = medicine.num;
            }
            if (stData.jc == 'c') {
                retEffect.mulhp = medicine.num;
            }
        }
        if (mpc != -1) {
            if (stData.jc == 'j') {
                retEffect.addmp = medicine.num;
            }
            if (stData.jc == 'c') {
                retEffect.mulmp = medicine.num;
            }
        }
        return retEffect;
    }

    getRandomPetSkill(skilllevel: any) {
        let list = this.petSkillItem[skilllevel];
        let r = Math.floor(Math.random() * list.length);
        return list[r];
    }

    getRandomCard(cardlevel: any) {
        let level = cardlevel;
        if(level == 1003){
            level = 3
        } else if(level == 1002){
            level = 2
        } else if(level == 1001){
            level = 1
        }
        let list = this.cardItem[level];
        let r = Math.floor(Math.random() * list.length);
        return list[r];
    }
}