RandomGFGoStop/Assets/Scripts/SingletonManagers/Managers/UIManager.cs

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using DG.Tweening;
using System.Collections;

public enum EPopupType
{
    Blind,
    SettingPopup,
    AllMonthTypePopup,
    AllMonthTypePopup_AI,
    AllMonthTypePopup_Floor,
    ResultPopup,
    PausePopup,
    FirstBbugPopup,
    ShakeSelectPopup,
    ShakePopup,
    ShakeSelectPopup_AI,
    DoublePeeSelectPopup,
    FloorCardSelectPopup,
    GoStopPopup,
    WaitForAIBehaviourPopup,
    QuitPopup,
    NagariPopup,
    KeyChargePopup,
    HeartChargePopup,
    GoldChargePopup,
    Max,
    NotMinimumVersionPopup,
    FailDowonloadPopup,
    PrivacyPoilcyPopup,
    AgreeConditionsPopup,
    NotOnline_ClosePopup,
    NotEnoughGoldPopup,
    FailIAPPopup,
    FailLoadADSPopup,
    NotVaildFreeHeartPopup,
    NotVaildFreeHaert_ADS_Popup,
    MonthlyPurchaselimitPopup,
    DoubleHeartWarningPopup,
    ADSRemovePopup,
    AlbumOpenPopup,
    PreViewPopup,
    PreViewUIPopup,
}

public enum EGraphicRaycasterType
{
    Max
}

public class UIManager : MonoBehaviour
{
    #region Fields
    private Stack<(EPopupType key, PopupBase value)> _stkActivatedPopupbases;
    private HashSet<EPopupType> _hashActivatedPopupTypes;
    private Dictionary<EGraphicRaycasterType, List<GraphicRaycaster>> _dicRegitedGRs;
    private Dictionary<EPopupType, PopupBase> _dicUnDetroyedPopups;
    private CanvasGroup _rootPanelCG;

    private IEnumerator _eHideDirect;
    private bool _isInStoreDuringGame;
    #endregion

    #region Properties
    public EPopupType TopPopup { get => _stkActivatedPopupbases.Count > 0 ? _stkActivatedPopupbases.Peek().key : EPopupType.Max; }
    public Transform PopupCanvasTransform;
    public bool Escapeable { get; set; } = true;
    #endregion

    #region Behaviour
    private void Awake()
    {
        this.InitializeContainers();

        _dicUnDetroyedPopups = new Dictionary<EPopupType, PopupBase>
        {
            { EPopupType.Blind, null },

        };
    }

    private void Start()
    {
        GameManager.Event.RegistEvent(EEventType.MoveToStore_Heart_DuringGame, this.MoveToStore_Heart_DuringGameCallback);
    }

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.Escape))
        {
            if (_isInStoreDuringGame)
            {
                GameManager.Event.InvokeEvent(EEventType.OnReturnToGameFromStore);
            }
            else if (_stkActivatedPopupbases.Count <= 0)
            {
                if (Escapeable && GamePanel.Instance != null)
                {
                    if (!GamePanel.Instance.GameOver)
                    {
                        if (GameManager.UI.IsOpendPopup(EPopupType.PausePopup) == false)
                            GameManager.UI.ShowNStackPopup(EPopupType.PausePopup);
                    }
                    else
                    {
                        if (GameManager.UI.IsOpendPopup(EPopupType.QuitPopup) == false)
                            GameManager.UI.ShowNStackPopup(EPopupType.QuitPopup);
                    }
                }
            }
            else
                HideTopPopup();
        }
    }
    #endregion

    #region Methods

    #region Public Methods ====================
    public void RegisterGraphicRaycaster(EGraphicRaycasterType grType, GraphicRaycaster raycaster)
    {
        if (_dicRegitedGRs.ContainsKey(grType))
        {
            _dicRegitedGRs[grType].Add(raycaster);
        }
        else
        {
            Debug.LogError($"{nameof(_dicRegitedGRs)} has not {grType}!, Please Check this Container.");
        }

    }

    public void ReleaseGraphicRaycaster(EGraphicRaycasterType grType, GraphicRaycaster raycaster)
    {
        if (_dicRegitedGRs.ContainsKey(grType))
        {
            for (int i = 0; i < _dicRegitedGRs[grType].Count; i++)
            {
                if (_dicRegitedGRs[grType][i] == raycaster)
                {
                    _dicRegitedGRs[grType].RemoveAt(i);
                    break;
                }
            }
        }
        else
        {
            Debug.LogWarning($"{grType} is Already Removed.");
        }

    }


    public void ShowNStackPopup(EPopupType type)
    {
        StartCoroutine(coroShowNStackPopup(type));
    }

    private System.Collections.IEnumerator coroShowNStackPopup(EPopupType type)
    {
        yield return new WaitForEndOfFrame();
        this.CreatePopup(type).ShowPopup(_stkActivatedPopupbases.Count);
    }

    public T ShowNStackPopup<T>(EPopupType type) where T : PopupBase
    {
        PopupBase pBase = this.CreatePopup(type);
        pBase.ShowPopup(_stkActivatedPopupbases.Count);
        return pBase as T;
    }

    public void HideTopPopup()
    {
        var popup = _stkActivatedPopupbases.Pop();
        popup.value.HidePopup();
        _hashActivatedPopupTypes.Remove(popup.key);

        if (_stkActivatedPopupbases.Count == 0)
        {
            _dicUnDetroyedPopups[EPopupType.Blind].HidePopup();
            this.HideDirectEnabled(false);
        }
        else
            _dicUnDetroyedPopups[EPopupType.Blind].SetDrawOrder(_stkActivatedPopupbases.Count);
    }

    public void HideAllPopup()
    {
        StartCoroutine(coroHideAllPopup());
    }

    private IEnumerator coroHideAllPopup()
    {
        while (_stkActivatedPopupbases.Count > 0)
        {
            HideTopPopup();
            yield return null;
        }
    }

    public bool IsOpendPopup(EPopupType type)
    {
        return _hashActivatedPopupTypes.Contains(type);
    }

    public bool IsAnyPopupOpened()
    {
        return _hashActivatedPopupTypes.Count > 0;
    }

    public void AllRaycastEnabled(bool enabled)
    {
        foreach (var pair in _dicRegitedGRs)
        {
            for (int i = 0; i < pair.Value.Count; i++)
                pair.Value[i].enabled = enabled;
        }
    }

    public void BlindPopupEnabled(bool b)
    {
        _dicUnDetroyedPopups[EPopupType.Blind].GetComponent<CanvasGroup>().alpha = b ? 1 : 0;
    }

    public void ActivateLoadingPage()
    {

    }

    public void DeactivateLoadingPage()
    {

    }

    #endregion

    #region Private Methods ====================

    private void InitializeContainers()
    {
        _dicRegitedGRs = new Dictionary<EGraphicRaycasterType, List<GraphicRaycaster>>();
        _stkActivatedPopupbases = new Stack<(EPopupType key, PopupBase value)>();
        _hashActivatedPopupTypes = new HashSet<EPopupType>();

        for (EGraphicRaycasterType i = 0; i < EGraphicRaycasterType.Max; i++)
            _dicRegitedGRs.Add(i, new List<GraphicRaycaster>());
    }

    private void MoveToStore_Heart_DuringGameCallback()
    {

    }

    private PopupBase CreatePopup(EPopupType type)
    {
        if (_stkActivatedPopupbases.Count == 0)
        {
            if (_dicUnDetroyedPopups[EPopupType.Blind] == null)
            {
                _dicUnDetroyedPopups[EPopupType.Blind] = this.LoadPopupPrefab(EPopupType.Blind);
            }

            BlindPopupEnabled(true);
        }

        PopupBase pBase;
        if (IsUnDestroyedPopup(type))
            pBase = this.GetUnDestroyedPopup(type);
        else
            pBase = this.LoadPopupPrefab(type);

        _stkActivatedPopupbases.Push((type, pBase));
        _hashActivatedPopupTypes.Add(type);

        _dicUnDetroyedPopups[EPopupType.Blind].ShowPopup(_stkActivatedPopupbases.Count);
        return pBase;
    }

    private bool IsUnDestroyedPopup(EPopupType type)
    {
        switch (type)
        {
            case EPopupType.Blind:
                return true;
            default:
                return false;
        }
    }

    private PopupBase GetUnDestroyedPopup(EPopupType type)
    {
        switch (type)
        {
            case EPopupType.Blind:
                {
                    if (_dicUnDetroyedPopups[type] == null)
                        _dicUnDetroyedPopups[type] = LoadPopupPrefab(type);
                    return _dicUnDetroyedPopups[type];
                }

            default:
                return LoadPopupPrefab(type);
        }
    }

    private PopupBase LoadPopupPrefab(EPopupType type)
    {
        if (PopupCanvasTransform == null)
        {
            if (GameManager.Scene.CurrentSceneType == ESceneType.Main)
            {

            }
            PopupCanvasTransform = GameObject.Find("PopupPanel").transform;
            _rootPanelCG = PopupCanvasTransform.GetComponent<CanvasGroup>();
        }

        string path = ResourceManager.PREFAB_PATH + "Popups/";

        switch (type)
        {
            case EPopupType.Blind:
                return Instantiate(Resources.Load<PopupBase>(path + "BlindPopup"), PopupCanvasTransform);
            case EPopupType.ResultPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "ResultPopup"), PopupCanvasTransform);
            case EPopupType.AllMonthTypePopup:
                return Instantiate(Resources.Load<PopupBase>(path + "AllMonthTypePopup"), PopupCanvasTransform);
            case EPopupType.AllMonthTypePopup_AI:
                return Instantiate(Resources.Load<PopupBase>(path + "AllMonthTypePopup_AI"), PopupCanvasTransform);
            case EPopupType.AllMonthTypePopup_Floor:
                return Instantiate(Resources.Load<PopupBase>(path + "AllMonthTypePopup_Floor"), PopupCanvasTransform);
            case EPopupType.PausePopup:
                return Instantiate(Resources.Load<PopupBase>(path + "PausePopup"), PopupCanvasTransform);
            case EPopupType.FirstBbugPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "FirstBbugPopup"), PopupCanvasTransform);
            case EPopupType.ShakeSelectPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "ShakeSelectPopup"), PopupCanvasTransform);
            case EPopupType.ShakePopup:
                return Instantiate(Resources.Load<PopupBase>(path + "ShakePopup"), PopupCanvasTransform);
            case EPopupType.ShakeSelectPopup_AI:
                return Instantiate(Resources.Load<PopupBase>(path + "ShakeSelectPopup_AI"), PopupCanvasTransform);
            case EPopupType.DoublePeeSelectPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "DoublePeeSelectPopup"), PopupCanvasTransform);
            case EPopupType.FloorCardSelectPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "FloorPeeSelectPopup"), PopupCanvasTransform);
            case EPopupType.GoStopPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "GoStopPopup"), PopupCanvasTransform);
            case EPopupType.WaitForAIBehaviourPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "WaitForAIBehaviourPopup"), PopupCanvasTransform);
            case EPopupType.QuitPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "QuitPopup"), PopupCanvasTransform);
            case EPopupType.NagariPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "NagariPopup"), PopupCanvasTransform);
            case EPopupType.KeyChargePopup:
                return Instantiate(Resources.Load<PopupBase>(path + "KeyChargePopup"), PopupCanvasTransform);
            case EPopupType.HeartChargePopup:
                return Instantiate(Resources.Load<PopupBase>(path + "HeartChargePopup"), PopupCanvasTransform);
            case EPopupType.GoldChargePopup:
                return Instantiate(Resources.Load<PopupBase>(path + "GoldChargePopup"), PopupCanvasTransform);
            case EPopupType.SettingPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "SettingPopup"), PopupCanvasTransform);
            case EPopupType.NotMinimumVersionPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "NotMinimumVersionPopup"), PopupCanvasTransform);
            case EPopupType.FailDowonloadPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "FailDowonloadPopup"), PopupCanvasTransform);
            case EPopupType.PrivacyPoilcyPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "PrivacyPoilcyPopup"), PopupCanvasTransform);
            case EPopupType.AgreeConditionsPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "AgreeConditionsPopup"), PopupCanvasTransform);
            case EPopupType.NotOnline_ClosePopup:
                return Instantiate(Resources.Load<PopupBase>(path + "NotOnline_ClosePopup"), PopupCanvasTransform);
            case EPopupType.FailIAPPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "FailIAPPopup"), PopupCanvasTransform);
            case EPopupType.FailLoadADSPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "FailLoadADSPopup"), PopupCanvasTransform);
            case EPopupType.NotEnoughGoldPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "NotEnoughGoldPopup"), PopupCanvasTransform);
            case EPopupType.NotVaildFreeHeartPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "NotVaildFreeHeartPopup"), PopupCanvasTransform);
            case EPopupType.NotVaildFreeHaert_ADS_Popup:
                return Instantiate(Resources.Load<PopupBase>(path + "NotVaildFreeHaert_ADS_Popup"), PopupCanvasTransform);
            case EPopupType.MonthlyPurchaselimitPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "MonthlyPurchaselimitPopup"), PopupCanvasTransform);
            case EPopupType.DoubleHeartWarningPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "DoubleHeartWarningPopup"), PopupCanvasTransform);
            case EPopupType.ADSRemovePopup:
                return Instantiate(Resources.Load<PopupBase>(path + "ADSRemovePopup"), PopupCanvasTransform);
            case EPopupType.AlbumOpenPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "AlbumOpenPopup"), PopupCanvasTransform);
            case EPopupType.PreViewPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "PreViewPopup"), PopupCanvasTransform);
            case EPopupType.PreViewUIPopup:
                return Instantiate(Resources.Load<PopupBase>(path + "PreViewUIPopup"), PopupCanvasTransform);
            default:
                return null;
        }

    }

    public void HideDirectEnabled(bool b)
    {
        if (PopupCanvasTransform == null)
        {
            if (GameManager.Scene.CurrentSceneType == ESceneType.Main)
            {
                PopupCanvasTransform = GameObject.Find("PopupPanel").transform;
                _rootPanelCG = PopupCanvasTransform.GetComponent<CanvasGroup>();
            }
        }
        else if (_rootPanelCG == null)
        {
            _rootPanelCG = PopupCanvasTransform.GetComponent<CanvasGroup>();
        }

        if (b)
        {
            if (_eHideDirect == null)
            {
                _eHideDirect = this.coroHideDirectEnabled(true);
                StartCoroutine(_eHideDirect);
            }
        }
        else
        {
            if (_eHideDirect != null)
            {
                StopCoroutine(_eHideDirect);
            }

            _eHideDirect = this.coroHideDirectEnabled(false);
            StartCoroutine(_eHideDirect);
        }
    }

    private IEnumerator coroHideDirectEnabled(bool b)
    {
        _rootPanelCG.DOFade(b ? 0 : 1, 0.1f).SetEase(Ease.Linear).SetRecyclable(true);
        yield return new WaitForSeconds(0.1f);
        _rootPanelCG.alpha = b ? 0 : 1;
        _eHideDirect = null;
    }
    #endregion
    #endregion
}

[RequireComponent(typeof(Canvas), typeof(GraphicRaycaster))]
public class PopupBase : MonoBehaviour
{
    protected float OpenDuration = 0.25f;
    protected float OpenStartScale = 0.8f;
    protected UnityEngine.Canvas canvas;

    protected virtual void Awake()
    {
        canvas = this.GetComponent<UnityEngine.Canvas>();

        if (canvas.worldCamera == null)
            canvas.worldCamera = Camera.main;
    }

    public virtual void ShowPopup(int drawOrder)
    {
        this.SetDrawOrder(drawOrder);
        this.GetComponent<UnityEngine.RectTransform>().DOScale(1f, OpenDuration).From(OpenStartScale).SetEase(Ease.OutExpo);

        if (!this.gameObject.activeInHierarchy)
            gameObject.SetActive(true);

    }

    public virtual void SetDrawOrder(int drawOrder)
    {
        if (canvas == null) canvas = this.GetComponent<UnityEngine.Canvas>();
        canvas.sortingOrder = (drawOrder + 1) * 2;
    }

    public virtual void GraphicRaycastEnabled(bool b)
    {
        UnityEngine.UI.GraphicRaycaster raycaster;

        if (this.TryGetComponent(out raycaster))
        {
            raycaster.enabled = b;
        }
        else
        {
            Debug.LogWarning($"{this.gameObject.name} has not 'Graphic Raycaster!'");
        }
    }

    public virtual void HidePopup()
    {
        GameManager.UI.HideDirectEnabled(false);
        Destroy(this.gameObject);
    }

    public void HideCanvasButtonDown()
    {
        GameManager.UI.HideDirectEnabled(true);
    }

    public void HideCanvasButtonUp()
    {
        GameManager.UI.HideDirectEnabled(false);
    }
}