import { GEvent } from '../../mx/module/event/GEvent';
import { Singleton } from '../../mx/tools/Singleton';
import { TableNames } from '../game/ConfigTableData';
import { StatusType } from '../game/GameData';




//角色id管理
export class RoleSingle extends Singleton {
    /**当前角色id */
    get roleId() {
        return gg.data.doc.roleId;
    }

    set roleId(id: number) {
        this.switchRoleData(id)
        gg.data.doc.roleId = id;
        GEvent.Ins.emit(GEvent.UpdateRole)
    }


    /**切换角色统一数据 如果是女转男，女数据同步男的； 男转女，男数据同步女的*/
    /**需要转的数据是碎片和皮肤等级，皮肤解锁的状态*/
    switchRoleData(id){
        let nanSkins = gg.data.table.getTableList<ITableSkin>(TableNames.RoleSkin).filter(skin => skin.roleId == 1);
        let nvSkins = gg.data.table.getTableList<ITableSkin>(TableNames.RoleSkin).filter(skin => skin.roleId == 0);
        if(id == 0){
            // 男转女：按同 type 把男号皮肤道具/碎片/等级写到女号（之前错写成仍用 config 的男 itemid）
            for(let i = 0; i < nanSkins.length; i++){
                let config = nanSkins[i];
                let itemid = config.itemid;
                let pieceid = config.piece;
                let itemNum = gg.data.getItemNum(itemid);
                let pieceNum = gg.data.getItemNum(pieceid);
                let levelNan = gg.skin.getSkinLevel(itemid);
                let findNvConfig = null;
                for(let j = 0; j < nvSkins.length; j++){
                    let nvConfig = nvSkins[j];
                    if(nvConfig.type == config.type){
                        findNvConfig = nvConfig;
                        break
                    }
                }
                if(!findNvConfig){
                    continue
                }
                let nvItemId = findNvConfig.itemid;
                let nvPieceId = findNvConfig.piece;
                if(itemNum > 0){
                    gg.data.setItemNum(nvItemId, itemNum);
                }
                if(pieceNum > 0){
                    gg.data.setItemNum(nvPieceId, pieceNum);
                }
                if(levelNan > 0){
                    gg.skin.setSkinLevel(nvItemId, levelNan);
                }
            }
        }else if(id == 1){
            //女转男，女数据同步男的
            for(let i=0;i<nvSkins.length;i++){
                let config = nvSkins[i];
                let itemid = config.itemid;
                let pieceid = config.piece;
                let itemNum = gg.data.getItemNum(itemid);
                let pieceNum = gg.data.getItemNum(pieceid);
                let levelNan = gg.skin.getSkinLevel(itemid);
                let findNanConfig = null;
                for(let j=0;j<nanSkins.length;j++){
                    let nanConfig = nanSkins[j];
                    if(nanConfig.type == config.type){
                        findNanConfig = nanConfig;
                        break
                    }
                }
                if(findNanConfig){
                    let itemNvid = findNanConfig.itemid;
                    let pieceNvid = findNanConfig.piece;
                    if(itemNum > 0){
                        gg.data.setItemNum(itemNvid, itemNum);
                    }
                    if(pieceNum > 0){
                        gg.data.setItemNum(pieceNvid, pieceNum);
                    }
                    if(levelNan > 0){
                        gg.skin.setSkinLevel(itemNvid, levelNan);
                    }
                }

            }
        }
    }
    /**根据当前皮肤切换到对应角色的皮肤id */
    changeSkinToRoleSkin(oldskinId:number){
        //oldskinId 是旧的皮肤id，需要切换到对应角色的皮肤id
        let skinId = this.getSkinItemIdFromReward(oldskinId);
        if(skinId){
            gg.skin.CurrentSkin = skinId;
            console.log("切换到对应角色的皮肤id", oldskinId, "->", skinId);
        }
    }

    //设置默认的皮肤
    setDefaultSkin(){
        if(this.allSkinItemid){

            let defaultSkin = this.allSkinItemid[0];
            console.log("设置默认的皮肤", defaultSkin);
            gg.data.setStatus(StatusType.CurrentSkin, defaultSkin.id);
        }

    }

    //获取当前皮肤的desc
    getCurSkinDesc(skinId:number){
        let  skinArr = this.allSkinConfig;
        let skin = skinArr.find(skin => skin.itemid == skinId);
        if(skin){
            return skin.desc;
        }
        return "";
    }

    /**获取当前角色匹配的所有的皮肤配置 */
    get allSkinConfig() {
        let skinArr = gg.data.table.getTableList<ITableSkin>(TableNames.RoleSkin).filter(skin => skin.roleId == this.roleId);
        return skinArr;
    }

    /**获取当前角色对应的皮肤id item */
    get allSkinItemid() {
        let arr = gg.data.table.getTableList<ITableItem>(TableNames.Item).filter(item => item.type == 5);
        //获取到所有的角色的皮肤
        let skinArr = this.allSkinConfig;
        //筛选出所有的任务
        let arr2 = arr.filter(item => skinArr.some(skin => skin.itemid == item.id));
        //console.log("获取当前角色对应的皮肤id array", arr2);
        //按照id排序
        arr2.sort((a, b) => a.id - b.id);
        return arr2;
    }

    /**获取当前角色对应的皮肤碎片id item */
    get allSkinPieceid() {
        let arr = gg.data.table.getTableList<ITableItem>(TableNames.Item).filter(item => item.type == 11);
          //获取到所有的角色的皮肤
        let skinArr = this.allSkinConfig;
        //筛选出所有的任务
        let arr2 = arr.filter(item => skinArr.some(skin => skin.piece == item.id));
        //console.log("获取当前角色对应的皮肤碎片id array", arr2);
        return arr2;
    }

    /****皮肤转化 为对应的id 返回皮肤id */
    getSkinIdFromReward(id: number) {
        let allSkinConfig = this.allSkinConfig;
        let skin = allSkinConfig.find(skin => skin.id == id);
        if(skin){
            console.log("是默认的角色", skin);
            return skin.id;
        }else{
            //不是默认的角色，需要找到对应的皮肤id 获取所有的皮肤配置
            let skinArr = gg.data.table.getTableList<ITableSkin>(TableNames.RoleSkin)
            let skinConfig = skinArr.find(skin => skin.id == id);
            if(skinConfig){
                //获取到默认的皮肤对应的配置
                let type = skinConfig.type;
                let skin = allSkinConfig.find(skin => skin.type == type);
                console.log("获取到默认的皮肤对应的配置", skin);

                return skin.id;
            }
    
        }
        return 0; 
    }

    /**皮肤转化 为对应的itemid */
    getSkinItemIdFromReward(itemID: number) {
        let allSkinConfig = this.allSkinConfig;
        let skin = allSkinConfig.find(skin => skin.itemid == itemID);
        if(skin){
            console.log("是默认的角色", skin);
            return skin.itemid;
        }else{
            //不是默认的角色，需要找到对应的皮肤id 获取所有的皮肤配置
            let skinArr = gg.data.table.getTableList<ITableSkin>(TableNames.RoleSkin)
            let skinConfig = skinArr.find(skin => skin.itemid == itemID);
            if(skinConfig){
        //获取到默认的皮肤对应的配置
                let type = skinConfig.type;
                let skin = allSkinConfig.find(skin => skin.type == type);
                console.log("获取到默认的皮肤对应的配置", skin);

                return skin.itemid;
            }
    
        }
        return 0; 
    }
    

    //奖励转换，获取当前角色对应的皮肤碎片id
    getPieceIdFromReward(itemID: number) {
        let allSkinConfig = this.allSkinConfig;
        let skin = allSkinConfig.find(skin => skin.itemid == itemID);
        if(skin){
            console.log("是默认的角色", skin);
            return skin.piece;
        }else{
            //不是默认的角色，需要找到对应的皮肤碎片id 获取所有的皮肤配置
            let skinArr = gg.data.table.getTableList<ITableSkin>(TableNames.RoleSkin)
            let skinConfig = skinArr.find(skin => skin.itemid == itemID);
            //获取到默认的皮肤对应的配置
            let type = skinConfig.type;
            let skin = allSkinConfig.find(skin => skin.type == type);
            console.log("获取到默认的皮肤对应的配置", skin);

            return skin.piece;
        }
    }

    //皮肤转碎片
    skinToPiece(itemID: number) {
         let allSkinConfig = this.allSkinConfig;
        let skin = allSkinConfig.find(skin => skin.itemid == itemID);
        if(skin){
            console.log("是默认的角色", skin);
            return {
                pieceId: skin.piece,
                num: skin.getnumber,
            };
        }else{
            //不是默认的角色，需要找到对应的皮肤id 获取所有的皮肤配置
            let skinArr = gg.data.table.getTableList<ITableSkin>(TableNames.RoleSkin)
            let skinConfig = skinArr.find(skin => skin.itemid == itemID);
            //获取到默认的皮肤对应的配置
            let type = skinConfig.type;
            let skin = allSkinConfig.find(skin => skin.type == type);
            console.log("获取到默认的皮肤对应的配置", skin);

            return {
                pieceId: skin.piece,
                num: skin.getnumber,
            };
        }
    }
    //如果拥有这个皮肤，皮肤会转为碎片
    checkHasSkin(itemid: number) {
        let hasSkin = gg.data.getItemNum(itemid) > 0;
        if(hasSkin){
            //如果拥有这个皮肤，皮肤会转为碎片
            let {pieceId, num} = this.skinToPiece(itemid);
            //给玩家添加碎片
            gg.data.addItemNum(pieceId, num);
        }
    }
}