using UnityEngine;
using System;
using System.Collections.Generic;
using System.IO;
using Cysharp.Threading.Tasks;
using UnityEngine.UI;
using Object = UnityEngine.Object;
using PhxhSDK;

public partial class UIRoot : SingletonMono<UIRoot>
{
    public Canvas RootCanvas;
    // 所有UI的根节点
    public GameObject Root;
    public Camera UICamera;
    public Camera UITopCamera;
    public GameObject UITopRoot;
    
    /// <summary>
    /// UI层级根节点字典（私有，通过方法访问）
    /// </summary>
    private Dictionary<UICanvasLayer, GameObject> _rootDic = new(6);
    
    // [Range(-5, 5)]
    // public float offsetX = 1.32f;
    // [Range(-5, 5)]
    // public float offsetY = 1.26f;
    // [Range(-5, 5)]
    // public float offsetZ = 0.83f;
    
    // Loading节点
    //public GameObject mUILoading;

    // 尝试修复花屏的问题
    bool isDirty = false;
    Font dirtyFont = null;
    
    
    public void Awake()
    {
        Object.DontDestroyOnLoad(this.gameObject);

        // Font.textureRebuilt += delegate (Font font1)
        // {
        //     isDirty = true;
        //     dirtyFont = font1;
        // };

        // var assemblies = AppDomain.CurrentDomain.GetAssemblies();
        //mUILoading.AddComponent(typeof(SliderZero));
        var backGround = transform.Find("UIBackGround");
        var normal = transform.Find("UINormal");
        var foreGround = transform.Find("UIForeGround");
        var tips = transform.Find("UITips");
        var guide = transform.Find("UIGuide");
        var system = transform.Find("UISystem");
        if (backGround)
        {
            _rootDic.Add(UICanvasLayer.BackGround, backGround.gameObject);
        }
        if (normal)
        {
            _rootDic.Add(UICanvasLayer.Normal, normal.gameObject);
        }
        if (foreGround)
        {
            _rootDic.Add(UICanvasLayer.ForeGround, foreGround.gameObject);
        }
        if (tips)
        {
            _rootDic.Add(UICanvasLayer.Tips, tips.gameObject);
        }
        if (guide)
        {
            _rootDic.Add(UICanvasLayer.Guide, guide.gameObject);
        }
        if (system)
        {
            _rootDic.Add(UICanvasLayer.System, system.gameObject);
        }
    }

    // private void LateUpdate()
    // {
    //     if (isDirty)
    //     {
    //         isDirty = false;
    //         foreach (Text text in FindObjectsOfType<Text>())
    //         {
    //             if (text.font == dirtyFont)
    //             {
    //                 text.FontTextureChanged();
    //             }
    //         }
    //         dirtyFont = null;
    //     }
    // }

    /// <summary>
    /// Creates the window.
    /// </summary>
    /// <returns>The window.</returns>
    /// <param name="windowName">UI预设名</param>
    /// <param name="type">UI类型</param>
    /// <param name="layer">UI层级</param>
    public async UniTask<UIWindow> CreateWindow(string windowName, UICanvasLayer layer = UICanvasLayer.Normal)
    {
        GameObject uiPrefab = await LoadPrefab(windowName);
        if (uiPrefab is null)
        {
            DebugUtil.LogError("{0}.CreateWindow, cannot find window resource : {1}", GetType(), windowName);
            return null;
        }

        UIWindow window = null;
        var root = _rootDic[layer];
        GameObject obj = Instantiate(uiPrefab, root.transform, false) as GameObject;
        string[] dirs = windowName.Split('/');
        string className = dirs[dirs.Length - 1] + "Controller";
        
        //window = obj.AddComponent(CommonUtilsFramework.GamePlayAssembly.GetType(className)) as UIWindow;
        window = CommonUtilsFramework.GamePlayAssembly.CreateInstance(className) as UIWindow;
        UIManager.BindWindowObj(window, obj);
        
        if (window == null)
        {
            DebugUtil.LogError("Cant find UIWindow: {0}, check the name or remove any outter namespace.", className);
            return null;
        }
        
        return window;
    }

    async UniTask<GameObject> LoadObj(string windowName)
    {
        GameObject uiPrefab = null;
        DebugUtil.Log($"LoadWindow:{windowName}");
        var path = string.Format(UIManager.UI_PREFAB_PATH, windowName);
        uiPrefab = await AssetManager.Instance.LoadAssetAsync<GameObject>(path);
        return uiPrefab;
    }

    private async UniTask<GameObject> LoadPrefab(string wName)
    {
        string windowName = wName;
        GameObject uiPrefab = null;
        // if (CommonUtils.IsLE_16_10())
        // {
        //     uiPrefab = LoadObj(windowName + "_Pad");
        //     if (uiPrefab == null)// 增加一层兼容。如果ab包里加载不到，就去Resources目录里加载
        //     {
        //         uiPrefab = Resources.Load<GameObject>(Path.Combine("Loading",windowName + "_Pad"));
        //     }
        // }

        if (uiPrefab is null)
        {
            uiPrefab = await LoadObj(windowName);
            if (uiPrefab is null) // 增加一层兼容。如果ab包里加载不到，就去Resources目录里加载
            {
                uiPrefab = Resources.Load<GameObject>(Path.Combine("Loading",windowName));
            }
        }

        return uiPrefab;
    }
    

    public Vector2 GetScreenCanvasScale()
    {
        var rectTransform = Root.GetComponent<RectTransform>();
        var screenSize = new Vector2(Screen.width, Screen.height);
        var rect = rectTransform.rect;
        return new Vector2(screenSize.x / rect.width, screenSize.y / rect.height);
    }

    public void EnableTouch(bool b)
    {
        var cg = RootCanvas.GetComponent<CanvasGroup>();
        cg.interactable = b;
        cg.blocksRaycasts = b;
    }

    /// <summary>
    /// 是否激活射线检测
    /// </summary>
    /// <param name="isEnable"></param>
    public void IsEnableGraphicRaycaster(bool isEnable)
    {
        GraphicRaycaster graphicRaycaster = Root.GetComponent<GraphicRaycaster>();
        if (graphicRaycaster is null)
            return;

        graphicRaycaster.enabled = isEnable;
    }

    /// <summary>
    /// 新手引导是否激活射线检测（新手引导用）
    /// </summary>
    /// <param name="isEnable"></param>
    public void IsEnableGraphicRaycasterByGuide(bool isEnable)
    {
        foreach (var kv in UIManager.Instance.mMemoryWindows)
        {
            if (UINameConst.UIFightScene == kv.Key)
                continue;

            if (UINameConst.UINoticeOne == kv.Key)
                continue;

            if (UINameConst.UINoticeTwo == kv.Key)
                continue;

            if (UINameConst.UI_GuideTip == kv.Key)
                continue;

            if (UINameConst.UI_Guide == kv.Key)
                continue;

            kv.Value.GraphicRaycasterManager.IsEnableGraphicRaycaster = isEnable;
        }
    }

    public void EnterUITopState()
    {
        UITopCamera.gameObject.SetActive(true);
    }

    public void ExitUITopState()
    {
        //UITopCamera.gameObject.SetActive(false);
    }

    public void AddUI2UITopRoot(GameObject obj, bool isFirst = false)
    {
        if (UITopRoot)
        {
            obj.transform.SetParent(UITopRoot.transform);
            if (isFirst)
                obj.transform.SetAsFirstSibling();
        }
    }

    /// <summary>
    /// 设置UI窗口的层级
    /// </summary>
    /// <param name="window">UI窗口</param>
    /// <param name="layer">目标层级</param>
    public void SetLayer(UIWindow window, UICanvasLayer layer)
    {
        if (window == null)
        {
            DebugUtil.LogWarning("[UIRoot] UIWindow is null");
            return;
        }
        
        SetLayer(window.gameObject, layer);
    }

    /// <summary>
    /// 设置UI对象的层级（用于非窗口UI元素，如血条、行动条等动态UI元素）
    /// </summary>
    /// <param name="go">UI对象</param>
    /// <param name="layer">目标层级</param>
    public void SetLayer(GameObject go, UICanvasLayer layer)
    {
        if (go == null)
        {
            DebugUtil.LogWarning("[UIRoot] GameObject is null");
            return;
        }
        
        if (!_rootDic.TryGetValue(layer, out GameObject goRoot))
        {
            DebugUtil.LogWarning($"[UIRoot] Cannot find canvas for layer: {layer}");
            return;
        }

        go.transform.SetParent(goRoot.transform, false);
    }
    
    /// <summary>
    /// 获取指定层级的根节点
    /// </summary>
    /// <param name="layer">UI层级</param>
    /// <returns>对应的根节点GameObject，如果不存在返回null</returns>
    public GameObject GetLayerRoot(UICanvasLayer layer)
    {
        return _rootDic.TryGetValue(layer, out var root) ? root : null;
    }
    
    /// <summary>
    /// 获取所有根节点的只读字典（用于初始化等场景）
    /// </summary>
    /// <returns>只读的根节点字典</returns>
    public IReadOnlyDictionary<UICanvasLayer, GameObject> GetAllLayerRoots()
    {
        return _rootDic;
    }
}