using System.Collections.Generic;
using UnityEngine;
using System;
using System.Linq;

public class HeroManager : GameSystemManager<HeroManager>
{
    //武将和图鉴的关系
    //同一个武将图鉴，可能有多个武将（物品）数据，或者没有武将，但是有图鉴信息
    //初始创建（0725），后续跟随背包事件增加删除  key = guid
    protected Dictionary<string, HeroInfo> heroInfoDict = new Dictionary<string, HeroInfo>();

    public Action<HeroInfo> onHeroChangeEvent;

    public Action<int> onHeroDeleteEvent;

    public override void Init()
    {
        base.Init();

        PackManager.Instance.ChangeItemEvent += ChangeHero;
        PackManager.Instance.DeleteItemEvent += DeleteHero;
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += OnBeforePlayerDataInitialize;
    }

    public override void Release()
    {
        base.Release();
        PackManager.Instance.ChangeItemEvent -= ChangeHero;
        PackManager.Instance.DeleteItemEvent -= DeleteHero;
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent -= OnBeforePlayerDataInitialize;
    }

    void OnBeforePlayerDataInitialize()
    {

        heroInfoDict.Clear();
    }


    // isCreate bool：true代表创建 false 刷新触发
    void ChangeHero(PackType packType, string guid, bool isCreate)
    {
        if (packType == PackType.Hero)
        {
            HeroInfo heroInfo = null;
            if (!heroInfoDict.TryGetValue(guid, out heroInfo))
            {
                heroInfo = new HeroInfo(PackManager.Instance.GetItemByGuid(guid));
                heroInfoDict.Add(guid, heroInfo);
            }
            else
            {
                heroInfo.UpdateHero(PackManager.Instance.GetItemByGuid(guid));
            }

            onHeroChangeEvent?.Invoke(heroInfo);
        }
    }

    void DeleteHero(PackType packType, string guid, int itemID, int index, int clearType)
    {
        if (packType == PackType.Hero)
        {
            HeroInfo heroInfo = null;
            heroInfoDict.TryGetValue(guid, out heroInfo);

            heroInfoDict.Remove(guid);

            onHeroDeleteEvent?.Invoke(itemID);
        }
    }

    public HeroInfo GetHero(string guid)
    {
        if (!heroInfoDict.ContainsKey(guid))
            return null;
        return heroInfoDict[guid];
    }

    public List<HeroInfo> GetHeroList()
    {
        return heroInfoDict.Values.ToList();
    }

    public List<string> GetHeroGuidList()
    {
        return heroInfoDict.Keys.ToList();
    }

    /// 参数： 职业，国家，伤害类型，6大战斗属性，特殊属性
    public List<string> GetHeroGuidList(List<int> selectList = null)
    {
        if (selectList.IsNullOrEmpty())
            return heroInfoDict.Keys.ToList();

        int job = selectList[0];
        int country = selectList[1];
        int hurtType = selectList[2];
        int fightAttrType = selectList[3];
        int specialAttrType = selectList[4];

        List<string> retGuidList = new List<string>();
        foreach (string guid in heroInfoDict.Keys)
        {
            HeroInfo heroInfo = heroInfoDict[guid];

            //0代表全部, 同级别是可复选，不同级别为且的关系
            bool isMatch = true;
            if (job != 0)
            {
                isMatch = isMatch && (job & (1 << heroInfo.heroConfig.Class)) > 0;
            }
            if (country != 0)
            {
                isMatch = isMatch && (country & (1 << heroInfo.heroConfig.Country)) > 0;
            }
            if (hurtType != 0)
            {
                isMatch = isMatch && (hurtType & (1 << heroInfo.heroConfig.HurtType)) > 0;
            }
            if (fightAttrType != 0)
            {
                isMatch = isMatch && (fightAttrType & (1 << heroInfo.heroConfig.Specialty)) > 0;
            }
            if (specialAttrType != 0)
            {
                bool isMatch2 = false;
                for (int i = 0; i < heroInfo.heroConfig.Specialty2.Length; i++)
                {
                    isMatch2 = (specialAttrType & (1 << heroInfo.heroConfig.Specialty2[i])) > 0;
                    if (isMatch2)
                        break;
                }
                isMatch = isMatch && isMatch2;
            }
            if (isMatch)
            {
                retGuidList.Add(guid);
            }

        }
        return retGuidList;
    }

    public List<HeroInfo> GetPowerfulHeroList()
    {
        List<HeroInfo> heroList = new List<HeroInfo>(heroInfoDict.Values);

        heroList.Sort((a, b) =>
        {
            long power1 = a.CalculateFightPower(false);
            long power2 = b.CalculateFightPower(false);

            if (power1 == power2)
            {
                return 0;
            }

            return power1 > power2 ? -1 : 1;
        });

        List<HeroInfo> retList = new List<HeroInfo>();

        for (int i = 0; i < TeamConst.MaxTeamHeroCount && i < heroList.Count; i++)
        {
            retList.Add(heroList[i]);
        }

        return retList;
    }


    public int GetHeroCount()
    {
        return heroInfoDict.Count;
    }

    public bool HasHero(int heroID)
    {
        return PackManager.Instance.GetSinglePack(PackType.Hero).HasItem(heroID);
    }

    public int GetHeroCountByID(int heroID)
    {
        return (int)PackManager.Instance.GetSinglePack(PackType.Hero).GetCountById(heroID);
    }

    //获得生效的武将数量
    public int GetAttrActiveHeroCount()
    {
        int count = 0;
        foreach (HeroInfo heroInfo in heroInfoDict.Values)
        {
            if (heroInfo.isAttrActive)
            {
                count++;
            }
        }
        return count;
    }

    //获得未生效的武将数量
    public int GetNotActiveHeroCount()
    {
        int count = 0;
        foreach (HeroInfo heroInfo in heroInfoDict.Values)
        {
            if (!heroInfo.isAttrActive)
            {
                count++;
            }
        }
        return count;
    }

    //获得指定ID且属性生效的武将
    public HeroInfo GetHeroByID(int heroID)
    {
        foreach (HeroInfo heroInfo in heroInfoDict.Values)
        {
            if (heroInfo.heroId == heroID && heroInfo.isAttrActive)
            {
                return heroInfo;
            }
        }
        return null;
    }

}