using System.Threading.Tasks;
using Common.Utility.CombatEvent;
using Core.Utility;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Combat.CombatTool;
using GameLogic.Hero;
using UnityEngine;
using UnityEngine.UI;
using Utility;

namespace Fort23.Mono
{
    [UIBinding(prefab = "WidgetHero")]
    public partial class WidgetHero : UIComponent
    {
        private bool _isSelectHeroCame;
        public HeroInfo heroInfo;

        private CombatHeroEntity _combatHeroEntity;

        private bool isUseSkill;
        private void Init()
        {
            SetMoreBtnActive(false);
        }

        public override void AddEvent()
        {
            // EventManager.Instance.AddEventListener(CustomEventType.HeroClick, HeroClickEvent);
            EventManager.Instance.AddEventListener(CustomEventType.HeroPowerUp, OnHeroPowerUp);
            CombatEventManager.Instance.AddEventListener(CombatEventType.HeroDie, HeroDie);
            CombatEventManager.Instance.AddEventListener(CombatEventType.HeroResurrection, HeroResurrection);
            CombatEventManager.Instance.AddEventListener(CombatEventType.HeroResurrection, HeroResurrection);
            CombatEventManager.Instance.AddEventListener(CombatEventType.UseSkill, UseSkill);
            StaticUpdater.Instance.AddRenderUpdateCallBack(Update);
        }

        public override void DelEvent()
        {
            // EventManager.Instance.RemoveEventListener(CustomEventType.HeroClick, HeroClickEvent);
            EventManager.Instance.RemoveEventListener(CustomEventType.HeroPowerUp, OnHeroPowerUp);
            CombatEventManager.Instance.RemoveEventListener(CombatEventType.HeroDie, HeroDie);
            CombatEventManager.Instance.RemoveEventListener(CombatEventType.HeroResurrection, HeroResurrection);
            CombatEventManager.Instance.RemoveEventListener(CombatEventType.UseSkill, UseSkill);
            StaticUpdater.Instance.RemoveRenderUpdateCallBack(Update);
            _combatHeroEntity = null;
        }

        public override void AddButtonEvent()
        {
            // LogTool.Log("添加英雄点击事件");
            btnHero.onClick.AddListener(OnHeroClick);
            btnUpgrade.onClick.AddListener(OnUpgradeClick);
            btnHeroPanel.onClick.AddListener(OnHeroPanelClick);
            Button_came.onClick.AddListener(OnHeroClickCame);
        }

        private void Update()
        {
          
            if (heroInfo == null || CombatController.currActiveCombat == null ||
                CombatController.currActiveCombat.CombatHeroController == null)
            {
                return;
            }

            if (_combatHeroEntity == null)
            {
                _combatHeroEntity =
                    CombatController.currActiveCombat.CombatHeroController.GetHeroForId(heroInfo.modelID);
            }

            if (_combatHeroEntity == null || _combatHeroEntity.CombatHeroSkillControl.currCdSkill == null)
            {
                return;
            }
            //
            // if (isUseSkill && _combatHeroEntity.CombatHeroSkillControl.currUseSkill !=
            //     _combatHeroEntity.CombatHeroSkillControl.currCdSkill)
            // {
            //     isUseSkill = false;
            //     WidgetHeroTwenn.Play("skillFinish", false);
            // }

            float bl = _combatHeroEntity.CombatHeroSkillControl.currCdSkill.SkillCd /
                       _combatHeroEntity.CombatHeroSkillControl.currCdSkill.SkillMaxCd;
            bl = 1 - Mathf.Clamp(bl, 0, 1);
            skillCdIcon.rectTransform.sizeDelta = new Vector2(134 * bl, skillCdIcon.rectTransform.sizeDelta.y);
        }

        private void UseSkill(IEventData eventData)
        {
            CombatUseSkillEventData combatUseSkillEventData = eventData as CombatUseSkillEventData;
            if (combatUseSkillEventData.useSkill.CombatHeroEntity.CurrCombatHeroInfo.modelID == heroInfo.modelID &&
                combatUseSkillEventData.useSkill.SelfSkillConfig.SkillType == 2)
            {
                isUseSkill = true;
                WidgetHeroTwenn.Play("skillShow", false);
            }
        }


        private void HeroResurrection(IEventData eventData)
        {
            HeroResurrectionEventData heroResurrectionEventData = eventData as HeroResurrectionEventData;
            if (this.heroInfo.modelID == heroResurrectionEventData.combatHeroEntity.CurrCombatHeroInfo.modelID)
            {
                UIManager.Instance.SetGray(own, false, true);
            }
        }

        private void HeroDie(IEventData eventData)
        {
            HeroDieEventData data = eventData as HeroDieEventData;

            if (this.heroInfo.modelID == data.combatHeroEntity.CurrCombatHeroInfo.modelID)
            {
                UIManager.Instance.SetGray(own, true, true);
            }
        }

        private void OnHeroPowerUp(IEventData eventData)
        {
            HeroPowerUpEventData data = eventData as HeroPowerUpEventData;

            if (data.upType == HeroUpType.BasicEquip)
            {
                return;
            }

            HeroInfo heroInfo = (HeroInfo)PlayerManager.Instance.heroController.GetHeroInfo(data.heroModelID);

            if (this.heroInfo.modelID == heroInfo.modelID)
            {
                UpdateWidgetUI(heroInfo);
            }
        }

        // private void HeroClickEvent(IEventData iEventData)
        // {
        //     HeroClickEventData heroClickEventData = iEventData as HeroClickEventData;
        //     if (heroClickEventData.heroId == heroInfo.modelID)
        //     {
        //         if (_isSelectHeroCame)
        //         {
        //             Button_came_icon.color = Color.white;
        //         }
        //         else
        //         {
        //             Button_came_icon.color = Color.green;
        //         }
        //
        //         _isSelectHeroCame = !_isSelectHeroCame;
        //     }
        //     else
        //     {
        //         if (_isSelectHeroCame)
        //         {
        //             Button_came_icon.color = Color.white;
        //         }
        //
        //         _isSelectHeroCame = false;
        //     }
        // }

        private void OnUpgradeClick()
        {
            // throw new System.NotImplementedException();
            HeroUpResultType resultType = PlayerManager.Instance.heroController.UpgradeHeroLogic(heroInfo);
            //PlayerManager.Instance.heroController.CanUpgrade(heroInfo)
            if (resultType == HeroUpResultType.Success)
            {
                txtUpgrade.color = Color.white;
            }
            else
            {
                txtUpgrade.color = Color.red;
            }
        }

        private async void OnHeroPanelClick()
        {
            // throw new System.NotImplementedException();
            await OpenHeroDetailPanel();
        }

        public void SetMoreBtnActive(bool isActive)
        {
            btnUpgrade.gameObject.SetActive(isActive);
            btnHeroPanel.gameObject.SetActive(isActive);
        }

        private async void OnHeroClickCame()
        {
            HeroClickEventData heroClickEventData = HeroClickEventData.Create();
            heroClickEventData.heroId = heroInfo.modelID;
            EventManager.Instance.Dispatch(CustomEventType.HeroClick, heroClickEventData);
        }

        private async void OnHeroClick()
        {
            // OffsetPos();
            await OpenHeroDetailPanel();
        }

        private void OffsetPos()
        {
            Vector3 curPos = transform.parent.localPosition;
            Vector3 newPos;
            if (curPos.y == 0)
            {
                newPos = new Vector3(curPos.x, curPos.y + GlobalParam.Hero_Pos_Offset, curPos.z);
                SetMoreBtnActive(true);
                txtUpgrade.text = heroInfo.powerUpConfig.levelUpExp.ToStringEx();
                if (PlayerManager.Instance.heroController.CanUpgrade(heroInfo) == HeroUpResultType.Success)
                {
                    txtUpgrade.color = Color.white;
                }
                else
                {
                    txtUpgrade.color = Color.red;
                }
            }
            else
            {
                newPos = new Vector3(curPos.x, curPos.y - GlobalParam.Hero_Pos_Offset, curPos.z);
                SetMoreBtnActive(false);
            }

            transform.parent.localPosition = newPos;
            MainSceneController.Instance.mainUI?.RestWidgetHeroPos(this);
        }

        private async Task OpenHeroDetailPanel()
        {
            // HeroDetailPanel heroDetailPanel = UIManager.Instance.GetComponent<HeroDetailPanel>();
            // if (heroDetailPanel == null)
            // {
            //     heroDetailPanel = await UIManager.Instance.LoadAndOpenPanel<HeroDetailPanel>(Callback);
            // }
            UIPanelName current = UIPanelName.MainPanel;
            HeroDetailPanel heroDetailPanel =
                await UIManager.Instance.LoadAndOpenPanel<HeroDetailPanel>(Callback, isFullUI: true);
            heroDetailPanel.InitHeroDetailPanel(this, current);
        }

        private void Callback(HeroDetailPanel obj)
        {
            LogTool.Log("HeroDetailPanel 加载完成");
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="heroInfo"></param>
        public void InitHero(HeroInfo heroInfo)
        {
            this.heroInfo = heroInfo;
            SetBasicData();
            SetDynamicData();
        }

        public void InitHeroForBag(HeroInfo heroInfo)
        {
            this.heroInfo = heroInfo;
            SetBasicData();
            SetDynamicData();
            // Button_came_icon.gameObject.SetActive(false);
        }

        private void SetBasicData()
        {
            iconHero.icon_name = heroInfo.modelConfig.headicon;
            iconZhiYe.icon_name = HeroUITools.GetZyIcon(heroInfo.modelConfig.profession);
            //heroInfo.iconZhiYe;
        }

        public void UpdateWidgetUI(HeroInfo heroInfo)
        {
            this.heroInfo = heroInfo;
            SetDynamicData();
        }

        public void SetDynamicData()
        {
            lv.text = heroInfo.level.Value.ToString();
            HeroUITools.SetStarShow(stars, heroInfo.star.Value);
        }
    }
}