geometry-tower-defense/Assets/GameMain/Scripts/UI/Combat/Controller/CombatFinishFormController.cs

using System.Collections.Generic;
using GameFramework.Event;
using GeometryTD.CustomEvent;
using GeometryTD.Definition;
using UnityGameFramework.Runtime;

namespace GeometryTD.UI
{
    public class CombatFinishFormController : UIFormControllerCommonBase<CombatFinishFormContext, CombatFinishForm>
    {
        private CombatFinishFormUseCase _useCase;

        protected override UIFormType UIFormTypeId => UIFormType.CombatFinishForm;

        protected override void RefreshUI(CombatFinishForm form, CombatFinishFormContext context)
        {
            form.RefreshUI(context);
        }

        protected override void SubscribeCustomEvents()
        {
            GameEntry.Event.Subscribe(CombatFinishReturnEventArgs.EventId, OnCombatFinishReturnButtonClicked);
        }

        protected override void UnsubscribeCustomEvents()
        {
            GameEntry.Event.Unsubscribe(CombatFinishReturnEventArgs.EventId, OnCombatFinishReturnButtonClicked);
        }

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

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

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

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

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

        public int? OpenUI(CombatFinishFormRawData rawData)
        {
            CombatFinishFormContext context = BuildContext(rawData);
            return OpenUIInternal(context);
        }

        public override void BindUseCase(IUIUseCase useCase)
        {
            if (!(useCase is CombatFinishFormUseCase combatFinishFormUseCase))
            {
                Log.Error("CombatFinishFormController.BindUseCase() useCase is invalid.");
                return;
            }

            _useCase = combatFinishFormUseCase;
        }

        private static CombatFinishFormContext BuildContext(CombatFinishFormRawData rawData)
        {
            if (rawData == null)
            {
                return null;
            }

            return new CombatFinishFormContext
            {
                EnemyKilledText = rawData.DefeatedEnemyCount.ToString(),
                GoldGainedText = rawData.GainedGold.ToString(),
                RewardItems = BuildRewardItems(rawData.RewardInventory),
                CanReturn = rawData.CanReturn
            };
        }

        private static RepoItemContext[] BuildRewardItems(BackpackInventoryData inventory)
        {
            if (inventory == null)
            {
                return System.Array.Empty<RepoItemContext>();
            }

            List<RepoItemContext> itemContexts = new List<RepoItemContext>();

            if (inventory.Towers != null)
            {
                for (int i = 0; i < inventory.Towers.Count; i++)
                {
                    var tower = inventory.Towers[i];
                    if (tower == null)
                    {
                        continue;
                    }

                    itemContexts.Add(new RepoItemContext
                    {
                        Title = $"[Tower] {tower.Name} ({tower.Rarity})",
                        InstanceId = tower.InstanceId,
                        ComponentSlotType = TowerCompSlotType.None
                    });
                }
            }

            if (inventory.MuzzleComponents != null)
            {
                for (int i = 0; i < inventory.MuzzleComponents.Count; i++)
                {
                    var item = inventory.MuzzleComponents[i];
                    if (item == null)
                    {
                        continue;
                    }

                    itemContexts.Add(new RepoItemContext
                    {
                        Title = $"[Muzzle] {item.Name} ({item.Rarity})",
                        InstanceId = item.InstanceId,
                        ComponentSlotType = TowerCompSlotType.Muzzle
                    });
                }
            }

            if (inventory.BearingComponents != null)
            {
                for (int i = 0; i < inventory.BearingComponents.Count; i++)
                {
                    var item = inventory.BearingComponents[i];
                    if (item == null)
                    {
                        continue;
                    }

                    itemContexts.Add(new RepoItemContext
                    {
                        Title = $"[Bearing] {item.Name} ({item.Rarity})",
                        InstanceId = item.InstanceId,
                        ComponentSlotType = TowerCompSlotType.Bearing
                    });
                }
            }

            if (inventory.BaseComponents != null)
            {
                for (int i = 0; i < inventory.BaseComponents.Count; i++)
                {
                    var item = inventory.BaseComponents[i];
                    if (item == null)
                    {
                        continue;
                    }

                    itemContexts.Add(new RepoItemContext
                    {
                        Title = $"[Base] {item.Name} ({item.Rarity})",
                        InstanceId = item.InstanceId,
                        ComponentSlotType = TowerCompSlotType.Base
                    });
                }
            }

            return itemContexts.ToArray();
        }

        private void OnCombatFinishReturnButtonClicked(object sender, GameEventArgs e)
        {
            if (!(sender is CombatFinishForm) || !(e is CombatFinishReturnEventArgs))
            {
                return;
            }

            _useCase?.TryReturnToMenu();
        }
    }
}