vampire-like/Assets/GameMain/Scripts/Presentation/Menu/SelectRole/SelectRoleController.cs

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

namespace SepCore.UI
{
    public class SelectRoleController : UIControllerBase<SelectRoleContext, SelectRoleForm>
    {
        private SelectRoleUseCase _useCase;

        protected override UIFormType UIFormType => UIFormType.SelectRoleForm;

        protected override void RefreshUI(SelectRoleForm form, SelectRoleContext context)
        {
            form.RefreshUI(context);
        }

        protected override void SubscribeCustomEvents()
        {
            GameEntry.Event.Subscribe(SelectRoleReturnEventArgs.EventId, OnSelectRoleReturn);
            GameEntry.Event.Subscribe(SelectRoleHoverEventArgs.EventId, OnSelectRoleHover);
            GameEntry.Event.Subscribe(SelectRoleConfirmEventArgs.EventId, OnMenuSelectRoleConfirm);
        }

        protected override void UnsubscribeCustomEvents()
        {
            GameEntry.Event.Unsubscribe(SelectRoleReturnEventArgs.EventId, OnSelectRoleReturn);
            GameEntry.Event.Unsubscribe(SelectRoleHoverEventArgs.EventId, OnSelectRoleHover);
            GameEntry.Event.Unsubscribe(SelectRoleConfirmEventArgs.EventId, OnMenuSelectRoleConfirm);
        }

        private static SelectRoleContext BuildContext(SelectRoleRawData rawData)
        {
            if (rawData == null)
            {
                Log.Error("SelectRoleController.BuildContext() rawData is null.");
                return null;
            }

            int count = rawData.RoleItems?.Length ?? 0;
            RoleItemContext[] roleItems = new RoleItemContext[count];
            for (int i = 0; i < count; i++)
            {
                RoleItemRawData itemRawData = rawData.RoleItems[i];
                roleItems[i] = new RoleItemContext
                {
                    RoleId = itemRawData.RoleId,
                    IconName = itemRawData.IconName
                };
            }

            RolePropertyAreaContext propertyContext = null;
            if (rawData.SelectedRole != null)
            {
                propertyContext = new RolePropertyAreaContext
                {
                    RoleName = rawData.SelectedRole.RoleName,
                    InitialPropertyText = ItemDescUtility.CreatePropDescription(rawData.SelectedRole.InitialProperties)
                        ?? string.Empty
                };
            }

            return new SelectRoleContext
            {
                RoleItemContexts = roleItems,
                RolePropertyAreaContext = propertyContext,
                ShowRoleProperty = propertyContext != null
            };
        }

        public override async UniTask OpenUIAsync(object userData = null, float timeout = 30f)
        {
            if (userData is SelectRoleRawData rawData)
            {
                await OpenUIAsync(rawData, timeout);
                return;
            }

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

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

            SelectRoleRawData initialRawData = _useCase.CreateModel();
            await OpenUIAsync(initialRawData, timeout);
        }

        public async UniTask<int?> OpenUIAsync(SelectRoleRawData rawData, float timeout = 30f)
        {
            SelectRoleContext context = BuildContext(rawData);
            return await OpenFormAsync(context, timeout);
        }

        public override void BindUseCase(IUIUseCase useCase)
        {
            if (useCase is not SelectRoleUseCase selectRoleUseCase)
            {
                Log.Error("SelectRoleUseCase.BindUseCase() useCase is invalid.");
                return;
            }

            _useCase = selectRoleUseCase;
        }

        public void UpdateShowRole(RolePropertyAreaContext rolePropertyAreaContext)
        {
            if (Context == null)
            {
                Log.Error("SelectRoleController.UpdateShowRole() Context is null.");
                return;
            }

            Context.RolePropertyAreaContext = rolePropertyAreaContext;
            Context.ShowRoleProperty = rolePropertyAreaContext != null;

            Form?.UpdateShowRole(Context.ShowRoleProperty, rolePropertyAreaContext);
        }

        private bool IsCurrentFormEventSender(object sender)
        {
            if (sender is SelectRoleForm selectRoleForm)
            {
                return selectRoleForm == Form;
            }

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

            return false;
        }

        private void OnSelectRoleReturn(object sender, GameEventArgs e)
        {
            if (sender is not SelectRoleForm selectRoleForm || selectRoleForm != Form)
            {
                return;
            }

            if (e is not SelectRoleReturnEventArgs)
            {
                return;
            }

            CloseUIAsync().Forget();
        }

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

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

            OnSelectRoleHoverAsync(args).Forget();
        }

        private async UniTaskVoid OnSelectRoleHoverAsync(SelectRoleHoverEventArgs args)
        {
            if (_useCase == null)
            {
                Log.Error("SelectRoleController.OnMenuSelectRoleSelected() useCase is null.");
                return;
            }

            SelectRoleRawData rawData = _useCase.SelectRole(args.RoleId);
            await OpenUIAsync(rawData);
        }

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

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

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

            _useCase.ConfirmSelectedRole();
        }
    }
}