using System.Collections;
using System.Collections.Generic;
using Core.Language;
using Core.Utility;
using Excel2Json;
using Fort23.UTool;
using GameLogic.Combat.CombatTool;
using GameLogic.Hero;
using GameLogic.Player;
using UnityEngine;
using UnityEngine.Serialization;
using Utility;

[System.Serializable]
public class CombatHeroInfo
{
    public enum AttributeType
    {
        Hp,
        Att,
        Def,
    }

    public int modelID;
    public EncryptionLong hp = new EncryptionLong();
    public EncryptionLong defense = new EncryptionLong();
    public EncryptionLong attack = new EncryptionLong();


    // public long 
    public EncryptionFloat attSpeed
    {
        get { return _attSpeed; }
    }

    public EncryptionInt level;
    public EncryptionInt exp = new EncryptionInt();

    public HeroModelConfig modelConfig;

    public HeroPowerUpConfig powerUpConfig;
    public MonsterPowerUpConfig MonsterPowerUpConfig;
    public EncryptionFloat _attSpeed;

    /// <summary>
    /// 功法强度的加成 %
    /// </summary>
    public float gongFaStrength;

    /// <summary>
    /// 护盾
    /// </summary>
    public EncryptionLong Shield;

    /// <summary>
    /// 神识
    /// </summary>
    public EncryptionLong shenshi;

    /// <summary>
    /// 添加的攻击速度比例%
    /// </summary>
    public float addAttSpeed_bl;

    /// <summary>
    /// 金
    /// </summary>
    public float Metal = 100;

    /// <summary>
    /// 木
    /// </summary>
    public float Wood = 100;

    /// <summary>
    /// 水
    /// </summary>
    public float Water = 100;

    /// <summary>
    /// 火
    /// </summary>
    public float Fire = 100;

    /// <summary>
    /// 土
    /// </summary>
    public float Earth = 100;

    /// <summary>
    /// 金
    /// </summary>
    public float Metal_Injury;

    /// <summary>
    /// 木
    /// </summary>
    public float Wood_Injury;

    /// <summary>
    /// 水
    /// </summary>
    public float Water_Injury;

    /// <summary>
    /// 火
    /// </summary>
    public float Fire_Injury;

    /// <summary>
    /// 土
    /// </summary>
    public float Earth_Injury;

    /// <summary>
    /// 1=英雄 2=小怪 3=精英怪 4=boss
    /// </summary>
    public int heroType;

    public string modelName;


    public bool isMonster;

    public int k;

    // public int[] skillId;
    // public List<SkillConfig> skillConfigs;
    /// <summary>
    /// 所有已解锁技能的ID
    /// </summary>
    public List<SkillInfo> unLockSkills = new List<SkillInfo>();

    public bool isGpu;
    public string heroName;

    public List<FaBaoInfo> MagicWeaponID = new List<FaBaoInfo>();

    /// <summary>
    /// 大道修炼ID
    /// </summary>
    public int TaoismSkillId;

    public float GetAttSpeed
    {
        get
        {
            float speed = CombatCalculateTool.Instance.GetVlaueRatioForFloat(attSpeed.Value,
                addAttSpeed_bl + 100);
            if (speed < 0)
            {
                speed = 0.01f;
            }

            return speed;
        }
    }

    public float GetAnimationSpeed
    {
        get { return GetAttSpeed / _attSpeed.Value; }
    }

    public CombatHeroInfo()
    {
    }


    protected Map<AttributeType, float> _AttributeCacheValue = new Map<AttributeType, float>();




    /// <summary>
    /// 获取五行灵根属性
    /// </summary>
    /// <param name="wuXingType"></param>
    /// <returns></returns>
    public float GetWuXingShuXing(WuXingType wuXingType)
    {
        switch (wuXingType)
        {
            case WuXingType.Gold:
                float Metal_v = Metal - Metal_Injury;
                if (Metal_v < 0)
                {
                    Metal_v = 0;
                }

                return Metal_v;
                break;
            case WuXingType.Wood:
                float Wood_v = Wood - Wood_Injury;
                if (Wood_v < 0)
                {
                    Wood_v = 0;
                }

                return Wood_v;
                break;
            case WuXingType.Water:
                float Water_v = Water - Water_Injury;
                if (Water_v < 0)
                {
                    Water_v = 0;
                }

                return Water_v;
                break;
            case WuXingType.Fire:
                float Fire_v = Fire - Fire_Injury;
                if (Fire_v < 0)
                {
                    Fire_v = 0;
                }

                return Fire_v;
                break;
            case WuXingType.Earth:
                float Earth_v = Earth - Earth_Injury;
                if (Earth_v < 0)
                {
                    Earth_v = 0;
                }

                return Earth_v;
                break;
            default:
                return 0;
        }
    }

    protected void CalBasicAttribute()
    {
        _AttributeCacheValue.Clear();
        modelID = modelConfig.ID;
        if (isMonster)
        {
            unLockSkills.Clear();
            hp = (EncryptionLong)(modelConfig.hp * MonsterPowerUpConfig.HPFactor);
            defense = (EncryptionLong)(modelConfig.def * MonsterPowerUpConfig.DEFFactor);
            attack = (EncryptionLong)(modelConfig.attack * MonsterPowerUpConfig.ATKFactor);
            k = MonsterPowerUpConfig.defK;
            Metal = modelConfig.Linggen[0] * MonsterPowerUpConfig.LinggenUp / 100;
            Water = modelConfig.Linggen[1] * MonsterPowerUpConfig.LinggenUp / 100;
            Wood = modelConfig.Linggen[2] * MonsterPowerUpConfig.LinggenUp / 100;
            Fire = modelConfig.Linggen[3] * MonsterPowerUpConfig.LinggenUp / 100;
            Earth = modelConfig.Linggen[4] * MonsterPowerUpConfig.LinggenUp / 100;
            Shield = (EncryptionLong)(modelConfig.shield * MonsterPowerUpConfig.HudunFactor);
            SetSkillAttSpeed(modelConfig.speed_atk);
            if (modelConfig.skillID != null)
            {
                for (int i = 0; i < modelConfig.skillID.Length; i++)
                {
                    int id = modelConfig.skillID[i];
                    if (id <= 0)
                    {
                        continue;
                    }

                    int startLevel = modelConfig.skillActiveLv[i];
                    if (startLevel > 0 && level < startLevel)
                    {
                        continue;
                    }


                    SkillInfo skillInfo =
                        new SkillInfo(id, MonsterPowerUpConfig.GongfaLv, MonsterPowerUpConfig.GongfaStar);
                    skillInfo.index = i;
                    unLockSkills.Add(skillInfo);
                }
            }

            if (modelConfig.fa_bao_id != null)
            {
                for (int i = 0; i < modelConfig.fa_bao_id.Length; i++)
                {
                    int faBaoId = modelConfig.fa_bao_id[i];
                    int startLevel = modelConfig.fabaoActiveLv[i];
                    if (startLevel > 0 && level < startLevel)
                    {
                        continue;
                    }

                    if (faBaoId > 0)
                    {
                        FaBaoInfo faBaoInfo = new FaBaoInfo(faBaoId, MonsterPowerUpConfig.FabaoLv,
                            MonsterPowerUpConfig.FabaoStar);
                        MagicWeaponID.Add(faBaoInfo);
                    }
                }
            }
        }
        else
        {
            hp = (EncryptionLong)(modelConfig.hp * powerUpConfig.HPFactor);
            defense = (EncryptionLong)(modelConfig.def * powerUpConfig.DEFFactor);
            attack = (EncryptionLong)(modelConfig.attack * powerUpConfig.ATKFactor);
            Shield = (EncryptionLong)(modelConfig.shield * powerUpConfig.HudunFactor);
            // shenshi = (EncryptionLong)(modelConfig.shenshi * powerUpConfig.ShenshiFactor);
            k = powerUpConfig.defK;
        }


        for (_AttributeCacheValue.Begin(); _AttributeCacheValue.Next();)
        {
            switch (_AttributeCacheValue.Key)
            {
                case AttributeType.Hp:
                    hp += CombatCalculateTool.Instance.GetVlaueRatioForLong(hp.Value, _AttributeCacheValue.Value);
                    break;
                case AttributeType.Att:
                    attack += CombatCalculateTool.Instance.GetVlaueRatioForLong(attack.Value,
                        _AttributeCacheValue.Value);
                    break;
                case AttributeType.Def:
                    defense += CombatCalculateTool.Instance.GetVlaueRatioForLong(defense.Value,
                        _AttributeCacheValue.Value);
                    break;
            }
        }

        if (!isMonster)
        {
            for (int i = 0; i < MagicWeaponID.Count; i++)
            {
                FaBaoInfo faBaoInfo = MagicWeaponID[i];
                foreach (var VARIABLE in faBaoInfo.attriButedIC)
                {
                    switch (VARIABLE.Key)
                    {
                        case 1:
                            hp += VARIABLE.Value;
                            break;
                        case 2:
                            defense += VARIABLE.Value;
                            break;
                        case 3:
                            attack += VARIABLE.Value;
                            break;
                    }
                }
            }
        }
    }

    public SkillConfig GetGroupSkillConfig(int idGroup)
    {
        if (unLockSkills == null)
        {
            return default;
        }

        for (int i = 0; i < unLockSkills.Count; i++)
        {
            // SkillConfig skillConfig = ConfigComponent.Instance.Get<SkillConfig>(unLockSkills[i]);
            if (unLockSkills[i].skillConfig.IDGroup == idGroup)
            {
                return unLockSkills[i].skillConfig;
            }
        }

        return default;
    }

    protected void CalAttribute()
    {
        CalBasicAttribute();


        // skillId = modelConfig.skillID;
        modelName = modelConfig.model;
        isGpu = modelConfig.isUseGpu;

        heroType = modelConfig.heroType;
    }

    public void SetSkillAttSpeed(float attSpeed)
    {
        _attSpeed = (EncryptionFloat)(1.0f / attSpeed);
    }


   
    protected void SetDataConfig(int modelID, int level)
    {
        modelConfig = ConfigComponent.Instance.Get<HeroModelConfig>(modelID);
        if (isMonster)
        {
            MonsterPowerUpConfig = ConfigComponent.Instance.Get<MonsterPowerUpConfig>(level);
        }
        else
        {
            powerUpConfig = ConfigComponent.Instance.Get<HeroPowerUpConfig>(level);
        }

        this.level = (EncryptionInt)level;
        heroName = LanguageManager.Instance.Text(modelConfig.name);
    }

    public void InitMonster(int modelID, int level)
    {
        isMonster = true;
        SetDataConfig(modelID, level);

        CalAttribute();
    }


    public CombatHeroInfo Copy()
    {
        CombatHeroInfo combatHeroInfo = (CombatHeroInfo)MemberwiseClone();
        return combatHeroInfo;
    }
}