ProjectDDD/Assets/_DDD/_Scripts/GameUi/PopupUi.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.InputSystem;

namespace DDD
{
    public static class EnumExtensions
    {
        public static IEnumerable<T> GetFlags<T>(this T input) where T : Enum
        {
            foreach (T value in Enum.GetValues(typeof(T)))
            {
                int intValue = Convert.ToInt32(value);
                int inputValue = Convert.ToInt32(input);
                if (intValue != 0 && (inputValue & intValue) == intValue) yield return value;
            }
        }
    }
    
    public abstract class PopupUi<T> : BasePopupUi where T : Enum
    {
        protected BaseUiActionsInputBindingSo<T> _baseUiActionsInputBindingSo;
        protected readonly List<(InputAction action, Action<InputAction.CallbackContext> handler)> _registeredHandlers = new();
        public override InputActionMaps InputActionMaps => _baseUiActionsInputBindingSo.InputActionMaps;
        
        private bool _isTopPopup => UiManager.Instance.IsTopPopup(this);

        private const string InputBindingSo = "InputBindingSo";
        
        protected override async void TryRegister()
        {
            base.TryRegister();

            UiManager.Instance.RegisterPopupUI(this);
            
            string addressableKey = $"{GetType().Name}_{typeof(T).Name}_{InputBindingSo}";
            _baseUiActionsInputBindingSo = await AssetManager.LoadAsset<BaseUiActionsInputBindingSo<T>>(addressableKey);
            
            Debug.Assert(_baseUiActionsInputBindingSo != null, $"{GetType().Name} class InputBindingSo not found: {addressableKey}");

            foreach (var actionEnum in _baseUiActionsInputBindingSo.BindingActions.GetFlags())
            {
                if (actionEnum.Equals(default(T))) continue;
                
                var inputAction = InputManager.Instance.GetAction(_baseUiActionsInputBindingSo.InputActionMaps, actionEnum.ToString());
                if (inputAction == null) continue;

                var startedHandler = new Action<InputAction.CallbackContext>(context =>
                {
                    OnInputStarted(actionEnum, context);
                });
                inputAction.started += startedHandler;

                var performedHandler = new Action<InputAction.CallbackContext>(context =>
                {
                    OnInputPerformed(actionEnum, context);
                });
                inputAction.performed += performedHandler;

                var canceledHandler = new Action<InputAction.CallbackContext>(context =>
                {
                    OnInputCanceled(actionEnum, context);
                });
                inputAction.canceled += canceledHandler;

                _registeredHandlers.Add((inputAction, startedHandler));
                _registeredHandlers.Add((inputAction, performedHandler));
                _registeredHandlers.Add((inputAction, canceledHandler));
            }
        }
        
        protected override void TryUnregister()
        {
            base.TryUnregister();
            UiManager.Instance.UnregisterPopupUI(this);
            
            foreach (var (action, handler) in _registeredHandlers)
            {
                if (action != null)
                {
                    action.started -= handler;
                    action.performed -= handler;
                    action.canceled -= handler;
                }
            }

            _registeredHandlers.Clear();
        }

        public override void Open(OpenPopupUiEvent evt)
        {
            base.Open(evt);
            
            transform.SetAsLastSibling();
            
            if (UiManager.Instance.IsTopPopup(this))
            {
                InputManager.Instance.SwitchCurrentActionMap(_baseUiActionsInputBindingSo.InputActionMaps);
            }
        }

        protected virtual bool OnInputStarted(T actionEnum, InputAction.CallbackContext context)
        {
            return _isTopPopup;
        }

        protected virtual bool OnInputPerformed(T actionEnum, InputAction.CallbackContext context)
        {
            return _isTopPopup;
        }

        protected virtual bool OnInputCanceled(T actionEnum, InputAction.CallbackContext context)
        {
            return _isTopPopup;
        }
    }
}