using System;
using System.Collections;
using System.Collections.Generic;

using UnityEngine;

public partial class HeroUIManager : GameSystemManager<HeroUIManager>
{
    

    #region 布阵界面
    public List<string> heroOnTeamSortList { get; private set; } = new List<string>();    //不同上阵的列表排序

    private TeamType m_SelectTeamType = TeamType.Story; //当前选中的是哪个阵容, 布阵相关逻辑使用
    public TeamType selectTeamType
    {
        get { return m_SelectTeamType; }
        set
        {
            if (m_SelectTeamType == value)
                return;
            //上一个阵容需要恢复到原状态
            if (m_SelectTeamType != TeamType.None)
            {
                TeamManager.Instance.GetTeam(m_SelectTeamType).RestoreTeam();
            }

            m_SelectTeamType = value;
        }
    }

    public int selectTeamPosJob = 0;    //布阵界面 筛选职业
    public int selectTeamPosCountry = 0;    //布阵界面 筛选国家

    public const float clickFlyPosTime = 0.5f;  //点击列表中的武将图标时, 飞入布阵的时间

    public event Action<List<int>, int, Vector3> OnTeamPosChangeEvent; //布阵变化 位置，列表的起飞索引，起飞坐标


    // 【阵容属性】 - 该阵容所有武将有效
    // 初始加成    lineupInitAddPer
    // 升级加成    lineupLVAddPer
    // 突破加成    lineupBreakLVAddPer
    // 吞噬加成    lineupStarAddPer
    // 阵容光环    lineupHaloValue 、 lineupHaloPer

    /// <summary>
    /// 按队伍汇总上阵属性
    /// </summary>
    /// <param name="type"></param>
    /// <param name="isPreview">true 客户端预览阵容，默认false 服务器阵容</param>
    /// <returns></returns>
    public Dictionary<string, int> GetLineupPer(TeamType type, bool isPreview = false)
    {
        Dictionary<string, int> lineUPPer = new Dictionary<string, int>()
        {
            {"lineupInitAddPer", 0},
            {"lineupLVAddPer", 0},
            {"lineupBreakLVAddPer", 0},
            {"lineupStarAddPer", 0},
        };

        var team = TeamManager.Instance.GetTeam(type);
        if (team == null)
        {
            return lineUPPer;
        }
        TeamHero[] teamHeroes = isPreview ? team.tempHeroes : team.serverHeroes;

        foreach (var teamHero in teamHeroes)
        {
            if (teamHero == null)
            {
                continue;
            }
            var config = HeroQualityConfig.Get(HeroConfig.Get(teamHero.heroId).Quality);
            lineUPPer["lineupInitAddPer"] += config.InitAddPer;

            HeroInfo hero = HeroManager.Instance.GetHero(teamHero.guid);
            if (hero == null) continue;
            lineUPPer["lineupLVAddPer"] += hero.GetLineupLVAddPer();
            lineUPPer["lineupBreakLVAddPer"] += hero.GetLineupBreakLVAddPer();
            lineUPPer["lineupStarAddPer"] += hero.GetLineupStarAddPer();

        }
        return lineUPPer;
    }

    /// <summary>
    /// 按队伍获得阵型（国家光环）属性
    /// </summary>
    /// <param name="teamType"></param>
    /// <param name="isPreview">true 客户端预览阵容，默认false 服务器阵容</param>
    /// <returns></returns>
    public Dictionary<int, int> GetCountryAttrs(TeamType teamType, bool isPreview = false)
    {
        Dictionary<int, int> countryAttrs = new Dictionary<int, int>();
        Int2 result = GetMaxCountHeroCountry(teamType, isPreview);
        var lineupconfig = HeroLineupHaloConfig.GetConfig(result.x, result.y);
        if (lineupconfig != null)
        {
            for (int i = 0; i < lineupconfig.AttrIDList.Length; i++)
            {
                countryAttrs[lineupconfig.AttrIDList[i]] = lineupconfig.AttrValueList[i];
            }
        }

        return countryAttrs;
    }

    public void SortHeroOnTeamList()
    {
        heroOnTeamSortList = HeroManager.Instance.GetHeroGuidList(selectTeamPosJob, selectTeamPosCountry);
        heroOnTeamSortList.Sort(CmpHeroByTeamType);
    }


    int CmpHeroByTeamType(string guidA, string guidB)
    {
        HeroInfo heroA = HeroManager.Instance.GetHero(guidA);
        HeroInfo heroB = HeroManager.Instance.GetHero(guidB);
        if (heroA == null || heroB == null)
        {
            return 0;
        }

        var team = TeamManager.Instance.GetTeam(selectTeamType);
        // 排序规则：上阵>武将等级＞突破等级＞武将觉醒阶级＞武将品质＞武将吞噬星级＞武将ID
        bool isInTeamA = team.HasHeroInServer(guidA);
        bool isInTeamB = team.HasHeroInServer(guidB);
        if (isInTeamA != isInTeamB)
        {
            return isInTeamA ? -1 : 1;
        }
        if (heroA.heroLevel != heroB.heroLevel)
        {
            return heroA.heroLevel > heroB.heroLevel ? -1 : 1;
        }
        if (heroA.breakLevel != heroB.breakLevel)
        {
            return heroA.breakLevel > heroB.breakLevel ? -1 : 1;
        }
        if (heroA.awakeLevel != heroB.awakeLevel)
        {
            return heroA.awakeLevel > heroB.awakeLevel ? -1 : 1;
        }
        if (heroA.Quality != heroB.Quality)
        {
            return heroA.Quality > heroB.Quality ? -1 : 1;
        }
        if (heroA.heroStar != heroB.heroStar)
        {
            return heroA.heroStar > heroB.heroStar ? -1 : 1;
        }

        return heroA.heroId.CompareTo(heroB.heroId);
    }




    /// <summary>
    /// 上阵队伍中各个国家的武将数量
    /// </summary>
    /// <param name="teamType"></param>
    /// <param name="isPreview">true 客户端预览阵容，默认false 服务器阵容</param>
    /// <returns></returns>
    public Dictionary<HeroCountry, int> GetCountryHeroCountByTeamType(TeamType teamType, bool isPreview = false)
    {
        Dictionary<HeroCountry, int> heroCountryCount = new Dictionary<HeroCountry, int>();

        var team = TeamManager.Instance.GetTeam(teamType);
        if (team == null)
        { 
            return heroCountryCount;
        }
        TeamHero[] teamHeroes = isPreview ? team.tempHeroes : team.serverHeroes;

        for (int i = 0; i < teamHeroes.Length; i++)
        {
            if (teamHeroes[i] == null)
                continue;
            var country = teamHeroes[i].Country;

            if (!heroCountryCount.ContainsKey(country))
            {
                heroCountryCount.Add(country, 1);
            }
            else
            {
                heroCountryCount[country] += 1;
            }

        }


        return heroCountryCount;
    }

    /// <summary>
    /// 获得上阵中武将数量最大的国家和数量
    /// </summary>
    /// <param name="teamType"></param>
    /// <param name="isPreview">true 客户端预览阵容，默认false 服务器阵容</param>
    /// <returns></returns>
    public Int2 GetMaxCountHeroCountry(TeamType teamType, bool isPreview = false)
    {
        var countryCountDict = GetCountryHeroCountByTeamType(teamType, isPreview);
        //找到最大的国家和数量
        HeroCountry country = HeroCountry.None;
        int maxValue = 0;
        foreach (var data in countryCountDict)
        {
            if (data.Value > maxValue)
            {
                country = data.Key;
                maxValue = data.Value;
            }
        }
        return new Int2((int)country, maxValue);
    }

    //在不同页签下选AttackType 0 攻击阵容 1 防守阵容
    public int GetSelectTeamTypeByAttackType(int AttackType)
    {
        if (selectTeamType == TeamType.Arena || selectTeamType == TeamType.ArenaDefense)
        {
            return AttackType == 0 ? (int)TeamType.Arena : (int)TeamType.ArenaDefense;
        }


        return (int)TeamType.Story;
    }


    public void NotifyOnTeamPosChangeEvent(List<int> posList, int flyIndex, Vector3 startPos)
    {
        OnTeamPosChangeEvent?.Invoke(posList, flyIndex, startPos);
    }

    //推荐阵容
    public List<string> SelectRecommend()
    {
        //推荐阵容的算法逻辑
        //自动选择优先级：武将等级＞突破等级＞武将觉醒阶级＞武将品质＞武将吞噬星级＞武将ID
        var tmpList = HeroManager.Instance.GetHeroGuidList();
        tmpList.Sort(CmpHeroRecommend);


        //推荐最多6个，存在相同heroid，则跳过
        List<string> selectHeroList = new List<string>();
        List<int> selectHeroIDList = new List<int>();
        for (int i = 0; i < tmpList.Count; i++)
        {
            if (selectHeroList.Count >= TeamConst.MaxTeamHeroCount)
                break;

            string guid = tmpList[i];
            HeroInfo heroInfo = HeroManager.Instance.GetHero(guid);
            if (selectHeroIDList.Contains(heroInfo.heroId))
                continue;
            //如果重复了,跳过
            if (selectHeroList.Contains(guid))
                continue;
            selectHeroList.Add(guid);
            selectHeroIDList.Add(heroInfo.heroId);
        }
        return selectHeroList;
    }


    int CmpHeroRecommend(string guidA, string guidB)
    {
        HeroInfo heroA = HeroManager.Instance.GetHero(guidA);
        HeroInfo heroB = HeroManager.Instance.GetHero(guidB);
        if (heroA == null || heroB == null)
        {
            return 0;
        }

        // 排序规则：武将等级＞突破等级＞武将觉醒阶级＞武将品质＞武将吞噬星级＞武将ID
        if (heroA.heroLevel != heroB.heroLevel)
        {
            return heroA.heroLevel > heroB.heroLevel ? -1 : 1;
        }
        if (heroA.breakLevel != heroB.breakLevel)
        {
            return heroA.breakLevel > heroB.breakLevel ? -1 : 1;
        }
        if (heroA.awakeLevel != heroB.awakeLevel)
        {
            return heroA.awakeLevel > heroB.awakeLevel ? -1 : 1;
        }
        if (heroA.Quality != heroB.Quality)
        {
            return heroA.Quality > heroB.Quality ? -1 : 1;
        }
        if (heroA.heroStar != heroB.heroStar)
        {
            return heroA.heroStar > heroB.heroStar ? -1 : 1;
        }

        return heroA.heroId.CompareTo(heroB.heroId);
    }


    #endregion

    
}