import { EffectCardCfg } from "cfg/parsers/EffectCardCfg";
import { HeroCfg } from "cfg/parsers/HeroCfg";
import { SkillCfg } from "cfg/parsers/SkillCfg";
import { UnitCfg } from "cfg/parsers/UnitCfg";
import arrUtil from "../../utils/array.util";
import { BaseConst } from "../../constants/BaseConst";
import { EffectCardType, EnhanceCalcType, EnhanceCustomType, EnhanceEffectType, SkillEffectSignType, SkillEffectValueType, SkillTargetType } from "./skill/SkillConst";

let CfgMan = {
    /**
     * findPlayerCfg
     *playerid: numer
    */
    _cardcache: new Map(),

    _typecards: new Map(),

    findPlayerCfg(playerid: number): HeroCfg{
        return global.$cfg.get(BaseConst.HERO).get(playerid);
    },

    findUnitCfg(unitid: number): UnitCfg{
        return global.$cfg.get(BaseConst.UNIT).get(unitid);
    },

    findSkillCfg(skillid: number): SkillCfg{
        return global.$cfg.get(BaseConst.SKILL).get(skillid);
    },

    findEffCardCfg(cardid: number): EffectCardCfg{
        return global.$cfg.get(BaseConst.EFFECTCARD).get(cardid);
    },

    calcEnhanceValue(
        eT: EnhanceEffectType,
        eV: number,
        eC: number,
        aP: number,
    ): number{
        switch(eT){
            case EnhanceEffectType.EN_POWER_BYAP:
            case EnhanceEffectType.EN_EFFV_BYAP:
                return eV * eC * aP;
            case EnhanceEffectType.EN_POWER_BYCFG:
            case EnhanceEffectType.EN_EFFV_BYCV:
                return eV * eC;
            case EnhanceEffectType.EN_QCOUNT:
                return eC;
            default:
                return 0;
        }
    },

    calcEffectValue(
        eVT: SkillEffectValueType,
        eST: SkillEffectSignType,
        eV: number,
        eVMax: number,
        aP: number
    ): number{
        let n = this.roundV(eV, eVMax);
        switch(eST){
            case SkillEffectSignType.PERCENT:
                n /= 100;
                break;
            default:
                break;
        }
        switch(eVT){
            case SkillEffectValueType.RATIO_AP:
                n *= aP;
                break;
            default:
                break;
        }
        return n;
    },

    _calcValue(ev: number, et: SkillEffectSignType){
        let n = ev;
        switch(et){
            case SkillEffectSignType.PERCENT:
                n /= 100;
                break;
            default:
                break;
        }
        return n;
    },

    calcEffctValueEx(       
        eCT: EnhanceCustomType, 
        eVT: SkillEffectValueType,
        eST: SkillEffectSignType,
        eV: number,
        aP: number,
        sP: number)
    {
        let n = this._calcValue(eV, eST);
        if(eCT == EnhanceCustomType.EFF_VALUE){
            switch(eVT){
                case SkillEffectValueType.RATIO_AP:
                    aP && (n *= aP);
                    break;
                case SkillEffectValueType.RATIO_SP:
                    sP && (n *= sP);
                    break;
            }
        }
        return n;
    },

    canEnhanceValue(eCT: EnhanceCustomType, eET: EnhanceEffectType): boolean{
        switch(eCT){
            case EnhanceCustomType.EFF_VALUE:
                return eET == EnhanceEffectType.EN_EFFV_BYAP || 
                eET == EnhanceEffectType.EN_EFFV_BYAP_MAX || 
                eET == EnhanceEffectType.EN_EFFV_BYAP_MM ||
                eET == EnhanceEffectType.EN_EFFV_BYCV || 
                eET == EnhanceEffectType.EN_EFFV_BYCV_MAX ||
                eET == EnhanceEffectType.EN_EFFV_BYCV_MM;
            case EnhanceCustomType.ENHANCE_MAGIC:
                return eET == EnhanceEffectType.EN_EM;
            case EnhanceCustomType.QUOTE_TIMES:
            case EnhanceCustomType.GET_TIMES:
                return eET == EnhanceEffectType.EN_QCOUNT || 
                eET == EnhanceEffectType.EN_QCOUNT_MAX || 
                eET == EnhanceEffectType.EN_QCOUNT_MM;
            case EnhanceCustomType.POWER:
                return eET == EnhanceEffectType.EN_POWER_BYAP || 
                eET == EnhanceEffectType.EN_POWER_BYCFG;
            case EnhanceCustomType.RELEASE_TIMES:
                return eET == EnhanceEffectType.EN_SKILL_RELEASE_MAX || 
                eET == EnhanceEffectType.EN_SKILL_RELEASE_MIN ||
                eET == EnhanceEffectType.EN_SKILL_RELEASE_MM;
            default:
                break;
        }
        return false;
    },

    randomEffValue(
        vMin: number,
        vMax: number,

        eET: EnhanceEffectType,

        eST: SkillEffectSignType,
        eEV: number,

        aC: number
    ): number{
        let eV = this._calcValue(eEV, eST);
        let nmin = vMin;
        let nmax = vMax;
        if(aC){
            switch(eET){
                case EnhanceEffectType.EN_EFFV_BYCV:
                    nmin += eV * aC;
                    break;
                case EnhanceEffectType.EN_EFFV_BYAP:
                    nmin += eV * aC;
                    break;
                case EnhanceEffectType.EN_QCOUNT:
                    nmin += aC;
                    break;
                case EnhanceEffectType.EN_POWER_BYCFG:
                    nmin += eV * aC;
                    nmax = nmin;
                    break;
                case EnhanceEffectType.EN_POWER_BYAP:
                    nmin += eV * aC;
                    nmax = nmin;
                    break;
                case EnhanceEffectType.EN_SKILL_RELEASE_MIN:
                    nmin += aC;
                    break;
                case EnhanceEffectType.EN_SKILL_RELEASE_MAX:
                    nmax += aC;
                    break;
                case EnhanceEffectType.EN_QCOUNT_MAX:
                    nmax += aC;
                    break;
                case EnhanceEffectType.EN_EFFV_BYCV_MAX:
                    nmax += eV * aC;
                    break;
                case EnhanceEffectType.EN_EFFV_BYCV_MM:
                    nmin += eV * aC;
                    nmax += eV * aC;
                    break;
                case EnhanceEffectType.EN_EFFV_BYAP_MAX:
                    nmax += eV * aC;
                    break;
                case EnhanceEffectType.EN_EFFV_BYAP_MM:
                    nmin += eV * aC;
                    nmax += eV * aC;
                    break;
                case EnhanceEffectType.EN_QCOUNT_MM:
                    nmin += aC;
                    nmax += aC;
                    break;
                case EnhanceEffectType.EN_SKILL_RELEASE_MM:
                    nmin += aC;
                    nmax += aC;
                    break;
                default:
                    break;
            }
        }
        return this.roundV(nmin, nmax);
    },

    getTargetByCard(cardid: number): SkillTargetType{
        let obj = this._cardcache.get(cardid + '');
        if(obj){
            return obj.target;
        }

        let cardcfg = this.findEffCardCfg(cardid);
        if(!cardcfg){
            return SkillTargetType.NONE;
        }
        let res = SkillTargetType.NONE;

        let skilllst: number[] = [];

        cardcfg.quoteskill1id && skilllst.push(cardcfg.quoteskill1id);
        cardcfg.quoteskill2id && skilllst.push(cardcfg.quoteskill2id);
        cardcfg.quoteskill3id && skilllst.push(cardcfg.quoteskill3id);
        cardcfg.quoteskill4id && skilllst.push(cardcfg.quoteskill4id);

        if(cardcfg.type_id == EffectCardType.NPC){
            let unitcfg = this.findUnitCfg(cardcfg.stageunit_id);
            if(unitcfg){
                unitcfg.base_skill1id && skilllst.push(unitcfg.base_skill1id);
                unitcfg.base_skill2id && skilllst.push(unitcfg.base_skill2id);
                unitcfg.base_skill3id && skilllst.push(unitcfg.base_skill3id);
            }
        }

        for(let i = 0; i < skilllst.length; i++){
            let skillcfg = this.findSkillCfg(skilllst[i]);
            if(skillcfg && skillcfg.select_targetID != SkillTargetType.NONE){
                res = skillcfg.select_targetID;
                break;
            }
        }

        this._cardcache.set(cardid + '', {target: res});

        return res;
    },

    randomCard(subtype: number): number{
        if(this._typecards.size == 0){
            for(let [key, val] of global.$cfg.get(BaseConst.EFFECTCARD)){
                let id1 = val.affix1id;
                let id2 = val.affix2id;
                if(id1){
                    let lst = this._typecards.get(id1 + '');
                    if(!lst){
                        lst = [key];
                        this._typecards.set(id1 + '', lst);
                    }else{
                        lst.push(key);
                    }
                }

                if(id2 && id2 != id1){
                    let lst = this._typecards.get(id2 + '');
                    if(!lst){
                        lst = [key];
                        this._typecards.set(id2 + '', lst);
                    }else{
                        lst.push(key);
                    }
                }
            }
        }

        let obj = this._typecards.get(subtype + '');

        return obj? arrUtil.randomOne(obj): 0;
    },

    roundV(minv: number, maxv: number): number{
        if(!maxv){
            return minv;
        }
        return Math.round(Math.random() * maxv + minv);
    },

    hasSummonPetSkill(skillids: number[]){
        let bok = false;
        for(let i=0; i<skillids.length;i++){
            let cfg = this.findSkillCfg(skillids[i]);
            if(cfg && cfg.quoteunitid && cfg.tigger_typeid == 0){
                bok = true;
                break;
            }
        }
        return bok;
    }
};

export default CfgMan;