MiniGame-PushPush/Assets/Scripts/Manage/UIManager.cs

using FirstVillain.Singleton;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class UIManager : UnitySingleton<UIManager>
{
    [SerializeField] private Canvas _uiCanvas;
    private Dictionary<E_UI_ROOT_TYPE, Transform> _uiRootDict = new();
    private Dictionary<E_UI_TYPE, GameObject> _loadedUIDict = new();

    //Basic UI
    private Stack<UIBase> _uiStack = new();

    //Loading UI - Loading<6E><67> 2<><32><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ŷ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ǿ<EFBFBD> 1<><31><EFBFBD><EFBFBD>
    private UIBase _loadingUI;
    public UIBase LoadingUI { get { return _loadingUI; } }

    //SystemUI
    private List<UIBase> _systemUIList = new();

    protected override void AwakeSingleton()
    {
        base.AwakeSingleton();
        InitRoot();
    }
    
    private void InitRoot()
    {
        for (int i = 0; i < _uiCanvas.transform.childCount; i++)
        {
            var root = _uiCanvas.transform.GetChild(i);
            //GetChild<6C><64> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD> <20>ѵ<EFBFBD> Ȥ<><C8A4> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> üũ <20><> <20><><EFBFBD><EFBFBD>
            foreach (E_UI_ROOT_TYPE rootType in System.Enum.GetValues(typeof(E_UI_ROOT_TYPE)))
            {
                if (rootType.ToString() == root.name)
                {
                    _uiRootDict.Add(rootType, root);
                }
            }
        }
    }

    #region Open UI
    public void OpenUI(E_UI_TYPE type, Action<UIBase> onComplete = null)
    {        
        if(_loadedUIDict.ContainsKey(type))
        {
            GenerateUI(_loadedUIDict[type], E_UI_ROOT_TYPE.UI, onComplete);
        }
        else
        {
            AddressableManager.Instance.LoadAssetAsync<GameObject>(type.ToString(), result =>
            {
                _loadedUIDict.Add(type, result);
                GenerateUI(result, E_UI_ROOT_TYPE.UI, onComplete);
            });
        }
    }

    //<2F>ý<EFBFBD><C3BD><EFBFBD> <20>޽<EFBFBD><DEBD><EFBFBD>, <20>佺Ʈ <20>޽<EFBFBD><DEBD><EFBFBD> - <20>ֻ<EFBFBD><D6BB><EFBFBD>
    public void OpenSystemUI(E_UI_TYPE type, Action<UIBase> onComplete = null)
    {
        if (_loadedUIDict.ContainsKey(type))
        {
            GenerateUI(_loadedUIDict[type], E_UI_ROOT_TYPE.System, onComplete);
        }
        else
        {
            AddressableManager.Instance.LoadAssetAsync<GameObject>(type.ToString(), result =>
            {
                _loadedUIDict.Add(type, result);
                GenerateUI(result, E_UI_ROOT_TYPE.System, onComplete);
            });
        }
    }

    public void OpenLoadingUI(E_UI_TYPE type, Action<UIBase> onComplete = null)
    {
        if (_loadedUIDict.ContainsKey(type))
        {
            GenerateUI(_loadedUIDict[type], E_UI_ROOT_TYPE.Loading, onComplete);
        }
        else
        {
            AddressableManager.Instance.LoadAssetAsync<GameObject>(type.ToString(), result =>
            {
                _loadedUIDict.Add(type, result);
                GenerateUI(result, E_UI_ROOT_TYPE.Loading, onComplete);
            });
        }
    }

    #endregion OpenUI

    private void GenerateUI(GameObject uiObj, E_UI_ROOT_TYPE rootType, Action<UIBase> onComplete)
    {
        var obj = Instantiate(uiObj, _uiRootDict[rootType]);
        var uiBase = obj.GetComponent<UIBase>();
        uiBase.SetUIBaseType(rootType);

        switch (rootType)
        {
            case E_UI_ROOT_TYPE.UI:
                _uiStack.Push(uiBase);
                break;
            case E_UI_ROOT_TYPE.Loading:
                _loadingUI = uiBase;
                break;
            case E_UI_ROOT_TYPE.System:
                _systemUIList.Add(uiBase);
                break;
        }

        uiBase.Open();
        onComplete?.Invoke(uiBase);
    }

    public void CloseUI(UIBase ui)
    {
        switch(ui.UI_ROOT_TYPE)
        {
            case E_UI_ROOT_TYPE.UI:
                if(_uiStack.Count > 1)
                {
                    var targetUI = _uiStack.Pop();
                    targetUI.CloseAction();
                    Destroy(targetUI.gameObject);
                }
                break;
            case E_UI_ROOT_TYPE.System:
                _systemUIList.Remove(ui);
                Destroy(ui.gameObject);
                break;
        }
    }

    public void CloseLoadingUI()
    {
        if(_loadingUI == null)
        {
            return;
        }
        StartCoroutine(DelayCloseLoading());

    }
    private IEnumerator DelayCloseLoading()
    {
        yield return new WaitForSeconds(1.5f);
        _loadingUI.CloseAction();
        Destroy(_loadingUI.gameObject);
        _loadingUI = null;
    }

    public void ReleaseUI()
    {
        while(_uiStack.Count > 0)
        {
            var ui = _uiStack.Pop();
            ui.CloseAction();
            Destroy(ui.gameObject);
        }

        foreach (var systemUI in _systemUIList)
        {
            Destroy(systemUI.gameObject);
        }
        _systemUIList = new();
    }
}