using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.U2D;
using UnityEngine.EventSystems;
using UnityEngine.AddressableAssets;
using System.Threading.Tasks;
using asap.core;
using System.Linq;

namespace GameCore
{
    public class GetUIAsyncEvent
    {
        public string uIType;
        public bool show = true;
    }
    public enum ScreenType
    {
        INVALID,
        LANDSCAPE,
        PORTRAIT,
    }

    public class UIType
    {
        public string Path { get; private set; }

        public string Name { get; private set; }
        public int UIOffset { get; private set; }

        public UIType(string path)
        {
            Path = path;
            Name = path.Substring(path.LastIndexOf('/') + 1);
            UITypes.UITypesDic[Name] = this;
        }

        public UIType(string path, int uiOffset)
        {
            Path = path;
            Name = path.Substring(path.LastIndexOf('/') + 1);
            UIOffset = uiOffset;
            UITypes.UITypesDic[Name] = this;
        }
        public void SetType(string path)
        {
            Path = path;
            Name = path.Substring(path.LastIndexOf('/') + 1);
            UITypes.UITypesDic[Name] = this;
        }
        public override string ToString()
        {
            return string.Format("UIType {0}({1})", Name, Path);
        }

        public override bool Equals(object obj)
        {
            if (obj is UIType otherType)
            {
                if (this.Path == otherType.Path)
                {
                    return true;
                }
            }

            return base.Equals(obj);
        }

        public override int GetHashCode()
        {
            return Path.GetHashCode();
        }
    }

    class SpriteAtlasCache
    {
        public SpriteAtlas atlas;
        public Dictionary<string, Sprite> spriteDict;

        public SpriteAtlasCache()
        {
            atlas = null;
            spriteDict = new Dictionary<string, Sprite>();
        }
    }


    public class UIManager : MonoBehaviour
    {
        public const int TIME_OUT_MS = 10000;
        public const int BLOCK_DELAY_MS = 1500; // in ms
        public const float TRANSITION_TIMER = 0.3f;

        public RectTransform WaitingPanel;
        public Image TransitionPanel;
        public Action WaitingTimeOutDefaultCallback;
        private RectTransform alertContainer;
        private UIType[] alertUIList;
        Dictionary<string, GameObject> _UIDict = new Dictionary<string, GameObject>();
        Dictionary<string, GameObject> _UIDictABB = new Dictionary<string, GameObject>();
        //非自动填充，具体业务需求填充
        public Stack<UIType> panelStack = new Stack<UIType>();

        Dictionary<string, SpriteAtlasCache> _atlasDict = new Dictionary<string, SpriteAtlasCache>();
        Dictionary<string, Dictionary<string, Texture>> _textureDict = new Dictionary<string, Dictionary<string, Texture>>();
        Dictionary<string, Dictionary<string, Sprite>> _spriteDict = new Dictionary<string, Dictionary<string, Sprite>>();
        Transform _topSibling = null; // Assuming there's only one top sibling needed, make it a list otherwise
        int _waitingAnimShowingTimer = int.MaxValue; // in milliseconds
        int _waitingBlockTimeout = 0; // in milliseconds
        float _waitingBlockStartTime;
        WaitingUI waitingUI;
        CanvasScaler canvasScaler;
        public CanvasScaler CanvasScaler => canvasScaler;

        ScreenOrientation
            prevLandscape; // Save previous Landscape orientation, OS tend to restore this when auto-rotation is on and change screen from portrait to landscape

        Dictionary<string, Action> _waitingBlockDict = new Dictionary<string, Action>();

        static public UIManager Instance { get; private set; }

        // public Camera UICamera { get; private set; }

        public Canvas UICanvas { get; private set; }
        GraphicRaycaster graphicRaycaster { get; set; }

        public RectTransform RectTrans { get; private set; }

        public ScreenType screenType { get; private set; }

        Rect safeArea;

        public Camera UI3DCamera { get; private set; }

        private float anchorMax;

        /*
         *        public static void Init(UIType ui_type, ScreenType screen_type, Action default_waiting_timeout_callback = null)
         *        {
         *            if (Instance != null || ui_type == null)
         *            {
         *                return;
         *            }
         *
         *            GameObject prefab = AssetManager.LoadAsset<GameObject>(ui_type.Path);
         *
         *            if (prefab != null)
         *            {
         *                GameObject main_ui = GameObject.Instantiate(prefab) as GameObject;
         *                DontDestroyOnLoad(main_ui);
         *
         *                if (main_ui != null)
         *                {
         *                    main_ui.name = ui_type.Name;
         *                }
         *
         *                Instance = main_ui.AddComponent<UIManager>();
         *                Instance.screenType = screen_type;
         *                Instance.canvasScaler = main_ui.GetComponent<CanvasScaler>();
         *                Instance.WaitingTimeOutDefaultCallback = default_waiting_timeout_callback;
         *
         *                var waiting_obj = main_ui.FindChildGameObject("WaitingBlock");
         *
         *                if (waiting_obj != null)
         *                {
         *                    var trans = waiting_obj.GetComponent<RectTransform>();
         *                    Instance.InitWaitingPanel(trans);
         *                    waiting_obj.SetActiveAsNeed(false);
         *                }
         *                else
         *                {
         *                    Debug.LogError("[UIManager]Init: Fail to find WaitingBlock GameObject");
         *                }
         *            }
         *        }
         */

        public static async Task Init(UIType ui_type, ScreenType screen_type, Action default_waiting_timeout_callback = null)
        {
            if (Instance != null || ui_type == null)
            {
                return;
            }

            var main_ui = await Addressables.InstantiateAsync(ui_type.Path).Task;

            if (main_ui != null)
            {
                DontDestroyOnLoad(main_ui);
                main_ui.name = ui_type.Name;

                Instance = main_ui.AddComponent<UIManager>();
                Instance.screenType = screen_type;
                Instance.canvasScaler = main_ui.GetComponent<CanvasScaler>();
                Instance.WaitingTimeOutDefaultCallback = default_waiting_timeout_callback;

                var waiting_obj = main_ui.FindChildGameObject("WaitingBlock");

                if (waiting_obj != null)
                {
                    var trans = waiting_obj.GetComponent<RectTransform>();
                    Instance.InitWaitingPanel(trans);
                    waiting_obj.SetActiveAsNeed(false);
                }
                else
                {
                    Debug.LogError("[UIManager]Init: Fail to find WaitingBlock GameObject");
                }

                var alertContainer = main_ui.FindChildGameObject("Alert");
                if (alertContainer != null)
                {
                    Instance.alertContainer = alertContainer.GetComponent<RectTransform>();
                    Instance.alertUIList = new UIType[] { UITypes.NoticeConfirmPopupPanel };
                }
            }
        }

        public static void SetUICamera(Camera camera, Camera ui3d)
        {
            if (Instance != null)
            {
                Instance.UI3DCamera = ui3d;
                Instance.UI3DCamera.gameObject.SetActive(false);
                Instance.UICanvas.worldCamera = camera;
                camera.orthographicSize = Screen.height * 0.5f;
            }
        }


        public static void Destroy()
        {
            Debug.Log("[UIManager]Destroy");

            if (Instance != null)
            {
                List<string> keys = new List<string>(Instance._UIDict.Keys);
                foreach (var kv in keys)
                {
                    Instance.DestroyUI(kv);
                    //Addressables.ReleaseInstance(kv.Value);
                }

                GameObject.DestroyImmediate(Instance.gameObject);
                Instance = null;
            }
        }

        static EventSystem _eventSystem;
        static float _inputBlockTimer = -1f;
        static Action _onInputBlockTimeOut = null;

        public static void BlockInput(float block_timer = -1f, Action on_time_out = null)
        {
            if (EventSystem.current != null && EventSystem.current.gameObject != null)
            {
                Debug.Log("[UIManager]BlockInput");
                _eventSystem = EventSystem.current;
                _eventSystem.enabled = false;
                _inputBlockTimer = block_timer;
                _onInputBlockTimeOut = on_time_out;
            }
        }

        public static void UnblockInput()
        {
            if (_eventSystem != null)
            {
                Debug.Log("[UIManager]UnblockInput");
                _eventSystem.enabled = true;
                _eventSystem = null;
                _onInputBlockTimeOut = null;
                _inputBlockTimer = -1f;
            }
        }

        public static bool isInputBlocked()
        {
            return _eventSystem != null;
        }

        public static void RestoreInputBlock()
        {
            if (Instance._waitingBlockDict.Count > 0)
            {
                BlockInput();
            }
        }

        public static bool IsShowingWaitingBlock(string message_id)
        {
            bool is_showing = false;

            if (Instance != null)
            {
                is_showing = Instance._IsShowingWaitingBlock(message_id);
            }

            return is_showing;
        }

        public static void ClearWaitingBlock()
        {
            if (Instance != null)
            {
                UnblockInput();
                Debug.Log("[UIManager]ClearWaitingBlock");
                Instance._ClearWaitingBlock();
            }
        }

        public static IEnumerator ChangeScreenOrientation(ScreenType screen_type)
        {
            Debug.Log($"[UIManager]ChangeScreenOrientation: {screen_type}");

            if (Instance == null || Instance.canvasScaler == null)
            {
                Debug.LogError($"[UIManager]ChangeScreenOrientation: Not found canvasScaler!");
                yield break;
            }

            var current_width = Instance.RectTrans.rect.width;
            var current_height = Instance.RectTrans.rect.height;
            var target_width = current_height;
            var target_height = current_width;
            var ref_res = Instance.canvasScaler.referenceResolution;
            var target_ref_res = new Vector2(ref_res.y, ref_res.x);

            if (screen_type == ScreenType.PORTRAIT)
            {
                // Already in the right orientation, just ignore this
                if (!Application.isEditor)
                {
                    if (Instance.screenType == ScreenType.PORTRAIT ||
                        Screen.orientation == ScreenOrientation.Portrait)
                    {
                        Debug.LogError(
                            $"[UIManager]ChangeScreenOrientation: Already in the screenType = {Instance.screenType}, or Orientation = {Screen.orientation}!");
                        yield break;
                    }
                }

                Instance.prevLandscape = Screen.orientation;

                var target_orientation = ScreenOrientation.Portrait;

                Screen.orientation = target_orientation;
                Instance.screenType = screen_type;

                if (!Application.isEditor)
                {
                    yield return null;

                    Instance.canvasScaler.referenceResolution = target_ref_res;

                    yield return new WaitUntil(() =>
                    {
                        return Instance.RectTrans.rect.width == target_width &&
                               Instance.RectTrans.rect.height == target_height;
                    });
                }

                Instance.canvasScaler.referenceResolution = target_ref_res;

                if (Instance.canvasScaler.screenMatchMode == CanvasScaler.ScreenMatchMode.MatchWidthOrHeight)
                {
                    Instance.canvasScaler.matchWidthOrHeight = 0;
                }
            }
            else if (screen_type == ScreenType.LANDSCAPE)
            {
                // Already in the right orientation, just ignore this
                if (!Application.isEditor)
                {
                    if (Instance.screenType == ScreenType.LANDSCAPE ||
                        Screen.orientation == ScreenOrientation.LandscapeLeft ||
                        Screen.orientation == ScreenOrientation.LandscapeRight)
                    {
                        Debug.LogError(
                            $"[UIManager]ChangeScreenOrientation: Already in the screenType = {Instance.screenType}, or Orientation = {Screen.orientation}!");
                        yield break;
                    }
                }

                var target_orientation = ScreenOrientation.LandscapeLeft;

                if (Instance.prevLandscape == ScreenOrientation.LandscapeLeft ||
                    Instance.prevLandscape == ScreenOrientation.LandscapeRight)
                {
                    target_orientation = Instance.prevLandscape;
                }

                if (Input.deviceOrientation == DeviceOrientation.LandscapeLeft)
                {
                    target_orientation = ScreenOrientation.LandscapeLeft;
                }
                else if (Input.deviceOrientation == DeviceOrientation.LandscapeRight)
                {
                    target_orientation = ScreenOrientation.LandscapeRight;
                }

                Screen.orientation = target_orientation;
                Instance.screenType = screen_type;

                if (!Application.isEditor)
                {
                    yield return null;

                    Instance.canvasScaler.referenceResolution = target_ref_res;

                    yield return new WaitUntil(() =>
                    {
                        return Instance.RectTrans.rect.width == target_width &&
                               Instance.RectTrans.rect.height == target_height;
                    });
                }

                Instance.canvasScaler.referenceResolution = target_ref_res;

                if (Instance.canvasScaler.screenMatchMode == CanvasScaler.ScreenMatchMode.MatchWidthOrHeight)
                {
                    Instance.canvasScaler.matchWidthOrHeight = 1;
                }

                Screen.autorotateToLandscapeLeft = true;
                Screen.autorotateToLandscapeRight = true;
                Screen.autorotateToPortrait = false;
                Screen.autorotateToPortraitUpsideDown = false;
                Screen.orientation = ScreenOrientation.AutoRotation;
            }
            else
            {
                Debug.LogError($"[UIManager]ChangeScreenOrientation: Not handle ScreenType {screen_type}");
            }
        }

        bool _IsShowingWaitingBlock(string message_id)
        {
            bool is_found = false;

            if (Instance != null)
            {
                if (_waitingBlockDict.ContainsKey(message_id))
                {
                    is_found = true;
                }
            }

            return is_found;
        }

        public static void ShowWaitingBlock(string message_id, Action time_out_callback = null,
            int delay_time_ms = BLOCK_DELAY_MS, int timeout_ms = TIME_OUT_MS)
        {
            if (IsShowingWaitingBlock(message_id))
            {
                return;
            }

            if (Instance != null)
            {
                Instance._ShowWaitingBlock(message_id, time_out_callback, delay_time_ms, timeout_ms);
            }
        }

        private static void ShowForceWaitingBlock()
        {
            if (Instance != null)
            {
                Instance.ShowWaitingBlock(-1);
            }
        }

        private static void HideForceWaitingBlock()
        {
            if (Instance != null)
            {
                Instance.HideWaitingBlock();
            }
        }

        public static void HideWaitingBlock(string message_id)
        {
            if (!IsShowingWaitingBlock(message_id))
            {
                return;
            }

            if (Instance != null)
            {
                Instance._HideWaitingBlock(message_id);
            }
        }

        void _ShowWaitingBlock(string message_id, Action time_out_callback = null, int delay_time_ms = BLOCK_DELAY_MS,
            int timeout_ms = TIME_OUT_MS)
        {
            if (Instance != null)
            {
                if (delay_time_ms > timeout_ms)
                {
                    Debug.LogError(
                        $"[UIManager]_ShowWaitingBlock: Delay timer {delay_time_ms} shouldn't bigger than timeout timer {timeout_ms}, will set it to timeout timer instead.");
                    delay_time_ms = timeout_ms;
                }

                if (delay_time_ms < _waitingAnimShowingTimer)
                {
                    _waitingAnimShowingTimer = delay_time_ms;
                }

                if (timeout_ms > _waitingBlockTimeout)
                {
                    _waitingBlockTimeout = timeout_ms;
                }

                if (_waitingBlockDict.Count == 0)
                {
                    _waitingBlockStartTime = Time.realtimeSinceStartup;
                }

                if (_waitingBlockDict.ContainsKey(message_id))
                {
                    _waitingBlockDict[message_id] = time_out_callback;

                    return;
                }

                BlockInput();

                //Debug.LogWithTrace("[UIManager]_ShowWaitingBlock: {0}, delay time {1}", message_id, delay_time_ms);
                Debug.LogFormat("[UIManager]_ShowWaitingBlock: {0}, delay time {1}", message_id, delay_time_ms);
                _waitingBlockDict.Add(message_id, time_out_callback);
            }
        }

        void _HideWaitingBlock(string message_id)
        {
            Debug.Log($"[UIManager]_HideWaitingBlock: {message_id}");

            if (_waitingBlockDict.Count == 0)
            {
                return;
            }

            if (_waitingBlockDict.ContainsKey(message_id))
            {
                _waitingBlockDict.Remove(message_id);
            }

            if (_waitingBlockDict.Count == 0)
            {
                if (WaitingPanel != null)
                {
                    WaitingPanel.gameObject.SetActiveAsNeed(false);
                    WaitingPanel.GetComponent<CanvasGroup>().alpha = 1;
                }

                _waitingAnimShowingTimer = int.MaxValue;
                _waitingBlockTimeout = 0;
                _waitingBlockStartTime = 0;
                UnblockInput();
                // Debug.Log("[UIManager]_HideWaitingBlock: No block any more!");
            }
            else
            {
                if (Application.isEditor)
                {
                    var etor = _waitingBlockDict.GetEnumerator();

                    while (etor.MoveNext())
                    {
                        var item_key = etor.Current.Key;
                        Debug.Log($"[UIManager]_HideWaitingBlock: {item_key} still waiting block");
                    }
                }
            }
        }

        bool isWaitingBlockShowing()
        {
            return WaitingPanel != null && WaitingPanel.gameObject.activeSelf;
        }

        // timeout_ms < 0 means keep showing and no time out trigger
        void ShowWaitingBlock(int timeout_ms)
        {
            if (WaitingPanel != null && !WaitingPanel.gameObject.activeSelf)
            {
                WaitingPanel.SetAsLastSibling();
                WaitingPanel.gameObject.SetActiveAsNeed(true);
            }

            if (waitingUI != null)
            {
                waitingUI.Show(timeout_ms);
            }

            BlockInput();
        }

        // Note: Only use this to hide force waiting block
        void HideWaitingBlock()
        {

            if (WaitingPanel != null)
            {
                WaitingPanel.gameObject.SetActiveAsNeed(false);
                WaitingPanel.GetComponent<CanvasGroup>().alpha = 1;
            }

            UnblockInput();
        }

        void _ClearWaitingBlock()
        {
            if (WaitingPanel != null)
            {
                WaitingPanel.gameObject.SetActiveAsNeed(false);
                WaitingPanel.GetComponent<CanvasGroup>().alpha = 1;
            }

            _waitingBlockDict.Clear();
        }

        void OnWaitingTimeOut()
        {
            Debug.LogError("[UIManager]OnWaitingTimeOut");

            bool is_handled = false;
            var etor = _waitingBlockDict.GetEnumerator();

            while (etor.MoveNext())
            {
                Debug.LogError($"[UIManager]OnWaitingTimeOut: Handling waiting time out of {etor.Current.Key}");

                var callback = etor.Current.Value;

                if (callback != null)
                {
                    callback();
                    is_handled = true;
                }

                if (_waitingBlockDict.Count <= 0)
                {
                    break;
                }
            }

            Debug.Log("[UIManager]OnWaitingTimeOut: No waiting lock any more.");
            UnblockInput();
            _ClearWaitingBlock();

            if (!is_handled)
            {
                if (WaitingTimeOutDefaultCallback != null)
                {
                    WaitingTimeOutDefaultCallback.Invoke();
                }
            }
        }

        IEnumerator CrossFadeAlpha(Image image, float alpha, float duration, Action on_complete = null)
        {
            image.CrossFadeAlpha(alpha, duration, true);

            yield return new WaitForSeconds(duration);

            on_complete?.Invoke();
        }

        public void ShowTransitionPanel(Action on_complete = null)
        {
            if (TransitionPanel == null)
            {
                Debug.LogError("[UIManager]ShowTransitionPanel: TransitionPanel not found under UIRoot");
                return;
            }

            Debug.Log("[UIManager]ShowTransitionPanel");
            TransitionPanel.gameObject.SetActiveAsNeed(true);
            StartCoroutine(CrossFadeAlpha(TransitionPanel, 1f, TRANSITION_TIMER, on_complete));
            BlockInput();
        }

        public void HideTransitionPanel(Action on_complete = null)
        {
            if (TransitionPanel == null)
            {
                Debug.LogError("[UIManager]HideTransitionPanel: TransitionPanel not found under UIRoot");
                return;
            }

            if (!TransitionPanel.gameObject.activeSelf)
            {
                Debug.Log("[UIManager]HideTransitionPanel: TransitionPanel already hidden");
                return;
            }

            Debug.Log("[UIManager]HideTransitionPanel");
            UnblockInput();

            StartCoroutine(CrossFadeAlpha(TransitionPanel, 0f, TRANSITION_TIMER, () =>
            {
                TransitionPanel.gameObject.SetActiveAsNeed(false);
                on_complete?.Invoke();
            }));
        }

        void Awake()
        {
            Instance = this;
            UICanvas = GetComponent<Canvas>();
            //UICamera = UICanvas.renderMode == RenderMode.ScreenSpaceOverlay ? Camera.main : GetComponentInChildren<Camera>();
            graphicRaycaster = GetComponent<GraphicRaycaster>();
            RectTrans = GetComponent<RectTransform>();
            safeArea = Screen.safeArea;
            Vector2 sizeDelta = RectTrans.sizeDelta;
            float resolutionRatioHeight = sizeDelta.y;
            float heightRatio = resolutionRatioHeight / Screen.height;

            anchorMax = (Screen.height - safeArea.size.y - safeArea.position.y) * heightRatio;

            var panel = gameObject.FindChildGameObject("TransitionPanel");

            if (panel != null)
            {
                TransitionPanel = panel.GetComponent<Image>();
            }

            if (WaitingPanel != null)
            {
                InitWaitingPanel();
            }
        }

        void Start()
        {
            // Fix issues about pressing buttons. Sometime very small movements in finger touch can be interpreted as scrolling rather than a simple touch.
            if (EventSystem.current != null)
            {
                int defaultValue = EventSystem.current.pixelDragThreshold;
                EventSystem.current.pixelDragThreshold =
                    Mathf.Max(defaultValue, (int)(defaultValue * Screen.dpi / 160f));
            }
        }

        void InitWaitingPanel(RectTransform trans = null)
        {
            if (trans != null)
            {
                WaitingPanel = trans;
            }

            if (WaitingPanel != null)
            {
                waitingUI = WaitingPanel.gameObject.GetComponentInChildren<WaitingUI>();

                if (waitingUI != null)
                {
                    waitingUI.OnTimeOut = OnWaitingTimeOut;
                }
            }
        }

        void Update()
        {
            if (_waitingBlockDict.Count > 0 && !isWaitingBlockShowing())
            {
                float current_time = Time.realtimeSinceStartup;
                var delta_time = current_time - _waitingBlockStartTime;

                if (delta_time > _waitingAnimShowingTimer * 0.001f)
                {
                    ShowWaitingBlock(_waitingBlockTimeout);
                }
            }

            if (_eventSystem != null && _inputBlockTimer > 0)
            {
                _inputBlockTimer -= Time.unscaledDeltaTime;

                if (_inputBlockTimer < 0f)
                {
                    if (_onInputBlockTimeOut != null)
                    {
                        _onInputBlockTimeOut();
                        _onInputBlockTimeOut = null;
                    }

                    UnblockInput();
                }
            }
        }

        public bool IsShowingUI(UIType ui_type)
        {
            string ui_type_name = ui_type.Name;
            if (_UIDict.ContainsKey(ui_type_name) && null != _UIDict[ui_type_name] && _UIDict[ui_type_name].activeSelf)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public bool ContainsUI(UIType ui_type)
        {
            string ui_type_name = ui_type.Name;
            return ContainsUI(ui_type_name);
        }
        public bool ContainsUI(string ui_type_name)
        {
            if (_UIDict.ContainsKey(ui_type_name) && null != _UIDict[ui_type_name])
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public GameObject GetContainedUI(UIType ui_type)
        {
            GameObject ui_obj = null;
            string ui_type_name = ui_type.Name;
            if (_UIDict.ContainsKey(ui_type_name))
            {
                ui_obj = _UIDict[ui_type_name];

                if (ui_obj == null)
                {
                    _UIDict.Remove(ui_type_name);
                }
            }

            return ui_obj;
        }

        public async void PreloadUI(UIType ui_type, Transform parent = null)
        {
            var obj = await GetUIAsync(ui_type, parent);

            if (obj != null)
            {
                obj.SetActiveAsNeed(false);
            }
        }

        public async Task<GameObject> GetUIAsync(UIType ui_type, Transform parent = null)
        {
            GameObject ui_obj = null;
            string ui_type_name = ui_type.Name;

            if (_UIDict.ContainsKey(ui_type_name))
            {
                ui_obj = _UIDict[ui_type_name];

                if (ui_obj == null)
                {
                    _UIDict.Remove(ui_type_name);
                }
            }

            if (ui_obj == null && !_UIDict.ContainsKey(ui_type_name))
            {
                graphicRaycaster.enabled = false;
                ui_obj = await LoadUIAssetAsync(ui_type);
                graphicRaycaster.enabled = true;
            }

            if (ui_type != UITypes.common_tips)
            {
                GetUIAsyncEvent(ui_type_name);
            }
            return ui_obj;
        }
        async void GetUIAsyncEvent(string ui_type_name, bool isShow = true)
        {

            if (ui_type_name.Contains("_tips") || ui_type_name == UITypes.GuidancePanel.Name || ui_type_name == UITypes.ToastPanel.Name)
            {
                return;
            }
            await Awaiters.NextFrame;
            GContext.Publish(new GetUIAsyncEvent() { uIType = ui_type_name, show = isShow });
        }

        public void DestroyUI(UIType ui_type, int delay_ms = 0)
        {
            string ui_type_name = ui_type.Name;
            DestroyUI(ui_type_name, delay_ms);
        }
        public async void DestroyUI(string ui_type, int delay_ms = 0)
        {
            async void Release(GameObject obj, int ms)
            {
                await Task.Delay(ms);
                Addressables.Release(obj);
            }

            if (!_UIDict.ContainsKey(ui_type))
            {
                //JJ.Debug.Log("[UIManager]_UIDict doesn't contain UIType : {0}", uiType); 
                return;
            }

            if (_UIDict[ui_type] != null)
            {
                GameObject ui_obj = _UIDict[ui_type];
                GameObject ui_obj_aab = _UIDictABB[ui_type];

                if (ui_obj.transform == _topSibling)
                {
                    _topSibling = null;
                }

                if (delay_ms > 0)
                {
                    GameObject.Destroy(ui_obj, delay_ms * 0.001f);
                    Release(ui_obj_aab, delay_ms);
                }
                else
                {
                    GameObject.Destroy(ui_obj);
                    Addressables.Release(ui_obj_aab);
                }
            }

            _UIDict.Remove(ui_type);
            _UIDictABB.Remove(ui_type);
            await Awaiters.NextFrame;
            GetUIAsyncEvent(ui_type, false);
        }

        public async Task<GameObject> RestartShowUI(UIType ui_type)
        {
            GameObject ui_obj;
            string ui_type_name = ui_type.Name;
            if (_UIDictABB.ContainsKey(ui_type_name))
            {
                if (_UIDict.ContainsKey(ui_type_name))
                {
                    GameObject _ui_obj = _UIDict[ui_type_name];
                    GameObject.Destroy(_ui_obj);
                    _UIDict.Remove(ui_type_name);
                }
                await Awaiters.NextFrame;
                GameObject _ui_obj_abb = _UIDictABB[ui_type_name];
                ui_obj = Instantiate(_ui_obj_abb, transform);
                ui_obj.name = ui_type.Name;
                SetRectTransform(ui_obj.GetComponent<RectTransform>(), ui_type.UIOffset);
                // Make sure top sibling always on top.
                if (_topSibling != null)
                {
                    _topSibling.SetAsLastSibling();
                }
                _UIDict[ui_type_name] = ui_obj;
            }
            else
            {
                ui_obj = await GetUIAsync(ui_type);
            }

            if (ui_obj != null && !ui_obj.activeSelf)
            {
                ui_obj.SetActive(true);
            }
            return ui_obj;
        }

        /// <summary>
        /// 已经确定提前下好 或不需要下载的Panel 走这个接口
        /// 不显示Loading条
        /// </summary>
        /// <param name="ui_type"></param>
        /// <returns></returns>
        public async Task<GameObject> ShowUINotLoading(UIType ui_type)
        {
            GameObject ui_obj = await GetUIAsync(ui_type);
            if (ui_obj != null && !ui_obj.activeSelf)
            {
                ui_obj.SetActive(true);
            }
            await Awaiters.NextFrame;
            return ui_obj;
        }

        /// <summary>
        /// 如果需要下载 并且不下载 就返回 Null
        /// </summary>
        /// <param name="ui_type"></param>
        /// <returns></returns>
        public async Task<GameObject> ShowUIPack(UIType ui_type)
        {
            GameObject ui_obj = null;
            string ui_type_name = ui_type.Name;
            if (_UIDict.ContainsKey(ui_type_name))
            {
                ui_obj = _UIDict[ui_type_name];
                if (ui_obj == null)
                {
                    _UIDict.Remove(ui_type_name);
                }
            }

            if (ui_obj == null)
            {
                graphicRaycaster.enabled = false;
                ILoadResourceService loadResourceService = GContext.container.Resolve<ILoadResourceService>();
                bool isCanEnter = await loadResourceService.Load(ui_type.Path);
                if (!isCanEnter)
                {
                    TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
                    var panel = await ShowUINotLoading(UITypes.DownLoadPopupPanel);
                    panel.GetComponent<DownLoadPopupPanel>().SetBtn(() => { task.SetResult(true); }, () => { task.SetResult(false); });
                    graphicRaycaster.enabled = true;
                    bool result = await task.Task;
                    if (!result)
                    {
                        return null;
                    }
                    else
                    {
                        graphicRaycaster.enabled = false;
                    }
                }
                ui_obj = await LoadUIAssetAsync(ui_type);
                graphicRaycaster.enabled = true;
            }

            if (ui_type != UITypes.common_tips)
            {
                GetUIAsyncEvent(ui_type.Name);
            }

            if (ui_obj != null && !ui_obj.activeSelf)
            {
                ui_obj.SetActive(true);
            }

            await Awaiters.NextFrame;
            return ui_obj;
        }

        /// <summary>
        /// 不确定是否下载走这个接口 弹loading动画
        /// </summary>
        /// <param name="ui_type"></param>
        /// <returns></returns>

        public async Task<GameObject> ShowUILoad(UIType ui_type)
        {
            GameObject ui_obj = null;
            string ui_type_name = ui_type.Name;
            if (_UIDict.ContainsKey(ui_type_name))
            {
                ui_obj = _UIDict[ui_type_name];
                if (ui_obj == null)
                {
                    _UIDict.Remove(ui_type_name);
                }
            }

            if (ui_obj == null)
            {
                graphicRaycaster.enabled = false;
                ILoadResourceService loadResourceService = GContext.container.Resolve<ILoadResourceService>();
                bool isCanEnter = await loadResourceService.Load(ui_type.Path);
                if (!isCanEnter)
                {
                    TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
                    var panel = await ShowUINotLoading(UITypes.CloudTransitionPanel);
                    panel.GetComponent<CloudTransitionPanel>().SetBtn(false, () => { task.SetResult(true); }, () => { task.SetResult(false); });
                    graphicRaycaster.enabled = true;
                    bool result = await task.Task;
                    if (!result)
                    {
                        return null;
                    }
                    else
                    {
                        graphicRaycaster.enabled = false;
                    }
                }
                ui_obj = await LoadUIAssetAsync(ui_type);
                graphicRaycaster.enabled = true;
            }

            if (ui_type != UITypes.common_tips)
            {
                GetUIAsyncEvent(ui_type_name);
            }

            if (ui_obj != null && !ui_obj.activeSelf)
            {
                ui_obj.SetActive(true);
            }

            await Awaiters.NextFrame;
            return ui_obj;
        }

        /// <summary>
        /// 请使用 ShowUILoad 并做好判空处理
        /// 如果确定已经下载好或者不需要下载 请使用 ShowUINotLoading
        /// </summary>
        /// <param name="ui_type"></param>
        /// <returns></returns>
        public async Task<GameObject> ShowUI(UIType ui_type)
        {
            GameObject ui_obj = null;
            string ui_type_name = ui_type.Name;
            if (_UIDict.ContainsKey(ui_type_name))
            {
                ui_obj = _UIDict[ui_type_name];
                if (ui_obj == null)
                {
                    _UIDict.Remove(ui_type_name);
                }
            }

            if (ui_obj == null)
            {
                graphicRaycaster.enabled = false;
                ui_obj = await LoadUIAssetAsync(ui_type);
                graphicRaycaster.enabled = true;
            }

            if (ui_type != UITypes.common_tips)
            {
                GetUIAsyncEvent(ui_type_name);
            }

            if (ui_obj != null && !ui_obj.activeSelf)
            {
                ui_obj.SetActive(true);
            }
            ui_obj.transform.SetAsLastSibling();

            await Awaiters.NextFrame;
            return ui_obj;
        }

        void SetRectTransform(RectTransform rect, float UIOffset)
        {
            if (UIOffset > -1)
            {
                float min = 1.777778f;
                float aspect = (float)Screen.height / Screen.width;
                float offset = (Math.Clamp(aspect, min, 2.16f) - min) / (2.16f - min) * UIOffset;
                rect.offsetMin = new Vector2(0, offset + 20);
                float anchorMaxY = anchorMax > offset ? anchorMax : offset;
                rect.offsetMax = new Vector2(0, -anchorMaxY);
            }
        }

        async Task<GameObject> LoadUIAssetAsync(UIType ui_type)
        {
            var add = await Addressables.LoadAssetAsync<GameObject>(ui_type.Path).Task;
            GameObject ui_obj = null;
            string ui_type_name = ui_type.Name;
            if (add != null)
            {
                if (!_UIDict.ContainsKey(ui_type_name))
                {
                    var par = alertUIList.Contains(ui_type) ? alertContainer : transform;
                    ui_obj = Instantiate(add, par);
                    ui_obj.name = ui_type.Name;
                    SetRectTransform(ui_obj.GetComponent<RectTransform>(), ui_type.UIOffset);
                    // Make sure top sibling always on top.
                    if (_topSibling != null)
                    {
                        _topSibling.SetAsLastSibling();
                    }
                    _UIDictABB[ui_type_name] = add;
                    _UIDict.Add(ui_type_name, ui_obj);
                }
                else
                {
                    ui_obj = _UIDict[ui_type_name];
                    Addressables.Release(add);
                }
            }
            return ui_obj;
        }


        public async void HideUI(UIType ui_type)
        {
            string ui_type_name = ui_type.Name;
            if (_UIDict.ContainsKey(ui_type_name) == false || _UIDict[ui_type_name] == null)
            {
                return;
            }

            GameObject ui_obj = _UIDict[ui_type_name];

            if (ui_obj.transform == _topSibling)
            {
                _topSibling = null;
            }

            if (ui_obj.activeSelf)
            {
                ui_obj.SetActive(false);
                await Awaiters.NextFrame;
                GetUIAsyncEvent(ui_type_name, false);
            }
        }

        public void SetAlwaysTopSibling(Transform top_transform)
        {
            _topSibling = top_transform;
        }

        // public bool IsUIEnable()
        // {
        //     return UICamera.enabled;
        // }
        //
        // public void ShowUI()
        // {
        //     UICamera.enabled = true;
        // }
        //
        // public void HideUI()
        // {
        //     UICamera.enabled = false;
        // }

        // Put the given object transform on top of all the UI
        public void PutOnTop(Transform ui_trans)
        {
            ui_trans.SetParent(RectTrans);
            ui_trans.SetAsLastSibling();

            // Make sure top sibling always on top.
            if (_topSibling != null)
            {
                _topSibling.SetAsLastSibling();
            }
        }

        /// <summary>
        /// Clone the first Sprite in this atlas that matches the name packed in this atlas and return it.
        /// Note: Using AssetBundle.GetAsset<Sprite> will not clone, and will be better.
        /// </summary>
        /// <param name="atlas_name"></param>
        /// <param name="sprite_name"></param>
        /// <returns></returns>
        public Sprite GetSprite(string atlas_name, string sprite_name)
        {
            Sprite sprite_ret = null;

            if (_atlasDict.TryGetValue(atlas_name, out var atlas_cache))
            {
                if (atlas_cache.spriteDict.ContainsKey(sprite_name))
                {
                    sprite_ret = atlas_cache.spriteDict[sprite_name];
                }
                else
                {
                    sprite_ret = atlas_cache.atlas.GetSprite(sprite_name);
                    atlas_cache.spriteDict[sprite_name] = sprite_ret;
                }
            }
            else
            {
                //var atlas = AssetManager.LoadAsset<SpriteAtlas>(atlas_name);
                var atlas = Addressables.LoadAssetAsync<SpriteAtlas>(atlas_name).WaitForCompletion();

                if (atlas != null)
                {
                    var new_atlas_cache = new SpriteAtlasCache
                    {
                        atlas = atlas
                    };
                    sprite_ret = atlas.GetSprite(sprite_name);
                    new_atlas_cache.spriteDict[sprite_name] = sprite_ret;
                }
            }

            if (sprite_ret == null)
            {
                Debug.LogError($"[UIManager]GetSprite: Not found sprite {sprite_name} in Atlas {atlas_name}");
            }

            return sprite_ret;
        }

        public void ClearAllUIAtlasRef()
        {
            _atlasDict.Clear();
        }

        public void ReleaseSpriteDic(string dicName)
        {
            if (!string.IsNullOrEmpty(dicName) && _spriteDict.TryGetValue(dicName, out var sprites))
            {
                foreach (var item in sprites)
                {
                    Addressables.Release(item.Value);
                }
                _spriteDict.Remove(dicName);
            }
        }
        public async Task SetTexture(RawImage rawImage, string textureName, string dicName = "dicName")
        {
            Texture texture;
            if (_textureDict.TryGetValue(dicName, out var textures))
            {
                if (textures.TryGetValue(textureName, out texture))
                {
                    rawImage.texture = texture;
                    return;
                }
            }
            else
            {
                textures = new Dictionary<string, Texture>();
                _textureDict.Add(dicName, textures);
            }

            texture = await Addressables.LoadAssetAsync<Texture>(textureName).Task;
            if (texture != null)
            {
                if (textures.ContainsKey(textureName))
                {
                    Addressables.Release(texture);
                    rawImage.texture = textures[textureName];
                }
                else
                {
                    rawImage.texture = texture;
                    textures[textureName] = texture;
                }
            }
        }
        public void ReleaseTextureDic(string dicName)
        {
            if (!string.IsNullOrEmpty(dicName) && _textureDict.TryGetValue(dicName, out var textures))
            {
                foreach (var item in textures)
                {
                    Addressables.Release(item.Value);
                }
                _textureDict.Remove(dicName);
            }
        }

        public Vector2 WorldToScreen(Vector3 worldPos)
        {
            Camera camera;
            if (UICanvas != null && UICanvas.worldCamera != null)
                camera = UICanvas.worldCamera;
            else
                camera = Camera.main;
            var screenPoint = RectTransformUtility.WorldToScreenPoint(Camera.main, worldPos);
            var res = camera.ScreenToWorldPoint(screenPoint);
            return res;
        }
    }
}