vampire-like/Assets/GameMain/Scripts/Presentation/Main/LevelUp/LevelUpController.cs

using System.Collections.Generic;
using Cysharp.Threading.Tasks;
using SepCore.Event;
using SepCore.Definition;
using SepCore.CustomUtility;
using GameFramework.Event;
using UnityGameFramework.Runtime;

namespace SepCore.UI
{
    public class LevelUpController : UIControllerBase<LevelUpContext, LevelUpForm>
    {
        private LevelUpUseCase _useCase;

        protected override UIFormType UIFormType => UIFormType.LevelUpForm;

        protected override void RefreshUI(LevelUpForm form, LevelUpContext context)
        {
            form.RefreshUI(context);
        }

        protected override void SubscribeCustomEvents()
        {
            GameEntry.Event.Subscribe(LevelUpRefreshEventArgs.EventId, LevelUpRefresh);
            GameEntry.Event.Subscribe(LevelUpPropSelectedEventArgs.EventId, LevelUpPropSelected);
        }

        protected override void UnsubscribeCustomEvents()
        {
            GameEntry.Event.Unsubscribe(LevelUpRefreshEventArgs.EventId, LevelUpRefresh);
            GameEntry.Event.Unsubscribe(LevelUpPropSelectedEventArgs.EventId, LevelUpPropSelected);
        }

        private static LevelUpContext BuildContext(LevelUpRawData rawData)
        {
            if (rawData == null)
            {
                Log.Error("LevelUpFormController.BuildContext() rawData is null.");
                return null;
            }

            if (rawData.Rewards == null)
            {
                Log.Error("LevelUpFormController.BuildContext() rewards are null.");
                return null;
            }

            List<LevelUpRewardItemContext> props = new List<LevelUpRewardItemContext>(rawData.Rewards.Count);
            foreach (var reward in rawData.Rewards)
            {
                if (reward == null)
                {
                    continue;
                }

                props.Add(new LevelUpRewardItemContext
                {
                    Title = reward.Title,
                    Icon = null,
                    ItemRarity = reward.Rarity,
                    Description = ItemDescUtility.CreatePropDescription(reward.Modifiers),
                    IconAssetName = reward.IconAssetName
                });
            }

            return new LevelUpContext
            {
                RefreshPrice = rawData.RefreshPrice,
                Props = props
            };
        }

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

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

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

            LevelUpRawData initialRawData = _useCase.CreateInitialModel();
            await OpenUIAsync(initialRawData, timeout);
        }

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

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

            _useCase = levelUpFormUseCase;
        }

        private async UniTask SelectRewardAsync(int selectedIndex)
        {
            if (_useCase == null)
            {
                Log.Error("LevelUpFormController.SelectRewardAsync() useCase is null.");
                return;
            }

            LevelUpRawData rawData = _useCase.SelectReward(selectedIndex);
            if (rawData == null)
            {
                return;
            }

            await OpenUIAsync(rawData);
        }

        private async UniTask RefreshRewardListAsync(int refreshCost)
        {
            if (_useCase == null)
            {
                Log.Error("LevelUpFormController.RefreshRewardListAsync() useCase is null.");
                return;
            }

            LevelUpRawData rawData = _useCase.TryRefresh(refreshCost);
            if (rawData == null)
            {
                return;
            }

            await OpenUIAsync(rawData);
        }

        private void LevelUpRefresh(object sender, GameEventArgs e)
        {
            if (sender is not LevelUpForm levelUpForm || levelUpForm != Form)
            {
                return;
            }

            if (e is not LevelUpRefreshEventArgs args)
            {
                return;
            }

            RefreshRewardListAsync(args.Cost).Forget();
        }

        private void LevelUpPropSelected(object sender, GameEventArgs e)
        {
            if (sender is not LevelUpForm levelUpForm || levelUpForm != Form)
            {
                return;
            }

            if (e is not LevelUpPropSelectedEventArgs args)
            {
                return;
            }

            SelectRewardAsync(args.SelectedId).Forget();
        }
    }
}