using System.Collections.Generic;
using Common.Utility.CombatEvent;
using Core.Utility;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Bag;

namespace GameLogic.Hero
{
    public class HeroController
    {
        /// <summary>
        /// 所有英雄
        /// </summary>
        public Dictionary<int, HeroInfo> allHeroDic = new Dictionary<int, HeroInfo>();
        

        /// <summary>
        /// 也可以叫主力(afk的共鸣英雄)，替补英雄等级=主力英雄的最低等级（和afk一样的）
        /// 主力英雄不一定等于上阵英雄，主力英雄只是决定了共鸣等级
        /// </summary>
        public Dictionary<int, HeroInfo> heroDicInLead = new Dictionary<int, HeroInfo>(4);

        /// <summary>
        /// 后备英雄(共享等级)
        /// </summary>
        public Dictionary<int, HeroInfo> heroDicInBack = new Dictionary<int, HeroInfo>();

        public int mainLevel => m_MainLevel;
    

        private int m_MainLevel;


        private void CalMainLevel()
        {
            //主力英雄不足4个时，就没有主力等级的说法
            if (heroDicInLead.Count < GlobalParam.Max_Deploy_HERO)
            {
                m_MainLevel = -1;
                return;
            }

            //计算主力英雄的最低等级
            int tmpLv = 9999;
            foreach (var keyValuePair in heroDicInLead)
            {
                if (keyValuePair.Value.level.Value < tmpLv)
                {
                    tmpLv = keyValuePair.Value.level.Value;
                }
            }
            
            m_MainLevel = tmpLv;
        }

        public HeroUpResultType CanUpgrade(HeroInfo heroInfo)
        {
            if (PlayerManager.Instance.gameConstantConfig.maxLv <= heroInfo.level.Value)
            {
                LogTool.Log("已到达最高等级:" + PlayerManager.Instance.gameConstantConfig.maxLv);
                return HeroUpResultType.MaxLv;
            }
            
            //计算主力英雄等级差, 如果再升一级，就大于最大等级差了，就不允许升了.
            if ((heroInfo.level.Value) - m_MainLevel >= GlobalParam.Max_Main_Level_Difference)
            {
                LogTool.Log(heroInfo.modelID + "主力英雄等级差不能超过:" + GlobalParam.Max_Main_Level_Difference);
                return HeroUpResultType.MainLevelNotEnough;
            }
            
            if (BagController.Instance.IsEnough(GlobalParam.Item_HeroExp_ID, heroInfo.powerUpConfig.levelUpExp))
            {
                return HeroUpResultType.Success;
            }
            else
            {
                return HeroUpResultType.ExpNotEnough;    
            }
        }

        /// <summary>
        /// 英雄升级逻辑，主要是改数据，不在这里做UI表现
        /// </summary>
        /// <param name="heroInfo"></param>
        public HeroUpResultType UpgradeHeroLogic(HeroInfo heroInfo)
        {
            HeroUpResultType resultType = CanUpgrade(heroInfo);
            if (resultType == HeroUpResultType.Success && 
                BagController.Instance.DuctHeroExp(heroInfo.powerUpConfig.levelUpExp))
            {
                heroInfo.Upgrade();
                
                //如果当前英雄等级等于主力等级，则升级时需要重新计算主力等级
                if (heroInfo.level.Value - 1 == m_MainLevel)
                {
                    CalMainLevel();
                }
                
                SendEvent(HeroUpType.Level, heroInfo, HeroUpResultType.Success);
                return HeroUpResultType.Success;
            }
            return resultType;
        }
        
        /// <summary>
        /// 发送英雄提升的事件
        /// </summary>
        /// <param name="upType">提升类型：升级、升星等.</param>
        private void SendEvent(HeroUpType upType, HeroInfo heroInfo, HeroUpResultType resultType = HeroUpResultType.None)
        {
            HeroPowerUpEventData data = new HeroPowerUpEventData();
            data.heroModelID = heroInfo.modelID;
            data.upType = upType;
            data.ResultType = resultType;
            
            PlayerManager.Instance.lastHeroInfo = heroInfo;
            EventManager.Instance.Dispatch(CustomEventType.HeroPowerUp, data);
            if (upType == HeroUpType.Level)
            {
                EventManager.Instance.Dispatch(CustomEventType.HeroLvUp, data);
            }
            else if (upType == HeroUpType.Promote)
            {
                EventManager.Instance.Dispatch(CustomEventType.HeroPromote, data);
            }
            
        }
        
        public void InitHeroes()
        {
            for (int i = 0; i < AccountFileInfo.Instance.playerData.HeroListData.Count; i++)
            {
                AccountFileInfo.HeroData heroData = AccountFileInfo.Instance.playerData.HeroListData[i];
                HeroInfo heroInfo = new HeroInfo();
                heroInfo.InitHero(heroData);
            
                AddHero(heroInfo);
            }
            
            CalMainLevel();
        }
        
        /// <summary>
        /// 获取英雄
        /// </summary>
        /// <param name="modelID">英雄ID modelID</param>
        /// <returns></returns>
        public CombatHeroInfo GetHeroInfo(int modelID)
        {

            if (allHeroDic.ContainsKey(modelID))
            {
                return allHeroDic[modelID];
            }
            
            LogTool.Error("没有这个英雄" + modelID);
            return null;
        }
        
        
        /// <summary>
        /// 添加英雄
        /// </summary>
        /// <param name="heroInfo"></param>
        public void AddHero(HeroInfo heroInfo)
        {
            if (heroInfo.isLead)
            {
                DeployHeroToLead(heroInfo);
            }
            else
            {
                DeployHeroToBack(heroInfo);
            }
        }

        /// <summary>
        /// 进入主力队伍
        /// </summary>
        /// <param name="heroInfo"></param>
        public void DeployHeroToLead(HeroInfo heroInfo)
        {
            if (heroDicInLead.Count >= GlobalParam.Max_Deploy_HERO)
            {
                return;
            }

            if (heroDicInLead.ContainsKey(heroInfo.modelID))
            {
                LogTool.Error("heroDicInLead不应该出现相同的英雄ID=" + heroInfo.modelID);
                return;
            }
            
            heroDicInLead.Add(heroInfo.modelID, heroInfo);
            heroInfo.isLead = true;
            
            allHeroDic.Add(heroInfo.modelID, heroInfo);
        }

        /// <summary>
        /// 更换主力
        /// </summary>
        /// <param name="heroInfo"></param>
        public void ChangeLeadHero(HeroInfo backHero, HeroInfo leadHero)
        {
            if (!heroDicInLead.ContainsKey(leadHero.modelID))
            {
                LogTool.Error("不是主力" + leadHero.modelID);
                return;
            }
            
            if (!heroDicInBack.ContainsKey(backHero.modelID))
            {
                LogTool.Error("不是替补" + backHero.modelID);
                return;
            }
            
            //从主力中移除，并加入后补
            heroDicInLead.Remove(leadHero.modelID);
            DeployHeroToBack(leadHero);

            //从后补中移除，并加入主力
            heroDicInBack.Remove(backHero.modelID);
            DeployHeroToLead(backHero);
            
            
        }
        
        /// <summary>
        /// 进入后备队伍（英雄背包）
        /// </summary>
        /// <param name="heroInfo"></param>
        public void DeployHeroToBack(HeroInfo heroInfo)
        {
            if (heroDicInBack.ContainsKey(heroInfo.modelID))
            {
                LogTool.Error("heroDicInBack不应该出现相同的英雄ID=" + heroInfo.modelID);
                return;
            }
            
            heroDicInBack.Add(heroInfo.modelID, heroInfo);
            heroInfo.isLead = false;
            
            allHeroDic.Add(heroInfo.modelID, heroInfo);
        }
        
        
        
    }
}