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

namespace GeometryTD.UI
{
    public partial class RewardSelectFormController : UIFormControllerCommonBase<RewardSelectFormContext, RewardSelectForm>
    {
        private RewardSelectFormUseCase _useCase;

        protected override UIFormType UIFormTypeId => UIFormType.RewardSelectForm;

        protected override void RefreshUI(RewardSelectForm form, RewardSelectFormContext context)
        {
            form.RefreshUI(context);
        }

        protected override void SubscribeCustomEvents()
        {
            GameEntry.Event.Subscribe(RewardSelectItemSelectedEventArgs.EventId, OnRewardSelected);
            GameEntry.Event.Subscribe(RewardSelectRefreshEventArgs.EventId, OnRefreshClicked);
            GameEntry.Event.Subscribe(RewardSelectGiveUpEventArgs.EventId, OnGiveUpClicked);
        }

        protected override void UnsubscribeCustomEvents()
        {
            GameEntry.Event.Unsubscribe(RewardSelectItemSelectedEventArgs.EventId, OnRewardSelected);
            GameEntry.Event.Unsubscribe(RewardSelectRefreshEventArgs.EventId, OnRefreshClicked);
            GameEntry.Event.Unsubscribe(RewardSelectGiveUpEventArgs.EventId, OnGiveUpClicked);
        }

        public override int? OpenUI(object userData = null)
        {
            if (userData is RewardSelectFormContext context)
            {
                return OpenUIInternal(context);
            }

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

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

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

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

        public int? OpenUI(RewardSelectFormRawData rawData)
        {
            RewardSelectFormContext context = BuildContext(rawData);
            return OpenUIInternal(context);
        }

        public override void BindUseCase(IUIUseCase useCase)
        {
            if (!(useCase is RewardSelectFormUseCase rewardSelectUseCase))
            {
                Log.Error("RewardSelectFormController.BindUseCase() useCase is invalid.");
                return;
            }

            _useCase = rewardSelectUseCase;
        }

        private void OnRewardSelected(object sender, GameEventArgs e)
        {
            if (!IsEventFromCurrentForm(sender) || !(e is RewardSelectItemSelectedEventArgs args))
            {
                return;
            }

            if (_useCase == null)
            {
                return;
            }

            RewardSelectFormRawData nextRawData = _useCase.SelectReward(args.SelectedIndex);
            if (nextRawData == null)
            {
                CloseUI();
                return;
            }

            OpenUI(nextRawData);
        }

        private void OnRefreshClicked(object sender, GameEventArgs e)
        {
            if (!IsEventFromCurrentForm(sender) || !(e is RewardSelectRefreshEventArgs))
            {
                return;
            }

            if (_useCase == null)
            {
                return;
            }

            RewardSelectFormRawData nextRawData = _useCase.TryRotateSelection();
            if (nextRawData == null)
            {
                CloseUI();
                return;
            }

            OpenUI(nextRawData);
        }

        private void OnGiveUpClicked(object sender, GameEventArgs e)
        {
            if (!IsEventFromCurrentForm(sender) || !(e is RewardSelectGiveUpEventArgs))
            {
                return;
            }

            if (_useCase == null)
            {
                return;
            }

            if (_useCase.TryGiveUp())
            {
                CloseUI();
            }
        }

        private bool IsEventFromCurrentForm(object sender)
        {
            if (Form == null)
            {
                return false;
            }

            if (ReferenceEquals(sender, Form))
            {
                return true;
            }

            if (sender is Component component)
            {
                RewardSelectForm ownerForm = component.GetComponentInParent<RewardSelectForm>();
                return ownerForm == Form;
            }

            return false;
        }
    }
}