public class TempListElementUI : MonoBehaviour
{
    [Header("must have"), Tooltip("should inherit from ISetupable")]
    [SerializeField]
    Component m_dataReceiver;
    [SerializeField, Tooltip("better to manual drag it in")]
    RectTransform m_elementTransform;
    [SerializeField, ReadOnly]
    private int m_index = -1;
    public int ElementIndex => m_index;
    public RectTransform ElementRectTransform
    {
        get
        {
            if (m_elementTransform == null)
                m_elementTransform = GetComponent<RectTransform>();
            return m_elementTransform;
        }
    }
    
    public void Setup<TData>(TData data)
    {
        SomeUtils.ISetup<Component, TData>(m_dataReceiver, data);
    }

    public void Show()
    {
        if (!this.gameObject.activeSelf)
            this.gameObject.SetActive(true);
    }

    public void Hide()
    {
        if (this.gameObject.activeSelf)
            this.gameObject.SetActive(false);
    }

    public void SetIndex(int index)
    {
        m_index = index;
    }

    private void Awake()
    {
        if (m_elementTransform == null)
            m_elementTransform = this.transform as RectTransform;
    }

#if UNITY_EDITOR
    private void Reset()
    {
        m_elementTransform = this.transform as RectTransform;
    }
#endif
}

public class TempListView : MonoBehaviour
{
#if UNITY_EDITOR
#endif
    // check when prefab change
    // [OnValueChanged("OnPrefabChanged")]
    [SerializeField, Header("place holder, the listview should only contains one type of element")]
    TempListElementUI m_elementPrefab;
    RectTransform Container => transform as RectTransform;
    [SerializeField, ReadOnly]
    List<TempListElementUI> m_actualUsedComponents = new List<TempListElementUI>(0);

    public int Count => m_actualUsedComponents.Count;
    public TempListElementUI this[int index] => m_actualUsedComponents[index];
    public IReadOnlyList<TempListElementUI> ElementList => m_actualUsedComponents;

    public TempListElementUI Add()
    {
        TempListElementUI element = InternalAdd();
        m_actualUsedComponents.Add(element);
        element.Show();
        return element;
    }

    public void Clear()
    {
        TempListElementUI element = null;
        while (m_actualUsedComponents.Count > 0)
        {
            element = m_actualUsedComponents[m_actualUsedComponents.Count - 1];
            m_actualUsedComponents.RemoveAt(m_actualUsedComponents.Count - 1);
            InternalRemove(element);
        }
    }

    public void Remove(TempListElementUI instance)
    {
        if (m_actualUsedComponents.Remove(instance))
        {
            instance.Hide();
        }
        else
        {
            Debug.LogError($"listview_{this.gameObject.name} does not contains {instance.ElementRectTransform.name}, remove failed");
        }
    }

    public void RemoveAt(int index)
    {
        if (index < 0 || index >= m_actualUsedComponents.Count)
        {
            Debug.LogError($"{index} is invalid for SimpleListView", this.gameObject);
            return;
        }

        TempListElementUI toRemove = m_actualUsedComponents[index];
        m_actualUsedComponents.RemoveAt(index);
        InternalRemove(toRemove);
    }

    public void InnerSwap(int indexA, int indexB)
    {
        if (indexA < 0 || indexA > m_actualUsedComponents.Count - 1 || indexB < 0 || indexB > m_actualUsedComponents.Count - 1)
        {
            return;
        }

        TempListElementUI temp = m_actualUsedComponents[indexA];
        int transformIndexA = temp.ElementRectTransform.GetSiblingIndex();
        int transformIndexB = m_actualUsedComponents[indexB].ElementRectTransform.GetSiblingIndex();
        m_actualUsedComponents[indexA] = m_actualUsedComponents[indexB];
        m_actualUsedComponents[indexB] = temp;
        m_actualUsedComponents[indexA].ElementRectTransform.SetSiblingIndex(transformIndexA);
        m_actualUsedComponents[indexB].ElementRectTransform.SetSiblingIndex(transformIndexB);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <returns>-1 means element is not in the list</returns>
    public int IndexOf(TempListElementUI instance)
    {
        try
        {
            return m_actualUsedComponents.IndexOf(instance);
        }
        catch (ArgumentOutOfRangeException)
        {
            return -1;
        }
    }

    protected virtual TempListElementUI InternalAdd()
    {
        // can apply object pool here
        if (Application.isEditor && !Application.isPlaying)
            return UnityEditor.PrefabUtility.InstantiatePrefab(m_elementPrefab, Container) as TempListElementUI;
        return Instantiate(m_elementPrefab, Container);
    }

    protected virtual void InternalRemove(TempListElementUI element)
    {
        // can apply object pool here
        if (element == null) return;
        element.Hide();
        if (Application.isEditor && !Application.isPlaying)
            GameObject.DestroyImmediate(element.ElementRectTransform.gameObject);
        else
            GameObject.Destroy(element.ElementRectTransform.gameObject);
    }

#if UNITY_EDITOR

    private void OnTransformChildrenChanged()
    {
        if (Application.isEditor && !Application.isPlaying)
            FindPrefabInstances();
    }

    private void OnPrefabChanged()
    {
        // remove pre objects
        int amount = m_actualUsedComponents.Count;
        for (int i = 0; i < m_actualUsedComponents.Count; i++)
        {
            GameObject.DestroyImmediate(m_actualUsedComponents[i].ElementRectTransform.gameObject);
        }

        if (m_elementPrefab != null)
        {
            for (int i = 0; i < amount; i++)
            {
                RectTransform rectTransform = (RectTransform)UnityEditor.PrefabUtility.InstantiatePrefab(m_elementPrefab, Container);
                m_actualUsedComponents[i] = (rectTransform.GetComponent<TempListElementUI>());
            }
        }
        else
        {
            m_actualUsedComponents.Clear();
        }
    }

    /// <summary>
    /// Retrieves prefab instances in the transform
    /// </summary>
    [ContextMenu("find prefab instances")]
    private void FindPrefabInstances()
    {
        bool hasPrefab = !(m_elementPrefab == null);
        TempListElementUI elementPrefab = m_elementPrefab.GetComponent<TempListElementUI>();
        m_actualUsedComponents.Clear();
        List<GameObject> toDeleteObjectList = new List<GameObject>();
        foreach (Transform child in Container)
        {
            TempListElementUI childElement = child.GetComponent<TempListElementUI>();
            if (childElement == null)
            {
                toDeleteObjectList.Add(child.gameObject);
                continue;
            }

            if (hasPrefab)
            {
                GameObject detectPrefabGo = UnityEditor.PrefabUtility.GetCorrespondingObjectFromSource(child.gameObject);
                TempListElementUI detectPrefab = (detectPrefabGo == null) ? null : detectPrefabGo.GetComponent<TempListElementUI>();
                if (elementPrefab == detectPrefab)
                {
                    // same source prefab
                    m_actualUsedComponents.Add(childElement);
                }
                else
                {
                    // different source prefab, delete this one
                    toDeleteObjectList.Add(child.gameObject);
                }
            }
            else if (UnityEditor.PrefabUtility.IsAnyPrefabInstanceRoot(child.gameObject))
            {
                // find the first prefab
                GameObject prefab = UnityEditor.PrefabUtility.GetCorrespondingObjectFromSource(child.gameObject);
                m_elementPrefab = prefab.GetComponent<TempListElementUI>();
                m_actualUsedComponents.Add(childElement);
                hasPrefab = true;
            }
        }

        for (int i = 0; i < toDeleteObjectList.Count; i++)
        {
            if (Application.isPlaying)
                GameObject.Destroy(toDeleteObjectList[i]);
            else
                GameObject.DestroyImmediate(toDeleteObjectList[i]);
        }
    }

    [ContextMenu("editor time add")]
    private void EditorTimeAdd()
    {
        if (Application.isPlaying) return;
        if (m_elementPrefab == null)
        {
            Debug.LogError("listview is missing element prefab");
            return;
        }
        TempListElementUI spawnObject = (TempListElementUI)UnityEditor.PrefabUtility.InstantiatePrefab(m_elementPrefab, Container);
        m_actualUsedComponents.Add(spawnObject);
    }

    [ContextMenu("editor time clear")]
    private void EditorTimeClear()
    {
        if (Application.isPlaying) return;
        // remove pre objects
        TempListElementUI[] preObjects = Container.GetComponentsInChildren<TempListElementUI>();
        for (int i = 0; i < preObjects.Length; i++)
        {
            GameObject.DestroyImmediate(preObjects[i].ElementRectTransform.gameObject);
        }
        m_actualUsedComponents.Clear();
    }

    [ContextMenu("test print elements")]
    private void TestPrintListElements()
    {
        if (m_actualUsedComponents != null)
        {
            StringBuilder printText = new StringBuilder($"temp list view children_{m_actualUsedComponents.Count} :\n");
            for (int i = 0; i < m_actualUsedComponents.Count; i++)
            {
                printText.AppendLine(m_actualUsedComponents[i].ElementRectTransform.name);
            }
            Debug.Log(printText);
        }
    }

#endif
}

public class BoundlessScrollRectController : UIBehaviour
{
    /*
    too much code, I will just show the draw
    */

    private void DrawContentItem()
    {
        IReadOnlyList<TempListElementUI> elementList = ElementList;
        int dataCount = m_simulatedDataCount;
        // TODO @Hiko use a general calculation later
        bool test = m_content.anchorMin != Vector2.up || m_content.anchorMax != Vector2.up || m_content.pivot != Vector2.up;
        if (test)
        {
            m_content.anchorMin = Vector2.up;
            m_content.anchorMax = Vector2.up;
            m_content.pivot = Vector2.up;
        }
        Vector3 dragContentAnchorPostion = m_content.anchoredPosition;
        Vector3 contentMove = dragContentAnchorPostion - SomeUtils.GetOffsetLocalPosition(m_content, SomeUtils.UIOffsetType.TopLeft);
        Vector2 itemSize = m_gridLayoutGroup.CellSize, spacing = m_gridLayoutGroup.Spacing;

        RectOffset padding = null;
        if (null != m_gridLayoutGroup)
            padding = m_gridLayoutGroup.RectPadding;

        // need to know the moving direction, then adjust it to prevent wrong draw
        float xMove = contentMove.x < 0 ? (-contentMove.x - padding.horizontal) : 0;
        xMove = Mathf.Clamp(xMove, 0.0f, Mathf.Abs(xMove));
        float yMove = contentMove.y > 0 ? (contentMove.y - padding.vertical) : 0;
        yMove = Mathf.Clamp(yMove, 0.0f, Mathf.Abs(yMove));

        // the column index of the top left item
        int tempColumnIndex = Mathf.FloorToInt((xMove + spacing.x) / (itemSize.x + spacing.x));
        if (xMove % (itemSize.x + spacing.x) - itemSize.x > spacing.x)
            tempColumnIndex = Mathf.Clamp(tempColumnIndex - 1, 0, tempColumnIndex);

        // the row index of the top left item
        int tempRowIndex = Mathf.FloorToInt((yMove + spacing.y) / (itemSize.y + spacing.y));
        if (yMove % (itemSize.y + spacing.y) - itemSize.y > spacing.y)
            tempRowIndex = Mathf.Clamp(tempRowIndex - 1, 0, tempRowIndex);

        Vector2Int rowTopLeftItemIndex = new Vector2Int(tempRowIndex, tempColumnIndex);

        int rowDataCount = 0, columnDataCount = 0;
        if (BoundlessGridLayoutData.Constraint.FixedColumnCount == m_gridLayoutGroup.constraint)
        {
            rowDataCount = m_gridLayoutGroup.constraintCount;
            columnDataCount = Mathf.CeilToInt((float)dataCount / rowDataCount);
        }
        else
        {
            columnDataCount = m_gridLayoutGroup.constraintCount;
            rowDataCount = Mathf.CeilToInt((float)dataCount / columnDataCount);
        }

        // x -> element amount on horizontal axis
        // y -> element amount on vertical axis
        Vector2Int contentRowColumnSize = new Vector2Int(rowDataCount, columnDataCount);

        // deal with content from left to right (simple case)
        int dataIndex = 0, uiItemIndex = 0;
        Vector3 rowTopLeftPosition = new Vector3(padding.left, -padding.top, 0.0f), itemTopLeftPosition = Vector3.zero;
        for (int columnIndex = 0; columnIndex < m_viewItemCountInColumn; columnIndex++)
        {
            if (columnIndex + rowTopLeftItemIndex.x == columnDataCount)
                break;

            rowTopLeftPosition = new Vector3(padding.left, -padding.top, 0.0f) + Vector3.down * (columnIndex + rowTopLeftItemIndex.x) * (itemSize.y + spacing.y);
            for (int rowIndex = 0; rowIndex < m_viewItemCountInRow; rowIndex++)
            {
                if (rowIndex + rowTopLeftItemIndex.y == rowDataCount)
                    break;

                Vector2Int elementIndex = new Vector2Int(rowIndex + rowTopLeftItemIndex.y, columnIndex + rowTopLeftItemIndex.x);
                dataIndex = CaculateDataIndex(elementIndex, contentRowColumnSize, GridLayoutData.startAxis, GridLayoutData.startCorner);
                itemTopLeftPosition = rowTopLeftPosition + Vector3.right * (rowIndex + rowTopLeftItemIndex.y) * (itemSize.x + spacing.x);

                // TODO @Hiko avoid overdraw
                if (uiItemIndex > 0 && elementList[uiItemIndex - 1].ElementIndex == dataIndex)
                    continue; // over draw case
                if (dataIndex > -1 && dataIndex < dataCount)
                {
                    elementList[uiItemIndex].ElementRectTransform.localPosition = itemTopLeftPosition;
                    elementList[uiItemIndex].SetIndex(dataIndex);
                    elementList[uiItemIndex].Show();
                    uiItemIndex++;
                }
            }
        }

        while (uiItemIndex < elementList.Count)
        {
            elementList[uiItemIndex].SetIndex(-1);
            elementList[uiItemIndex].Hide();
            elementList[uiItemIndex].ElementRectTransform.position = Vector3.zero;
            uiItemIndex++;
        }

        NotifyOnContentItemFinishDrawing();
    }
}

// apply this on the target shows actual data
public interface ISetupable<TData>
{
    void Setup(TData data);
}

/// <summary>
/// target component should inherit from ISetupable
/// </summary>
/// <param name="component"></param>
/// <param name="data"></param>
/// <typeparam name="TData"></typeparam>
public static void ISetup<TComponent, TData>(this Component component, TData data) where TComponent : Component
{
    // I guess this check should be fine  :(
    if (component is ISetupable<TData> target)
    {
        target.Setup(data);
        return;
    }
    UnityEngine.Debug.LogError($"component_{component.name} is not a setupable");
}

public class RaycastTarget : Graphic
{
    // Additionally, If you need a Raycast target that is not a rectangle, you can implement bool Raycast(Vector2 sp, Camera eventCamera) method from Graphic.
    public override void SetMaterialDirty() { return; }
    public override void SetVerticesDirty() { return; }
    /// Probably not necessary since the chain of calls `Rebuild()`->`UpdateGeometry()`->`DoMeshGeneration()`->`OnPopulateMesh()` won't happen; so here really just as a fail-safe.
    protected override void OnPopulateMesh(VertexHelper vh)
    {
        vh.Clear();
        return;
    }

#if UNITY_EDITOR

    private void OnDrawGizmos()
    {
        if (!this.enabled)
            return
        RectTransform rectTransform = this.transform as RectTransform;
        Color wireColor = Color.yellow;
        if (this.isActiveAndEnabled)
            wireColor.a *= 0.7f
        // Padding to be applied to the masking
        // X = Left, Y = Bottom, Z = Right, W = Top
        // if you wanna make it bigger, then the all value shouble be negative
        Vector4 padding = this.raycastPadding * -1.0f;
        Matrix4x4 localToWorld = rectTransform.localToWorldMatrix
        Vector3 topLeft = SomeUtils.GetOffsetLocalPosition(rectTransform, SomeUtils.UIOffsetType.TopLeft);
        Vector3 topRight = SomeUtils.GetOffsetLocalPosition(rectTransform, SomeUtils.UIOffsetType.TopRight);
        Vector3 bottomLeft = SomeUtils.GetOffsetLocalPosition(rectTransform, SomeUtils.UIOffsetType.BottomLeft);
        Vector3 bottomRight = SomeUtils.GetOffsetLocalPosition(rectTransform, SomeUtils.UIOffsetType.BottomRight)
        topLeft = localToWorld.MultiplyPoint(topLeft + (Vector3.left * padding.x) + (Vector3.up * padding.w));
        topRight = localToWorld.MultiplyPoint(topRight + (Vector3.right * padding.z) + (Vector3.up * padding.w));
        bottomLeft = localToWorld.MultiplyPoint(bottomLeft + (Vector3.left * padding.x) + (Vector3.down * padding.y));
        bottomRight = localToWorld.MultiplyPoint(bottomRight + (Vector3.right * padding.z) + (Vector3.down * padding.y))
        Color tempColor = Gizmos.color;
        Gizmos.color = wireColor
        Gizmos.DrawLine(topLeft, topRight);
        Gizmos.DrawLine(topLeft, bottomLeft);
        Gizmos.DrawLine(bottomRight, topRight);
        Gizmos.DrawLine(bottomRight, bottomLeft);
        Gizmos.color = tempColor
    }

#endif

}

public void OnScrollWheel(InputAction.CallbackContext context)
{
    if (IsActive())
    {
        PointerEventData eventData = GetPointerData();
        eventData.button = PointerEventData.InputButton.Middle;
        eventData.Reset();
        eventData.scrollDelta = context.ReadValue<Vector2>()
        GameObject testScrollObject = ExecuteEventExecuteHierarchy(eventData.pointerCurrentRaycasgameObject, eventData, ExecuteEvents.scrollHandler)
        if (testScrollObject != null)
        {
            // to re-do the reycast cuz we may scroll a recyclscrollrect
            HandlePointerExitAndEnter(eventData, null);
            m_rayCastDelayFrame = SCROLL_RAYCAST_DELAY;
            // SCROLL_RAYCAST_DELAY =3 or 5, depends....
        }
    }
}

// will call in update
public override void Process()
{
    /*
    .....
    */
    CheckAndDoDelayRaycast();
}

void CheckAndDoDelayRaycast()
{
    if (m_rayCastDelayFrame < 0)
    {
        return;
    
    if (--m_rayCastDelayFrame == 0)
    {
        var eventData = GetPointerData();
        eventSystem.RaycastAll(eventData, m_RaycastResultCache);
        var firstRaycast = FindFirstRaycast(m_RaycastResultCache)
        eventData.pointerCurrentRaycast = firstRaycast;
        m_RaycastResultCache.Clear()
        var temp = eventData.pointerCurrentRaycast.gameObject;
        HandlePointerExitAndEnter(eventData, temp);
        m_rayCastDelayFrame = -1;
    }
}

// to find the reference of the target unity object

public static class FindReferencesInProject
{
    public static bool TryFindReferenceOfUobject(UnityEngine.Object uobject)
    {
        bool result = false;
        string path = AssetDatabase.GetAssetPath(uobject);
        if (AssetDatabase.IsValidFolder(path))
        {
            // dun do it for a folder :)
            return false;
        }

        FindObjectReference(uobject);

        return result;
    }

    // why the order is like this?
    [MenuItem("Assets/Find References In Project")]
    public static void FindSelectedObjectReferences()
    {
        if (null != Selection.activeObject)
        {
            string path = AssetDatabase.GetAssetPath(Selection.activeObject);
            if (!AssetDatabase.IsValidFolder(path))
            {
                FindObjectReference(Selection.activeObject);
            }
        }
    }

    private static void FindObjectReference(UnityEngine.Object uobject)
    {
        System.Diagnostics.Stopwatch stopWatcher = new System.Diagnostics.Stopwatch();
        stopWatcher.Start();

        string targetPath = AssetDatabase.GetAssetPath(uobject);
        List<string> referencesPaths = new List<string>();
        Dictionary<string, List<string>> referenceCache = new Dictionary<string, List<string>>();
        string[] assetGuids = AssetDatabase.FindAssets("");

        for (int i = 0; i < assetGuids.Length; i++)
        {
            string assetPath = AssetDatabase.GUIDToAssetPath(assetGuids[i]);
            string[] dependencies = AssetDatabase.GetDependencies(assetPath, false);

            for (int j = 0; j < dependencies.Length; j++)
            {
                if (dependencies[j] == targetPath)
                {
                    referencesPaths.Add(assetPath);
                }
            }
        }

        FindReferencesInProjectEditor.OpenWindow();
        FindReferencesInProjectEditor window = FindReferencesInProjectEditor.GetWindow();
        window.SetPaths(referencesPaths.ToArray());
        window.SetTargetUobject(uobject);

        stopWatcher.Stop();
        Debug.Log($"search references for {uobject.name} cost {stopWatcher.ElapsedMilliseconds}ms");

        referenceCache.Clear();
    }
}

// a simple window to show the result, and also we can ping those result object :D

public class FindReferencesInProjectEditor : EditorWindow
{
    private Rect m_viewportRect = default;
    private Rect m_listRect = default;
    private Rect m_bottomRect = default;

    private float m_scrollPosition = default;
    private string[] m_targetPaths = null;

    private const float ELEMENT_HEIGHT = 20.0f;
    private const float ELEMENT_ICON_SIZE = 20.0f;
    private const float SCROLLER_WIDTH = 15.0f;

    private bool m_hasGetGUIStyle = false;

    private GUIStyle m_scrollerStyle = null;
    private GUIStyle m_buttonElementStyle = null;

    private UnityEngine.Object m_selectedUnityObject = null;
    private System.Type m_uobjType = null;

    public static void OpenWindow()
    {
        FindReferencesInProjectEditor window = GetWindow<FindReferencesInProjectEditor>();
        Texture2D icon = EditorGUIUtility.Load("icons/UnityEditor.ConsoleWindow.png") as Texture2D;
        window.titleContent = new GUIContent("reference find result", icon);
        Vector2 minSize = new Vector2(500.0f, 300.0f);
        window.minSize = minSize;
    }

    public static FindReferencesInProjectEditor GetWindow()
    {
        return GetWindow<FindReferencesInProjectEditor>();
    }

    public void SetPaths(in string[] paths)
    {
        m_targetPaths = paths;
    }

    public void SetTargetUobject(UnityEngine.Object uobject)
    {
        m_selectedUnityObject = uobject;
    }

    private void DrawContent()
    {
        // only use half space of this shit window
        m_viewportRect = new Rect(0.0f, 0.0f, this.position.width - SCROLLER_WIDTH, this.position.height * 0.8f);
        m_listRect = new Rect(0.0f, 0.0f, m_viewportRect.width, m_viewportRect.height);
        int elementCount = m_targetPaths.Length;

        if (elementCount < 1)
            return;

        GUI.BeginClip(m_listRect); // to clip the overflow stuff
        int indexOffset = Mathf.FloorToInt(m_scrollPosition / ELEMENT_HEIGHT);
        int showCount = Mathf.CeilToInt(m_listRect.height / ELEMENT_HEIGHT);
        showCount = showCount > elementCount ? elementCount : showCount;
        float startPosY = (indexOffset * ELEMENT_HEIGHT) - m_scrollPosition;

        for (int i = 0; i < showCount; i++)
        {
            Rect elementRect = new Rect(0, 0 + startPosY + i * ELEMENT_HEIGHT, m_listRect.width, ELEMENT_HEIGHT);
            DrawElement(elementRect, indexOffset + i);
        }
        GUI.EndClip();
    }

    private void DrawElement(Rect elementRect, int dataIndex)
    {
        if (dataIndex < m_targetPaths.Length && GUI.Button(elementRect, $"path {m_targetPaths[dataIndex]} ;", m_buttonElementStyle))
        {
            Debug.Log($"{m_targetPaths[dataIndex]}");
            UnityEngine.Object targetObj = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(m_targetPaths[dataIndex]);
            EditorGUIUtility.PingObject(targetObj);
        }
    }

    private void DrawScroller()
    {
        // draw scroller on the right correctly
        int elementCount = m_targetPaths.Length;
        float fullElementHeight = elementCount * ELEMENT_HEIGHT;

        Rect scrollbarRect = new Rect(m_viewportRect.x + m_viewportRect.width, m_viewportRect.y, SCROLLER_WIDTH, m_viewportRect.height);
        m_scrollPosition = Mathf.Max(0, GUI.VerticalScrollbar(scrollbarRect, m_scrollPosition, m_listRect.height, 0, Mathf.Max(fullElementHeight, m_listRect.height)));

        int controlId = GUIUtility.GetControlID(FocusType.Passive);
        float scrollSensitivity = ELEMENT_HEIGHT;
        float maxScrollPos = (fullElementHeight > m_listRect.height) ? (fullElementHeight - m_listRect.height) : 0;

        if (EventType.ScrollWheel == Event.current.GetTypeForControl(controlId))
        {
            m_scrollPosition = Mathf.Clamp(m_scrollPosition + Event.current.delta.y * scrollSensitivity, 0, maxScrollPos);
            Event.current.Use();
        }
    }

    private void GetGUIStyle()
    {
        // scroller
        m_scrollerStyle = new GUIStyle(GUI.skin.verticalScrollbar);
        m_scrollerStyle.stretchWidth = false;
        m_scrollerStyle.fixedWidth = SCROLLER_WIDTH;

        // button element
        m_buttonElementStyle = new GUIStyle(GUI.skin.button);
        m_buttonElementStyle.alignment = TextAnchor.MiddleLeft;

        m_uobjType = typeof(UnityEngine.Object);
    }

    private void DrawBottom()
    {
        m_bottomRect = new Rect(0.0f, this.position.height * 0.8f, this.position.width, this.position.height * 0.2f);
        Rect fieldRect = new Rect(10.0f, m_bottomRect.y + 10.0f, 100.0f, 20.0f);

        if (null == m_uobjType)
            m_uobjType = typeof(UnityEngine.Object);

        m_selectedUnityObject = EditorGUI.ObjectField(fieldRect, m_selectedUnityObject, m_uobjType, true);

        Rect buttonRect = new Rect(150.0f, m_bottomRect.y, 200.0f, 40.0f);
        if (GUI.Button(buttonRect, "try find reference"))
        {
            FindObjectReference();
        }

    }

    private void FindObjectReference()
    {
        if (null == m_selectedUnityObject)
        {
            return;
        }

        Clear();
        FindReferencesInProject.TryFindReferenceOfUobject(m_selectedUnityObject);
    }

    private void Clear()
    {
        m_targetPaths = System.Array.Empty<string>();
    }

    private void OnGUI()
    {
        if (!m_hasGetGUIStyle)
        {
            GetGUIStyle();
            m_hasGetGUIStyle = true;
        }

        DrawContent();
        DrawScroller();
        DrawBottom();
    }

}

[RequireComponent(typeof(AudioSource))]
public class MetronomeExample : MonoBehaviour
{
    public double bpm = 128.0f;
    public int signatureHi = 4;
    public int signatureLo = 4;
    private double nextTick = 0.0F;
    private double sampleRate = 0.0F;
    private int accent= 0;
    private bool running = false;

    public event System.Action<int, int> OnBeatTick;

    private void Start()
    {
        accent = signatureHi;
        sampleRate = AudioSettings.outputSampleRate;
        nextTick = AudioSettings.dspTime * sampleRate;
        running = true;
    }

    private void OnAudioFilterRead(float[] data, int channels)
    {
        if (!running)
            return;

        double samplesPerTick = sampleRate * (60.0f / bpm) * (4.0f / signatureLo);
        double sample = AudioSettings.dspTime * sampleRate;
        int dataLen = data.Length / channels;
        int n = 0;
        while (n < dataLen)
        {
            while (sample + n >= nextTick)
            {
                nextTick += samplesPerTick;
                if (++accent > signatureHi)
                {
                    accent = 1;
                }
                OnBeatTick?.Invoke(accent, signatureHi);
                Debug.Log($"Tick: {accent} / {signatureHi}");
            }
            n++;
        }
    }
}

nextTick = AudioSettings.dspTime * sampleRate; 
``` 
从 Start() 开始，先做节拍器的初始化。 因为需要准确的音频数据，所以我们会使用音频相关的函数来操作，而不是使用 Update()。
通过当前的时间 * 当前的采样率，大概就能得到当前的音频信息总量。

``` CSharp
OnAudioFilterRead(float[] data, int channels)
``` 
接着我们可以把 OnAudioFilterRead() 看作 Update() 来使用。 
channels 大概是声道数,比如我平时用的辣鸡机器是双声道（左右的），那么 channels 的值就是2。
data[] 中存储的是当前这一次遍历的音频数据，也会包含不同声道的音频信息，比如\[0L, 1R, 2L, 3R....\]之类的。

``` CSharp
double samplesPerTick = sampleRate * (60.0f / bpm) * (4.0f / signatureLo);
double sample = AudioSettings.dspTime * sampleRate;
``` 
这里是用与计算拍子的间隔时间。(60.0f / bpm) 所计算的是对于 4/4 拍而言的拍子间隔时间。
而 (4.0f / signatureLo) 可以算出一个参数，并乘给 4/4 拍而言的拍子间隔时间。
sample 可以粗浅的认为是当前的时间。

``` CSharp
while (n < dataLen)
{
    while (sample + n >= nextTick)
    {
        // 用起来就相当于
        // nextTime = Time.time * timeInterval; 
        nextTick += samplesPerTick;
        if (++accent > signatureHi)
        {
            accent = 1;
        }
        OnBeatTick?.Invoke(accent, signatureHi);
        Debug.Log($"Tick: {accent} / {signatureHi}");
    }
    n++;
}

while (n<dataLen)
{
    float x = gain * amp * Mathf.Sin(phase);
    int i = 0;
    while (i < channels)
    {
        data[n * channels + i] += x;
        i++;
    }
    while (sample + n >= nextTick)
    {
        nextTick += samplesPerTick;
        amp = 1.0F;
        if (++accent > signatureHi)
        {
            accent = 1;
            amp *= 2.0F;
        }
        OnBeatTick?.Invoke(accent, signatureHi);
        Debug.Log($"Tick: {accent} / {signatureHi}");
    }
    phase += amp* 0.3F;
    amp *= 0.993F;
    n++;
}

namespace TempDraw
{
    [System.Serializable]
    public struct TempDrawData
    {
        public int IconTag;
        public string TempMessage;
    }

    public class TempDrawWindowTester : MonoBehaviour
    {
        private TempDrawWindowTester _instance = null;
        public TempDrawWindowTester Instance => _instance;

        List<TempDrawData> m_data = null;

        // used to give out the data
        public static event System.Action<List<TempDrawData>> OnDataSpread;
    }
}

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

namespace TempDraw
{
    public class TempDrawWindow : EditorWindow
    {
        public static string WINDOW_NAME = "Temp Draw Window";
        private static TempDrawWindow _instance = null;
        public static TempDrawWindow Instance => _instance;

        private List<TempDrawData> m_data = null;
        private float m_scrollPosition = 0.0f;

        #region temp element
        private const float ELEMENT_HEIGHT = 20.0f;
        private const float ELEMENT_ICON_SIZE = 20.0f;

        #endregion

        #region icons
        private Texture2D m_infoIconSmall = null;
        private Texture2D m_warningIconSmall = null;
        #endregion

        [MenuItem("Window/Temp Draw Window")]
        private static void OpenWindow()
        {
            TempDrawWindow window = GetWindow<TempDrawWindow>();
            Texture2D icon = EditorGUIUtility.Load("icons/UnityEditor.ConsoleWindow.png") as Texture2D;
            window.titleContent = new GUIContent(WINDOW_NAME, icon);
        }

        public void SetData(List<TempDrawData> data)
        {
            if (null == m_data)
                m_data = new List<TempDrawData>();
            else
                m_data.Clear();

            m_data.AddRange(data);
        }

        private void DrawTempElement(Rect elementRect, int dataIndex)
        {
            Rect iconRect = new Rect(elementRect.x, elementRect.y, ELEMENT_ICON_SIZE, elementRect.height);
            if (m_data[dataIndex].IconTag == 0)
                GUI.Label(iconRect, m_infoIconSmall);
            else
                GUI.Label(iconRect, m_warningIconSmall);

            Rect labelRect = new Rect(elementRect.x + ELEMENT_ICON_SIZE, elementRect.y, elementRect.width - ELEMENT_ICON_SIZE, elementRect.height);
            GUI.Label(labelRect, $"Tag: {m_data[dataIndex].IconTag} ; Message: {m_data[dataIndex].TempMessage} ;");
        }

        private void DrawTempRect()
        {
            // only use half space of this shit window
            Rect viewportRect = new Rect(0.0f, 0.0f, this.position.width, this.position.height * 0.5f);

            float scrollbarWidth = GUI.skin.verticalScrollbar.fixedWidth;
            Rect scrollbarRect = new Rect(viewportRect.x + viewportRect.width - scrollbarWidth, viewportRect.y, scrollbarWidth, viewportRect.height);
            Rect currentRect = new Rect(0.0f, 0.0f, viewportRect.width - scrollbarWidth, viewportRect.height);
            float viewportHeight = viewportRect.height;
            int elementCount = m_data.Count;

            GUI.BeginClip(currentRect); // to clip the overflow stuff
            int indexOffset = Mathf.FloorToInt(m_scrollPosition / ELEMENT_HEIGHT);
            int showCount = Mathf.CeilToInt(currentRect.height / ELEMENT_HEIGHT);
            showCount = showCount > elementCount ? elementCount : showCount;
            float startPosY = (indexOffset * ELEMENT_HEIGHT) - m_scrollPosition;

            for (int i = 0; i < showCount; i++)
            {
                Rect elementRect = new Rect(0, 0 + startPosY + i * ELEMENT_HEIGHT, currentRect.width, ELEMENT_HEIGHT);
                DrawTempElement(elementRect, indexOffset + i);
            }
            GUI.EndClip();

            // do stuff for scroller
            float fullElementHeight = elementCount * ELEMENT_HEIGHT;
            m_scrollPosition = Mathf.Max(0, GUI.VerticalScrollbar(scrollbarRect, m_scrollPosition, currentRect.height, 0, Mathf.Max(fullElementHeight, currentRect.height)));

            int controlId = GUIUtility.GetControlID(FocusType.Passive);
            float scrollSensitivity = ELEMENT_HEIGHT;
            float maxScrollPos = (fullElementHeight > currentRect.height) ? (fullElementHeight - currentRect.height) : 0;

            if (EventType.ScrollWheel == Event.current.GetTypeForControl(controlId))
            {
                m_scrollPosition = Mathf.Clamp(m_scrollPosition + Event.current.delta.y * scrollSensitivity, 0, maxScrollPos);
                Event.current.Use();
            }

        }

        private void GetAsset()
        {
            m_infoIconSmall = EditorGUIUtility.Load("icons/console.infoicon.sml.png") as Texture2D;
            m_warningIconSmall = EditorGUIUtility.Load("icons/console.warnicon.sml.png") as Texture2D;
        }

        #region life cycle

        private void Awake()
        {
            _instance = this;
            m_data = new List<TempDrawData>();
        }

        private void OnEnable()
        {
            TempDrawWindowTester.OnDataSpread -= SetData;
            TempDrawWindowTester.OnDataSpread += SetData;
            GetAsset();
        }

        private void OnGUI()
        {
            DrawTempRect();
        }

        private void OnDestroy()
        {
            TempDrawWindowTester.OnDataSpread -= SetData;
            _instance = null;
        }

        #endregion

    }
}