using System;
using Cysharp.Threading.Tasks;
using SepCore.Event;
using SepCore.Definition;
using GameFramework.Event;
using UnityEngine;
using UnityGameFramework.Runtime;

namespace SepCore.UI
{
    public class DisplayItemInfoController : UIControllerBase<DisplayItemInfoContext, DisplayItemInfoForm>
    {
        protected override UIFormType UIFormType => UIFormType.DisplayItemInfoForm;

        private bool _locked = false;
        private Action<int, int> _onRecycle;

        protected override void SubscribeCustomEvents()
        {
            GameEntry.Event.Subscribe(DisplayItemInfoLockEventArgs.EventId, DisplayItemInfoLock);
            GameEntry.Event.Subscribe(DisplayItemInfoHideEventArgs.EventId, DisplayItemInfoHide);
            GameEntry.Event.Subscribe(DisplayItemInfoRecycleEventArgs.EventId, DisplayItemInfoRecycle);
        }

        protected override void UnsubscribeCustomEvents()
        {
            GameEntry.Event.Unsubscribe(DisplayItemInfoLockEventArgs.EventId, DisplayItemInfoLock);
            GameEntry.Event.Unsubscribe(DisplayItemInfoHideEventArgs.EventId, DisplayItemInfoHide);
            GameEntry.Event.Unsubscribe(DisplayItemInfoRecycleEventArgs.EventId, DisplayItemInfoRecycle);
        }

        protected override void RefreshUI(DisplayItemInfoForm form, DisplayItemInfoContext context)
        {
            form.RefreshUI(context).Forget();
        }

        protected override void CloseLoadedFormDirect(DisplayItemInfoForm form)
        {
            GameEntry.UI.CloseUIForm(form);
        }

        private static DisplayItemInfoContext BuildContext(DisplayItemInfoRawData rawData)
        {
            if (rawData == null)
            {
                Log.Error("DisplayItemInfoFormController.BuildContext() rawData is null.");
                return null;
            }

            return new DisplayItemInfoContext(rawData);
        }

        public override async UniTask OpenUIAsync(object userData = null, float timeout = 30f)
        {
            if (userData is not DisplayItemInfoRawData rawData)
            {
                if (userData != null)
                {
                    Log.Warning("DisplayItemInfoController.OpenUIAsync() userData type is invalid.");
                }
                else
                {
                    Log.Warning("DisplayItemInfoController.OpenUIAsync() rawData is required.");
                }

                return;
            }

            DisplayItemInfoContext context = BuildContext(rawData);
            if (context == null)
            {
                Log.Warning("DisplayItemInfoController.OpenUIAsync() rawData is invalid.");
                return;
            }

            _onRecycle = rawData.OnRecycle;
            await OpenFormAsync(context, timeout);
        }

        public override async UniTask CloseUIAsync(object userData = null, float timeout = 30f)
        {
            _locked = false;
            _onRecycle = null;
            await base.CloseUIAsync(userData, timeout);
        }

        public override void BindUseCase(IUIUseCase useCase)
        {
            if (useCase != null)
            {
                Log.Warning("DisplayItemInfoController does not use a use case.");
            }
        }

        private bool IsCurrentFormSender(object sender)
        {
            if (sender is DisplayItemInfoForm displayItemInfoForm)
            {
                return displayItemInfoForm == Form;
            }

            if (sender is Component component && Form != null)
            {
                return component.transform.IsChildOf(Form.transform);
            }

            return false;
        }

        #region Event Handlers

        private void DisplayItemInfoLock(object sender, GameEventArgs e)
        {
            if (e is not DisplayItemInfoLockEventArgs)
            {
                return;
            }

            _locked = true;
        }

        private void DisplayItemInfoHide(object sender, GameEventArgs e)
        {
            if (e is not DisplayItemInfoHideEventArgs args)
            {
                return;
            }

            if (_locked && !args.Force) return;

            GameEntry.UIRouter.CloseUIAsync(UIFormType.DisplayItemInfoForm).Forget();
        }

        private void DisplayItemInfoRecycle(object sender, GameEventArgs e)
        {
            if (e is not DisplayItemInfoRecycleEventArgs args)
            {
                return;
            }

            if (!IsCurrentFormSender(sender))
            {
                return;
            }

            _onRecycle?.Invoke(args.Index, args.Price);
        }

        #endregion
    }
}