using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;

namespace TyphoonUI
{
    internal class UIManagerImpl : MonoBehaviour
    {
        private static readonly object _lock = new object();
        private static UIManagerImpl _instance = null;

        public static UIManagerImpl Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_lock)
                    {
                        if (_instance == null)
                        {
                            var clone = new GameObject("UIManager");
                            _instance = clone.AddComponent<UIManagerImpl>();
                            _instance.Init();
                        }
                    }
                }

                return _instance;
            }
        }

        //行为队列
        public IOperationQueue OperationQueue;

        //UI相机
        public UICamera UICamera;

        //EventSystem
        public EventSystem EventSystem;

        //画布字典
        public Dictionary<CanvasLayer, UICanvas> Canvases = new Dictionary<CanvasLayer, UICanvas>();

        //层级面板
        public Dictionary<CanvasLayer, HashSet<string>> LayerPanels = new Dictionary<CanvasLayer, HashSet<string>>();

        //UI面板
        public Dictionary<string, UIPanel> Panels = new Dictionary<string, UIPanel>();

        public AbstractBinding Binding;

        //UI资源包
        public Dictionary<string, UIPackage> UIPackages = new Dictionary<string, UIPackage>();


        //是否存在实例
        public static bool HasInstance() => _instance != null;

        private void Init()
        {
            DontDestroyOnLoad(gameObject);
            //构建队列
            var operationQueue = gameObject.AddComponent<UIOperationQueue>();
            operationQueue.Initialize();
            OperationQueue = operationQueue;
            //绑定UIBinding
            InitializeBinding();
            //初始化画布
            InitializeCanvas();
#if UNITY_EDITOR
            //添加监控类
            gameObject.AddComponent<UIManagerMonitor>();
#endif
        }

        /// <summary>
        /// 初始化绑定UI资源
        /// </summary>
        private void InitializeBinding()
        {
            var type = GetType("TyphoonUI.UIBinding");
            if (type == null)
            {
                throw new Exception("未找到TyphoonUI.UIBinding,请先执行TyphoonUI/安装,生成资源绑定类UIBinding.cs");
            }

            Binding = Activator.CreateInstance(type) as AbstractBinding;
            Binding.Initialize();
        }

        /// <summary>
        /// 初始化画布
        /// </summary>
        private void InitializeCanvas()
        {
            var coreSource = CoreSource.Default;
            if (coreSource == null)
            {
                throw new Exception($"不存在画布资源,请从选项中导入预设...");
            }

            if (coreSource.UICamera == null)
            {
                throw new Exception($"{coreSource} 未配置UICamera");
            }

            if (coreSource.EventSystem == null)
            {
                throw new Exception($"{coreSource} 未配置EventSystem");
            }

            UICamera = Instantiate(coreSource.UICamera).GetComponent<UICamera>();
            if (UICamera == null)
            {
                throw new Exception($"{coreSource.UICamera}缺少UICamera组件");
            }

            DontDestroyOnLoad(UICamera.gameObject);

            EventSystem = Instantiate(coreSource.EventSystem).GetComponent<EventSystem>();

            if (EventSystem == null)
            {
                throw new Exception($"{coreSource.EventSystem}缺少EventSystem组件");
            }

            DontDestroyOnLoad(EventSystem.gameObject);

            //创建画布
            foreach (var element in coreSource.Canvases)
            {
                var clone = Instantiate(element);
                clone.name = element.name;
                var canvas = clone.GetComponent<UICanvas>();
                canvas.Canvas.worldCamera = UICamera.Camera;
                if (canvas == null)
                {
                    throw new Exception($"{element}缺少组件：UICanvas");
                }

                DontDestroyOnLoad(clone);
                Canvases.Add(canvas.Layer, canvas);
                LayerPanels.Add(canvas.Layer, new HashSet<string>());
            }
        }

        /// <summary>
        /// 初始化
        /// </summary>
        public void Initialize()
        {
        }

        /// <summary>
        /// 获取画布
        /// </summary>
        public UICanvas GetCanvas(CanvasLayer layer)
        {
            return Canvases[layer];
        }

        /// <summary>
        /// 获取资源
        /// </summary>
        public GameObject GetSourcePrefab(string package, string sourceName)
        {
            if (!UIPackages.TryGetValue(package, out var match))
            {
                throw new Exception($"未注入UIPackage:{package}");
            }

            if (match.TryGet(sourceName, out var source))
            {
                return source;
            }

            throw new Exception($"UIPackage不存在资源：{sourceName}");
        }

        /// <summary>
        /// 注册面板到画布
        /// </summary>
        public T CreatePanel<T>() where T : UIPanel
        {
            var script = typeof(T).FullName;
            if (Panels.TryGetValue(script, out var match))
            {
                //已经生成，直接返回
                return match as T;
            }

            var (binding, layer) = Binding.GetPanelBinding<T>();
            var source = GetSourcePrefab(binding.Package, binding.SourceName);
            var canvas = GetCanvas(layer);
            var clone = Instantiate(source, canvas.Canvas.transform);
            clone.transform.localPosition = Vector3.zero;
            clone.transform.localEulerAngles = Vector3.zero;
            clone.transform.localScale = Vector3.one;
            var result = clone.AddComponent<T>();
            var view = clone.GetComponent<UIObject>();
            if (view == null)
            {
                throw new Exception($"view为null,{binding.SourceName}资源根节点不存在UIObject");
            }

            result.Attach(view);
            result.PanelScript = script;
            result.RootView.alpha = 0;
            result.RootView.blocksRaycasts = false;
            LayerPanels[layer].Add(script);
            Panels.Add(script, result);
            return result;
        }

        /// <summary>
        /// 实例化组件
        /// </summary>
        public T CreateComponent<T>() where T : UIComponent
        {
            var binding = Binding.GetComponentBinding<T>();
            var source = GetSourcePrefab(binding.Package, binding.SourceName);
            var clone = Instantiate(source);
            var result = clone.AddComponent<T>();
            var view = clone.GetComponent<UIObject>();
            if (view == null)
            {
                throw new Exception($"view为null,{binding.SourceName}资源根节点不存在UIObject");
            }

            result.Attach(view);
            return result;
        }

        /// <summary>
        /// 实例化组件
        /// </summary>
        public static T CreateComponent<T>(GameObject viewObjectRoot) where T : UIComponent
        {
            var view = viewObjectRoot.GetComponent<UIObject>();
            var result = viewObjectRoot.AddComponent<T>();
            if (view == null)
            {
                throw new Exception($"{viewObjectRoot} 不存在 UIObject");
            }

            result.Attach(view);
            return result;
        }

        /// <summary>
        /// 实例化组件
        /// </summary>
        /// <param name="parent"></param>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public T CreateComponent<T>(Transform parent) where T : UIComponent
        {
            var binding = Binding.GetComponentBinding<T>();
            var source = GetSourcePrefab(binding.Package, binding.SourceName);
            var clone = Instantiate(source, parent);
            var result = clone.AddComponent<T>();
            var view = clone.GetComponent<UIObject>();
            if (view == null)
            {
                throw new Exception($"view为null,{binding.SourceName}资源根节点不存在UIObject");
            }

            result.Attach(view);
            return result;
        }


        /// <summary>
        /// 打开面板
        /// </summary>
        public void OpenPanel<T>(object data = null) where T : UIPanel
        {
            var panelName = typeof(T).FullName;
            //获取面板层级
            var (binding, layer) = Binding.GetPanelBinding<T>();
            var canvas = GetCanvas(layer);
            switch (canvas.Mode)
            {
                case UICanvas.PanelMode.Single: //单页面模式
                {
                    //关闭该层画布的其它面板
                    var hash = LayerPanels[layer];
                    foreach (var element in hash)
                    {
                        if (element != panelName)
                        {
                            Panels[element].Close();
                        }
                    }
                }
                    break;
            }

            if (Panels.TryGetValue(panelName, out var match))
            {
                match.Open(data);
            }
            else
            {
                CreatePanel<T>().Open(data);
            }
        }

        /// <summary>
        /// 关闭面板
        /// </summary>
        public void ClosePanel<T>(object data = null) where T : UIPanel
        {
            var panelName = typeof(T).FullName;
            if (Panels.TryGetValue(panelName, out var match))
            {
                match.Close(data);
            }
        }

        /// <summary>
        /// 关闭所有
        /// </summary>
        public void CloseAll(CanvasLayer[] ignoreLayers = null, string[] panels = null)
        {
            var ignore = new HashSet<string>();
            if (ignoreLayers != null)
            {
                foreach (var layer in ignoreLayers)
                {
                    var arr = LayerPanels[layer];
                    foreach (var element in arr)
                    {
                        ignore.Add(element);
                    }
                }
            }

            if (panels != null)
            {
                foreach (var element in panels)
                {
                    ignore.Add(element);
                }
            }

            foreach (var kv in Panels)
            {
                var key = kv.Key;
                var panel = kv.Value;
                if (!ignore.Contains(key))
                {
                    panel.Close();
                }
            }
        }

        /// <summary>
        /// 获取面板
        /// </summary>
        public T GetPanel<T>() where T : UIPanel
        {
            var fullname = typeof(T).FullName;
            if (Panels.TryGetValue(fullname, out var match))
            {
                return match as T;
            }

            return null;
        }

        /// <summary>
        /// 获取面板
        /// </summary>
        public UIPanel GetPanel(string panelScript)
        {
            if (Panels.TryGetValue(panelScript, out var match))
            {
                return match;
            }

            return null;
        }

        /// <summary>
        /// 是否存在面板
        /// </summary>
        public bool HasPanel<T>() where T : UIPanel
        {
            var fullname = typeof(T).FullName;
            return HasPanel(fullname);
        }

        /// <summary>
        /// 是否存在面板
        /// </summary>
        public bool HasPanel(string panelScript)
        {
            return Panels.ContainsKey(panelScript);
        }

        /// <summary>
        /// 获取层级画布面板
        /// </summary>
        public List<UIPanel> GetCanvasPanels(CanvasLayer layer)
        {
            var result = new List<UIPanel>();
            if (LayerPanels.TryGetValue(layer, out var match))
            {
                foreach (var fullname in match)
                {
                    var panel = GetPanel(fullname);
                    if (panel != null)
                    {
                        result.Add(panel);
                    }
                }
            }

            return result;
        }

        /// <summary>
        /// 层级画布面板排序（按binding item优先级）
        /// </summary>
        public void SortCanvasPanelsInHierarchy(CanvasLayer canvasLayer)
        {
            var bindingItems = new List<BindingItem>();
            //获取顺序
            var panels = GetCanvasPanels(canvasLayer);
            var panelOrders = new List<UIPanel>();
            foreach (var panel in panels)
            {
                var item = Binding.GetPanelBinding(panel.PanelScript);
                if (item != null)
                {
                    panelOrders.Add(panel);
                    bindingItems.Add(item);
                }
            }

            panelOrders.Sort((a, b) =>
            {
                return a.transform.GetSiblingIndex().CompareTo(b.transform.GetSiblingIndex());
            });
            bindingItems.Sort((a, b) => { return a.Priority.CompareTo(b.Priority); });
            var rebuild = false;
            for (int i = 0; i < panelOrders.Count && i < bindingItems.Count; i++)
            {
                if (panelOrders[i].PanelScript != bindingItems[i].Script)
                {
                    rebuild = true;
                    break;
                }
            }

            if (rebuild)
            {
                //更新层级排序
                foreach (var element in panelOrders)
                {
                    element.transform.SetAsLastSibling();
                }
            }
        }

        /// <summary>
        /// 注入资源包
        /// </summary>
        public void LoadPackage(UIPackage package)
        {
            var packageName = package.name;
            UIPackages[packageName] = package;
        }

        /// <summary>
        /// 卸载资源包
        /// </summary>
        public void UnloadPackage(string packageName)
        {
            if (UIPackages.TryGetValue(packageName, out var match))
            {
                UIPackages.Remove(packageName);
                Resources.UnloadAsset(match);
            }
        }

        /// <summary>
        /// 获取UIPackage
        /// </summary>
        public UIPackage GetPackage(string packageName)
        {
            if (UIPackages.TryGetValue(packageName, out var match))
            {
                return match;
            }

            throw new Exception("未注入UIPackage:{packageName");
        }

        /// <summary>
        /// 销毁面板
        /// </summary>
        public bool DestroyPanel<T>() where T : UIPanel
        {
            var panelScript = typeof(T).FullName;
            return DestroyPanel(panelScript);
        }

        /// <summary>
        /// 销毁面板
        /// </summary>
        public bool DestroyPanel(string panelScript)
        {
            if (panelScript == null)
            {
                return false;
            }

            if (Panels.TryGetValue(panelScript, out var match))
            {
                Destroy(match.gameObject);
                Panels.Remove(panelScript);
                foreach (var layer in LayerPanels)
                {
                    layer.Value.Remove(panelScript);
                }

                return true;
            }

            return false;
        }

        /// <summary>
        /// 通知语言发生变化
        /// </summary>
        public void NoticeLanguageChanged()
        {
            foreach (var kv in Panels)
            {
                var panel = kv.Value;
                panel.OnLanguageChanged();
            }
        }

        /// <summary>
        /// 反射获取类型
        /// </summary>
        private static Type GetType(string typeName)
        {
            Type type = null;
            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
            {
                type = assembly.GetType(typeName);
                if (type != null)
                    break;
            }

            return type;
        }
    }
}