using System.Collections.Generic;
using cfg.CharacterCfg;
using Framework;
using CharacterInfo = Gameplay.Net.CharacterInfo;
using cfg;
using Gameplay;
using Gameplay.Utils;
using PhxhSDK;
using cfg.WeaponCfg;
using UnityEngine;
using Gameplay.Common;

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 Dispose()
    {
        DataList.Clear();
        DataDic.Clear();
    }

    public void AddAllCfgCharacter()
    {
        DataList.Clear();
        DataDic.Clear();
        cfg.Tables Table = TableManager.Instance.Tables;

        CharacterAttri attriCfg = Table.CharacterAttri;
        foreach (var item in attriCfg.DataList)
        {
            var isAvaliable = _CheckCharacterCfgAvaliable(item);
            if (!isAvaliable)
            {
                DebugUtil.LogError("角色ID:{0}的配置不可用", item.RoleID);
                continue;
            }
            CharacterDataInfo info = new CharacterDataInfo(item);
            if (DataDic.ContainsKey((uint)info.Cfg.RoleID))
            {
                continue;
            }
            info.ConstructRedPointTree(30);//TableManager.Instance.Tables.RedPointConfig.Get(30).ParentID
            DataList.Add(info);
            DataDic[(uint)info.Cfg.RoleID] = info;
        }
    }

    private bool _CheckCharacterCfgAvaliable(DataCharacterAttri checkCfg)
    {
        if (checkCfg.Attack.Count == 0)
        {
            DebugUtil.LogError($"角色ID:{checkCfg.RoleID}的攻击配置为空");
            return false;
        }

        var skinCfg = TableManager.Instance.Tables.SkinCfg.Get(GLConfig.Inst.data.DEFAULTSKINID, checkCfg.RoleID);
        if (skinCfg == null)
        {
            DebugUtil.LogError($"角色ID:{checkCfg.RoleID}的皮肤配置为空");
            return false;
        }
        
        var picHeadPath = CommonUtils.GetWholeHeadPath(skinCfg.PIcHeadPath);
        if (!AssetManager.Instance.CanLocateAsset<Sprite>(picHeadPath))
        {
            DebugUtil.LogError($"角色ID:{checkCfg.RoleID}的头像资源路径:{picHeadPath}不存在");
            // TODO: 暂时允许头像资源不存在
            // return false;
        }

        var fakeSkillLevel = 1;
        var skillLevelInfo = TableManager.Instance.Tables.CharacterSkillLevel.Get(checkCfg.RoleID, fakeSkillLevel);
        if (skillLevelInfo == null)
        {
            DebugUtil.LogError($"角色ID:{checkCfg.RoleID}的技能等级配置为空");
            return false;
        }
        var skillGroupInfo = TableManager.Instance.Tables.SkillReferConfig.Get(skillLevelInfo.SkillGroupId);
        if (skillGroupInfo == null)
        {
            DebugUtil.LogError($"角色ID:{checkCfg.RoleID}的技能组配置为空");
            return false;
        }
        
        var awakeLevel = 1;
        var awakeCfg = TableManager.Instance.Tables.CharacterAwaking.Get(checkCfg.RoleID, awakeLevel);
        if (awakeCfg == null)
        {
            DebugUtil.LogError($"角色ID:{checkCfg.RoleID}的觉醒配置为空");
            return false;
        }
        var breakLevel = 1;
        var breakCfg = TableManager.Instance.Tables.CharacterBreak.Get(checkCfg.RoleID, breakLevel);
        if (breakCfg == null)
        {
            DebugUtil.LogError($"角色ID:{checkCfg.RoleID}的突破配置为空");
            return false;
        }
        

        return true;
    }
    
    public void Add(CharacterInfo info)
    {
        if (DataDic.TryGetValue(info.ID, out CharacterDataInfo 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();
            var cfg = TableManager.Instance.Tables.CharacterAttri.GetOrDefault((int)info.ID);
            if (cfg == null)
            {
                DebugUtil.LogError($"CharacterDefaultConfig缺少角色配置，当前角色ID：{info.ID}");
                return;
            }

            newInfo.Refresh(info);
            newInfo.ConstructRedPointTree(30);//TableManager.Instance.Tables.RedPointConfig.Get(30).ParentID
            DataList.Add(newInfo);
            DataDic[info.ID] = newInfo;
            EventManager.Instance.Send(EventManager.EventName.GetNewCharacter, info.ID);
        }

    }

    public void SortCharactersByLevel()
    {
        DataList.Sort((a, b) => b.Level.CompareTo(a.Level));
    }

    public void SortCharactersByID()//角色ID排序默认为从小到大升序
    {
        DataList.Sort((a, b) => a.Cfg.RoleID.CompareTo(b.Cfg.RoleID));
    }

    public void SortCharacterDefault()//默认排序方式：整体以等级降序，等级相同的情况下按照角色ID升序
    {
        DataList.Sort((a, b) =>
        {
            int ret = b.Level.CompareTo(a.Level);
            if (ret == 0)
            {
                ret = a.Cfg.RoleID.CompareTo(b.Cfg.RoleID);
            }
            return ret;
        });
        foreach (var id in DataList)
        {
            DebugUtil.Log("sortDefault:" + id.Name + "," + id.ID);
        }
    }

    public void SortCharactersByLevel(List<CharacterDataInfo> dataInfos)
    {
        dataInfos.Sort((a, b) => b.Level.CompareTo(a.Level));
    }

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

    public CharacterDataInfo GetMaxLevelCharacter()
    {
        if (DataList.Count <= 0)
        {
            return null;
        }
        var dataList = new List<CharacterDataInfo>(DataList);
        
        dataList.Sort((a, b) =>
        {
            if (a.Level > b.Level) return 1;
            return 0;
        });

        return dataList[0];
    }

    /// <summary>
    /// 获取指挥官推荐职业列表
    /// </summary>
    public List<ProvideJob> GetCommanderProvideJobs(uint id)
    {
        var jobs = new List<ProvideJob>();
        if (DataDic.TryGetValue(id, out var characterDataInfo))
        {
            if (characterDataInfo.Cfg.Job != Ejob.Job_Commander)
            {
                DebugUtil.LogError("该角色不为指挥官{0}", id);
                return jobs;
            }
            var provideJobs = characterDataInfo.Cfg.ProvideJob;
            if (provideJobs.Length == 0)
            {
                DebugUtil.LogError("该指挥官{0}推荐职位为空", id);
                return jobs;
            }

            var vehicleList = new List<ProvideJob>();
            var characterList = new List<ProvideJob>();

            foreach (var job in provideJobs)
            {
                if (job == ProvideJob.Job_None)
                {
                    DebugUtil.LogError("该指挥官{0}配置的推荐职业包含空");
                    continue;
                }

                if (job == ProvideJob.Job_Vehicle)
                {
                    vehicleList.Add(job);
                }
                else
                {
                    characterList.Add(job);
                }
                   
            }
            jobs.AddRange(vehicleList);
            jobs.AddRange(characterList);
        }

        return jobs;
    }
    
    public int GetSpendLeadership(uint id)
    {
        if (DataDic.TryGetValue(id, out var characterDataInfo))
        {
            if (characterDataInfo.Cfg != null)
                return characterDataInfo.Cfg.SpendLeadership;
        }
        
        return 0;
    }

}

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

    private DataCharacterBreak _breakCfg;
    public DataCharacterBreak BreakCfg => _breakCfg;

    private DataCharacterAwaking _awakeCfg;
    public DataCharacterAwaking AwakeCfg => _awakeCfg;

    RedPointNodeCharacter _redPointNode;
    public RedPointNodeCharacter RedPointNode => _redPointNode;

    RedPointNodeCharacter characterAwakingNode;
    public RedPointNodeCharacter CharacterAwakingNode => characterAwakingNode;

    public uint Uid => ID;
    public CharacterDataInfo()
    {
    }
    public CharacterDataInfo(uint id, uint level, uint breakLevel, uint awakeLevel)
    {
        ID = id;
        Level = level;
        BreakLevel = breakLevel;
        AwakeLevel = awakeLevel;
        LikelyExp = 0;
        LikelyLevel = 0;
        UltraSkillLevel = 0;
        SkinID = 1;
        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 string Name => CommonUtils.GetLocalizeText(_cfg.NameRead);

    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);
    }
    /// <summary>
    /// 指定等级护盾值
    /// </summary>
    /// <param name="level"></param>
    /// <returns></returns>
    public int ArmorLevelUp(int level)
    {
        if (level > Cfg.Shield.Count)
        {
            DebugUtil.LogError("characterDefault表的shield不够了！！！！！");
            return Cfg.Shield[Cfg.Shield.Count - 1] + ArmorAwakeLvUp() + ArmorBreakLvUp();
        }
        else
        {
            return Cfg.Shield[(int)level - 1] + ArmorAwakeLvUp() + ArmorBreakLvUp();
        }
    }
    //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();
    }
    public float DamageToHp()
    {
        return Cfg.AttackHpScale;
    }
    public float DamageToArmor()
    {
        return Cfg.AttackShiledScale;
    }
    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;

    }

    /// <summary>
    /// 是否满好感度
    /// </summary>
    /// <returns></returns>
    public bool IsMaxLikely()
    {
        return LikelyLevel >= GetMaxLikelyLevel();
    }

    public int GetMaxLikelyLevel()
    {
        int maxLevel = 0;
        CharacterLikability likelyCfg = TableManager.Instance.Tables.CharacterLikability;

        for (int i = 0; i < likelyCfg.DataList.Count; i++)
        {
            if (likelyCfg.DataList[i].RoleID == ID && likelyCfg.DataList[i].LikabilityLevel > maxLevel)
                maxLevel = likelyCfg.DataList[i].LikabilityLevel;
        }

        return maxLevel;
    }

    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 = GLConfig.Inst.data.DEFAULTSKINID;

        return CommonUtils.GetWholeHeadPath(TableManager.Instance.Tables.SkinCfg.Get(Skinindex, Cfg.RoleID).PIcHeadPath);

    }

    public string PrefabPath =>
        PathEx.GetCharacterDisplayModelPath(Cfg.NameID);

    public string WeaponName()
    {
        DataWeapon dataWeapon = TableManager.Instance.Tables.WeaponConfig.Get(Cfg.WeaponId);
        if (dataWeapon == null)
        {
            DebugUtil.LogError("武器id为{0}的武器没配" + Cfg.WeaponId);
            return Cfg.WeaponId.ToString();
        }
        return CommonUtils.GetLocalizeText(E_LocalizePrefix.weapon, Cfg.WeaponId);//dataWeapon.Name

    }

    public void ConstructRedPointTree(int parentID)
    {
        //角色节点，非叶子节点
        _redPointNode = RedPointManager.Instance.AddDynamicNode(cfg.RedPoint.NodeType.Character, parentID) as RedPointNodeCharacter;

        //此处添加角色所需要的所有红点节点，如觉醒，突破，技能等，挂在角色节点下
        #region 觉醒红点
        characterAwakingNode = RedPointManager.Instance.AddDynamicNode
            (cfg.RedPoint.NodeType.Character, 
            _redPointNode.ID, 
            new List<int>() { (int)ID, (int)RedPointNodeCharacter.CharacterType.Awaking }) as RedPointNodeCharacter;
        #endregion

        if (_redPointNode == null)
            DebugUtil.LogError("_redPointNode is null");
        if (characterAwakingNode == null)
        {
            DebugUtil.LogError("characterAwakingNode is null");
        }
    }

    public void ConstructRedPointTree(RedPointNode parent)
    {
        throw new System.NotImplementedException();
    }
}