if (m_currentSpriteAsset.m_FaceInfo.pointSize > 0)
{
    float spriteScale = m_currentFontSize / m_currentSpriteAsset.m_FaceInfo.pointSize * m_currentSpriteAsset.m_FaceInfo.scale * (m_isOrthographic ? 1 : 0.1f);
    currentElementScale = sprite.m_Scale * sprite.m_Glyph.scale * spriteScale;
    elementAscentLine = m_currentSpriteAsset.m_FaceInfo.ascentLine;
    baselineOffset = m_currentSpriteAsset.m_FaceInfo.baseline * fontScale * m_fontScaleMultiplier * m_currentSpriteAsset.m_FaceInfo.scale;
    elementDescentLine = m_currentSpriteAsset.m_FaceInfo.descentLine;
}
else
{
    float spriteScale = m_currentFontSize / m_currentFontAsset.m_FaceInfo.pointSize * m_currentFontAsset.m_FaceInfo.scale * (m_isOrthographic ? 1 : 0.1f);
    currentElementScale = m_currentFontAsset.m_FaceInfo.ascentLine / sprite.m_Glyph.metrics.height * sprite.m_Scale * sprite.m_Glyph.scale * spriteScale;
    float scaleDelta = spriteScale / currentElementScale;
    elementAscentLine = m_currentFontAsset.m_FaceInfo.ascentLine * scaleDelta;
    baselineOffset = m_currentFontAsset.m_FaceInfo.baseline * fontScale * m_fontScaleMultiplier * m_currentFontAsset.m_FaceInfo.scale;
    elementDescentLine = m_currentFontAsset.m_FaceInfo.descentLine * scaleDelta;
}

namespace UI.Editor
{
    /// <summary> A shortcut to creatre TMP sprite asset </summary>
    public class TextMeshProIconPacker : ScriptableObject
    {
        [Header("Result Config")]
        [SerializeField,]
        private string _textureOutPutName = "TempIconAtlas";
        [SerializeField,]
        private string m_spawnedAtlasPath;
        [SerializeField,]
        private TMP_SpriteAsset m_target;

        [Header("Sprite Pack")]
        [SerializeField]
        private Sprite[] _spriteToPack;
        [SerializeField]
        private int _maxSize = 512;
        [SerializeField]
        private int _iconSize = 64;
        [SerializeField]
        private int _padding = 2;
        [SerializeField]
        private float _iconScale = 1.2f;

        [SerializeField]
        private SpriteRect[] m_spriteRects;

        [MenuItem("Assets/UI/CreateTMPSpriteConfigTemplate")]
        private static void InternalCreateTestAsset()
        {
            TextMeshProIconPacker asset = ScriptableObject.CreateInstance<TextMeshProIconPacker>();
            // TODO Change this path
            string assetPath = "Assets/TMPSpriteConfig/TMPSpriteConfigTemplate.asset";
            UnityEditor.AssetDatabase.CreateAsset(asset, assetPath);
            UnityEditor.AssetDatabase.SaveAssets();
        }

        [ContextMenu("Create Sprite Atlas")]
        public void PackSpritesForTMP_EditorOnly()
        {
            if (null == _spriteToPack || 0 == _spriteToPack.Length)
            {
                return;
            }
            // grab all sprite as textures
            Texture2D[] sourceTextures = GatherTextures();
            FixImportSettings(sourceTextures, true);
            Texture2D[] texture2Pack = GetAdjustedT2D(sourceTextures);

            // create sprite rects for atlas
            Texture2D texture = new Texture2D(_maxSize, _maxSize, TextureFormat.RGBA32, false);
            Rect[] rects = texture.PackTextures(texture2Pack, _padding, _maxSize);
            m_spriteRects = new SpriteRect[rects.Length];
            for (int i = 0; i < rects.Length; i++)
            {
                m_spriteRects[i] = new SpriteRect()
                {
                    name = texture2Pack[i].name,
                    spriteID = GUID.Generate(),
                    rect = ConvertToPixelRect(texture.width, texture.height, rects[i]),
                    alignment = SpriteAlignment.BottomLeft, // it's fine to put it here, cuz we gonna manulla adjust it later :D
                };
            }

            EditorUtility.SetDirty(this);
            AssetDatabase.SaveAssetIfDirty(this);

            string path = AssetDatabase.GetAssetPath(this);
            string folderPath = Path.GetDirectoryName(path);
            string pngPath = $"{folderPath}/{_textureOutPutName}Atlas.png";

            // save sprite atlas
            Texture2D decopmpresseTex = DeCompress(texture);
            byte[] bytes = decopmpresseTex.EncodeToPNG();
            File.WriteAllBytes(pngPath, bytes);
            int temp = name.Length + 6;
            m_spawnedAtlasPath = path.Substring(0, path.Length - temp) + $"{_textureOutPutName}Atlas.png";

            // revert sprite readable
            FixImportSettings(sourceTextures, false);
            for (int i = 0, length = texture2Pack.Length; i < length; i++)
            {
                Texture.DestroyImmediate(texture2Pack[i]);
            }
            texture2Pack = null;
            AssetDatabase.Refresh();

            TextureImporter textureImporter = AssetImporter.GetAtPath(pngPath) as TextureImporter;
            textureImporter.textureType = TextureImporterType.Sprite;
            textureImporter.spriteImportMode = SpriteImportMode.Multiple;
            textureImporter.SaveAndReimport();

            textureImporter = AssetImporter.GetAtPath(pngPath) as TextureImporter;
            SpriteDataProviderFactories factory = new();
            factory.Init();
            ISpriteEditorDataProvider dataProvider = factory.GetSpriteEditorDataProviderFromObject(textureImporter);
            dataProvider.InitSpriteEditorDataProvider();
            dataProvider.SetSpriteRects(m_spriteRects);

            // Note: This section is only for Unity 2021.2 and newer
            // Register the new Sprite Rect's name and GUID with the ISpriteNameFileIdDataProvider
            ISpriteNameFileIdDataProvider spriteNameFileIdDataProvider = dataProvider.GetDataProvider<ISpriteNameFileIdDataProvider>();
            List<SpriteNameFileIdPair> nameFileIdPairs = spriteNameFileIdDataProvider.GetNameFileIdPairs().ToList();
            nameFileIdPairs.AddRange(m_spriteRects.Select(spriteRect => new SpriteNameFileIdPair(spriteRect.name, spriteRect.spriteID)));
            spriteNameFileIdDataProvider.SetNameFileIdPairs(nameFileIdPairs);

            dataProvider.Apply();
            textureImporter.SaveAndReimport();
        }

        [ContextMenu("Generate asset by sprite atlas")]
        public void ApplyAtlasToAsset()
        {
            string path = AssetDatabase.GetAssetPath(this);
            string folderPath = Path.GetDirectoryName(path);
            string pngPath = $"{folderPath}/{_textureOutPutName}Atlas.png";

            if (null == m_target)
            {
                m_target = ScriptableObject.CreateInstance<TMP_SpriteAsset>();
                m_target.name = _textureOutPutName;
                m_target.spriteInfoList = new();
                AssetDatabase.CreateAsset(m_target, $"{folderPath}/{_textureOutPutName}.asset");
            }
            else
            {
                // seens like we dun need to destroy it
                //Material matToDestroy = m_target.material;
                //m_target.material = null;
                //Material.DestroyImmediate(matToDestroy);
            }
            m_target.spriteSheet = AssetDatabase.LoadAssetAtPath<Texture2D>(pngPath);
            AddDefaultMaterial(m_target);

            Type hackType = typeof(TMP_SpriteAssetMenu);
            MethodInfo[] hackMethods = hackType.GetMethods(BindingFlags.NonPublic | BindingFlags.Static);
            for (int i = 0, length = hackMethods.Length; i < length; i++)
            {
                MethodInfo hackMethod = hackMethods[i];
                ParameterInfo[] paramInfos = hackMethod.GetParameters();
                if (1 == paramInfos.Length && typeof(TMP_SpriteAsset) == paramInfos[0].ParameterType)
                {
                    hackMethod.Invoke(null, new object[] { m_target }); // actually this wont work, I have to manully press "Update info" on the TextMeshProSpriteAsset :D
                    break;
                }
            }

            List<TMP_SpriteCharacter> characters = m_target.spriteCharacterTable;
            for (int i = 0, length = characters.Count; i < length; i++)
            {
                TMP_SpriteCharacter character = characters[i];
                character.scale = _iconScale;
            }

            EditorUtility.SetDirty(m_target);
            AssetDatabase.SaveAssetIfDirty(m_target);
        }

        [ContextMenu("Clear result")]
        public void Clear()
        {
            if (null != m_target)
            {
                string taragetath = AssetDatabase.GetAssetPath(m_target);
                AssetDatabase.DeleteAsset(taragetath);
            }
            if (!string.IsNullOrEmpty(m_spawnedAtlasPath))
            {
                AssetDatabase.DeleteAsset(m_spawnedAtlasPath);
            }
            m_target = null;
            m_spawnedAtlasPath = string.Empty;
            m_spriteRects = null;
        }

        private Texture2D[] GatherTextures()
        {
            List<Texture2D> resultTexture = new List<Texture2D>();
            for (int i = 0, length = _spriteToPack.Length; i < length; i++)
            {
                Sprite existSprite = _spriteToPack[i];
                string assetPath = AssetDatabase.GetAssetPath(existSprite);
                if (string.IsNullOrEmpty(assetPath))
                {
                    continue;
                }
                Texture2D loadedT2D = AssetDatabase.LoadAssetAtPath<Texture2D>(assetPath);
                resultTexture.Add(loadedT2D);
            }
            return resultTexture.ToArray();
        }

        private void FixImportSettings(Texture2D[] textures, bool readable)
        {
            for (int i = 0, length = textures.Length; i < length; i++)
            {
                Texture2D texture = textures[i];
                string path = AssetDatabase.GetAssetPath(texture);
                TextureImporter importer = AssetImporter.GetAtPath(path) as TextureImporter;

                if (importer == null) continue;
                importer.isReadable = readable;
                importer.SaveAndReimport();
            }
        }

        private Rect ConvertToPixelRect(int width, int height, Rect uvRect)
        {
            float pixelLeft = uvRect.x * width;
            float pixelTop = uvRect.y * height;
            float pixelWidth = uvRect.width * width;
            float pixelHeight = uvRect.height * height;
            return new Rect(pixelLeft, pixelTop, pixelWidth, pixelHeight);
        }

        private Texture2D DeCompress(Texture2D source)
        {
            RenderTexture renderTex = RenderTexture.GetTemporary(
                source.width,
                source.height,
                0,
                RenderTextureFormat.Default,
                RenderTextureReadWrite.Linear);

            Graphics.Blit(source, renderTex);
            RenderTexture previous = RenderTexture.active;
            RenderTexture.active = renderTex;
            Texture2D readableText = new Texture2D(source.width, source.height);
            readableText.ReadPixels(new Rect(0, 0, renderTex.width, renderTex.height), 0, 0);
            readableText.Apply();
            RenderTexture.active = previous;
            RenderTexture.ReleaseTemporary(renderTex);
            return readableText;
        }

        private void AddDefaultMaterial(TMP_SpriteAsset spriteAsset)
        {
            Shader shader = Shader.Find("TextMeshPro/Sprite");
            Material material = new Material(shader);
            material.SetTexture(ShaderUtilities.ID_MainTex, spriteAsset.spriteSheet);

            spriteAsset.material = material;
            material.hideFlags = HideFlags.HideInHierarchy;
            AssetDatabase.AddObjectToAsset(material, spriteAsset);
        }

        private Texture2D[] GetAdjustedT2D(Texture2D[] source)
        {
            Texture2D[] result = new Texture2D[source.Length];
            for (int i = 0, length = source.Length; i < length; i++)
            {
                Texture2D after = GPUTextureScaler.GetScaledResult(source[i], _iconSize, _iconSize);
                result[i] = after;
            }
            return result;
        }

    }

    // from https://discussions.unity.com/t/how-to-resize-scale-down-texture-without-losing-quality/810223/14
    public class GPUTextureScaler
    {
        /// <summary>
        /// Returns a scaled copy of given texture.
        /// </summary>
        /// <param name="tex">Source texure to scale</param>
        /// <param name="width">Destination texture width</param>
        /// <param name="height">Destination texture height</param>
        /// <param name="mode">Filtering mode</param>
        public static Texture2D GetScaledResult(Texture2D src, int width, int height, FilterMode mode = FilterMode.Trilinear)
        {
            Rect texR = new(0, 0, width, height);
            DoGPUScale(src, width, height, mode);

            //Get rendered data back to a new texture
            Texture2D result = new(width, height, TextureFormat.ARGB32, true);
            result.Reinitialize(width, height);
            result.ReadPixels(texR, 0, 0, true);
            result.name = src.name;
            return result;
        }

        /// <summary>
        /// Scales the texture data of the given texture.
        /// </summary>
        /// <param name="tex">Texure to scale</param>
        /// <param name="width">New width</param>
        /// <param name="height">New height</param>
        /// <param name="mode">Filtering mode</param>
        public static void Scale(Texture2D tex, int width, int height, FilterMode mode = FilterMode.Trilinear)
        {
            Rect texR = new(0, 0, width, height);
            DoGPUScale(tex, width, height, mode);

            // Update new texture
            tex.Reinitialize(width, height);
            tex.ReadPixels(texR, 0, 0, true);
            tex.Apply(true); //Remove this if you hate us applying textures for you :)
        }

        // Internal unility that renders the source texture into the RTT - the scaling method itself.
        private static void DoGPUScale(Texture2D src, int width, int height, FilterMode fmode)
        {
            //We need the source texture in VRAM because we render with it
            src.filterMode = fmode;
            src.Apply(true);

            //Using RTT for best quality and performance. Thanks, Unity 5
            RenderTexture rtt = new(width, height, 32);

            //Set the RTT in order to render to it
            Graphics.SetRenderTarget(rtt);

            //Setup 2D matrix in range 0..1, so nobody needs to care about sized
            GL.LoadPixelMatrix(0, 1, 1, 0);

            //Then clear & draw the texture to fill the entire RTT.
            GL.Clear(true, true, new Color(0, 0, 0, 0));
            Graphics.DrawTexture(new Rect(0, 0, 1, 1), src);
        }
    }
}

[CustomPropertyDrawer(typeof(AssetPath<>), true)]
public class AssetPathDrawer : PropertyDrawer
{
    public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
    {
        float baseHeight = base.GetPropertyHeight(property, label);
        return 3f * baseHeight; // we need 3 line to show stuff
    }

    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        EditorGUI.BeginProperty(position, label, property);

        // Draw label
        position = EditorGUI.PrefixLabel(position, GUIUtility.GetControlID(FocusType.Passive), label);

        float elementHeight = base.GetPropertyHeight(property, label);
        SerializedProperty guidProperty = property.FindPropertyRelative("m_guid");
        SerializedProperty pathProperty = property.FindPropertyRelative("m_path");

        GUIStyle buttonStyle = new GUIStyle(GUI.skin.button);
        buttonStyle.alignment = TextAnchor.MiddleLeft;
        Rect rect = new Rect(position.x, position.y, position.width, elementHeight);
        string guidText = guidProperty.stringValue;
        if (GUI.Button(rect, new GUIContent($"Guid: {guidText}"), buttonStyle))
        {
            GUIUtility.systemCopyBuffer = guidText; // copy to clipboard
            Debug.Log($"Copy guid text '{guidText}' to clipboard");
        }

        rect = new Rect(position.x, position.y + elementHeight, position.width, elementHeight);
        string pathText = pathProperty.stringValue;
        if (GUI.Button(rect, new GUIContent($"Path: {pathText}"), buttonStyle))
        {
            GUIUtility.systemCopyBuffer = pathText; // copy to clipboard
            Debug.Log($"Copy path text '{guidText}' to clipboard");
        }

        rect = new Rect(position.x, position.y + elementHeight * 2, position.width, elementHeight);
        SerializedProperty assetProperty = property.FindPropertyRelative("m_assetCache");
        if (null != assetProperty)
        {
            UnityObject assetValue = assetProperty.objectReferenceValue;
            Type assetType;
            if (null == assetValue)
            {
                Type fieldType = fieldInfo.FieldType;
                Type[] genericTypes = fieldType.BaseType.GenericTypeArguments;
                if (null == genericTypes || 0 == genericTypes.Length)
                {
                    assetType = typeof(UnityObject);
                }
                else
                {
                    assetType = genericTypes[0];
                }
            }
            else
            {
                assetType = assetValue.GetType();
            }
            UnityObject next = EditorGUI.ObjectField(rect, assetValue, assetType, false); // do not allow scene obj so it will actually be asset
            if (next != assetValue) // value has changed, set guid and path
            {
                pathText = AssetDatabase.GetAssetPath(next);
                guidText = AssetDatabase.AssetPathToGUID(pathText);
                pathProperty.stringValue = pathText;
                guidProperty.stringValue = guidText;
                assetProperty.objectReferenceValue = next;
            }
        }

        EditorGUI.EndProperty();
    }
}

public static class BundlePreprocess_AssetPath
{
    private static void PreProcess_AssetPathSoftLink()
    {
        /*
        * @Hiko
        * 
        * Need to match case below, then we get guid, parse actual path
        * m_path: Assets/XX/resource.xx
        * m_guid: 382c74c3721d4f3480e557657b6cbc27
        */
        void DoTextReplace(string[] assetGUIDs)
        {
            // I have 0 knowledge of Regex, so I ask AI do it :)
            // HACK put 4 space here is becuz there is at least 4 spc before the field name if you take a look into asset yaml file
            string patternAsSingleField = @"\s*\s\s\s\s\m_path:\s*(?<path>.*)?\s*m_guid:\s*(?<guid>[a-fA-F0-9]*)?";
            // if it is a array element, there should be a '-'
            string patternAsArrayElement = @"\s*-\m_path:\s*(?<path>.*)?\s*m_guid:\s*(?<guid>[a-fA-F0-9]*)?";
            for (int i = 0, assetCount = assetGUIDs.Length; i < assetCount; i++)
            {
                string assetGuid = assetGUIDs[i];
                string assetPath = AssetDatabase.GUIDToAssetPath(assetGuid);
                if (assetPath.StartsWith("Packages"))
                {
                    continue; // dun know hot to use asset search fitler, skip asset in package here
                }
                string assetFullpath = Application.dataPath + assetPath.Substring("Assets".Length);
                string assetText = File.ReadAllText(assetFullpath);
                string resultText = assetText;

                // AssetPath as normal field
                MatchCollection matchCollection = Regex.Matches(assetText, patternAsSingleField, RegexOptions.Multiline);
                ulong execCount = 0;
                int matchCount = matchCollection.Count;
                if (0 < matchCount)
                {
                    for (int matchIndex = 0; matchIndex < matchCount; matchIndex++)
                    {
                        Match match = matchCollection[matchIndex];
                        if (match.Success)
                        {
                            string matchContent = match.Value;
                            int spaceCount = matchContent.IndexOf("p") - 1;
                            string guidString = match.Groups["guid"].Value;
                            if (string.IsNullOrEmpty(guidString) || 36 > guidString.Length) // invalid guid
                            {
                                continue;
                            }
                            string space = new string(' ', spaceCount); // add space
                            string path = AssetDatabase.GUIDToAssetPath(guidString);
                            string result1 = $"m_path: {path}";
                            string result2 = $"m_guid: {guidString}";
                            string result = $"\n{space}{result1}\n{space}{result2}";
                            resultText = resultText.Replace(matchContent, result);
                            ++execCount;
                        }
                    }
                }

                // Asset Path as array element
                assetText = resultText;
                matchCollection = Regex.Matches(assetText, patternAsArrayElement, RegexOptions.Multiline);
                matchCount = matchCollection.Count;
                if (0 < matchCount)
                {
                    for (int matchIndex = 0; matchIndex < matchCount; matchIndex++)
                    {
                        Match match = matchCollection[matchIndex];
                        if (match.Success)
                        {
                            string matchContent = match.Value;
                            int spaceCount = matchContent.IndexOf("p") - 1;
                            string guidString = match.Groups["guid"].Value;
                            if (string.IsNullOrEmpty(guidString) || 36 > guidString.Length) // invalid guid
                            {
                                continue;
                            }
                            string space = new string(' ', spaceCount); // add space
                            string path = AssetDatabase.GUIDToAssetPath(guidString);
                            string result1 = $"- m_path: {path}";
                            string result2 = $"m_guid: {guidString}";
                            string result = $"\n{new string(' ', spaceCount - 2)}{result1}\n{space}{result2}";
                            resultText = resultText.Replace(matchContent, result);
                            ++execCount;
                        }
                    }
                }

                if (0 < execCount) // has changes
                {
                    File.WriteAllText(assetFullpath, resultText);
                }
            }
        }

        // do stuff for SO first
        string[] guids = AssetDatabase.FindAssets($"t: {nameof(ScriptableObject)}");
        DoTextReplace(guids);
        // then prefab
        guids = AssetDatabase.FindAssets($"t: prefab");
        DoTextReplace(guids);
        // finally scenes
        guids = AssetDatabase.FindAssets($"t: scene");
        DoTextReplace(guids);
        // refresh assets
        AssetDatabase.Refresh();
    }
}

public class TempTMP : TextMeshProUGUI, IPointerClickHandler
{
    public void OnPointerClick(PointerEventData eventData)
    {
        int linkIndex = TMP_TextUtilities.FindIntersectingLink(this, eventData.position, eventData.pressEventCamera);
        if (linkIndex != -1)
        {
            /*
            * e.g. <link="a2,b2">Mesh</link>
            * linkInfo.GetLinkID() will "get a2,b2"
            * linkInfo.GetLinkText() will get "Mesh"
            */
            TMP_LinkInfo linkInfo = this.textInfo.linkInfo[linkIndex];
            Debug.Log($"linkId {linkInfo.GetLinkID()} / linkText {linkInfo.GetLinkText()}");
            // Do stuff u want here :D
        }
    }
}

public interface IFileOperation<T>
{
    int FileCount { get; }
    int Operated { get; }
    Task<T> OperationTask { get; }
    float PercentCompletion { get; }
    string CurrentOperationMessage { get; }
    bool Running { get; }
    void Cancel();
}

public class FileAnalysis : IFileOperation<string[]>
{
    private string[] m_folders;
    private Predicate<string> m_fileFilter;
    private Regex m_regexCheck;

    private CancellationTokenSource m_tokenSource;
    private CancellationToken m_cachedToken;

    public Task<string[]> OperationTask { get; set; }
    public float PercentCompletion { get; set; }
    public string CurrentOperationMessage { get; set; }
    public int FileCount { get; set; }
    public int Operated { get; set; }
    public bool Running => OperationTask.Status switch
    {
        TaskStatus.RanToCompletion => false,
        TaskStatus.Faulted => false,
        TaskStatus.Canceled => false,
        _ => true
    };

    public CancellationToken Token => m_cachedToken;

    public static IFileOperation<string[]> AnalyzeFolders(string[] folders, Predicate<string> fileFilter, Regex regexCheck)
    {
        FileAnalysis operation = new FileAnalysis(folders, fileFilter, regexCheck);
        operation.DoOperation();
        return operation;
    }

    public FileAnalysis(string[] folders, Predicate<string> fileFilter, Regex regexCheck)
    {
        m_folders = folders;
        m_fileFilter = fileFilter;
        m_regexCheck = regexCheck;
        m_tokenSource = new CancellationTokenSource();
    }

    public void Cancel()
    {
        if (null != m_tokenSource)
        {
            m_tokenSource.Cancel();
            m_tokenSource.Dispose();
            m_tokenSource = null;
        }
    }

    public void DoOperation()
    {
        if (null == OperationTask)
        {
            try
            {
                OperationTask = Task.Factory.StartNew<string[]>(CheckFolders, cancellationToken: m_cachedToken = m_tokenSource.Token);
            }
            catch (Exception _) { }
        }
    }

    private string[] CheckFolders()
    {
        string[] files = m_folders.SelectMany(folder => Directory.GetFiles(folder, "*", SearchOption.AllDirectories)).ToArray();
        List<string> result = new List<string>(200);
        int count = files.Length;
        FileCount = count;
        Operated = 0;
        PercentCompletion = 0f;
        for (int i = 0; i < count; i++)
        {
            Token.ThrowIfCancellationRequested();
            string filePath = files[i];
            if (m_fileFilter(filePath))
            {
                CurrentOperationMessage = filePath;
                if (CheckFile(filePath, m_regexCheck))
                {
                    result.Add(filePath.Replace('\\', '/'));
                }
                Operated++;
                PercentCompletion = (i / (float)count) * 100f;
            }
        }
        return result.ToArray();
    }
    private bool CheckFile(string filepath, Regex check)
    {
        string assetText = File.ReadAllText(filepath);
        MatchCollection matches = check.Matches(assetText);
        bool result = matches.Count > 0;
        return result;
    }

}

public class FileTextReplace : IFileOperation<string[]>
{
    private string[] m_fullPaths;
    private string m_prevText;
    private string m_nextText;

    private CancellationTokenSource m_tokenSource;
    private CancellationToken m_cachedToken;

    public Task<string[]> OperationTask { get; private set; }
    public float PercentCompletion { get; private set; }
    public string CurrentOperationMessage { get; private set; }
    public int FileCount { get; private set; }
    public int Operated { get; private set; }
    public bool Running => OperationTask.Status switch
    {
        TaskStatus.RanToCompletion => false,
        TaskStatus.Faulted => false,
        TaskStatus.Canceled => false,
        _ => true
    };

    public CancellationToken Token => m_cachedToken;

    public static IFileOperation<string[]> ReplaceText(string[] fullpaths, string prevText, string nextText)
    {
        FileTextReplace operation = new FileTextReplace(fullpaths, prevText, nextText);
        operation.DoOperation();
        return operation;
    }

    public FileTextReplace(string[] fullpaths, string prevText, string nextText)
    {
        m_fullPaths = fullpaths;
        m_prevText = prevText;
        m_nextText = nextText;
        m_tokenSource = new CancellationTokenSource();
    }

    public void DoOperation()
    {
        if (null == OperationTask)
        {
            try
            {
                OperationTask = Task.Factory.StartNew<string[]>(DoReplaceToFiles, cancellationToken: m_cachedToken = m_tokenSource.Token);
            }
            catch (Exception _) { }
        }
    }

    public void Cancel()
    {
        if (null != m_tokenSource)
        {
            m_tokenSource.Cancel();
            m_tokenSource.Dispose();
            m_tokenSource = null;
        }
    }

    private string[] DoReplaceToFiles()
    {
        List<string> temp = new List<string>();
        Operated = 0;
        FileCount = m_fullPaths.Length;
        for (int i = 0, length = m_fullPaths.Length; i < length; i++)
        {
            Token.ThrowIfCancellationRequested();
            string assetFullPath = m_fullPaths[i];
            string assetText = File.ReadAllText(assetFullPath);
            string nextAssetText = assetText.Replace(m_prevText, m_nextText);
            File.WriteAllText(assetFullPath, nextAssetText);
            temp.Add(assetFullPath);
            Operated++;
            CurrentOperationMessage = assetFullPath;
            PercentCompletion = (i / (float)length) * 100f;
        }
        if (0 < temp.Count)
        {
            return temp.ToArray();
        }
        return null;
    }

}

public class AssetUsageSearchWindow : EditorWindow
{
    [Flags]
    private enum AssetFilter
    {
        Asset = 1 << 0,
        Material = 1 << 1,
        Prefab = 1 << 2,
        Scene = 1 << 3
    }

    [Serializable]
    private struct SearchRequest
    {
        public bool searchTextOnly;
        public string targetString;
        public UnityObject Asset
        {
            get
            {
                string path = AssetPath;
                if (string.IsNullOrEmpty(path))
                {
                    return null;
                }
                return AssetDatabase.LoadAssetAtPath<UnityObject>(path);
            }
            set
            {
                if (null != value && AssetDatabase.TryGetGUIDAndLocalFileIdentifier<UnityObject>(value, out string guid, out _))
                {
                    targetString = guid;
                }
            }
        }

        public string AssetPath => searchTextOnly ? string.Empty : AssetDatabase.GUIDToAssetPath(targetString);
        public long FileID
        {
            get
            {
                UnityObject asset = Asset;
                if (null != asset && AssetDatabase.TryGetGUIDAndLocalFileIdentifier(asset, out _, out long fileId))
                {
                    return fileId;
                }
                return 0;
            }
        }
    }

    [Serializable]
    private struct AssetResult
    {
        public string fullPath;
        public UnityObject asset;
        ///// <summary>
        ///// used to ping the actual asset dat has the direct reference
        ///// </summary>
        //public UnityObject subAssetIfNeed;
    }

    /// <summary>
    /// only search specify text from asset
    /// </summary>
    private bool m_searchTextOnly = false;

    private AssetFilter m_filter = (AssetFilter)~0; // Everything by default
    private List<string> m_searchFolders = new List<string>();
    private SearchRequest m_search;

    private IFileOperation<string[]> m_operationTask = null;
    private bool m_waitForResult = false;
    private AssetResult[] m_assetResults = null;
    private Regex m_pathFilterRegex;

    private Vector2 m_scrollPos;
    private Stopwatch m_processTime;

    private string m_searchReplaceText = string.Empty;

    private bool IsBusy => null != m_operationTask && m_operationTask.Running;

    [MenuItem("Tools/Temp Asset Usage Search", priority = 4)]
    private static void OpenWindowLah()
    {
        if (EditorWindow.HasOpenInstances<AssetUsageSearchWindow>())
        {
            UnityDebug.LogError($"Editor window {nameof(AssetUsageSearchWindow)} can only have 1 instance.");
            return;
        }
        AssetUsageSearchWindow window = CreateWindow<AssetUsageSearchWindow>();
        window.Show();

        // init
        window.titleContent = new GUIContent("Asset Usage Search");
        window.RefreshPathFilter();
    }

    private void OnGUI()
    {
        using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
        {
            bool isSearching = null != m_operationTask && m_operationTask.OperationTask.Status == TaskStatus.Running;
            bool isFaulted = null != m_operationTask && m_operationTask.OperationTask.Status == TaskStatus.Faulted;

            using (new EditorGUI.DisabledGroupScope(IsBusy))
            {
                // draw search info
                m_searchTextOnly = EditorGUILayout.Toggle("Search Text Only", m_searchTextOnly);
                string searchLable = m_searchTextOnly ? "Search for string (Text)" : "Search for Asset (GUID)";
                SearchRequest request = m_search;
                using (new EditorGUILayout.HorizontalScope())
                {
                    EditorGUILayout.PrefixLabel(searchLable);
                    if (m_searchTextOnly)
                    {
                        request.targetString = EditorGUILayout.TextField(request.targetString);
                        m_searchReplaceText = EditorGUILayout.TextField("Replace Text", m_searchReplaceText);
                    }
                    else
                    {
                        bool prev = GUI.enabled;
                        GUI.enabled = false;
                        request.targetString = EditorGUILayout.TextField(request.targetString);
                        GUI.enabled = prev;
                        request.Asset = EditorGUILayout.ObjectField(request.Asset, typeof(UnityObject), false);
                        using (new EditorGUI.DisabledGroupScope(true))
                        {
                            EditorGUILayout.TextField("FileID: ", request.FileID.ToString());
                        }
                    }
                }
                m_search = request;
                m_filter = (AssetFilter)EditorGUILayout.EnumFlagsField("Asset Filter", m_filter);

                // Draw folder
                EditorGUILayout.LabelField("Target folders:");
                using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
                {
                    if (GUILayout.Button("Add Folder"))
                    {
                        m_searchFolders.Add(Application.dataPath);
                    }
                    for (int i = 0; i < m_searchFolders.Count; i++)
                    {
                        using (new EditorGUILayout.HorizontalScope())
                        {
                            if (GUILayout.Button("X", EditorStyles.miniButton, GUILayout.Width(26)))
                            {
                                m_searchFolders.RemoveAt(i);
                                i--;
                                continue;
                            }
                            string folderResult = DrawSelectFolder(m_searchFolders[i]);
                            m_searchFolders[i] = string.IsNullOrEmpty(folderResult) ? m_searchFolders[i] : folderResult;
                        }
                    }
                }

                // search button
                if (GUILayout.Button($"Search References for  \"{m_search.targetString}\"") && !string.IsNullOrEmpty(m_search.targetString))
                {
                    DoSearch();
                }

                // replace button
                if (!IsBusy && !isSearching && !isFaulted && m_searchTextOnly && (null != m_assetResults && 0 < m_assetResults.Length))
                {
                    if (GUILayout.Button($"Replace Text"))
                    {
                        DoTextReplace(); // TODO @Hiko use task to prevent editor window STUCK :(
                    }
                }
            }

            if (isSearching) DrawOperatingGUI();
            else if (isFaulted) EditorGUILayout.HelpBox($"Error while running search:\n{m_operationTask.OperationTask.Exception}", MessageType.Error);
            else if (m_assetResults != null) DrawOperationResultGUI();
        }
    }

    private string DrawSelectFolder(string folderPath)
    {
        using (new EditorGUILayout.HorizontalScope())
        {
            bool prev = GUI.enabled;
            GUI.enabled = false;
            EditorGUILayout.TextField(folderPath);
            GUI.enabled = prev;
            if (GUILayout.Button("Select"))
            {
                folderPath = EditorUtility.OpenFolderPanel("Select target folder", Application.dataPath, "");
            }
        }
        return folderPath;
    }

    private void DoTextReplace()
    {
        List<string> pathList = new List<string>(m_assetResults.Length);
        for (int i = 0, length = m_assetResults.Length; i < length; i++)
        {
            AssetResult searchResult = m_assetResults[i];
            //if (searchResult.subAssetIfNeed)
            //{
            //    continue;
            //}
            pathList.Add(searchResult.fullPath);
        }
        if (0 < pathList.Count)
        {
            if (EditorUtility.DisplayDialog("Are you sure?", "The operation can not be canceled", "Yes just do it", "Dun do it"))
            {
                m_assetResults = Array.Empty<AssetResult>();
                m_processTime = Stopwatch.StartNew();
                m_operationTask = FileTextReplace.ReplaceText(pathList.ToArray(), m_search.targetString, m_searchReplaceText);
                m_waitForResult = true;
            }
        }
    }

    private void DoSearch()
    {
        m_assetResults = Array.Empty<AssetResult>();
        m_processTime = Stopwatch.StartNew();
        RefreshPathFilter();
        m_operationTask = FileAnalysis.AnalyzeFolders(m_searchFolders.Count > 0 ? m_searchFolders.ToArray() : new string[] { Application.dataPath }, FilterPath, new Regex(m_search.targetString));
        m_waitForResult = true;
    }

    private bool FilterPath(string path)
    {
        if (null == m_pathFilterRegex)
        {
            return false;
        }
        return m_pathFilterRegex.IsMatch(path);
    }

    private void DrawOperatingGUI()
    {
        EditorGUILayout.LabelField($"Operating: {m_operationTask.PercentCompletion:F2}%");
        EditorGUILayout.LabelField(m_operationTask.CurrentOperationMessage);
        if (GUILayout.Button("Cancel"))
        {
            m_operationTask.Cancel();
            //m_operationTask = null;
            m_processTime.Stop();
        }
    }

    private void DrawOperationResultGUI()
    {
        EditorGUILayout.LabelField($"Result {m_assetResults.Length} assets:");
        if (null != m_processTime)
        {
            if (m_processTime.IsRunning)
            {
                m_processTime.Stop();
            }
            if (m_operationTask is FileAnalysis)
            {
                EditorGUILayout.LabelField($"Operation time {m_processTime.ElapsedMilliseconds}ms, {m_operationTask.Operated}/{m_operationTask.FileCount} files scanned");
            }
            else if (m_operationTask is FileTextReplace)
            {
                EditorGUILayout.LabelField($"Operation time {m_processTime.ElapsedMilliseconds}ms, {m_operationTask.Operated}/{m_operationTask.FileCount} files got text replced");
            }
        }
        using (new EditorGUILayout.HorizontalScope())
        {
            if (GUILayout.Button("Copy list to clipboard", EditorStyles.miniButton))
            {
                GUIUtility.systemCopyBuffer = string.Join("\n", m_assetResults.Select(rst => rst.fullPath));
            }
            GUILayout.FlexibleSpace();
        }
        // since we dun have tons of result, we dun need to apply recycle scroll view here
        using (EditorGUILayout.ScrollViewScope scrollview = new EditorGUILayout.ScrollViewScope(m_scrollPos, EditorStyles.helpBox))
        {
            m_scrollPos = scrollview.scrollPosition;
            using (new EditorGUILayout.VerticalScope())
            {
                for (int i = 0; i < m_assetResults.Length; i++)
                {
                    using (new EditorGUILayout.HorizontalScope(EditorStyles.helpBox))
                    {
                        AssetResult result = m_assetResults[i];
                        Rect foldoutRect = GUILayoutUtility.GetRect(20, EditorGUIUtility.singleLineHeight, GUILayout.Width(20));
                        EditorGUILayout.ObjectField(result.asset, typeof(UnityObject), false);
                        string assetFullPath = result.fullPath;
                        if (GUILayout.Button(new GUIContent(assetFullPath, result.fullPath)))
                        {
                            UnityDebug.Log($"copy full path {assetFullPath} to clipboard");
                            GUIUtility.systemCopyBuffer = assetFullPath;
                            EditorGUIUtility.PingObject(result.asset);
                        }
                        m_assetResults[i] = result;
                        EditorGUILayout.EndFoldoutHeaderGroup();
                    }
                }
            }
        }
    }

    private void Update()
    {
        if (null != m_operationTask)
        {
            if (m_operationTask.OperationTask.Status == TaskStatus.Running)
            {
                Repaint();
            }
            else if (m_operationTask.OperationTask.Status == TaskStatus.RanToCompletion && m_waitForResult)
            {

                if (m_operationTask is FileAnalysis) { }
                else if (m_operationTask is FileTextReplace)
                {
                    string[] results = m_operationTask.OperationTask.Result;
                    string tempLog = string.Empty;
                    for (int i = 0, length = results.Length; i < length; i++)
                    {
                        string assetFullPath = results[i];
                        AssetDatabase.ImportAsset(assetFullPath);
                        string assetPath = assetFullPath.Substring(Application.dataPath.Length - 6);
                        tempLog += $"{assetPath}\n";
                    }

                    UnityDebug.Log($"Do Text reaplce for asset:\n {tempLog}");
                    EditorUtility.DisplayDialog("Done", $"Did text replace for {results.Length} files", "OK");
                    AssetDatabase.Refresh();
                }

                // Result filling is done here because it needs to run on main thread
                m_waitForResult = false;
                string[] result = m_operationTask.OperationTask.Result;
                int count = result.Length;
                if (0 == count)
                {
                    m_assetResults = Array.Empty<AssetResult>();
                }
                else
                {
                    if (null == m_assetResults)
                    {
                        m_assetResults = new AssetResult[count];
                    }
                    else if (m_assetResults.Length != count)
                    {
                        Array.Resize(ref m_assetResults, count);
                    }
                }
                for (int i = 0; i < count; i++)
                {
                    string assetPath = $"Assets{result[i].Substring(Application.dataPath.Length)}";
                    UnityObject asset = AssetDatabase.LoadAssetAtPath<UnityObject>(assetPath);
                    m_assetResults[i] = new AssetResult
                    {
                        fullPath = result[i],
                        asset = asset,
                    };
                }
                Repaint();
            }
        }
    }

    private void RefreshPathFilter()
    {
        string extensionFilter = GetExtensionFilter(m_filter);
        m_pathFilterRegex = new Regex(string.Format(@"^.*\.({0})$", extensionFilter));
    }

    private string GetExtensionFilter(AssetFilter filter)
    {
        List<string> extensions = new List<string>();
        if (filter.HasFlag(AssetFilter.Asset))
        {
            extensions.Add("asset");
        }
        if (filter.HasFlag(AssetFilter.Material))
        {
            extensions.Add("mat");
        }
        if (filter.HasFlag(AssetFilter.Prefab))
        {
            extensions.Add("prefab");
        }
        if (filter.HasFlag(AssetFilter.Scene))
        {
            extensions.Add("unity");
        }
        string extensionFilter = string.Join("|", extensions);
        return extensionFilter;
    }

}

[ExecuteAlways, DisallowMultipleComponent, RequireComponent(typeof(RectTransform))]
public class CutRectSetter : UIBehaviour, IClipper
{
    [SerializeField]
    private Canvas _canvas;
    [SerializeField]
    private MaskableGraphic _clipTarget;

    private bool m_shouldRecalculateClipRects = false;
    private Rect m_prevClipRect = default;
    private bool m_hasClipped = false;

    public void PerformClipping()
    {
        // IDK why unity use ReferenceEquals, I just copied it from RectMask2D.cs :(
        if (ReferenceEquals(_canvas, null) || null == _clipTarget)
        {
            return;
        }

        RectTransform selfRectTransform = transform as RectTransform;
        RectTransform targetTectTransform = _clipTarget.transform as RectTransform;
        if (!IsInsideRect(selfRectTransform, targetTectTransform))
        {
            CancelClip();
            m_prevClipRect = default;
            m_shouldRecalculateClipRects = false;
            return;
        }

        Rect currentRect = selfRectTransform.rect;
        Vector2 selfPivot = selfRectTransform.pivot;
        // get pivot position
        currentRect.position = SwitchToRectTransform(selfRectTransform, targetTectTransform);
        // rect's position is bottom left
        Vector2 delta = new Vector2(-currentRect.width * selfPivot.x, -currentRect.height * selfPivot.y);
        currentRect.position += delta;

        m_shouldRecalculateClipRects = m_shouldRecalculateClipRects || m_prevClipRect != currentRect;
        if (m_shouldRecalculateClipRects)
        {
            _clipTarget.SetClipRect(default, true);
            _clipTarget.SetClipRect(currentRect, true);
            _clipTarget.Cull(currentRect, true);
            m_prevClipRect = currentRect;
            m_shouldRecalculateClipRects = false;
        }
    }

    [ContextMenu(nameof(CancelClip))]
    private void CancelClip()
    {
        _clipTarget.SetClipRect(default, true);
        m_hasClipped = false;
    }

    protected override void OnEnable()
    {
        base.OnEnable();
        m_shouldRecalculateClipRects = true;
        ClipperRegistry.Register(this);
        MaskUtilities.Notify2DMaskStateChanged(this);
    }

    protected override void OnDisable()
    {
        base.OnDisable();
        ClipperRegistry.Unregister(this);
        MaskUtilities.Notify2DMaskStateChanged(this);
        CancelClip();
    }

    protected override void OnTransformParentChanged()
    {
        m_shouldRecalculateClipRects = true;
    }

    protected override void OnCanvasHierarchyChanged()
    {
        m_shouldRecalculateClipRects = true;
    }

    #region some utils

    private readonly Vector2 RECT_TOP = new Vector2(0.5f, 1f);
    private readonly Vector2 RECT_BOTTOM = new Vector2(0.5f, 0f);
    private readonly Vector2 RECT_LEFT = new Vector2(0f, 0.5f);
    private readonly Vector2 RECT_RIGHT = new Vector2(1f, 0.5f);
    private readonly Vector2 RECT_CENTER = new Vector2(0.5f, 0.5f);

    private readonly Vector2 RECT_BOTTOM_LEFT = new Vector2(0f, 0f);
    private readonly Vector2 RECT_BOTTOM_RIGHT = new Vector2(1f, 0f);
    private readonly Vector2 RECT_TOP_LEFT = new Vector2(0f, 1f);
    private readonly Vector2 RECT_TOP_RIGHT = new Vector2(1f, 1f);

    private Vector2 SwitchToRectTransform(RectTransform from, RectTransform to)
    {
        Vector2 screenP = RectTransformUtility.WorldToScreenPoint(null, from.position);
        RectTransformUtility.ScreenPointToLocalPointInRectangle(to, screenP, null, out Vector2 localPoint);
        return localPoint;
    }

    private bool IsInsideRect(RectTransform rectTransform, RectTransform outterRect)
    {
        Vector3 checkWorldPoint = RectOffsetToWorld(rectTransform, RECT_BOTTOM_LEFT);
        bool bottomLeftOut = !RectTransformUtility.RectangleContainsScreenPoint(outterRect, checkWorldPoint);
        checkWorldPoint = RectOffsetToWorld(rectTransform, RECT_BOTTOM_RIGHT);
        bool bottomRightOut = !RectTransformUtility.RectangleContainsScreenPoint(outterRect, checkWorldPoint);
        checkWorldPoint = RectOffsetToWorld(rectTransform, RECT_TOP_LEFT);
        bool topLeftOut = !RectTransformUtility.RectangleContainsScreenPoint(outterRect, checkWorldPoint);
        checkWorldPoint = RectOffsetToWorld(rectTransform, RECT_TOP_RIGHT);
        bool topRightOut = !RectTransformUtility.RectangleContainsScreenPoint(outterRect, checkWorldPoint);

        return !(bottomLeftOut || bottomRightOut || topLeftOut || topRightOut);
    }

    private Vector3 RectOffsetToWorld(RectTransform rectTransform, Vector2 normalizedRectPosition)
    {
        Rect selfRect = rectTransform.rect;
        Vector2 localposition = Vector2.zero;
        if (RECT_CENTER == normalizedRectPosition) // RectPositionType.Center
        {
            localposition = selfRect.center;
        }
        else if (RECT_TOP == normalizedRectPosition) // RectPositionType.Top
        {
            localposition = new Vector2(selfRect.center.x, selfRect.yMax);
        }
        else if (RECT_BOTTOM == normalizedRectPosition) // RectPositionType.Bottom
        {
            localposition = new Vector2(selfRect.center.x, selfRect.yMin);
        }
        else if (RECT_LEFT == normalizedRectPosition) // RectPositionType.Left
        {
            localposition = new Vector2(selfRect.xMin, selfRect.center.y);
        }
        else if (RECT_RIGHT == normalizedRectPosition) // RectPositionType.Right
        {
            localposition = new Vector2(selfRect.xMax, selfRect.center.y);
        }
        else if (RECT_TOP_LEFT == normalizedRectPosition) // RectPositionType.TopLeft
        {
            localposition = new Vector2(selfRect.xMin, selfRect.yMax);
        }
        else if (RECT_TOP_RIGHT == normalizedRectPosition) // RectPositionType.TopRight
        {
            localposition = selfRect.max;
        }
        else if (RECT_BOTTOM_LEFT == normalizedRectPosition) // RectPositionType.BottomLeft
        {
            localposition = selfRect.min;
        }
        else if (RECT_BOTTOM_RIGHT == normalizedRectPosition) // RectPositionType.BottomRight
        {
            localposition = new Vector2(selfRect.xMax, selfRect.yMin);
        }
        else
        {
            Debug.LogError($"{normalizedRectPosition} is not a normalized rect position");
        }

        return rectTransform.TransformPoint(localposition);
    }

    #endregion

}