using System.Collections.Generic;
using cfg.CharacterCfg;
using Framework;
using CharacterInfo = Gameplay.Net.CharacterInfo;
using cfg;
using Gameplay;
using PhxhSDK;

public class CharacterDataInfoManager : Singlenton<CharacterDataInfoManager>, IInitable
{
    public List<CharacterDataInfo> DataList;
    public Dictionary<uint, CharacterDataInfo> DataDic;

    void IInitable.Init()
    {
        DataList = new List<CharacterDataInfo>();
        DataDic = new Dictionary<uint, CharacterDataInfo>();

    }

    void IInitable.Release()
    {
        DataList.Clear();
        DataDic.Clear();
    }
    public void AddAllCfgCharacter()
    {
        DataList.Clear();
        DataDic.Clear();
        cfg.Tables Table = TableManager.Instance.Tables ?? new Tables(TableManager.LoadByteBuf);

        CharacterAttri attriCfg = Table.CharacterAttri;
        foreach (var item in attriCfg.DataList)
        {
            CharacterDataInfo info = new CharacterDataInfo(item);
            DataList.Add(info);
            DataDic[(uint)info.Cfg.RoleID] = info;
        }
    }
    public void Add(CharacterInfo info)
    {
        CharacterDataInfo info2;
        if (DataDic.TryGetValue(info.ID, out info2))
        {
            DataDic[info.ID].Refresh(info);
            for (int i = 0; i < DataList.Count; i++)
            {
                if (DataList[i].ID == info.ID)
                {
                    DataList[i].Refresh(info);
                    return;
                }

            }
        }
        else
        {
            CharacterDataInfo newInfo = new CharacterDataInfo();
            newInfo.Refresh(info);
            DataList.Add(newInfo);
            DataDic[info.ID] = newInfo;
            EventManager.Instance.Send(EventManager.EventName.GetNewCharacter, info.ID);
        }
        
    }

    public CharacterDataInfo GetCharacterInfo(uint selectId)
    {
        if (DataDic.TryGetValue(selectId, out var info))
        {
            return info;
        }
        else
        {
            DebugUtil.LogError("找不到该角色ID {0}", selectId);
            return null;
        }
    }



}

public class CharacterDataInfo : CharacterInfo
{
    public DataCharacterAttri Cfg => _cfg;
    private DataCharacterAttri _cfg;

    private DataCharacterBreak _breakCfg;
    private DataCharacterAwaking _awakeCfg;

    public uint Uid => ID;
    public CharacterDataInfo()
    {
    }
    public CharacterDataInfo(uint id, uint level, uint breakLevel, uint awakeLeel)
    {
        ID = id;
        Level = level;
        BreakLevel = breakLevel;
        AwakeLevel = awakeLeel;
        LikelyExp = 0;
        LikelyLevel = 0;
        UltraSkillLevel = 0;
        SkinID = 0;
        CfgLoad();
    }

    private void CfgLoad()
    {
        _cfg = TableManager.Instance.Tables.CharacterAttri.GetOrDefault((int)ID);
        OnBreakCfgLoaded(TableManager.Instance.Tables.CharacterBreak);
        OnAwakeCfgLoaded(TableManager.Instance.Tables.CharacterAwaking);
    }


    private void OnAwakeCfgLoaded(CharacterAwaking characterAwaking)
    {
        _awakeCfg = characterAwaking.Get((int)Cfg.RoleID, (int)AwakeLevel);
        if (_awakeCfg != null) return;
        if (AwakeLevel >= characterAwaking.DataList[^1].AwakingLevel)
        {
            _awakeCfg = characterAwaking.DataList[^1];
            DebugUtil.LogError("该角色的觉醒等级超过觉醒表最大等级 {0}", Cfg.RoleID);
        }
    }

    private void OnBreakCfgLoaded(CharacterBreak characterBreak)
    {
        _breakCfg = characterBreak.Get((int)Cfg.RoleID, (int)BreakLevel);
        if (_breakCfg != null) return;
        if (AwakeLevel >= characterBreak.DataList[^1].BreakLevel)
        {
            _breakCfg = characterBreak.DataList[^1];
            DebugUtil.LogError("该角色的突破等级超过突破表最大等级 {0}", Cfg.RoleID);
        }
    }

    public int GetBreakPassiveId()
    {
        if (BreakLevel == 0)
        {
            return Cfg.PassiveBreakSkillID;
        }
        else
        {
            return _breakCfg.PassiveSkillID;
        }

    }
    public int HasPassiveSkillCount()
    {
        var count = 0;
        if (GetBreakPassiveId() != 0)
        {
            count++;
        }
        if (GetAwakePassiveId() != 0)
        {
            count++;
        }
        return count;
    }

    public int GetMaxBreakPassiveSkillLv()
    {
        return GetMaxBreakLevel();
    }
    public int GetMaxAwakePassiveSkillLv()
    {
        return 0;
    }
    public int GetAwakePassiveId()
    {
        if (AwakeLevel == 0)
        {
            return Cfg.PassiveAwakeSkillID;
        }
        else
        {
            return _awakeCfg.PassiveSkillID;

        }
    }
    public CharacterDataInfo(DataCharacterAttri cfg)
    {
        ID = (uint)cfg.RoleID;
        Exp = 10000;
        Level = 10;
        BreakLevel = 1;
        AwakeLevel = 1;
        LikelyExp = 1;
        LikelyLevel = 1;
        UltraSkillLevel = 1;
        SkinID = 1;
        CfgLoad();

    }



    public void Refresh(CharacterInfo info)
    {

        ID = info.ID;
        Exp = info.Exp;
        Level = info.Level;
        BreakLevel = info.BreakLevel;
        AwakeLevel = info.AwakeLevel;
        LikelyExp = info.LikelyExp;
        LikelyLevel = info.LikelyLevel;
        UltraSkillLevel = info.UltraSkillLevel;
        SkinID = info.SkinID;
        CfgLoad();
    }



    private float HPBreakLvUp()
    {

        return _breakCfg.Hp;
    }
    private float HpAwakeLvUp()
    {
        if (_awakeCfg != null)
        {
            return _awakeCfg.Hp;
        }
        return 0;
    }
    private int AttackBreakLvUp()
    {
        return _breakCfg.Attack;
    }
    private int AttackAwakeLvUp()
    {
        if (_awakeCfg != null)
        {
            return _awakeCfg.Attack;
        }
        return 0;
    }
    public float HP()
    {
        return HpLevelUp((int)Level) + HPBreakLvUp() + HpAwakeLvUp();
    }
    public float HpLevelUp(int level)
    {
        if (level > Cfg.Hp.Count)
        {
            DebugUtil.LogError("characterDefault表的HP不够了！！！！！");
            return Cfg.Hp[Cfg.Hp.Count - 1];
        }
        else
        {
            return Cfg.Hp[(int)level - 1];
        }
    }
    public int Attack()
    {
        return AttackLevelUp((int)Level) + AttackAwakeLvUp() + AttackBreakLvUp();
    }
    public int AttackLevelUp(int level)
    {
        if (level > Cfg.Attack.Count)
        {
            DebugUtil.LogError("characterDefault表的attack不够了！！！！！");
            return Cfg.Attack[Cfg.Attack.Count - 1];
        }
        else
        {
            return Cfg.Attack[(int)level - 1];
        }
    }

    //private float LevelUpDefence()
    //{
    //    return Cfg.DefenceLevelUpTemplate[Level - 1];
    //}

    private int ArmorAwakeLvUp()
    {
        if (_awakeCfg != null)
        {
            return _awakeCfg.Shield;
        }
        return 0;
    }
    private int ArmorBreakLvUp()
    {
        return _breakCfg.Shield;
    }
    public float Armor()
    {

        return ArmorLevelUp((int)Level) + ArmorAwakeLvUp() + ArmorBreakLvUp();

    }
    public int ArmorLevelUp(int level)
    {
        if (level > Cfg.Shield.Count)
        {
            DebugUtil.LogError("characterDefault表的shield不够了！！！！！");
            return Cfg.Shield[Cfg.Shield.Count - 1];
        }
        else
        {
            return Cfg.Shield[(int)Level - 1];
        }
    }
    //private float LevelUpArmor()
    //{
    //    return Cfg.ShieldLevelUpTemplate[Level - 1];
    //}
    private float DenfenceBreakLvUp()
    {
        return _breakCfg.Defence;
    }
    private float DenfenceAwakeLvUp()
    {
        if (_awakeCfg != null)
        {
            return _awakeCfg.Defence;
        }
        return 0;
    }

    public float Defence()
    {
        return DefenceLevelUp((int)Level) + DenfenceAwakeLvUp() + DenfenceBreakLvUp();
    }

    public int DefenceLevelUp(int level)
    {
        if (level > Cfg.Defence.Count)
        {
            DebugUtil.LogError("characterDefault表的dnfence不够了！！！！！");
            return Cfg.Defence[Cfg.Defence.Count - 1];
        }
        else
        {
            return Cfg.Defence[(int)level - 1];
        }
    }
    public float Corrage()
    {
        // 最大士气值
        return Cfg.MaxMorale;
    }
    private int ManagazinContainAwakeLvUp()
    {
        if (_awakeCfg != null)
        {
            return _awakeCfg.ManagazinContain;
        }
        return 0;
    }


    public int BulletCapacity()
    {
        return Cfg.ManagazinContain + _breakCfg.ManagazinContain + ManagazinContainAwakeLvUp();
    }

    public float ChangeBulletTime()
    {
        return Cfg.ChangeBulletTime + _breakCfg.ChangeBulletTime + ChangeBulletTimeAwakeLvUp();
    }
    private float ShootSpeedAwakeLvUp()
    {
        if (_awakeCfg != null)
        {
            return _awakeCfg.ShootSpeed;
        }
        return 0;
    }
    public float ShootSpeed()
    {
        return Cfg.ShootSpeed + _breakCfg.ShootSpeed + ShootSpeedAwakeLvUp(); ;

    }
    private float ChangeBulletTimeAwakeLvUp()
    {
        if (_awakeCfg != null)
        {
            return _awakeCfg.ChangeBulletTime;
        }
        return 0;
    }

    private float SpeedAwakeLvUp()
    {
        if (_awakeCfg != null)
        {
            return _awakeCfg.Speed;
        }
        return 0;
    }

    public float MoveSpeed()
    {
        return Cfg.Speed + _breakCfg.Speed + SpeedAwakeLvUp();
    }
    private float YaZhiAwakeLvUp()
    {
        if (_awakeCfg != null)
        {
            return _awakeCfg.YaZhi;
        }
        return 0;
    }
    public float YaZhi()
    {
        return Cfg.YaZhi + _breakCfg.YaZhi + YaZhiAwakeLvUp();
    }
    private float DamageToHumanAwakeLvUp()
    {
        if (_awakeCfg != null)
        {
            return _awakeCfg.DamageToHuman;
        }
        return 0;
    }
    public float DamageToHuman()
    {
        return Cfg.DamageToHuman + _breakCfg.DamageToHuman + DamageToHumanAwakeLvUp();
    }
    private float DamageToCarrierAwakeLvUp()
    {
        if (_awakeCfg != null)
        {
            return _awakeCfg.DamageToCarrier;
        }
        return 0;
    }
    public float DamageToCarrier()
    {
        return Cfg.DamageToCarrier + _breakCfg.DamageToCarrier + DamageToCarrierAwakeLvUp();
    }
    private float CriticalDamageAwakeLvUp()
    {
        if (_awakeCfg != null)
        {
            return _awakeCfg.CriticalDamage;
        }
        return 0;
    }
    public float CriticalDamage()
    {
        return Cfg.CriticalDamage + _breakCfg.CriticalDamage + CriticalDamageAwakeLvUp();
    }
    private float CriticalRatioAwakeLvUp()
    {
        if (_awakeCfg != null)
        {
            return _awakeCfg.CriticalRatio;
        }
        return 0;
    }
    public float CriticalRatio()
    {
        return Cfg.CriticalRatio + _breakCfg.CriticalRatio + CriticalRatioAwakeLvUp();
    }

    public void AddLikeLyEXPInfo(int exp)
    {
        SetLikelyLv();
    }
    private void SetLikelyLv()
    {

    }
    public bool IsMaxBreak()
    {
        if ((GetBreakPassiveId() == 0) || BreakLevel >= GetMaxBreakLevel())
        {
            return true;
        }
        return false;
    }
    public bool IsMaxAwake()
    {
        if ((GetAwakePassiveId() == 0) || AwakeLevel >= GetMaxAwakeLevel())
        {
            return true;
        }
        return false;

    }
    public int GetMaxBreakLevel()
    {
        int maxLevel = 0;
        CharacterBreak breakCfg = TableManager.Instance.Tables.CharacterBreak;

        for (int i = 0; i < breakCfg.DataList.Count; i++)
        {
            if (breakCfg.DataList[i].RoleID == ID)
            {
                if (breakCfg.DataList[i].BreakLevel > maxLevel)
                {
                    maxLevel = breakCfg.DataList[i].BreakLevel;
                }
            }
        }
        return maxLevel;
    }
    public int GetMaxAwakeLevel()
    {
        int maxLevel = 0;
        CharacterAwaking breakCfg = TableManager.Instance.Tables.CharacterAwaking;
        for (int i = 0; i < breakCfg.DataList.Count; i++)
        {
            if (breakCfg.DataList[i].RoleID == ID)
            {
                if (breakCfg.DataList[i].AwakingLevel > maxLevel)
                {
                    maxLevel = breakCfg.DataList[i].AwakingLevel;
                }
            }
        }
        return maxLevel;
    }
    public int GetMaxUltralSkillLevel()
    {
        int maxSkillLevel = 0;
        CharacterSkillLevel cfg = TableManager.Instance.Tables.CharacterSkillLevel;
        for (int i = 0; i < cfg.DataList.Count; i++)
        {
            if (cfg.DataList[i].RoleID == ID)
            {
                if (cfg.DataList[i].SkillLevel > maxSkillLevel)
                {
                    maxSkillLevel = cfg.DataList[i].SkillLevel;
                }
            }

        }
        return maxSkillLevel;
    }

    public string GetWholeHeadPath(int Skinindex=-1)
    {
        if (Skinindex == -1)
            Skinindex = Cfg.DefaultSkinIndex;
        
        return CommonUtils.GetWholeHeadPath(TableManager.Instance.Tables.SkinCfg.Get(Skinindex, Cfg.RoleID).PIcHeadPath);

    }
}