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

namespace vnxbqy.UI
{
    
    public class WindowCenter : SingletonMonobehaviour<WindowCenter>
    {
        public event Action<Window> windowBeforeOpenEvent;
        public event Action<Window> windowAfterOpenEvent;
        public event Action<Window> windowBeforeCloseEvent;
        public event Action<Window> windowAfterCloseEvent;
        public event Action<Window> jumpWindowCloseEvent;

        UIRoot m_UIRoot;
        public UIRoot uiRoot
        {
            get
            {
                if (m_UIRoot == null)
                {
                    var prefab = BuiltInLoader.LoadPrefab("UIRoot");
                    var instance = GameObject.Instantiate(prefab, Vector3.zero, Quaternion.identity);
                    instance.name = "UIRoot";
                    m_UIRoot = instance.GetComponent<UIRoot>();
                    if (Application.isPlaying)
                    {
                        GameObject.DontDestroyOnLoad(instance);
                    }
                }
                return m_UIRoot;
            }
        }

        WindowAsyncLoad m_AnyncLoad;
        public WindowAsyncLoad asyncLoad
        {
            get
            {
                if (m_AnyncLoad == null)
                {
                    var gameObject = new GameObject("WindowAnyncLoad");
                    m_AnyncLoad = gameObject.AddMissingComponent<WindowAsyncLoad>();
                    GameObject.DontDestroyOnLoad(gameObject);
                }

                return m_AnyncLoad;
            }
        }

        Windows windows = new Windows();
        List<OpenCommand> openCommands = new List<OpenCommand>();
        List<CloseCommand> closeCommands = new List<CloseCommand>();

        public T Get<T>() where T : Window
        {
            T win = null;
            if (TryGetWindow(out win))
            {
                return win;
            }
            else
            {
                DebugEx.LogFormat("没有找到窗口:{0}", typeof(T).Name);
                return null;
            }

        }

        public Window Get(string name)
        {
            WindowTrim(name);
            if (windows.ContainsKey(name))
            {
                return windows[name];
            }
            else
            {
                return null;
            }
        }

        public WindowType GetWindowType(string name)
        {
            return windows.GetWindowType(name);
        }

        public void OpenFromLocal<T>(int functionOrder = 0) where T : Window
        {
            var command = new OpenCommand()
            {
                name = typeof(T).Name,
                sync = true,
                playAnimatioin = false,
                fromBuiltIn = true,
                functionOrder = functionOrder
            };

            PushOpenCommand(command);
        }

        public void OpenFromLocal(string name)
        {
            var command = new OpenCommand()
            {
                name = name,
                sync = true,
                playAnimatioin = false,
                fromBuiltIn = true,
                functionOrder = 0
            };

            PushOpenCommand(command);
        }

        public void Open<T>(bool forceSync = false, int functionOrder = 0, string fixParentName = "") where T : Window
        {
            var command = new OpenCommand()
            {
                name = typeof(T).Name,
                sync = forceSync,
                playAnimatioin = true,
                fromBuiltIn = false,
                functionOrder = functionOrder,
                fixParentName = fixParentName
            };

            PushOpenCommand(command);
        }

        public void Open(string name, bool forceSync = false, int functionOrder = 0, string fixParentName = "")
        {
            var command = new OpenCommand()
            {
                name = name,
                sync = forceSync,
                playAnimatioin = true,
                fromBuiltIn = false,
                functionOrder = functionOrder,
                fixParentName = fixParentName
            };

            PushOpenCommand(command);
        }

#if UNITY_EDITOR
        public Dictionary<string, bool> openWinNames = new Dictionary<string, bool>();
#endif

        private void PushOpenCommand(OpenCommand command)
        {
#if UNITY_EDITOR
            //用于工具导出打开的界面的图片
            openWinNames[command.name] = command.fromBuiltIn;
#endif
            DebugEx.LogFormat("打开窗口：{0} ", command.name);
            var name = command.name;
            var index = closeCommands.FindIndex((x) => { return x.name == name; });
            if (index != -1)
            {
                closeCommands.RemoveAt(index);
            }

            var exist = openCommands.Exists((x) => { return x.name == name; });
            if (!exist)
            {
                openCommands.Add(command);
            }
        }

        public void Close<T>() where T : Window
        {
            PushCloseCommand(new CloseCommand()
            {
                name = typeof(T).Name,
            });
        }

        public void Close(string name)
        {
            if (WindowConfig.IsChildWindow(name))
            {
                CloseImmediately(name);
            }
            else
            {
                PushCloseCommand(new CloseCommand()
                {
                    name = name,
                });
            }
        }

        public void CloseImmediately(string name)
        {
            Window window;
            if (windows.TryGetValue(name, out window))
            {
                if (window.windowState != Window.WindowState.Closed)
                {
                    window.CloseImmediately();
                }
            }
        }

        private void PushCloseCommand(CloseCommand command)
        {
            var name = command.name;
            var index = openCommands.FindIndex((x) => { return x.name == name; });
            if (index != -1)
            {
                openCommands.RemoveAt(index);
            }

            var exist = closeCommands.Exists((x) => { return x.name == name; });
            if (!exist)
            {
                closeCommands.Add(command);
            }
        }

        public List<string> GetAll()
        {
            return new List<string>(windows.Keys);
        }

        public void CloseAll(CloseAllIgnoreType ignoreType = CloseAllIgnoreType.BaseAndCustom)
        {
            for (var i = windows.Keys.Count - 1; i >= 0; i--)
            {
                var name = windows.Keys[i];
                var window = windows[name];
                if (window == null)
                {
                    continue;
                }

                var isIgnore = false;
                switch (ignoreType)
                {
                    case CloseAllIgnoreType.Base:
                        isIgnore = window.windowInfo.windowType <= WindowType.Base;
                        break;
                    case CloseAllIgnoreType.BaseAndCustom:
                        isIgnore = window.windowInfo.windowType <= WindowType.Base || CloseAllIgnoreWindowConfig.IsIgnore(name);
                        break;
                    case CloseAllIgnoreType.System:
                        isIgnore = window.windowInfo.windowType >= WindowType.System;
                        break;
                    case CloseAllIgnoreType.Custom:
                        isIgnore = CloseAllIgnoreWindowConfig.IsIgnore(name);
                        break;
                    case CloseAllIgnoreType.SystemAndCustom:
                        isIgnore = window.windowInfo.windowType >= WindowType.System || CloseAllIgnoreWindowConfig.IsIgnore(name);
                        break;
                }

                isIgnore = isIgnore || WindowConfig.IsChildWindow(name);
                if (!isIgnore)
                {
                    if (window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening)
                    {
                        Close(name);
                    }
                }
            }

            asyncLoad.StopAllTasks();
        }

        public void CloseOthers<T>() where T : Window
        {
            for (var i = windows.Keys.Count - 1; i >= 0; i--)
            {
                var name = windows.Keys[i];
                var window = windows[name];
                if (window == null || window is T)
                {
                    continue;
                }

                var isIgnore = WindowConfig.IsChildWindow(name);
                if (isIgnore)
                {
                    continue;
                }

                if (window != null)
                {
                    if (window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening)
                    {
                        Close(name);
                    }
                }
            }

            asyncLoad.StopAllTasks();
        }

        public void CloseOthers(List<string> windowNames, CloseAllIgnoreType ignoreType)
        {
            for (var i = windows.Keys.Count - 1; i >= 0; i--)
            {
                var name = windows.Keys[i];
                var window = windows[name];
                if (window == null)
                {
                    continue;
                }

                var isIgnore = false;
                switch (ignoreType)
                {
                    case CloseAllIgnoreType.Base:
                        isIgnore = windowNames.Contains(name) || window.windowInfo.windowType <= WindowType.Base;
                        break;
                    case CloseAllIgnoreType.BaseAndCustom:
                        isIgnore = windowNames.Contains(name) || window.windowInfo.windowType <= WindowType.Base || CloseAllIgnoreWindowConfig.IsIgnore(name);
                        break;
                    case CloseAllIgnoreType.System:
                        isIgnore = windowNames.Contains(name) || window.windowInfo.windowType >= WindowType.System;
                        break;
                    case CloseAllIgnoreType.Custom:
                        isIgnore = windowNames.Contains(name) || CloseAllIgnoreWindowConfig.IsIgnore(name);
                        break;
                    case CloseAllIgnoreType.SystemAndCustom:
                        isIgnore = windowNames.Contains(name) || window.windowInfo.windowType >= WindowType.System || CloseAllIgnoreWindowConfig.IsIgnore(name);
                        break;
                }

                isIgnore = isIgnore || WindowConfig.IsChildWindow(name);
                if (!isIgnore)
                {
                    if (window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening)
                    {
                        Close(name);
                    }
                }
            }

            asyncLoad.StopAllTasks();
        }

        public void DestoryWinsByStage(WindowStage windowStage)
        {
            switch (windowStage)
            {
                case WindowStage.Launch:
                    DestroyWin<DownLoadWin>();
                    DestroyWin<VersionUpdateWin>();
                    DestroyWin<LaunchWin>();

                    if (!AssetSource.uiFromEditor)
                    {
                        AssetBundleUtility.Instance.UnloadAssetBundle("builtin/prefabs", true, false);
                    }
                    break;
                case WindowStage.Login:
                    DestroyWin<LoginWin>();
                    DestroyWin<ServerListWin>();

                    UILoader.UnLoadPriorityWindow("LoginWin");
                    break;
                case WindowStage.SelectRole:
                    DestroyWin<CreateRoleWin>();
                    DestroyWin<LaunchBackGroundWin>();

                    UILoader.UnLoadPriorityWindow("CreateRoleWin");
                    UILoader.UnLoadPriorityWindow("SelectRoleWin");
                    UILoader.UnLoadPriorityWindow("LaunchBackGroundWin");
                    break;
                default:
                    break;
            }

            UnLoadAssetBundle(windowStage);
        }

        public void DestroyWin<T>() where T : Window
        {
            DestroyWin(typeof(T).Name);
        }

        public void DestroyWin(string name)
        {
            if (windows.ContainsKey(name))
            {
                var win = windows[name];
                win.CloseImmediately();
                GameObject.Destroy(win.gameObject, 0.3f);
                MonoBehaviour.Destroy(win, 0.3f);
                windows[name] = null;
                windows.Remove(name);
            }
            else
            {
                DebugEx.LogFormat("{0} 窗口无法获得！", name);
            }
        }

        public void UnLoadAssetBundle(WindowStage windowStage)
        {
            if (!AssetSource.uiFromEditor)
            {
                switch (windowStage)
                {
                    case WindowStage.Launch:
                        break;
                    case WindowStage.Login:
                        AssetBundleUtility.Instance.UnloadAsset("ui/prioritywindow", "LoginWin");
                        AssetBundleUtility.Instance.UnloadAsset("ui/prioritywindow", "ServerListWin");
                        break;
                    case WindowStage.SelectRole:
                        AssetBundleUtility.Instance.UnloadAsset("ui/prioritywindow", "CreateRoleWin");
                        AssetBundleUtility.Instance.UnloadAsset("ui/prioritywindow", "SelectRoleWin");
                        break;
                    default:
                        break;
                }
            }
        }

        public bool IsOpen<T>() where T : Window
        {
            T win = null;
            if (TryGetWindow(out win))
            {
                var open = win.windowState == Window.WindowState.Opened
                               || win.windowState == Window.WindowState.Opening;

                return open;
            }
            else
            {
                return false;
            }
        }

        public bool IsOpen(string name)
        {
            if (windows.ContainsKey(name) && windows[name] != null)
            {
                var window = windows[name];
                return window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening;
            }
            else
            {
                return false;
            }
        }

        public bool ExistAnyFullScreenOrMaskWin()
        {
            var exist = false;
            foreach (var name in windows.Keys)
            {
                var window = windows[name];
                if (window.windowInfo.needMask || window.windowInfo.fullScreen)
                {
                    if (window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening)
                    {
                        exist = true;
                        break;
                    }
                }
            }

            return exist;
        }

        /// <summary>
        /// 是否存在大于或等于这个层级的全屏或有模糊背景的界面
        /// </summary>
        /// <param name="windowType"></param>
        /// <returns></returns>
        public bool ExistAnyFullScreenOrMaskWinLEqual(WindowType windowType)
        {
            var exist = false;
            foreach (var name in windows.Keys)
            {
                var window = windows[name];
                if ((window.windowInfo.needMask || window.windowInfo.fullScreen) && window.windowInfo.windowType >= windowType)
                {
                    if (window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening)
                    {
                        exist = true;
                        break;
                    }
                }
            }

            return exist;
        }

        internal void NotifyBeforeOpen<T>(T window) where T : Window
        {
            //if (ConfigInitiator.done && window is not MainInterfaceWin && !WindowJumpMgr.Instance.IsJumpState)
            //    CalcMainInterfaceWin();

            if (windowBeforeOpenEvent != null)
            {
                windowBeforeOpenEvent(window);
            }
        }

        internal void NotifyAfterOpen<T>(T window) where T : Window
        {
            if (windowAfterOpenEvent != null)
            {
                windowAfterOpenEvent(window);
            }
        }

        internal void NotifyBeforeClose<T>(T window) where T : Window
        {
            if (windowBeforeCloseEvent != null)
            {
                windowBeforeCloseEvent(window);
            }
        }

        internal void NotifyAfterClose<T>(T window) where T : Window
        {
            if (windowAfterCloseEvent != null)
            {
                windowAfterCloseEvent(window);
            }
        }

        internal void JumpNotifyAfterClose<T>(T window) where T : Window
        {
            //if (ConfigInitiator.done && window is not MainInterfaceWin && !WindowJumpMgr.Instance.IsJumpState)
            //    CalcMainInterfaceWin();
            checkMainWin = true;
            if (jumpWindowCloseEvent != null)
            {
                jumpWindowCloseEvent(window);
            }
        }

        private bool TryGetWindow<T>(out T win) where T : Window
        {
            var name = typeof(T).Name;
            Window window = null;
            if (TryGetWindow(name, out window))
            {
                win = windows[name] as T;
                return win != null;
            }
            else
            {
                win = null;
                return false;
            }
        }

        private bool TryGetWindow(string name, out Window win)
        {
            WindowTrim(name);
            if (windows.ContainsKey(name))
            {
                win = windows[name];
                return win != null;
            }
            else
            {
                win = null;
                return false;
            }
        }

        private void WindowTrim(string name)
        {
            if (windows.ContainsKey(name))
            {
                if (windows[name] == null || windows[name].gameObject == null)
                {
                    windows.Remove(name);
                }
            }
        }

        float checkTimer = 0f;
        private void LateUpdate()
        {
            var checkMainWinImmedidately = closeCommands.Count + openCommands.Count > 0;

            if (checkMainWin)
            {
                checkMainWinImmedidately = true;
                checkMainWin = false;
            }

            while (closeCommands.Count > 0)
            {
                var command = closeCommands[0];
                closeCommands.RemoveAt(0);
                Window window = null;
                if (windows.TryGetValue(command.name, out window))
                {
                    if (window.windowState != Window.WindowState.Closed)
                    {
                        window.CloseImmediately();
                    }
                }

                asyncLoad.StopTask(command.name);
            }

            while (openCommands.Count > 0)
            {
                var command = openCommands[0];
                openCommands.RemoveAt(0);
                Window window = null;
                if (windows.TryGetValue(command.name, out window))
                {
                    if (window.windowState == Window.WindowState.Closed)
                    {
                        window.playAnimation = command.playAnimatioin;
                        window.functionOrder = command.functionOrder;
                        window.fixParentName = command.fixParentName;
                        window.Open();
                    }
                    else
                    {
                        DebugEx.LogFormat("{0} 窗口已经打开！", command.name);
                    }
                }
                else
                {
                    ExecuteFirstOpen(command);
                }

            }

            checkTimer += checkMainWinImmedidately ? 1f : Time.deltaTime;
            if (checkTimer > 0.2f)
            {
                checkTimer = 0f;
                CalcMainInterfaceWin();
            }
        }

        bool checkMainWin = false;

        //主界面的开关默认处理
        public void CalcMainInterfaceWin()
        {
            if (!StageLoad.Instance.isLoading)
            {
                var exceptOpen = StageLoad.Instance.stageType == Stage.E_StageType.Dungeon
                    && !ExistAnyFullScreenOrMaskWinLEqual(WindowType.Base)
                    && !IsOpen("DefaultDialogueBoxWin")
                    && !IsOpen("DialogueDuidanceWin")
                    && !IsOpen("TaskBoxBGMWin")
                    && !IsOpen("WelcomeWin")
                    && !IsOpen("HazyRegionDialogueWin")
                    && !IsOpen("NormalDialogueWin")
                    && !IsOpen("GuideDialogueWin");

                if (exceptOpen != IsOpen("MainInterfaceWin") && windows.ContainsKey("MainInterfaceWin"))
                {
                    if (exceptOpen)
                    {
                        windows["MainInterfaceWin"].Open();
                    }
                    else
                    {
                        windows["MainInterfaceWin"].CloseImmediately();
                    }
                }
            }
        }


        private void ExecuteFirstOpen(OpenCommand command)
        {
            GetWindowPrefab(command, (bool ok, GameObject prefab) =>
            {
                if (ok)
                {
                    CreateWindowInstance(command, prefab);
                    Window window = null;
                    if (windows.TryGetValue(command.name, out window))
                    {
                        window.playAnimation = command.playAnimatioin;
                        window.functionOrder = command.functionOrder;
                        window.fixParentName = command.fixParentName;
                        window.Open();
                    }
                }
            });
        }

        private void GetWindowPrefab(OpenCommand command, Action<bool, GameObject> callBack)
        {
            if (command.sync)
            {
                var name = command.name;
                var fromBuiltIn = command.fromBuiltIn;
                var prefab = fromBuiltIn ? BuiltInLoader.LoadPrefab(name) : UILoader.LoadWindow(name);

                if (callBack != null)
                {
                    callBack(prefab != null, prefab);
                }
            }
            else
            {
                var name = command.name;
                var task = new WindowAsyncLoad.Task(name, (bool ok, UnityEngine.Object @object) =>
                {
                    var prefab = @object as GameObject;
                    if (callBack != null)
                    {
                        callBack(prefab != null, prefab);
                    }
                });

                asyncLoad.PushTask(task);
            }
        }

        private void CreateWindowInstance(OpenCommand command, GameObject prefab)
        {
            var name = command.name;
            Window window = null;
            if (!windows.ContainsKey(name))
            {
                prefab.SetActive(false);
                var instance = GameObject.Instantiate(prefab);

                if (AssetSource.uiFromEditor)
                {
                    prefab.SetActive(true);
                }

                if (command.fromBuiltIn)
                {
                    BuiltInLoader.UnLoadPrefab(name);
                }
                else
                {
                    UILoader.UnLoadWindowAsset(name);
                }

                window = instance.GetComponent<Window>();
                instance.name = name;
                if (window != null)
                {
                    windows[name] = window;
                }
                else
                {
                    Debug.LogFormat("无法获得  {0}  的资源！", name);
                }
            }
        }

        public struct OpenCommand
        {
            public string name;
            public bool sync;
            public int functionOrder;
            public bool playAnimatioin;
            public bool fromBuiltIn;
            public string fixParentName;
        }

        public struct CloseCommand
        {
            public string name;
        }

        public enum WindowStage
        {
            Launch,
            Login,
            SelectRole,
            Other,
        }

        public enum CloseAllIgnoreType
        {
            Base = 1,
            System = 2,
            Custom = 3,
            BaseAndCustom = 4,
            SystemAndCustom = 5,
        }

        class Windows
        {
            Dictionary<string, Window> windows = new Dictionary<string, Window>();
            List<string> windowKeys = new List<string>();

            public Window this[string key]
            {
                get { return windows[key]; }
                set
                {
                    windows[key] = value;
                    if (!windowKeys.Contains(key))
                    {
                        windowKeys.Add(key);
                    }
                }
            }

            public List<string> Keys { get { return windowKeys; } }

            public bool ContainsKey(string key)
            {
                return windowKeys.Contains(key);
            }

            public bool TryGetValue(string key, out Window window)
            {
                return windows.TryGetValue(key, out window);
            }

            public void Remove(string key)
            {
                windows.Remove(key);
                windowKeys.Remove(key);
            }

            public WindowType GetWindowType(string key)
            {
                if (windows.ContainsKey(key))
                {
                    return windows[key].windowInfo.windowType;
                }
                else
                {
                    return WindowType.Flag;
                }
            }

        }

    }

}