#if UNITY_EDITOR
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using UnityEditor.SceneManagement;
using System.Reflection;
using System;
using System.IO;
using Object = UnityEngine.Object;
using System.Linq;
using System.Text.RegularExpressions;
using UnityEngine.UIElements;
using UnityEditor.UIElements;
#if UNITY_2021_3_OR_NEWER
using PrefabStageUtility = UnityEditor.SceneManagement.PrefabStageUtility;

#else
using PrefabStageUtility = UnityEditor.Experimental.SceneManagement.PrefabStageUtility;
#endif

namespace Aliciza.UXTool
{
    public static partial class Utils
    {
#if !UNITY_2021_3_OR_NEWER
        private static readonly float m_WindowToolbarHeight = 21f;
        private static readonly float m_StageHandlingFixedHeight = 25f;
        private static readonly float m_TabHeight = 19f;
#endif

        #region Reflection

        //反射方法 性能消耗较大 调用后尽量缓存结果
        /// <summary>
        /// 有可能引起window重新生成实例 暂时废弃
        /// </summary>
        /// <returns></returns>
        [Obsolete]
        public static EditorWindow GetGameView()
        {
            var type = typeof(Editor).Assembly.GetType("UnityEditor.GameView");
            var gameview = EditorWindow.GetWindow(type);
            return gameview;
        }

        /// <summary>
        /// 获取GameView对象
        /// </summary>
        /// <returns></returns>
        public static object GetMainPlayModeView()
        {
            var playModeViewType = System.Type.GetType("UnityEditor.PlayModeView,UnityEditor");
            var GetMainPlayModeView = playModeViewType.GetMethod("GetMainPlayModeView", BindingFlags.NonPublic | BindingFlags.Static);
            var view = GetMainPlayModeView.Invoke(null, null);
            return view;
        }

        /// <summary>
        /// 获取所有的GameView对象
        /// </summary>
        /// <returns></returns>
        public static Object[] GetPlayViews()
        {
            Assembly assembly = typeof(EditorWindow).Assembly;
            Type type = assembly.GetType("UnityEditor.GameView");
            return UnityEngine.Resources.FindObjectsOfTypeAll(type);
        }

        public static EditorWindow GetHierarchyWindow()
        {
            var HierarchyViewType = System.Type.GetType("UnityEditor.SceneHierarchyWindow,UnityEditor");

            //var GetSceneHierarchyWindow = HierarchyViewType.GetMethod("GetSceneHierarchyWindowToFocusForNewGameObjects", BindingFlags.NonPublic | BindingFlags.Static);
            //var hierarchyWindow = GetSceneHierarchyWindow.Invoke(null, null);

            object hierarchyWindow = GetPropertyValue(HierarchyViewType, "lastInteractedHierarchyWindow");
            EditorWindow window = hierarchyWindow as EditorWindow;

            return window;
        }

        public static SceneView GetSceneView()
        {
            return SceneView.currentDrawingSceneView;
        }

        public static EditorWindow GetEditorWindow(string EditorWindowClassName)
        {
            var assembly = typeof(EditorWindow).Assembly;
            var type = assembly.GetType(EditorWindowClassName);
            var editorWindow = EditorWindow.GetWindow(type);
            return editorWindow;
        }

        public static Editor GetEditor(Object[] targets, string EditorClassName)
        {
            var assembly = typeof(Editor).Assembly;
            var type = assembly.GetType(EditorClassName);
            var editor = Editor.CreateEditor(targets, type);
            return editor;
        }

        public static Editor GetEditor(Object target, string EditorClassName)
        {
            var assembly = typeof(Editor).Assembly;
            var type = assembly.GetType(EditorClassName);
            var editor = Editor.CreateEditor(target, type);
            return editor;
        }

        /// <summary>
        /// 获取Editor中的类方法
        /// </summary>
        /// <param name="editorClassType"></param>
        /// <param name="methodName"></param>
        /// <param name="paraCount">要获取的method的参数个数,用于区分重载方法</param>
        /// <returns></returns>
        public static List<MethodInfo> GetEditorMethod(Type editorClassType, string methodName, int paraCount = -1)
        {
            List<MethodInfo> m = new List<MethodInfo>();

            MethodInfo[] methods = editorClassType.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
            foreach (var method in methods)
            {
                if (method.Name == methodName && method.GetParameters().Length == paraCount)
                {
                    m.Add(method);
                }
            }

            return m;
        }

        /// <summary>
        /// 获取没有重载的Editor方法
        /// </summary>
        /// <param name="editorClassType"></param>
        /// <param name="methodName"></param>
        /// <returns></returns>
        public static MethodInfo GetEditorMethod(Type editorClassType, string methodName)
        {
            MethodInfo[] methods = editorClassType.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
            foreach (var method in methods)
            {
                if (method.Name == methodName)
                {
                    return method;
                }
            }

            return null;
        }

        /// <summary>
        /// 通过反射调用非静态方法
        /// </summary>
        /// <param name="obj">调用对象，若调用静态函数请使用typeof(className)</param>
        /// <param name="methodName">方法名称</param>
        /// <param name="parameters">方法的参数，默认为null，表示不传参</param>
        /// <returns>非静态方法的返回值</returns>
        public static object InvokeMethod(object obj, string methodName, object[] parameters = null)
        {
            if (parameters == null)
            {
                return obj.GetType().GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance).Invoke(obj, null);
            }

            Type[] types = new Type[parameters.Length];
            for (int i = 0; i < parameters.Length; i++)
            {
                types[i] = parameters[i].GetType();
            }

            return obj.GetType().GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, types, null).Invoke(obj, parameters);
        }

        /// <summary>
        /// 通过反射调用静态方法
        /// </summary>
        /// <param name="type">调用静态函数请使用typeof(className)</param>
        /// <param name="methodName">方法名称</param>
        /// <param name="parameters">方法的参数，默认为null，表示不传参</param>
        /// <returns>静态方法的返回值</returns>
        public static object InvokeMethod(Type type, string methodName, object[] parameters = null)
        {
            if (parameters == null)
            {
                return type.GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static).Invoke(null, null);
            }

            Type[] types = new Type[parameters.Length];
            for (int i = 0; i < parameters.Length; i++)
            {
                types[i] = parameters[i].GetType();
            }

            return type.GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static, null, types, null).Invoke(null, parameters);
        }

        /// <summary>
        /// 通过反射获取非静态属性的值
        /// </summary>
        /// <param name="obj">调用对象，若调用静态属性请使用typeof(className)</param>
        /// <param name="propertyName">属性名称</param>
        /// <param name="index">索引属性的参数，默认为null，表示获取非索引属性</param>
        /// <returns>非静态属性的值</returns>
        public static object GetPropertyValue(object obj, string propertyName, object[] index = null)
        {
            if (index == null)
            {
                return obj.GetType().GetProperty(propertyName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance).GetValue(obj);
            }

            Type[] types = new Type[index.Length];
            for (int i = 0; i < index.Length; i++)
            {
                types[i] = index[i].GetType();
            }

            return obj.GetType().GetProperty(propertyName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, null, types, null).GetValue(obj, index);
        }

        /// <summary>
        /// 通过反射获取静态属性的值
        /// </summary>
        /// <param name="obj">调用静态属性请使用typeof(className)</param>
        /// <param name="propertyName">属性名称</param>
        /// <param name="index">索引属性的参数，默认为null，表示获取非索引属性</param>
        /// <returns>静态属性的值</returns>
        public static object GetPropertyValue(Type type, string propertyName, object[] index = null)
        {
            if (index == null)
            {
                return type.GetProperty(propertyName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static).GetValue(null);
            }

            Type[] types = new Type[index.Length];
            for (int i = 0; i < index.Length; i++)
            {
                types[i] = index[i].GetType();
            }

            return type.GetProperty(propertyName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static, null, null, types, null).GetValue(null, index);
        }

        /// <summary>
        /// 通过反射获取非静态变量的值
        /// </summary>
        /// <param name="obj">调用对象，若调用静态变量请使用typeof(className)</param>
        /// <param name="fieldName">变量名称</param>
        /// <returns>非静态变量的值</returns>
        public static object GetFieldValue(object obj, string fieldName)
        {
            return obj.GetType().GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance).GetValue(obj);
        }

        /// <summary>
        /// 通过反射获取静态变量的值
        /// </summary>
        /// <param name="obj">调用静态变量请使用typeof(className)</param>
        /// <param name="fieldName">变量名称</param>
        /// <returns>静态变量的值</returns>
        public static object GetFieldValue(Type type, string fieldName)
        {
            return type.GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static).GetValue(null);
        }

        public static Rect GetSceneViewCameraRect()
        {
            var type = typeof(SceneView);
            PropertyInfo info = type.GetProperty("cameraRect", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
            object r = info.GetValue(SceneView.lastActiveSceneView, null);
            Rect rect = (Rect)r;
            return rect;
        }

        public static float GetSceneViewOffest()
        {
#if !UNITY_2021_3_OR_NEWER
            //if (SceneView.sceneViews.Count == 0)
            //{
            //    return 19 + 25;
            //}
            //
            //SceneView sceneView = (SceneView)SceneView.sceneViews[0];
            ////SceneView sceneView = SceneView.currentDrawingSceneView;
            //
            //var sceneviewtype = typeof(SceneView);
            //PropertyInfo toolbarHeightInfo = sceneviewtype.GetProperty("toolbarHeight", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
            //float toolbarHeight = (float)toolbarHeightInfo.GetValue(sceneView, null);
            //
            //
            //var dockareaType = typeof(Editor).Assembly.GetType("UnityEditor.DockArea");
            //FieldInfo kTabHeightInfo = dockareaType.GetField("kTabHeight", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
            //float kTabHeight = (float)kTabHeightInfo.GetValue(null);
            //
            //return kTabHeight + toolbarHeight;
            return m_TabHeight + GetSceneViewToolbarHeight();
#else
            var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
            if (prefabStage != null)
            {
                return 19 + 46;
            }
            else
            {
                return 19 + 25;
            }
#endif
        }

        public static float GetSceneViewToolbarHeight()
        {
#if !UNITY_2021_3_OR_NEWER
            //var sceneviewtype = typeof(SceneView);
            //PropertyInfo toolbarHeightInfo = sceneviewtype.GetProperty("toolbarHeight", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
            //float toolbarHeight = (float)toolbarHeightInfo.GetValue(SceneView.lastActiveSceneView, null);
            //return toolbarHeight;
            var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
            if (prefabStage != null)
            {
                return m_WindowToolbarHeight + m_StageHandlingFixedHeight;
            }
            else
            {
                return m_WindowToolbarHeight;
            }
#else
            return 0;
#endif
        }

        #endregion

        #region GameView

        public static Vector2 GetGameViewSize()
        {
            MethodInfo GetSizeOfMainGameView = GetEditorMethod(Type.GetType("UnityEditor.GameView,UnityEditor"), "GetSizeOfMainGameView");
            if (GetSizeOfMainGameView != null)
            {
                var Res = GetSizeOfMainGameView.Invoke(null, null);
                return (Vector2)Res;
            }

            return Vector2.zero;
        }

        #endregion

        #region Prefab

        public static void OpenPrefab(string prefabPath)
        {
            PrefabStageUtility.OpenPrefab(prefabPath);
            List<MethodInfo> m = GetEditorMethod(typeof(PrefabStageUtility), "OpenPrefab", 1);
            m[0].Invoke(null, new object[] { prefabPath });
        }

        public static void SetCursor(Texture2D texture)
        {
            List<MethodInfo> m = GetEditorMethod(typeof(EditorGUIUtility), "SetCurrentViewCursor", 3);
            m[0].Invoke(null, new object[] { texture, new Vector2(16, 16), MouseCursor.CustomCursor });
        }

        public static void ClearCurrentViewCursor()
        {
            List<MethodInfo> m = GetEditorMethod(typeof(EditorGUIUtility), "ClearCurrentViewCursor", 0);
            m[0].Invoke(null, null);
        }

        #endregion

        #region Editor State

        public static void ExitPrefabStage()
        {
            StageUtility.GoToMainStage();
        }

        public static void EnterPlayMode()
        {
            EditorApplication.isPlaying = true;
            PlayerPrefs.SetString("previewStage", "true");
        }

        public static void StopPlayMode()
        {
            EditorApplication.isPlaying = false;
            PlayerPrefs.SetString("previewStage", "false");
        }

        #endregion

        #region Selecion

        /// <summary>
        /// 获得Hierarchy中选中且激活的对象。
        /// </summary>
        public static GameObject selectionActiveGameObject
        {
            get
            {
                if (UXSelectionUtil.activeGameObject == null) return null;
                return UXSelectionUtil.activeGameObject.activeInHierarchy ? UXSelectionUtil.activeGameObject : null;
            }
        }

        /// <summary>
        /// 获取当前选中对象
        /// 若选中超过1个以上的对象返回False
        /// </summary>
        /// <param name="obj">返回选中对象</param>
        /// <returns>是否成功获取</returns>
        public static bool TryGetSelectObject(out GameObject obj)
        {
            obj = null;
            if (selectionActiveGameObject == null || UXSelectionUtil.gameObjects.Length > 1)
                return false;

            obj = selectionActiveGameObject;
            //这里要避免选中Prefab中用于预览的Canvas
            var rect = obj.transform as RectTransform;
            bool isCanvasEnvironment = obj.transform.parent == null && obj.name == "Canvas(Environment)";
            return obj != null && !isCanvasEnvironment;
        }

        /// <summary>
        /// 获取当前选中对象的RectTransform
        /// 若选中超过1个以上的对象返回False
        /// </summary>
        /// <param name="rect">返回选中对象Rect</param>
        /// <returns>是否成功获取</returns>
        public static bool TryGetSelectionRectTransform(out RectTransform rect)
        {
            rect = null;
            if (selectionActiveGameObject == null || UXSelectionUtil.gameObjects.Length > 1)
                return false;
            rect = selectionActiveGameObject.transform as RectTransform;
            //这里要避免选中Prefab中用于预览的Canvas
            bool isCanvasEnvironment = rect.parent == null && rect.name == "CanvasEnvironment";
            return rect != null && !isCanvasEnvironment;
        }

        /// <summary>
        /// 获取全部选中对象RrectTransform
        /// </summary>
        /// <returns>返回列表</returns>
        public static List<RectTransform> GetAllSelectionRectTransform()
        {
            List<RectTransform> rects = new List<RectTransform>();
            GameObject[] objects = UXSelectionUtil.gameObjects;
            foreach (var obj in objects)
            {
                RectTransform rect = obj.GetComponent<RectTransform>();
                if (rect != null)
                    rects.Add(rect);
            }

            return rects;
        }

        /// <summary>
        /// 获取当前选中对象的path
        /// 若选中超过1个以上的对象返回False
        /// </summary>
        /// <returns>是否成功获取</returns>
        public static bool TryGetSelectionPath(out string path)
        {
            path = "";
            if (Selection.assetGUIDs.Length == 1)
            {
                path = AssetDatabase.GUIDToAssetPath(Selection.assetGUIDs[0]);
            }

            return !string.IsNullOrEmpty(path);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public static List<string> GetAllSelectionPath()
        {
            return Selection.assetGUIDs.Select(AssetDatabase.GUIDToAssetPath).ToList();
        }

        #endregion

        #region Texutre&Icon

        //生成和缓存 preview图片
        static Dictionary<string, Texture> m_PreviewDict = new Dictionary<string, Texture>();
        static Dictionary<string, Texture2D> m_PreviewDict2D = new Dictionary<string, Texture2D>();

        public static Texture GetAssetsPreviewTexture(string guid, int previewSize = 79)
        {
            if (!File.Exists(AssetDatabase.GUIDToAssetPath(guid))) return null;

            if (!m_PreviewDict.TryGetValue(guid, out var tex))
            {
                tex = GenAssetsPreviewTexture(guid, previewSize);
                if (tex != null)
                {
                    m_PreviewDict[guid] = tex;
                }
            }

            if (tex == null)
            {
                tex = GenAssetsPreviewTexture(guid, previewSize);
                if (tex != null)
                    m_PreviewDict[guid] = tex;
            }

            return tex;
        }

        public static Texture UpdatePreviewTexture(string guid, int previewSize = 79)
        {
            var tex = GenAssetsPreviewTexture(guid, previewSize);
            if (tex != null)
                m_PreviewDict[guid] = tex;

            return tex;
        }

        public static Texture GetAssetsNewPreviewTexture(string guid, int previewSize = 79)
        {
            Texture tex = GenAssetsPreviewTexture(guid, previewSize);
            if (tex != null)
            {
                m_PreviewDict[guid] = tex;
            }

            return tex;
        }

        public static Texture2D GetAssetsPreviewTexture2D(string guid, int previewSize = 79)
        {
            if (!m_PreviewDict2D.TryGetValue(guid, out var tex))
            {
                Texture tex1 = GetAssetsPreviewTexture(guid, previewSize);
                if (tex1 != null)
                {
                    tex = TextureToTexture2D(tex1);
                    m_PreviewDict2D[guid] = tex;
                }
            }

            return tex;
        }

        private static Texture2D TextureToTexture2D(Texture texture)
        {
            Texture2D texture2D = new Texture2D(texture.width, texture.height, TextureFormat.RGBA32, false);
            RenderTexture currentRT = RenderTexture.active;
            RenderTexture renderTexture = RenderTexture.GetTemporary(texture.width, texture.height, 32);
            Graphics.Blit(texture, renderTexture);

            RenderTexture.active = renderTexture;
            texture2D.ReadPixels(new Rect(0, 0, renderTexture.width, renderTexture.height), 0, 0);
            texture2D.Apply();

            RenderTexture.active = currentRT;
            RenderTexture.ReleaseTemporary(renderTexture);

            return texture2D;
        }

        /// <summary>
        /// 生成prefab的预览图,
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="previewSize"></param>
        /// <returns></returns>
        public static Texture GenAssetsPreviewTexture(string guid, int previewSize = 79)
        {
            // if (EditorApplication.isPlaying)
            // {
            //     return null;
            // }

            string path = AssetDatabase.GUIDToAssetPath(guid);
            GameObject obj = AssetDatabase.LoadAssetAtPath<GameObject>(path);

            GameObject canvas = new GameObject("UXRenderCanvas", typeof(Canvas));
            GameObject cameraObj = new GameObject("UXRenderCamera", typeof(Camera));
            canvas.transform.position = new Vector3(10000, 10000, 10000);
            canvas.GetComponent<RectTransform>().sizeDelta = new Vector2(Screen.currentResolution.width, Screen.currentResolution.height);

            GameObject go = GameObject.Instantiate(obj, canvas.transform);

            Bounds bound = GetBounds(go);

            cameraObj.transform.position = new Vector3((bound.max.x + bound.min.x) / 2, (bound.max.y + bound.min.y) / 2, (bound.max.z + bound.min.z) / 2 - 100);
            cameraObj.transform.LookAt(cameraObj.transform.position);

            Camera camera = cameraObj.GetComponent<Camera>();
            camera.cameraType = CameraType.SceneView;
            camera.orthographic = true;
            camera.clearFlags = CameraClearFlags.SolidColor;
            camera.backgroundColor = new Color(0, 0, 0, 0f);

            float width = bound.max.x - bound.min.x;
            float height = bound.max.y - bound.min.y;
            float max_camera_size = (width > height ? width : height) + 10;
            camera.orthographicSize = max_camera_size / 2;

            RenderTexture rt = RenderTexture.GetTemporary(previewSize, previewSize, 24);
            camera.targetTexture = rt;
            camera.RenderDontRestore();

            RenderTexture tex = new RenderTexture(previewSize, previewSize, 0, RenderTextureFormat.Default);
            Graphics.Blit(rt, tex);

            //Texture2D tex = new Texture2D(previewSize, previewSize, TextureFormat.ARGB32, false);
            //tex.ReadPixels(new Rect(0, 0, previewSize, previewSize), 0, 0);
            //tex.Apply();

            RenderTexture.active = null;
            camera.targetTexture = null;
            rt.Release();
            RenderTexture.ReleaseTemporary(rt);

            Object.DestroyImmediate(canvas);
            Object.DestroyImmediate(cameraObj);

            return tex;
        }

        public static Bounds GetBounds(GameObject obj)
        {
            Vector3 Min = new Vector3(99999, 99999, 99999);
            Vector3 Max = new Vector3(-99999, -99999, -99999);
            MeshRenderer[] renders = obj.GetComponentsInChildren<MeshRenderer>();
            if (renders.Length > 0)
            {
                for (int i = 0; i < renders.Length; i++)
                {
                    if (renders[i].bounds.min.x < Min.x)
                        Min.x = renders[i].bounds.min.x;
                    if (renders[i].bounds.min.y < Min.y)
                        Min.y = renders[i].bounds.min.y;
                    if (renders[i].bounds.min.z < Min.z)
                        Min.z = renders[i].bounds.min.z;

                    if (renders[i].bounds.max.x > Max.x)
                        Max.x = renders[i].bounds.max.x;
                    if (renders[i].bounds.max.y > Max.y)
                        Max.y = renders[i].bounds.max.y;
                    if (renders[i].bounds.max.z > Max.z)
                        Max.z = renders[i].bounds.max.z;
                }
            }
            else
            {
                RectTransform[] rectTrans = obj.GetComponentsInChildren<RectTransform>();
                Vector3[] corner = new Vector3[4];
                for (int i = 0; i < rectTrans.Length; i++)
                {
                    //获取节点的四个角的世界坐标，分别按顺序为左下左上，右上右下
                    rectTrans[i].GetWorldCorners(corner);
                    if (corner[0].x < Min.x)
                        Min.x = corner[0].x;
                    if (corner[0].y < Min.y)
                        Min.y = corner[0].y;
                    if (corner[0].z < Min.z)
                        Min.z = corner[0].z;

                    if (corner[2].x > Max.x)
                        Max.x = corner[2].x;
                    if (corner[2].y > Max.y)
                        Max.y = corner[2].y;
                    if (corner[2].z > Max.z)
                        Max.z = corner[2].z;
                }
            }

            Vector3 center = (Min + Max) / 2;
            Vector3 size = new Vector3(Max.x - Min.x, Max.y - Min.y, Max.z - Min.z);
            return new Bounds(center, size);
        }

        public static void DrawGreenRect(int instanceID, Rect selectionRect, string text)
        {
            GameObject go = EditorUtility.InstanceIDToObject(instanceID) as GameObject;
            Rect rect = new Rect(selectionRect)
            {
                width = selectionRect.width + (PrefabUtility.IsAnyPrefabInstanceRoot(go) ? 0 : 20)
            };
            EditorGUI.DrawRect(rect, new Color(0.157f, 0.157f, 0.157f, 1f));
            GUI.Label(selectionRect, PrefabUtility.GetIconForGameObject(go));
            GUI.Label(new Rect(selectionRect) { x = selectionRect.x + 20 },
                text, new GUIStyle() { normal = { textColor = Color.green } });
        }

        #endregion

        #region Regex

        public static bool CheckHasAlphanumeric(string input)
        {
            const string pattern = "^[a-zA-Z0-9_]+$";
            return Regex.IsMatch(input, pattern);
        }

        #endregion

        // #region Panel
        // public static string SelectFolder(bool needUnderAssets = true)
        // {
        //     string folderPath = PlayerPrefs.GetString("LastParticleCheckPath");
        //     string path = EditorUtility.OpenFolderPanel(EditorLocalization.GetLocalization(EditorLocalizationStorage.Def_选择路径), folderPath, "");
        //     if (path != "")
        //     {
        //         int index = path.IndexOf("Assets");
        //         if (index != -1 || !needUnderAssets)
        //         {
        //             PlayerPrefs.SetString("LastParticleCheckPath", path);
        //             if (needUnderAssets)
        //             {
        //                 path = path.Substring(index);
        //             }
        //             return path + "/";
        //         }
        //         else
        //         {
        //             EditorUtility.DisplayDialog("messageBox",
        //                     EditorLocalization.GetLocalization(EditorLocalizationStorage.Def_目录不在Assets下Tip),
        //                     EditorLocalization.GetLocalization(EditorLocalizationStorage.Def_确定));
        //         }
        //     }
        //     return null;
        // }
        //
        // public static string SelectFile()
        // {
        //     string filePath = PlayerPrefs.GetString("LastParticleCheckPath");
        //     string path = EditorUtility.OpenFilePanel(EditorLocalization.GetLocalization(EditorLocalizationStorage.Def_选择文件), filePath, "");
        //     if (path != "")
        //     {
        //         int index = path.IndexOf("Assets");
        //         if (index != -1)
        //         {
        //             PlayerPrefs.SetString("LastParticleCheckPath", path);
        //             return path.Substring(index);
        //         }
        //         else
        //         {
        //             EditorUtility.DisplayDialog("messageBox",
        //                 EditorLocalization.GetLocalization(EditorLocalizationStorage.Def_目录不在Assets下Tip),
        //                 EditorLocalization.GetLocalization(EditorLocalizationStorage.Def_确定));
        //         }
        //     }
        //     return null;
        // }
        //
        // public static string SaveFile(string defaultName = "", string extension = "")
        // {
        //     string filePath = PlayerPrefs.GetString("LastParticleCheckPath");
        //     string path = EditorUtility.SaveFilePanel(EditorLocalization.GetLocalization(EditorLocalizationStorage.Def_保存), filePath, defaultName, extension);
        //     if (path != "")
        //     {
        //         int index = path.IndexOf("Assets");
        //         if (index != -1)
        //         {
        //             PlayerPrefs.SetString("LastParticleCheckPath", path);
        //             return path.Substring(index);
        //         }
        //         else
        //         {
        //             EditorUtility.DisplayDialog("messageBox",
        //                 EditorLocalization.GetLocalization(EditorLocalizationStorage.Def_目录不在Assets下Tip),
        //                 EditorLocalization.GetLocalization(EditorLocalizationStorage.Def_确定));
        //         }
        //     }
        //     return null;
        // }
        // #endregion

        public static int EnumPopupEx(Rect rect, string label, Type type, int enumValueIndex, string[] labels)
        {
            int[] ints = (int[])Enum.GetValues(type);
            string[] strings = Enum.GetNames(type);
            if (labels.Length != ints.Length)
            {
                return EditorGUI.IntPopup(rect, label, enumValueIndex, strings, ints);
            }
            else
            {
                return EditorGUI.IntPopup(rect, label, enumValueIndex, labels, ints);
            }
        }

        public static int EnumPopupLayoutEx(string label, Type type, int enumValueIndex, string[] labels)
        {
            int[] ints = (int[])Enum.GetValues(type);
            string[] strings = Enum.GetNames(type);
            if (labels.Length != ints.Length)
            {
                return EditorGUILayout.IntPopup(label, enumValueIndex, strings, ints);
            }
            else
            {
                return EditorGUILayout.IntPopup(label, enumValueIndex, labels, ints);
            }
        }
    }
}
#endif