using UnityEngine;
using UnityEngine.UI;

[ExecuteAlways]
public class LayoutGroupTempAnimationParam : MonoBehaviour
{
    [SerializeField]
    private LayoutGroup _target;

    [SerializeField]
    private int _left;
    [SerializeField]
    private int _right;
    [SerializeField]
    private int _top;
    [SerializeField]
    private int _bottom;

    [Header("GridLayout must use GridSpacing")]
    [SerializeField]
    private bool _alsoControlSpacing;
    [SerializeField]
    private int _normalSpacing = 0;
    [SerializeField]
    private Vector2 _gridSpacing = Vector2.zero;

    private RectOffset m_targetPadding;

    public void OnDidApplyAnimationProperties()
    {
        if (_target == null)
        {
            return;
        }
        ApplyPadding();
        if (_alsoControlSpacing)
        {
            ApplySpacing();
        }
        // need to notify refresh
        RectTransform rectTransform = this.transform as RectTransform;
        LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
    }

    private void ApplyPadding()
    {
        m_targetPadding = _target.padding;
        if (m_targetPadding != null)
        {
            m_targetPadding.left = _left;
            m_targetPadding.right = _right;
            m_targetPadding.top = _top;
            m_targetPadding.bottom = _bottom;
        }
    }

    private void ApplySpacing()
    {
        if (_target is HorizontalOrVerticalLayoutGroup layoutGroup)
        {
            layoutGroup.spacing = _normalSpacing;
        }
        else if (_target is GridLayoutGroup gridLayoutGroup)
        {
            gridLayoutGroup.spacing = _gridSpacing;
        }
    }

#if UNITY_EDITOR

    private void OnValidate()
    {
        ApplyPadding();
        if (_alsoControlSpacing)
        {
            ApplySpacing();
        }
        if (!Application.isPlaying)
        {
            // need to notify refresh
            RectTransform rectTransform = this.transform as RectTransform;
            LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
        }
    }

    private void Reset()
    {
        _target = this.GetComponent<LayoutGroup>();
        m_targetPadding = _target.padding;
    }

#endif
}

public static class EditorWwiseManager
{
    static bool m_isPaused = false;

    static EditorWwiseManager()
    {
        EditorApplication.update += OnUpdate;
        EditorApplication.pauseStateChanged += OnPauseStateChanged;
    }

    private static void OnPauseStateChanged(PauseState state)
    {
        switch (state)
        {
            case PauseState.Paused:
                m_isPaused = true;
                break;
            case PauseState.Unpaused:
                m_isPaused = false;
                break;
        }
    }

    static void OnUpdate()
    {
        if (EditorUtility.audioMasterMute && !m_isPaused)
        {
            AkSoundEngine.Suspend(true);
            m_isPaused = true;
        }
        else if (!EditorUtility.audioMasterMute && m_isPaused)
        {
            AkSoundEngine.WakeupFromSuspend();
            m_isPaused = false;
        }
    }
}

public class PredicateTempTest
{
    public struct TempPack
    {
        public int tempValue;
        private static Random s_random = new Random(DateTime.Now.Millisecond);
        public static TempPack CreateTempPack()
        {
            TempPack pack = default;
            if (s_random == null)
            {
                s_random = new Random(DateTime.Now.Millisecond);
            }
            pack.tempValue = s_random.Next(0, 10);
            return pack;
        }
    }

    private static List<List<TempPack>> s_tempListContainer = new List<List<TempPack>>(10000);

    public static void DoTest(int tempCount)
    {
        FillTestData(tempCount);
        DoTestLambda();
        DoTestPassMethod();
        DoTestPassExistPredicate();
    }

    private static void FillTestData(int tempCount)
    {
        s_tempListContainer.Clear();
        s_tempListContainer.Capacity = tempCount;
        for (int i = 0; i < tempCount; i++)
        {
            List<TempPack> tempList = new List<TempPack>(tempCount);
            s_tempListContainer.Add(tempList);
            for (int j = 0; j < tempCount; j++)
            {
                tempList.Add(TempPack.CreateTempPack());
            }
        }
    }

    private static void DoTestLambda()
    {
        Console.WriteLine("");
        Console.WriteLine("TestLambda start");
        Stopwatch stopWatch = new Stopwatch();
        stopWatch.Start();
        for (int i = 0, containerSize = s_tempListContainer.Count; i < containerSize; i++)
        {
            List<TempPack> tempList = s_tempListContainer[i];
            tempList.Find((existPack) => existPack.tempValue % 5 == 0);
        }
        stopWatch.Stop();
        Console.WriteLine($"TestLambda end, result_{stopWatch.ElapsedMilliseconds}ms");
    }

    private static void DoTestPassMethod()
    {
        Console.WriteLine("");
        Console.WriteLine("PassMethod start");
        Stopwatch stopWatch = new Stopwatch();
        stopWatch.Start();
        for (int i = 0, containerSize = s_tempListContainer.Count; i < containerSize; i++)
        {
            List<TempPack> tempList = s_tempListContainer[i];
            tempList.Find(CheckPack);
        }
        stopWatch.Stop();
        Console.WriteLine($"PassMethod end, result_{stopWatch.ElapsedMilliseconds}ms");
    }

    private static void DoTestPassExistPredicate()
    {
        Console.WriteLine("");
        Console.WriteLine("PassExistPredicate start");
        Stopwatch stopWatch = new Stopwatch();
        stopWatch.Start();
        Predicate<TempPack> predicate = new Predicate<TempPack>(CheckPack);
        for (int i = 0, containerSize = s_tempListContainer.Count; i < containerSize; i++)
        {
            List<TempPack> tempList = s_tempListContainer[i];
            tempList.Find(predicate);
        }
        stopWatch.Stop();
        Console.WriteLine($"PassExistPredicate end, result_{stopWatch.ElapsedMilliseconds}ms");
    }

    private static bool CheckPack(TempPack pack)
    {
        return pack.tempValue % 5 == 0;
    }
        
}

using UnityEngine;
using UnityEngine.UI;

namespace Temp
{
    public enum RectPositionType
    {
        Center = 0,

        Top = 1,
        Bottom = 2,
        Left = 3,
        Right = 4,

        TopLeft = 5,
        TopRight = 6,

        BottomLeft = 7,
        BottomRight = 8,
    }

    public class UIElementPositionSetter : MonoBehaviour
    {
        [Header("Target setting")]
        [SerializeField]
        private RectPositionType _targetRectPosition = RectPositionType.Center;
        [SerializeField]
        private Vector2 _targetPivot = Vector2.zero;
        [SerializeField]
        private Vector2 _extraOffset = Vector2.zero;
        [SerializeField]
        private RectOffset _adaptionOffset;
        [SerializeField]
        private bool _doScreenAdaption;

        [Header("Other setting")]
        [SerializeField]
        private RectTransform _defaultBoundsCanvasTransform;
        [SerializeField]
        private bool _adjustHorizontal = true;
        [SerializeField]
        private bool _adjustVertical = true;

        public void SetPosition(RectTransform target)
        {
            RectTransform self = transform as RectTransform;
            Vector3 spawnPos = GetLocalRectPosition(self, _targetRectPosition);
            spawnPos += new Vector3(_extraOffset.x, _extraOffset.y, 0f);
            spawnPos = self.localToWorldMatrix.MultiplyPoint(spawnPos);
            target.pivot = _targetPivot;
            target.position = spawnPos;
            if (_doScreenAdaption)
            {
                // HACK @Hiko force rebuild to make sure the size is correct
                LayoutRebuilder.ForceRebuildLayoutImmediate(target);
                DoAdaption(target);
            }
        }

        public void DoAdaption(RectTransform targetTransform)
        {
            if (_adjustHorizontal)
            {
                AdjustHorizontal(targetTransform, _defaultBoundsCanvasTransform);
            }
            if (_adjustVertical)
            {
                AdjustVertical(targetTransform, _defaultBoundsCanvasTransform);
            }
        }

        public void AdjustHorizontal(RectTransform target, RectTransform outterBoundRectTransform)
        {
            Vector2 targetSize = target.rect.size;
            Matrix4x4 targetLocalToWorld = target.localToWorldMatrix;
            Matrix4x4 boundRectWorldToLocal = outterBoundRectTransform.worldToLocalMatrix;
            Vector2 topLeftPos = GetLocalRectPosition(target, RectPositionType.TopLeft);

            Vector3 checkWorldPoint = targetLocalToWorld.MultiplyPoint(topLeftPos + Vector2.down * targetSize.y * 0.5f + Vector2.left * _adaptionOffset.left);
            Vector2 leftCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
            Vector2 leftCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Left);
            bool leftOut = leftCheckLocalPoint.x < leftCheckBoundPoint.x;

            checkWorldPoint = targetLocalToWorld.MultiplyPoint(topLeftPos + Vector2.down * targetSize.y * 0.5f + Vector2.right * targetSize.x + Vector2.right * _adaptionOffset.right);
            Vector2 rightCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
            Vector2 rightCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Right);
            bool rightOut = rightCheckLocalPoint.x > rightCheckBoundPoint.x;

            if (leftOut && rightOut)
            {
                // outter bound is too small
                return;
            }

            if (leftOut)
            {
                float xDelta = leftCheckLocalPoint.x - leftCheckBoundPoint.x;
                Vector3 tempPos = target.localPosition;
                tempPos.x -= xDelta;
                target.localPosition = tempPos;
            }
            if (rightOut)
            {
                float xDelta = rightCheckLocalPoint.x - rightCheckBoundPoint.x;
                Vector3 tempPos = target.localPosition;
                tempPos.x -= xDelta;
                target.localPosition = tempPos;
            }
            if (leftOut || rightOut)
            {
                LayoutRebuilder.ForceRebuildLayoutImmediate(target);
            }
        }

        public void AdjustVertical(RectTransform target, RectTransform outterBoundRectTransform)
        {
            Vector2 targetSize = target.rect.size;
            Matrix4x4 targetLocalToWorld = target.localToWorldMatrix;
            Matrix4x4 boundRectWorldToLocal = outterBoundRectTransform.worldToLocalMatrix;
            Vector2 topLeftPos = GetLocalRectPosition(target, RectPositionType.TopLeft);

            Vector3 checkWorldPoint = targetLocalToWorld.MultiplyPoint(topLeftPos + Vector2.right * targetSize.x * 0.5f + Vector2.up * _adaptionOffset.top);
            Vector2 topCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
            Vector2 topCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Top);
            bool topOut = topCheckLocalPoint.y > topCheckBoundPoint.y;

            checkWorldPoint = targetLocalToWorld.MultiplyPoint(topLeftPos + Vector2.down * targetSize.y + Vector2.right * targetSize.x * 0.5f + Vector2.down * _adaptionOffset.bottom);
            Vector2 bottomCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
            Vector2 bottomCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Bottom);
            bool bottomOut = bottomCheckLocalPoint.y < bottomCheckBoundPoint.y;

            if (topOut && bottomOut)
            {
                // outter bound is too small
                return;
            }

            if (topOut)
            {
                float yDelta = topCheckLocalPoint.y - topCheckBoundPoint.y;
                Vector3 tempPos = target.localPosition;
                tempPos.y -= yDelta;
                target.localPosition = tempPos;
            }
            if (bottomOut)
            {
                float yDelta = bottomCheckLocalPoint.y - bottomCheckBoundPoint.y;
                Vector3 tempPos = target.localPosition;
                tempPos.y -= yDelta;
                target.localPosition = tempPos;
            }
            if (topOut || bottomOut)
            {
                LayoutRebuilder.ForceRebuildLayoutImmediate(target);
            }
        }

        #region position util

        public static Vector2 GetLocalRectPosition(RectTransform target, RectPositionType offsetType)
        {
            return GetLocalRectPosition(target, offsetType, Vector2.zero);
        }

        public static Vector2 GetLocalRectPosition(RectTransform target, RectPositionType offsetType, Vector2 offset)
        {
            return GetLocalRectPosition(target.rect.size, target.pivot, offsetType, offset);
        }

        public static Vector2 GetLocalRectPosition(Vector2 targetSize, Vector2 targetPivot, RectPositionType offsetType, Vector2 offset)
        {
            Vector2 bottomLeft = Vector2.zero;
            bottomLeft.x -= targetPivot.x * targetSize.x;
            bottomLeft.y -= targetPivot.y * targetSize.y;
            Vector2 result = bottomLeft;
            switch (offsetType)
            {
                case RectPositionType.Top:
                    result += Vector2.right * 0.5f * targetSize.x + Vector2.up * targetSize.y;
                    break;
                case RectPositionType.Bottom:
                    result += Vector2.right * 0.5f * targetSize.x;
                    break;
                case RectPositionType.Left:
                    result += Vector2.up * 0.5f * targetSize.y;
                    break;
                case RectPositionType.Right:
                    result += Vector2.right * targetSize.x + Vector2.up * 0.5f * targetSize.y;
                    break;
                case RectPositionType.TopLeft:
                    result += Vector2.up * targetSize.y;
                    break;
                case RectPositionType.TopRight:
                    result += Vector2.right * targetSize.x + Vector2.up * targetSize.y;
                    break;
                case RectPositionType.BottomRight:
                    result += Vector2.right * targetSize.x;
                    break;
                case RectPositionType.BottomLeft:
                default:
                    break;
            }
            return result + offset;
        }

        public static Vector3 RectPositionToWorld(RectTransform rect, RectPositionType offsetType)
        {
            return RectPositionToWorld(rect, offsetType, Vector2.zero);
        }

        public static Vector3 RectPositionToWorld(RectTransform rect, RectPositionType offsetType, Vector2 offset)
        {
            var localPosition = GetLocalRectPosition(rect, offsetType, offset);
            return rect.TransformPoint(localPosition);
        }

        private Vector2 GetTargetRectPositionInLocalReference(RectPositionType offsetType)
        {
            RectTransform self = transform as RectTransform;
            Vector2 targetPivotPos = GetLocalRectPosition(self, _targetRectPosition, _extraOffset);
            Vector2 virtualCenterPos = targetPivotPos;
            virtualCenterPos += GetLocalRectPosition(_targetSize, _targetPivot, offsetType, Vector2.zero);
            return virtualCenterPos;
        }

        #endregion

#if UNITY_EDITOR

        [Header("Preview setting")]
        [SerializeField]
        private Vector2 _targetSize = Vector2.one * 128f;
        [SerializeField]
        private Color _previewColor = Color.white;
        [SerializeField]
        private bool _doDrawAdaptionOffsetRect = false;

        [System.Serializable]
        private struct TempCheckResult
        {
            public bool previewLeftOut;
            public bool previewRightOut;
            public bool previewTopOut;
            public bool previewBottomOut;
        }

        [SerializeField]
        private TempCheckResult _checkResult;

        private bool _previewLeftOut;
        private bool _previewRightOut;
        private bool _previewTopOut;
        private bool _previewBottomOut;

        private void OnDrawGizmosSelected()
        {
            // draw A box to show the position of target
            RectTransform self = transform as RectTransform;
            Vector2 localSpawnPos = GetLocalRectPosition(self, _targetRectPosition);
            localSpawnPos += _extraOffset;

            Vector2 pivot = _targetPivot;
            Vector2 topLeftPos = localSpawnPos;
            topLeftPos.x -= pivot.x * _targetSize.x;
            topLeftPos.y -= (pivot.y - 1f) * _targetSize.y;

            if (_doScreenAdaption)
            {
                // do adaption
                if (_defaultBoundsCanvasTransform != null) // if there is no bound, we can take the screen as the bound
                {
                    Matrix4x4 localToWorld = self.localToWorldMatrix;
                    RectTransform outterBoundRectTransform = _defaultBoundsCanvasTransform;
                    Matrix4x4 boundRectWorldToLocal = outterBoundRectTransform.worldToLocalMatrix;

                    Vector3 checkWorldPoint = localToWorld.MultiplyPoint(topLeftPos + Vector2.down * _targetSize.y * 0.5f + Vector2.left * _adaptionOffset.left);
                    Vector2 leftCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
                    Vector2 leftCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Left);
                    _previewLeftOut = leftCheckLocalPoint.x < leftCheckBoundPoint.x;

                    checkWorldPoint = localToWorld.MultiplyPoint(topLeftPos + Vector2.down * _targetSize.y * 0.5f + Vector2.right * _targetSize.x + Vector2.right * _adaptionOffset.right);
                    Vector2 rightCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
                    Vector2 rightCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Right);
                    _previewRightOut = rightCheckLocalPoint.x > rightCheckBoundPoint.x;

                    checkWorldPoint = localToWorld.MultiplyPoint(topLeftPos + Vector2.right * _targetSize.x * 0.5f + Vector2.up * _adaptionOffset.top);
                    Vector2 topCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
                    Vector2 topCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Top);
                    _previewTopOut = topCheckLocalPoint.y > topCheckBoundPoint.y;

                    checkWorldPoint = localToWorld.MultiplyPoint(topLeftPos + Vector2.down * _targetSize.y + Vector2.right * _targetSize.x * 0.5f + Vector2.down * _adaptionOffset.bottom);
                    Vector2 bottomCheckLocalPoint = boundRectWorldToLocal.MultiplyPoint(checkWorldPoint);
                    Vector2 bottomCheckBoundPoint = GetLocalRectPosition(outterBoundRectTransform, RectPositionType.Bottom);
                    _previewBottomOut = bottomCheckLocalPoint.y < bottomCheckBoundPoint.y;

                    if (_adjustHorizontal)
                    {
                        if (_previewLeftOut && _previewRightOut)
                        {
                            // bound too small
                        }
                        else
                        {
                            if (_previewLeftOut)
                            {
                                float xDelta = leftCheckLocalPoint.x - leftCheckBoundPoint.x;
                                Vector3 tempPos = topLeftPos;
                                tempPos.x -= xDelta;
                                topLeftPos = tempPos;
                            }
                            if (_previewRightOut)
                            {
                                float xDelta = rightCheckLocalPoint.x - rightCheckBoundPoint.x;
                                Vector3 tempPos = topLeftPos;
                                tempPos.x -= xDelta;
                                topLeftPos = tempPos;
                            }
                        }
                    }

                    if (_adjustVertical)
                    {
                        if (_previewTopOut && _previewBottomOut)
                        {
                            // bound too small
                        }
                        else
                        {
                            if (_previewTopOut)
                            {
                                float yDelta = topCheckLocalPoint.y - topCheckBoundPoint.y;
                                Vector3 tempPos = topLeftPos;
                                tempPos.y -= yDelta;
                                topLeftPos = tempPos;
                            }
                            if (_previewBottomOut)
                            {
                                float yDelta = bottomCheckLocalPoint.y - bottomCheckBoundPoint.y;
                                Vector3 tempPos = topLeftPos;
                                tempPos.y -= yDelta;
                                topLeftPos = tempPos;
                            }
                        }
                    }
                }
            }

            _checkResult.previewLeftOut = _previewLeftOut;
            _checkResult.previewRightOut = _previewRightOut;
            _checkResult.previewTopOut = _previewTopOut;
            _checkResult.previewBottomOut = _previewBottomOut;

            if (_doDrawAdaptionOffsetRect && _defaultBoundsCanvasTransform != null)
            {
                Vector2 innerBoundLeftPos = GetLocalRectPosition(_defaultBoundsCanvasTransform, RectPositionType.TopLeft, new Vector2(_adaptionOffset.left, -_adaptionOffset.top));
                Vector2 size = _defaultBoundsCanvasTransform.rect.size;
                size.x -= _adaptionOffset.horizontal;
                size.y -= _adaptionOffset.vertical;
                DrawBox(_defaultBoundsCanvasTransform, innerBoundLeftPos, size, Color.blue);
            }
            DrawBox(self, topLeftPos, _targetSize, _previewColor);
        }

        private void DrawBox(RectTransform reference, Vector2 topLeftPos, Vector2 size, Color color)
        {
            Color cachedColor = Gizmos.color;
            Gizmos.color = color;
            Gizmos.DrawLine(reference.TransformPoint(topLeftPos), reference.TransformPoint(topLeftPos + Vector2.right * size.x));
            Gizmos.DrawLine(reference.TransformPoint(topLeftPos), reference.TransformPoint(topLeftPos + Vector2.down * size.y));
            Gizmos.DrawLine(reference.TransformPoint(topLeftPos + Vector2.right * size.x), reference.TransformPoint(topLeftPos + Vector2.right * size.x + Vector2.down * size.y));
            Gizmos.DrawLine(reference.TransformPoint(topLeftPos + Vector2.down * size.y), reference.TransformPoint(topLeftPos + Vector2.right * size.x + Vector2.down * size.y));
            Gizmos.color = cachedColor;
        }

#endif

    }
}

// Analyze asset as text file

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

public static class FileAnalyzer
{
    public class FileAnalysis<T> : IFileAnalysis<T>
    {
        CancellationTokenSource m_tokenSource = new CancellationTokenSource
        public Task<T> Task { get; set; }
        public float PercentCompletion { get; set; }
        public string CurrentOperationMessage { get; set; }
        public int FileCount { get; set; }
        public int Scanned { get; set; }
        public bool Running => Task.Status switch
        {
            TaskStatus.RanToCompletion => false,
            TaskStatus.Faulted => false,
            TaskStatus.Canceled => false,
            _ => true
        };
        public CancellationToken Token => m_tokenSource.Token
        public void Cancel()
        {
            m_tokenSource.Cancel();
        }
    }
    
    public static IFileAnalysis<string[]> AnalyzeFolders(string[] folders, System.Predicate<string> fileFilter, Regex content)
    {
        FileAnalysis<string[]> operation = new FileAnalysis<string[]>();
        operation.Task = Task.Factory.StartNew<string[]>(() => CheckFolders(folders, fileFilter, content, operation), TaskCreationOptions.LongRunning);
        return operation;
    }
    
    private static string[] CheckFolders(string[] folders, System.Predicate<string> fileFilter, Regex fileContent, FileAnalysis<string[]> operationStatus)
    {
        string[] files = folders.SelectMany(folder => Directory.GetFiles(folder, "*", SearchOption.AllDirectories)).ToArray();
        List<string> result = new List<string>(200);
        int count = files.Length;
        operationStatus.FileCount = count;
        operationStatus.Scanned = 0;
        operationStatus.PercentCompletion = 0f;
        for (int i = 0; i < count; i++)
        {
            operationStatus.Token.ThrowIfCancellationRequested();
            string filePath = files[i];
            if (fileFilter(filePath))
            {
                operationStatus.CurrentOperationMessage = filePath;
                if (CheckFile(filePath, fileContent))
                {
                    result.Add(filePath);
                }
                operationStatus.Scanned++;
                operationStatus.PercentCompletion = (i / (float)count) * 100f;
            }
        }
        return result.ToArray();
    }

    private static bool CheckFile(string filepath, Regex fileContent)
    {
        string assetText = File.ReadAllText(filepath);
        MatchCollection matches = fileContent.Matches(assetText);
        bool result = matches.Count > 0;
        return result;
    }  
}

// Editor window

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;
            }
        }
    }

    [System.Serializable]
    private struct SearchResult
    {
        public string path;
        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 IFileAnalysis<string[]> m_findTask = null;
    private bool m_waitForResult = false;
    private SearchResult[] m_findResults = null;
    private Regex m_pathFilterRegex;

    private Vector2 m_scrollPos;
    private Stopwatch m_processTime;

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

    [MenuItem("Muy Tools/Asset Usage Search", priority = 4)]
    private static void Init()
    {
        AssetUsageSearchWindow window = CreateWindow<AssetUsageSearchWindow>();
        window.Show();
        window.titleContent = new GUIContent("Asset Usage Search");
    }

    private void OnGUI()
    {
        using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
        {
            // switch search mode
            m_searchTextOnly = EditorGUILayout.Toggle("Search Text Only", m_searchTextOnly  
            // draw search info
            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);
                }
                else
                {
                    GUI.enabled = false;
                    request.targetString = EditorGUILayout.TextField(request.targetString);
                    GUI.enabled = true;
                    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("Search Filter", m_filter);
            EditorGUILayout.LabelField("Search folders:");
            using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
            {
                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;
                    }

                if (GUILayout.Button("Add Folder"))
                {
                    m_searchFolders.Add(Application.dataPath);
                }
            }
        }       

        // search button
        using (new EditorGUI.DisabledGroupScope(IsBusy))
        {
            if (GUILayout.Button($"Search References for {m_search.targetString}"))
            {
                if (!string.IsNullOrEmpty(m_search.targetString))
                {
                    DoFind();
                }
            }

        bool isSearching = null != m_findTask && m_findTask.Task.Status == TaskStatus.Running;
        bool isFaulted = null != m_findTask && m_findTask.Task.Status == TaskStatus.Faulted 
        if (isSearching) SearchingGUI();
        else if (isFaulted) EditorGUILayout.HelpBox($"Error while running search:\n{m_findTask.Task.Exception}", MessageType.Error);
        else if (m_findResults != null) SearchResultGUI();
    }

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

    private void DoFind()
    {
        m_findResults = null;
        m_waitForResult = true;
        m_processTime = Stopwatch.StartNew();
        RefreshPathFilter();
        m_findTask = FileAnalyzer.AnalyzeFolders(m_searchFolders.Count > 0 ? m_searchFolders.ToArray() : new string[] { Application.dataPath }, FilterPath, new Regex(m_search.targetString));
        m_findTask.Task.ContinueWith(task =>
        {
            if (task.Status == TaskStatus.RanToCompletion)
            {
                string[] result = task.Result;
            }
        });
    }

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

    private void SearchingGUI()
    {
        EditorGUILayout.LabelField($"Searching: {m_findTask.PercentCompletion}%");
        EditorGUILayout.LabelField(m_findTask.CurrentOperationMessage);
        if (GUILayout.Button("Cancel"))
        {
        m_findTask.Cancel();
        m_findTask = null;
    }

    private void SearchResultGUI()
    {
        EditorGUILayout.LabelField($"Found {m_findResults.Length} assets:");
        if (null != m_processTime)
        {
            m_processTime.Stop();
            EditorGUILayout.LabelField($"Search time {m_processTime.ElapsedMilliseconds}ms, {m_findTask.Scanned}/{m_findTask.FileCount} files scanned");
        }
        using (new EditorGUILayout.HorizontalScope())
        {
            if (GUILayout.Button("Copy list to clipboard", EditorStyles.miniButton))
            {
                GUIUtility.systemCopyBuffer = string.Join("\n", m_findResults.Select(rst => rst.path));
            }
            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_findResults.Length; i++)
                {
                    using (new EditorGUILayout.HorizontalScope(EditorStyles.helpBox))
                    {
                        SearchResult result = m_findResults[i];
                        Rect foldoutRect = GUILayoutUtility.GetRect(20, EditorGUIUtility.singleLineHeight, GUILayout.Width(20));
                        EditorGUILayout.ObjectField(result.asset, typeof(UnityObject), false);
                        EditorGUILayout.LabelField(new GUIContent(result.path, result.path));
                        m_findResults[i] = result;
                        EditorGUILayout.EndFoldoutHeaderGroup();
                    }
                }
            }
        }
    }

    private void Update()
    {
        if (null != m_findTask)
        {
            if (m_findTask.Task.Status == TaskStatus.Running)
            {
                Repaint();
            }
            else if (m_findTask.Task.Status == TaskStatus.RanToCompletion && m_waitForResult)
            {
                // Result filling is done here because it needs to run on main thread
                m_waitForResult = false;
                string[] result = m_findTask.Task.Result;
                int count = result.Length;
                m_findResults = new SearchResult[count];
                for (int i = 0; i < count; i++)
                {
                    string assetPath = $"Assets{result[i].Substring(Application.dataPath.Length)}";
                    UnityObject asset = AssetDatabase.LoadAssetAtPath<UnityObject>(assetPath);
                    m_findResults[i] = new SearchResult
                    {
                        path = 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;
    }
}

void OnEnable()
{
    m_player.prepareCompleted += OnPrepareCompleted;
}

void OnPrepareCompleted(VideoPlayer source)
{
    Debug.Log("OnPrepareCompleted");
    m_player.Play();
}

public void SetVideo(string path)
{
    m_player.source = VideoSource.Url;
    // I guess this process may not be finished now.
    m_player.url = path;
    m_player.Prepare();
}

public class UITagDrawer : PropertyDrawer
{
    // the object for string state
    class EditingState
    {
        public bool IsEditing = false;
    }

    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        /***/

        // get state object
        EditingState state = GUIUtility.GetStateObject(typeof(EditingState), GUIUtility.GetControlID(FocusType.Passive)) as EditingState;

        using (new EditorGUILayout.HorizontalScope(style))
        {
            Rect editButtonRect = new Rect(position.x, position.y, 16f, 16f);
            if (GUI.Button(editButtonRect, "E"))
            {
                // well since it's a class we dun need to set it back :>
                state.IsEditing = !state.IsEditing;
            }

            if (GUILayout.Button("X", GUILayout.Width(18)))
            {
                state.IsEditing = !state.IsEditing;
            }
            if (state.IsEditing)
            {
                // show text field
                tagStr = EditorGUILayout.TextField(tagStr);
            }
            else
            {
                // show lable
                EditorGUILayout.LabelField(tagStr);
            }
        }
        
    }
}