using GameFramework.Event;
using GeometryTD.CustomEvent;
using GeometryTD.Definition;
using UnityEngine;
using UnityGameFramework.Runtime;

namespace GeometryTD.UI
{
    public partial class CombatSelectFormController : UIFormControllerCommonBase<CombatSelectFormContext, CombatSelectForm>
    {
        private CombatSelectFormUseCase _useCase;

        protected override UIFormType UIFormTypeId => UIFormType.CombatSelectForm;

        protected override void RefreshUI(CombatSelectForm form, CombatSelectFormContext context)
        {
            form.RefreshUI(context);
        }

        protected override void SubscribeCustomEvents()
        {
            GameEntry.Event.Subscribe(CombatSelectItemClickEventArgs.EventId, OnSelectItemClicked);
            GameEntry.Event.Subscribe(CombatCoinChangedEventArgs.EventId, OnCombatCoinChanged);
        }

        protected override void UnsubscribeCustomEvents()
        {
            GameEntry.Event.Unsubscribe(CombatSelectItemClickEventArgs.EventId, OnSelectItemClicked);
            GameEntry.Event.Unsubscribe(CombatCoinChangedEventArgs.EventId, OnCombatCoinChanged);
        }

        public int? OpenUI(CombatSelectFormRawData rawData)
        {
            CombatSelectFormContext context = BuildContext(rawData);
            if (context == null || !context.IsVisible)
            {
                CloseUI();
                return null;
            }

            return OpenUIInternal(context);
        }

        public override int? OpenUI(object userData = null)
        {
            if (userData is CombatSelectFormUserData clickUserData)
            {
                return OpenUI(clickUserData);
            }

            if (userData is CombatSelectFormContext context)
            {
                if (context == null || !context.IsVisible)
                {
                    CloseUI();
                    return null;
                }

                return OpenUIInternal(context);
            }

            if (userData is CombatSelectFormRawData rawDataFromUserData)
            {
                return OpenUI(rawDataFromUserData);
            }

            if (userData != null)
            {
                Log.Warning("CombatSelectFormController.OpenUI() userData type is invalid.");
                return null;
            }

            if (_useCase == null)
            {
                Log.Error("CombatSelectFormController.OpenUI() useCase is null.");
                return null;
            }

            CombatSelectFormRawData rawData = _useCase.CreateInitialModel();
            return OpenUI(rawData);
        }

        public int? OpenUI(CombatSelectFormUserData userData)
        {
            if (_useCase == null)
            {
                Log.Error("CombatSelectFormController.OpenUI() useCase is null.");
                return null;
            }

            if (userData == null)
            {
                _useCase.Hide();
                CloseUI();
                return null;
            }

            switch (userData.ClickObjectType)
            {
                case CombatSelectClickObjectType.Foundation:
                    _useCase.SetUpgradeVisible(true);
                    _useCase.ShowForFoundation(userData.ScreenPosition);
                    break;
                case CombatSelectClickObjectType.Tower:
                    _useCase.SetUpgradePrice(userData.UpgradeCost);
                    _useCase.SetUpgradeVisible(!userData.IsTowerAtMaxLevel);
                    _useCase.SetDestroyGain(userData.DestroyGain);
                    _useCase.ShowForTower(userData.ScreenPosition);
                    break;
                default:
                    _useCase.Hide();
                    CloseUI();
                    return null;
            }

            return OpenUI(_useCase.TryRefresh());
        }

        public override void BindUseCase(IUIUseCase useCase)
        {
            if (!(useCase is CombatSelectFormUseCase combatSelectFormUseCase))
            {
                Log.Error("CombatSelectFormController.BindUseCase() useCase is invalid.");
                return;
            }

            _useCase = combatSelectFormUseCase;
        }

        public int? ShowForFoundation(Vector2 screenPosition)
        {
            if (_useCase == null)
            {
                Log.Error("CombatSelectFormController.ShowForFoundation() useCase is null.");
                return null;
            }

            _useCase.SetUpgradeVisible(true);
            _useCase.ShowForFoundation(screenPosition);
            return OpenUI(_useCase.TryRefresh());
        }

        public int? ShowForTower(Vector2 screenPosition, int upgradeCost, int destroyGain)
        {
            if (_useCase == null)
            {
                Log.Error("CombatSelectFormController.ShowForTower() useCase is null.");
                return null;
            }

            _useCase.SetUpgradePrice(upgradeCost);
            _useCase.SetUpgradeVisible(true);
            _useCase.SetDestroyGain(destroyGain);
            _useCase.ShowForTower(screenPosition);
            return OpenUI(_useCase.TryRefresh());
        }

        public void HideSelection()
        {
            _useCase?.Hide();
            CloseUI();
        }

        public void RefreshFromUseCase()
        {
            if (_useCase == null)
            {
                return;
            }

            CombatSelectFormRawData rawData = _useCase.TryRefresh();
            CombatSelectFormContext context = BuildContext(rawData);
            if (context == null || !context.IsVisible)
            {
                CloseUI();
                return;
            }

            SetContext(context);
            RefreshCurrentUI();
        }

        private void OnSelectItemClicked(object sender, GameEventArgs e)
        {
            if (!(e is CombatSelectItemClickEventArgs args))
            {
                return;
            }

            if (_useCase == null)
            {
                return;
            }

            if (Form != null && sender is Component component)
            {
                CombatSelectForm ownerForm = component.GetComponentInParent<CombatSelectForm>();
                if (ownerForm != Form)
                {
                    return;
                }
            }

            _useCase.TryExecuteAction(args.ActionType, args.ActionIndex);
            RefreshFromUseCase();
        }

        private void OnCombatCoinChanged(object sender, GameEventArgs e)
        {
            if (!(e is CombatCoinChangedEventArgs))
            {
                return;
            }

            if (Form == null)
            {
                return;
            }

            RefreshFromUseCase();
        }
    }
}