import { Singleton } from '../../mx/tools/Singleton';
import { OtherDataType, StatusType } from '../game/GameData';
import { GEvent } from '../../mx/module/event/GEvent';
import { AddType, ATTR_TYPE_MAP, CONDITION_STRATEGIES, AttrResult, WearingAddType } from '../interface/AttributeInterface';


export class RoleSkin extends Singleton {

    /**获取所有皮肤列表 */
    get allSkin() {
        let arr = gg.role.allSkinItemid;
        //console.log("所有皮肤配置", arr);
        return arr;
    }

    /**获取当前拥有的皮肤列表 */
    get skinList() {
        let allSkin = this.allSkin;
        let have = [allSkin[0]]; //拥有默认的初始皮肤
        for (let item of allSkin) {
            if (gg.data.getItemNum(item.id) > 0) {
                have.push(item);
            }
        }
        //console.log("当前拥有的皮肤 物品配置", have);

        return have;
    }

    /**获取当前穿戴的皮肤 */
    get CurrentSkin() {
        let skinId = gg.data.getStatus(StatusType.CurrentSkin);
       
        if(skinId == 0){
            gg.role.setDefaultSkin();
            skinId = gg.data.getStatus(StatusType.CurrentSkin);
        }
        return skinId;
    }

    set CurrentSkin(skinId: number) {
        if (this.CurrentSkin == skinId) {
            return;
        }
        gg.data.setStatus(StatusType.CurrentSkin, skinId);
        GEvent.Ins.emit(GEvent.CHANGE_SKIN, skinId);
    }

    /**获取指定皮肤需要的锁片 */
    getNeedPieceNum(skinId: number) {
        let skin = gg.role.allSkinConfig.find(item => item.itemid == skinId);
        let skinLevel = this.getSkinLevel(skinId);
        let upneeds = skin.upneed.split(",");
        return Number(upneeds[skinLevel]);
    }
    //
    getHavePieceId(skinId: number){
        let skinConfig = gg.role.allSkinConfig.find(item => item.itemid == skinId);
        let pieceId = skinConfig.piece;
        return pieceId;
    }
    getHavePieceNum(skinId: number) {
        let skinConfig = gg.role.allSkinConfig.find(item => item.itemid == skinId);
        let pieceId = skinConfig.piece;
        return gg.data.getItemNum(pieceId);
    }

    /**检查是否有指定的皮肤 */
    checkHasSkin(skinId: number) {
        return this.skinList.some(item => item.id == skinId);
    }

    /**获取指定的皮肤 */
    getSkin(skinId: number) {
        return this.allSkin.find(item => item.id == skinId);
    }

    /**获得皮肤 */
    addSkin(skinId: number) {
        return gg.data.addItemNum(skinId, 1);
    }

    //根据itemId获取皮肤的配置
    getSkinConfig(itemid: number) {
        return gg.role.allSkinConfig.find(item => item.itemid == itemid);
    }
    /***根据skinid获取皮肤配置 */
    getSkinConfigBySkinId(skinId: number) {
        return gg.role.allSkinConfig.find(item => item.id == skinId);
    }
    //获取当前皮肤的type AddType
    getCurrentSkinAddType(skinId){
        let config = this.getSkinConfig(skinId);
        let addType = config.alladd.split('|').map(Number);
        return addType[0];
    }   
    //获取当前皮肤的加成系数
    getCurrentSkinAddValue(skinId){
        let config = this.getSkinConfig(skinId);
        let addType = config.alladd.split('|').map(Number);
        return addType[1];
    }
    //获取当前皮肤是不是满级了
    isMaxLevel(skinId){
        let config = this.getSkinConfig(skinId);
        let level = this.getSkinLevel(skinId);
        return level >= config.upneed.split(',').length;
    }

    maxLevel(skinId){
        let config = this.getSkinConfig(skinId);
        let level = this.getSkinLevel(skinId);
        let max = config.upneed.split(',').length-1;
        return max;
    }
    //当前等级皮肤的加成系数和下一级的加成系数
    getCurrentSkinAddValueAndNext(skinId){
        let config = this.getSkinConfig(skinId);
        let level = this.getSkinLevel(skinId);
        let upattr = config.upattr.split(',').map(Number);
        let nextLevel = level+1;
        let nextAddValue = upattr[nextLevel];
        if(level >= config.upattr.length){
            nextAddValue = -999 //满级标记
        }
        return {
            addValue:upattr[level],
            nextAddValue:nextAddValue
        }
    }



    //获取当前皮肤穿戴的onadd类型
    getCurrentSkinOnAddType(skinId){
        let config = this.getSkinConfig(skinId);
        if (!config || !config.onadd) {
            return { WearingAddType: 0, WearingAddValue: 0, addType: 0 };
        }
        let addType = config.onadd.split('|').map(Number);
        if (addType.length < 3) {
            return { WearingAddType: addType[0] ?? 0, WearingAddValue: addType[1] ?? 0, addType: addType[2] ?? 0 };
        }
        return {
            WearingAddType:addType[0],
            WearingAddValue:addType[1],
            addType:addType[2]
        }
    }



    /**获取皮肤等级 */
    getSkinLevel(skinId: number) {
        let allSkin = this.allSkin;
        let have = allSkin[0]; //拥有默认的初始皮肤

        let level = 1;
        let skinLevel = gg.data.getkeyKeyValue(OtherDataType.SkinLevel, skinId);
        level = skinLevel && skinLevel != "" ? parseInt(skinLevel) : 0;
        if(level == 0 && skinId == have.id){
            //默认皮肤不需要解锁
            level = 1;
        }else if(this.checkHasSkin(skinId) && level == 0){
            //如果有皮肤，等级从1开始
            level = 1;
        }
        //console.log("皮肤等级", skinId, level);
        return level;
    }
    /**设置皮肤等级 */
    setSkinLevel(skinId: number, level: number) {
        gg.data.setkeyKeyValue(OtherDataType.SkinLevel, skinId, level);
    }
    /**皮肤升级 */
    upgradeSkin(skinId: number) {
        let level = this.getSkinLevel(skinId);
        if(level == 0){
            //如果是0等级刚刚开始解锁的， 设置一下皮肤的道具为1
            gg.data.setItemNum(skinId, 1);
        }
        level++;
        let maxLevel = this.maxLevel(skinId);
        if(level > maxLevel){
            level = maxLevel;
        }
        this.setSkinLevel(skinId, level);
    }


    //皮肤加成 万分比没有做处理
    //获取皮肤攻击力加成
    /**获取皮肤加成 */
    getSkinAdd() {
        //获取当前穿戴的皮肤的加成 fix me
        //alladd == AddType.Atk
        let skinList = this.skinList; //当前拥有的皮肤
        let allSkinConfig = gg.role.allSkinConfig
        let atkAdd = 0;
        for(let item of skinList){
            let skinConfig = allSkinConfig.find(skin => skin.itemid == item.id);
            if(skinConfig){
                let addType = skinConfig.alladd.split('|').map(Number);
                if(addType[0] == AddType.Atk || addType[0] == AddType.Atk2){
                    //攻击力加成
                    atkAdd += Number(addType[1]);
                }
            }
        }
        //console.log("皮肤攻击力加成", atkAdd);
        //1+atkAdd/10000;
        let curSkinAttr = this.getCurSkinAttr()
        let cdAll = curSkinAttr.atkAdd+curSkinAttr.atk2Add;
        return 1+atkAdd/10000+cdAll;
    }

    //获取皮肤暴击加成
    getSkinCritAdd() {
        let skinList = this.skinList;
        let allSkinConfig = gg.role.allSkinConfig
        let critAdd = 0;
        for(let item of skinList){
            let skinConfig = allSkinConfig.find(skin => skin.itemid == item.id);
            if(skinConfig){
                let addType = skinConfig.alladd.split('|').map(Number);
                if(addType[0] == AddType.Crit){
                    //暴击加成
                    critAdd += Number(addType[1]);
                }
            }
        }
        //console.log("皮肤暴击加成", critAdd);
        //1+critAdd/10000;  
        let curSkinAttr = this.getCurSkinAttr()
        let all = curSkinAttr.critAdd;
        return 1+critAdd/10000+all;
    }

    //获取皮肤冷却加成
    getSkinCDAdd() {
        let skinList = this.skinList;
        let allSkinConfig = gg.role.allSkinConfig
        let cdAdd = 0;
        for(let item of skinList){
            let skinConfig = allSkinConfig.find(skin => skin.itemid == item.id);
            if(skinConfig){
                let addType = skinConfig.alladd.split('|').map(Number);
                if(addType[0] == AddType.CD){
                    //冷却加成
                    cdAdd += Number(addType[1]);
                }
            }
        }
        //console.log("皮肤冷却加成", cdAdd);
        //1+cdAdd/10000;
        let curSkinAttr = this.getCurSkinAttr()
        let cdAll = curSkinAttr.cdAdd;
        return 1+cdAdd/10000+cdAll;
    }

    //皮肤全局加成
    getSkinGlobalAdd() {
        let skinList = this.skinList; //当前拥有的皮肤
        let allSkinConfig = gg.role.allSkinConfig //当前皮肤列表
     
       const result: AttrResult = {
                atkAdd: 0, cdAdd: 0, critAdd: 0, atk2Add: 0,
                damageAdd: 0, critDamageAdd: 0, igniteAdd: 0, shockAdd: 0
            };

    // 3. 遍历皮肤列表
        for (const item of skinList) {
            const skinConfig = allSkinConfig.find(skin => skin.itemid == item.id);
            if (!skinConfig) continue;

            // 解析配置: alladd 格式假设为 "属性类型|数值"
            const addConfig = skinConfig.alladd.split('|').map(Number);
            
            // 防御性检查：确保数据格式正确 (至少要有类型和数值)
            if (addConfig.length < 2) continue;

            const [attrType, addValueRaw] = addConfig;

            // --- 核心逻辑 (一行代码替代 8 个 if-else) ---
            
            // A. 查表获取对应的属性键名
            const resultKey = ATTR_TYPE_MAP[attrType];

            // B. 如果键名存在，直接累加
            if (resultKey !== undefined) {
                result[resultKey] += addValueRaw;
            }
            
            // --- 结束 ---
        }

        return result; // 别忘了返回结果
     
    }

    /**获取穿戴皮肤加成之后的全局属性 */
    getCurSkinAttr(){
        let currentSkinItemId = this.CurrentSkin;
        let allSkinConfig = gg.role.allSkinConfig
        const skinConfig = allSkinConfig?.find(skin => skin.itemid == currentSkinItemId);
        const result: AttrResult = {
                atkAdd: 0, cdAdd: 0, critAdd: 0, atk2Add: 0,
                damageAdd: 0, critDamageAdd: 0, igniteAdd: 0, shockAdd: 0
            };
        if (!skinConfig || !skinConfig.onadd) {
            return result;
        }
        const addTypeConfig = skinConfig.onadd.split('|').map(Number);
        if (addTypeConfig.length < 3) {
            return result;
        }
        const [conditionType, conditionParam, attrType] = addTypeConfig;

        if(conditionType == WearingAddType.AllWeapon){

            let skinLevel = this.getSkinLevel(currentSkinItemId);
            if (!skinConfig.upattr) {
                return result;
            }
            const shuxing = skinConfig.upattr.split(',').map(Number);
            if (shuxing.length === 0) {
                return result;
            }
            // 防御性检查：防止等级超出配置范围
            if (skinLevel >= shuxing.length){
                skinLevel = shuxing.length-1;
            } 
            
            const addNum = shuxing[skinLevel];

            const resultKey = ATTR_TYPE_MAP[attrType];
      

            if (resultKey !== undefined) {
                // 原逻辑: 最终值 = 1 + 总和/10000
                // 这里直接累加增量部分 (/10000)
                result[resultKey] += addNum / 10000;
            }
            return result;
        }else{
            //没有全局武器加成
            return result;
        }
    }


    
    //皮肤穿戴加成
    /**获取皮肤加成后的属性 */
    getSkinAttrByWeapon(weaponId: number):AttrResult {
        let weaponData: ITableWeapon2 = gg.data.project.getWeaponData(weaponId);
        let skinList = this.skinList;
        let allSkinConfig = gg.role.allSkinConfig
        let currentSkinItemId = this.CurrentSkin;
        const result: AttrResult = {
                atkAdd: 0, cdAdd: 0, critAdd: 0, atk2Add: 0,
                damageAdd: 0, critDamageAdd: 0, igniteAdd: 0, shockAdd: 0
            };

            
  
        // 4. 遍历皮肤列表
        for (const item of skinList) {
            // 防御性检查：确保数据格式正确 (至少要有类型和数值)
            if (item.id != currentSkinItemId) continue;

            const skinConfig = allSkinConfig.find(skin => skin.itemid == item.id);
            if (!skinConfig) continue;

            const skinLevel = this.getSkinLevel(item.id);
            const shuxing = skinConfig.upattr.split(',').map(Number);
            
            // 防御性检查：防止等级超出配置范围
            if (skinLevel >= shuxing.length) continue; 
            
            const addNum = shuxing[skinLevel];
            if (addNum === 0) continue; // 优化：0 加成直接跳过

            if (!skinConfig.onadd) continue;
            const addTypeConfig = skinConfig.onadd.split('|').map(Number);
            if (addTypeConfig.length < 3) continue;
            // 解构: [条件类型, 条件参数, 属性类型]
            const [conditionType, conditionParam, attrType] = addTypeConfig;

            // --- 核心逻辑 (通用处理所有情况) ---

            // A. 检查武器条件是否满足
            const checkFunc = CONDITION_STRATEGIES[conditionType] ||  (() => false);;
            if (!checkFunc || !checkFunc(conditionParam, weaponData)) {
                continue; // 条件不满足，跳过
            }

            // B. 查找对应的属性键名
            const resultKey = ATTR_TYPE_MAP[attrType];
            
            // C. 如果属性类型有效，累加数值
            if (resultKey !== undefined) {
                // 原逻辑: 最终值 = 1 + 总和/10000
                // 这里直接累加增量部分 (/10000)
                result[resultKey] += addNum;
            }
            
            // --- 结束 ---
        }

        return result;
}








}