using UnityEditorInternal;
using System.Reflection;
using System;
using System.Collections;
using UnityEngine;
using System.Collections.Generic;
using System.IO;
using UnityEngine.Profiling;
using UnityEditor.Profiling;
#if UNITY_2021_2_OR_NEWER
using Unity.Profiling.Editor;
// stub so that ProfilerWindow can be moved to this namespace in trunk without a need to change PA
namespace Unity.Profiling.Editor {}
#endif

namespace UnityEditor.Performance.ProfileAnalyzer
{
    internal class ProfilerWindowInterface
    {
        bool m_ProfilerWindowInitialized = false;
        const float k_NsToMs = 1000000;
        ProgressBarDisplay m_progressBar;

        [NonSerialized] bool m_SendingSelectionEventToProfilerWindowInProgress = false;
        [NonSerialized] int m_LastSelectedFrameInProfilerWindow = 0;

#if UNITY_2021_1_OR_NEWER
        [NonSerialized] ProfilerWindow m_ProfilerWindow;
        [NonSerialized] IProfilerFrameTimeViewSampleSelectionController m_CpuProfilerModule;
#else
        Type m_ProfilerWindowType;
        EditorWindow m_ProfilerWindow;
        FieldInfo m_CurrentFrameFieldInfo;
        FieldInfo m_TimeLineGUIFieldInfo;
        FieldInfo m_SelectedEntryFieldInfo;
        FieldInfo m_SelectedNameFieldInfo;
        FieldInfo m_SelectedTimeFieldInfo;
        FieldInfo m_SelectedDurationFieldInfo;
        FieldInfo m_SelectedInstanceIdFieldInfo;
        FieldInfo m_SelectedFrameIdFieldInfo;
        FieldInfo m_SelectedThreadIndexFieldInfo;
        FieldInfo m_SelectedNativeIndexFieldInfo;
        FieldInfo m_SelectedInstanceCountFieldInfo;
        FieldInfo m_SelectedInstanceCountForThreadFieldInfo;
        FieldInfo m_SelectedInstanceCountForFrameFieldInfo;
        FieldInfo m_SelectedMetaDataFieldInfo;
        FieldInfo m_SelectedThreadCountFieldInfo;
        FieldInfo m_SelectedCallstackInfoFieldInfo;

        MethodInfo m_GetProfilerModuleInfo;
        Type m_CPUProfilerModuleType;
#endif

        public ProfilerWindowInterface(ProgressBarDisplay progressBar)
        {
            m_progressBar = progressBar;

#if !UNITY_2021_1_OR_NEWER
            Assembly assem = typeof(Editor).Assembly;
            m_ProfilerWindowType = assem.GetType("UnityEditor.ProfilerWindow");
            m_CurrentFrameFieldInfo = m_ProfilerWindowType.GetField("m_CurrentFrame", BindingFlags.NonPublic | BindingFlags.Instance);

            m_TimeLineGUIFieldInfo = m_ProfilerWindowType.GetField("m_CPUTimelineGUI", BindingFlags.NonPublic | BindingFlags.Instance);
            if (m_TimeLineGUIFieldInfo == null)
            {
                // m_CPUTimelineGUI isn't present in 2019.3.0a8 onward
                m_GetProfilerModuleInfo = m_ProfilerWindowType.GetMethod("GetProfilerModule", BindingFlags.NonPublic | BindingFlags.Instance);
                if (m_GetProfilerModuleInfo == null)
                {
                    Debug.Log("Unable to initialise link to Profiler Timeline, no GetProfilerModule found");
                }

                m_CPUProfilerModuleType = assem.GetType("UnityEditorInternal.Profiling.CPUProfilerModule");
                m_TimeLineGUIFieldInfo = m_CPUProfilerModuleType.GetField("m_TimelineGUI", BindingFlags.NonPublic | BindingFlags.Instance);
                if (m_TimeLineGUIFieldInfo == null)
                {
                    Debug.Log("Unable to initialise link to Profiler Timeline");
                }
            }

            if (m_TimeLineGUIFieldInfo != null)
                m_SelectedEntryFieldInfo = m_TimeLineGUIFieldInfo.FieldType.GetField("m_SelectedEntry", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            if (m_SelectedEntryFieldInfo != null)
            {
                m_SelectedNameFieldInfo = m_SelectedEntryFieldInfo.FieldType.GetField("name", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                m_SelectedTimeFieldInfo = m_SelectedEntryFieldInfo.FieldType.GetField("time", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                m_SelectedDurationFieldInfo = m_SelectedEntryFieldInfo.FieldType.GetField("duration", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                m_SelectedInstanceIdFieldInfo = m_SelectedEntryFieldInfo.FieldType.GetField("instanceId", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                m_SelectedFrameIdFieldInfo = m_SelectedEntryFieldInfo.FieldType.GetField("frameId", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                // confusingly this is called threadId but is the thread _index_
                m_SelectedThreadIndexFieldInfo = m_SelectedEntryFieldInfo.FieldType.GetField("threadId", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                m_SelectedNativeIndexFieldInfo = m_SelectedEntryFieldInfo.FieldType.GetField("nativeIndex", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                m_SelectedInstanceCountFieldInfo = m_SelectedEntryFieldInfo.FieldType.GetField("instanceCount", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                m_SelectedInstanceCountForThreadFieldInfo = m_SelectedEntryFieldInfo.FieldType.GetField("instanceCountForThread", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                m_SelectedInstanceCountForFrameFieldInfo = m_SelectedEntryFieldInfo.FieldType.GetField("instanceCountForFrame", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                m_SelectedThreadCountFieldInfo = m_SelectedEntryFieldInfo.FieldType.GetField("threadCount", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                m_SelectedMetaDataFieldInfo = m_SelectedEntryFieldInfo.FieldType.GetField("metaData", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                m_SelectedCallstackInfoFieldInfo = m_SelectedEntryFieldInfo.FieldType.GetField("callstackInfo", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            }
#endif
        }

        public bool IsReady()
        {
            return m_ProfilerWindow != null && m_ProfilerWindowInitialized;
        }

        public void GetProfilerWindowHandle()
        {
            Profiler.BeginSample("GetProfilerWindowHandle");
#if UNITY_2021_1_OR_NEWER
            if (m_CpuProfilerModule != null)
            {
                m_CpuProfilerModule.selectionChanged -= OnSelectionChangedInCpuProfilerModule;
                m_CpuProfilerModule = null;
            }

            var windows = Resources.FindObjectsOfTypeAll<ProfilerWindow>();
            if (windows != null && windows.Length > 0)
                m_ProfilerWindow = windows[0];
            if (m_ProfilerWindow != null)
            {
#if UNITY_2021_2_OR_NEWER
                var cpuModuleIdentifier = ProfilerWindow.cpuModuleIdentifier;
#else
                var cpuModuleIdentifier = ProfilerWindow.cpuModuleName;
#endif
                m_CpuProfilerModule =
                    m_ProfilerWindow.GetFrameTimeViewSampleSelectionController(cpuModuleIdentifier);
                m_CpuProfilerModule.selectionChanged -= OnSelectionChangedInCpuProfilerModule;
                m_CpuProfilerModule.selectionChanged += OnSelectionChangedInCpuProfilerModule;

                m_ProfilerWindow.Repaint();
                m_ProfilerWindowInitialized = false;
                // wait a frame for the Profiler to get Repainted
                EditorApplication.delayCall += () => m_ProfilerWindowInitialized = true;
            }
#else
            UnityEngine.Object[] windows = Resources.FindObjectsOfTypeAll(m_ProfilerWindowType);
            if (windows != null && windows.Length > 0)
                m_ProfilerWindow = (EditorWindow)windows[0];
            m_ProfilerWindowInitialized = true;
#endif
            Profiler.EndSample();
        }

        public void OpenProfilerOrUseExisting()
        {
            // Note we use existing if possible to fix a bug after domain reload
            // Where calling EditorWindow.GetWindow directly causes a second window to open
            if (m_ProfilerWindow == null)
            {
#if UNITY_2021_1_OR_NEWER
                m_ProfilerWindow = EditorWindow.GetWindow<ProfilerWindow>();
#if UNITY_2021_2_OR_NEWER
                var cpuModuleIdentifier = ProfilerWindow.cpuModuleIdentifier;
#else
                var cpuModuleIdentifier = ProfilerWindow.cpuModuleName;
#endif
                m_CpuProfilerModule = m_ProfilerWindow.GetFrameTimeViewSampleSelectionController(cpuModuleIdentifier);
                m_CpuProfilerModule.selectionChanged -= OnSelectionChangedInCpuProfilerModule;
                m_CpuProfilerModule.selectionChanged += OnSelectionChangedInCpuProfilerModule;
#else
                // Create new
                m_ProfilerWindow = EditorWindow.GetWindow(m_ProfilerWindowType);
#endif
            }
        }

        public bool GetFrameRangeFromProfiler(out int first, out int last)
        {
            if (m_ProfilerWindow != null)
            {
                first = 1 + ProfilerDriver.firstFrameIndex;
                last = 1 + ProfilerDriver.lastFrameIndex;
                return true;
            }

            first = 1;
            last = 1;
            return false;
        }

        public void CloseProfiler()
        {
            if (m_ProfilerWindow != null)
                m_ProfilerWindow.Close();
        }

#if !UNITY_2021_1_OR_NEWER
        object GetTimeLineGUI()
        {
            object timeLineGUI = null;

            if (m_CPUProfilerModuleType != null)
            {
                object[] parametersArray = new object[] { ProfilerArea.CPU };
                var getCPUProfilerModuleInfo = m_GetProfilerModuleInfo.MakeGenericMethod(m_CPUProfilerModuleType);
                var cpuModule = getCPUProfilerModuleInfo.Invoke(m_ProfilerWindow, parametersArray);

                timeLineGUI = m_TimeLineGUIFieldInfo.GetValue(cpuModule);
            }
            else if (m_TimeLineGUIFieldInfo != null)
            {
                timeLineGUI = m_TimeLineGUIFieldInfo.GetValue(m_ProfilerWindow);
            }

            return timeLineGUI;
        }

#endif


#if UNITY_2021_1_OR_NEWER
        private void OnSelectionChangedInCpuProfilerModule(IProfilerFrameTimeViewSampleSelectionController controller, ProfilerTimeSampleSelection selection)
        {
            if (controller == m_CpuProfilerModule && !m_SendingSelectionEventToProfilerWindowInProgress)
            {
                if (selection != null && selection.markerNamePath != null && selection.markerNamePath.Count > 0)
                {
                    selectedMarkerChanged(selection.markerNamePath[selection.markerNamePath.Count - 1], selection.threadGroupName, selection.threadName);
                }
            }
        }

#endif

        public event Action<string, string, string> selectedMarkerChanged = delegate {};

        public void PollProfilerWindowMarkerName()
        {
#if !UNITY_2021_1_OR_NEWER
            if (m_ProfilerWindow != null)
            {
                var timeLineGUI = GetTimeLineGUI();
                if (timeLineGUI != null && m_SelectedEntryFieldInfo != null)
                {
                    var selectedEntry = m_SelectedEntryFieldInfo.GetValue(timeLineGUI);
                    if (selectedEntry != null && m_SelectedNameFieldInfo != null)
                    {
                        string threadGroupName = null;
                        string threadName = null;
                        if (m_SelectedFrameIdFieldInfo != null && m_SelectedThreadIndexFieldInfo != null)
                        {
                            using (RawFrameDataView frameData = ProfilerDriver.GetRawFrameDataView((int)m_SelectedFrameIdFieldInfo.GetValue(selectedEntry), (int)m_SelectedThreadIndexFieldInfo.GetValue(selectedEntry)))
                            {
                                if (frameData != null && frameData.valid)
                                {
                                    threadGroupName = frameData.threadGroupName;
                                    threadName = frameData.threadName;
                                }
                            }
                        }
                        selectedMarkerChanged(m_SelectedNameFieldInfo.GetValue(selectedEntry).ToString(), threadGroupName, threadName);
                    }
                }
            }
#endif
        }

        public ProfileData PullFromProfiler(int firstFrameDisplayIndex, int lastFrameDisplayIndex)
        {
            Profiler.BeginSample("ProfilerWindowInterface.PullFromProfiler");

            bool recording = IsRecording();
            if (recording)
                StopRecording();

            int firstFrameIndex = Mathf.Max(firstFrameDisplayIndex - 1, 0);
            int lastFrameIndex = lastFrameDisplayIndex - 1;
            ProfileData profileData = GetData(firstFrameIndex, lastFrameIndex);

            if (recording)
                StartRecording();

            Profiler.EndSample();
            return profileData;
        }

        public int GetThreadCountForFrame(int frameIndex)
        {
            if (!IsReady())
                return 0;

            ProfilerFrameDataIterator frameData = new ProfilerFrameDataIterator();
            frameData.SetRoot(frameIndex, 0);
            return frameData.GetThreadCount(frameIndex);
        }

        public ProfileFrame GetProfileFrameForThread(int frameIndex, int threadIndex)
        {
            if (!IsReady())
                return null;

            var frame = new ProfileFrame();
            using (RawFrameDataView frameData = ProfilerDriver.GetRawFrameDataView(frameIndex, threadIndex))
            {
                frame.msStartTime = frameData.frameStartTimeMs;
                frame.msFrame = frameData.frameTimeMs;
            }
            return frame;
        }

        ProfileData GetDataRaw(ProfileData data, int firstFrameIndex, int lastFrameIndex)
        {
            bool firstError = true;

            data.SetFrameIndexOffset(firstFrameIndex);

            var depthStack = new Stack<int>();

            var threadNameCount = new Dictionary<string, int>();
            var markerIdToNameIndex = new Dictionary<int, int>();

            for (int frameIndex = firstFrameIndex; frameIndex <= lastFrameIndex; ++frameIndex)
            {
                m_progressBar.AdvanceProgressBar();

                int threadIndex = 0;

                threadNameCount.Clear();
                ProfileFrame frame = null;
                while (true)
                {
                    using (RawFrameDataView frameData = ProfilerDriver.GetRawFrameDataView(frameIndex, threadIndex))
                    {
                        if (threadIndex == 0)
                        {
                            if ((frameIndex == firstFrameIndex || frameIndex == lastFrameIndex)
                                && firstFrameIndex != lastFrameIndex && (!frameData.valid || frameData.frameTimeNs == 0))
                            {
                                // skip incomplete frames when they are at the beginning or end of the capture
                                if (++frameIndex <= lastFrameIndex)
                                {
                                    data.FirstFrameIncomplete = true;
                                    data.SetFrameIndexOffset(frameIndex);
                                    continue;
                                }
                                else
                                {
                                    // break out entirely if this is the last frame
                                    data.LastFrameIncomplete = true;
                                    break;
                                }
                            }
                            frame = new ProfileFrame();
                            if (frameData.valid)
                            {
                                frame.msStartTime = frameData.frameStartTimeMs;
                                frame.msFrame = frameData.frameTimeMs;
                            }
                            data.Add(frame);
                        }

                        if (!frameData.valid)
                            break;

                        string threadNameWithIndex = null;
                        string threadName = frameData.threadName;
                        if (threadName.Trim() == "")
                        {
                            Debug.Log(string.Format("Warning: Unnamed thread found on frame {0}. Corrupted data suspected, ignoring frame", frameIndex));
                            threadIndex++;
                            continue;
                        }
                        var groupName = frameData.threadGroupName;
                        threadName = ProfileData.GetThreadNameWithGroup(threadName, groupName);

                        int nameCount = 0;
                        threadNameCount.TryGetValue(threadName, out nameCount);
                        threadNameCount[threadName] = nameCount + 1;

                        threadNameWithIndex = ProfileData.ThreadNameWithIndex(threadNameCount[threadName], threadName);

                        var thread = new ProfileThread();
                        data.AddThreadName(threadNameWithIndex, thread);

                        frame.Add(thread);

                        // The markers are in depth first order
                        depthStack.Clear();
                        // first sample is the thread name
                        for (int i = 1; i < frameData.sampleCount; i++)
                        {
                            float durationMS = frameData.GetSampleTimeMs(i);
                            int markerId = frameData.GetSampleMarkerId(i);
                            if (durationMS < 0)
                            {
                                if (firstError)
                                {
                                    int displayIndex = data.OffsetToDisplayFrame(frameIndex);

                                    string name = frameData.GetSampleName(i);
                                    Debug.LogFormat("Ignoring Invalid marker time found for {0} on frame {1} on thread {2} ({3} < 0)",
                                        name, displayIndex, threadName, durationMS);

                                    firstError = false;
                                }
                            }
                            else
                            {
                                int depth = 1 + depthStack.Count;
                                var markerData = ProfileMarker.Create(durationMS, depth);

                                // Use name index directly if we have already stored this named marker before
                                int nameIndex;
                                if (markerIdToNameIndex.TryGetValue(markerId, out nameIndex))
                                {
                                    markerData.nameIndex = nameIndex;
                                }
                                else
                                {
                                    string name = frameData.GetSampleName(i);
                                    data.AddMarkerName(name, markerData);
                                    markerIdToNameIndex[markerId] = markerData.nameIndex;
                                }

                                thread.AddMarker(markerData);
                            }

                            int childrenCount = frameData.GetSampleChildrenCount(i);
                            if (childrenCount > 0)
                            {
                                depthStack.Push(childrenCount);
                            }
                            else
                            {
                                while (depthStack.Count > 0)
                                {
                                    int remainingChildren = depthStack.Pop();
                                    if (remainingChildren > 1)
                                    {
                                        depthStack.Push(remainingChildren - 1);
                                        break;
                                    }
                                }
                            }
                        }
                    }
                    threadIndex++;
                }
            }

            data.Finalise();

            return data;
        }

        ProfileData GetDataOriginal(ProfileData data, int firstFrameIndex, int lastFrameIndex)
        {
            ProfilerFrameDataIterator frameData = new ProfilerFrameDataIterator();
            bool firstError = true;

            data.SetFrameIndexOffset(firstFrameIndex);

            Dictionary<string, int> threadNameCount = new Dictionary<string, int>();
            for (int frameIndex = firstFrameIndex; frameIndex <= lastFrameIndex; ++frameIndex)
            {
                m_progressBar.AdvanceProgressBar();

                int threadCount = frameData.GetThreadCount(frameIndex);
                frameData.SetRoot(frameIndex, 0);

                var msFrame = frameData.frameTimeMS;

                if ((frameIndex == firstFrameIndex || frameIndex == lastFrameIndex)
                    && firstFrameIndex != lastFrameIndex && msFrame == 0)
                {
                    var nextFrame = frameIndex + 1;
                    // skip incomplete frames when they are at the beginning or end of the capture
                    if (nextFrame <= lastFrameIndex)
                    {
                        data.FirstFrameIncomplete = true;
                        data.SetFrameIndexOffset(nextFrame);
                        continue;
                    }
                    else
                    {
                        // break out entirely if this is the last frame
                        data.LastFrameIncomplete = true;
                        break;
                    }
                }

                /*
                if (frameIndex == lastFrameIndex)
                {
                    // Check if last frame appears to be invalid data
                    float median;
                    float mean;
                    float standardDeviation;
                    CalculateFrameTimeStats(data, out median, out mean, out standardDeviation);
                    float execessiveDeviation = (3f * standardDeviation);
                    if (msFrame > (median + execessiveDeviation))
                    {
                        Debug.LogFormat("Dropping last frame as it is significantly larger than the median of the rest of the data set {0} > {1} (median {2} + 3 * standard deviation {3})", msFrame, median + execessiveDeviation, median, standardDeviation);
                        break;
                    }
                    if (msFrame < (median - execessiveDeviation))
                    {
                        Debug.LogFormat("Dropping last frame as it is significantly smaller than the median of the rest of the data set {0} < {1} (median {2} - 3 * standard deviation {3})", msFrame, median - execessiveDeviation, median, standardDeviation);
                        break;
                    }
                }
                */

                ProfileFrame frame = new ProfileFrame();
                frame.msStartTime = 1000.0 * frameData.GetFrameStartS(frameIndex);
                frame.msFrame = msFrame;
                data.Add(frame);

                threadNameCount.Clear();
                for (int threadIndex = 0; threadIndex < threadCount; ++threadIndex)
                {
                    frameData.SetRoot(frameIndex, threadIndex);

                    var threadName = frameData.GetThreadName();
                    if (threadName.Trim() == "")
                    {
                        Debug.Log(string.Format("Warning: Unnamed thread found on frame {0}. Corrupted data suspected, ignoring frame", frameIndex));
                        continue;
                    }

                    var groupName = frameData.GetGroupName();
                    threadName = ProfileData.GetThreadNameWithGroup(threadName, groupName);

                    ProfileThread thread = new ProfileThread();
                    frame.Add(thread);

                    int nameCount = 0;
                    threadNameCount.TryGetValue(threadName, out nameCount);
                    threadNameCount[threadName] = nameCount + 1;

                    data.AddThreadName(ProfileData.ThreadNameWithIndex(threadNameCount[threadName], threadName), thread);

                    const bool enterChildren = true;
                    // The markers are in depth first order and the depth is known
                    // So we can infer a parent child relationship
                    while (frameData.Next(enterChildren))
                    {
                        if (frameData.durationMS < 0)
                        {
                            if (firstError)
                            {
                                int displayIndex = data.OffsetToDisplayFrame(frameIndex);

                                Debug.LogFormat("Ignoring Invalid marker time found for {0} on frame {1} on thread {2} ({3} < 0) : Instance id : {4}",
                                    frameData.name, displayIndex, threadName, frameData.durationMS, frameData.instanceId);

                                firstError = false;
                            }
                            continue;
                        }
                        var markerData = ProfileMarker.Create(frameData);

                        data.AddMarkerName(frameData.name, markerData);
                        thread.AddMarker(markerData);
                    }
                }
            }

            data.Finalise();

            frameData.Dispose();
            return data;
        }

        ProfileData GetData(int firstFrameIndex, int lastFrameIndex)
        {
            ProfileData data = new ProfileData(ProfileAnalyzerWindow.TmpPath);
            GetDataRaw(data, firstFrameIndex, lastFrameIndex);
            data.Write();
            return data;
        }

        public float GetFrameTimeRaw(int frameIndex)
        {
            using (RawFrameDataView frameData = ProfilerDriver.GetRawFrameDataView(frameIndex, 0))
            {
                if (!frameData.valid)
                    return 0f;

                return frameData.frameTimeMs;
            }
        }

        public float GetFrameTime(int frameIndex)
        {
            return GetFrameTimeRaw(frameIndex);
        }

        struct ThreadIndexIterator
        {
            public ProfilerFrameDataIterator frameData;
            public int threadIndex;
        }

        IEnumerator<ThreadIndexIterator> GetNextThreadIndexFittingThreadFilters(int frameIndex, List<string> threadFilters)
        {
            ProfilerFrameDataIterator frameData = new ProfilerFrameDataIterator();

            int threadCount = frameData.GetThreadCount(frameIndex);
            Dictionary<string, int> threadNameCount = new Dictionary<string, int>();
            for (int threadIndex = 0; threadIndex < threadCount; ++threadIndex)
            {
                frameData.SetRoot(frameIndex, threadIndex);

                var threadName = frameData.GetThreadName();
                // Name here could be "Worker Thread 1"

                var groupName = frameData.GetGroupName();
                threadName = ProfileData.GetThreadNameWithGroup(threadName, groupName);

                int nameCount = 0;
                threadNameCount.TryGetValue(threadName, out nameCount);
                threadNameCount[threadName] = nameCount + 1;

                var threadNameWithIndex = ProfileData.ThreadNameWithIndex(threadNameCount[threadName], threadName);

                // To compare on the filter we need to remove the postfix on the thread name
                // "3:Worker Thread 0" -> "1:Worker Thread"
                // The index of the thread (0) is used +1 as a prefix
                // The preceding number (3) is the count of number of threads with this name
                // Unfortunately multiple threads can have the same name
                threadNameWithIndex = ProfileData.CorrectThreadName(threadNameWithIndex);

                if (threadFilters.Contains(threadNameWithIndex))
                {
                    yield return new ThreadIndexIterator {frameData = frameData, threadIndex = threadIndex};
                }
            }
            frameData.Dispose();
        }

        bool GetMarkerInfo(string markerName, int frameIndex, List<string> threadFilters, out int outThreadIndex, out int outNativeIndex, out float time, out float duration, out int instanceId)
        {
            outThreadIndex = 0;
            outNativeIndex = 0;
            time = 0.0f;
            duration = 0.0f;
            instanceId = 0;
            bool found = false;

            var iterator = GetNextThreadIndexFittingThreadFilters(frameIndex, threadFilters);
            while (iterator.MoveNext())
            {
                const bool enterChildren = true;
                while (iterator.Current.frameData.Next(enterChildren))
                {
                    if (iterator.Current.frameData.name == markerName)
                    {
                        time = iterator.Current.frameData.startTimeMS;
                        duration = iterator.Current.frameData.durationMS;
                        instanceId = iterator.Current.frameData.instanceId;
                        outNativeIndex = iterator.Current.frameData.sampleId;
                        outThreadIndex = iterator.Current.threadIndex;
                        found = true;
                        break;
                    }
                }

                if (found)
                    break;
            }

            return found;
        }

        public bool SetProfilerWindowMarkerName(string markerName, List<string> threadFilters)
        {
            m_SendingSelectionEventToProfilerWindowInProgress = true;
            if (m_ProfilerWindow == null)
                return false;
#if UNITY_2021_1_OR_NEWER
#if UNITY_2021_2_OR_NEWER
            var cpuModuleIdentifier = ProfilerWindow.cpuModuleIdentifier;
            var selectedModuleIdentifier = m_ProfilerWindow.selectedModuleIdentifier;
#else
            var cpuModuleIdentifier = ProfilerWindow.cpuModuleName;
            var selectedModuleIdentifier = m_ProfilerWindow.selectedModuleName;
#endif
            m_CpuProfilerModule = m_ProfilerWindow.GetFrameTimeViewSampleSelectionController(cpuModuleIdentifier);
            if (m_CpuProfilerModule != null && selectedModuleIdentifier == cpuModuleIdentifier
                && m_ProfilerWindow.firstAvailableFrameIndex >= 0)
            {
                // Read profiler data direct from profile to find time/duration
                int currentFrameIndex = (int)m_ProfilerWindow.selectedFrameIndex;

                var iterator = GetNextThreadIndexFittingThreadFilters(currentFrameIndex, threadFilters);
                while (iterator.MoveNext())
                {
                    using (var rawFrameDataView = ProfilerDriver.GetRawFrameDataView(currentFrameIndex, iterator.Current.threadIndex))
                    {
                        if (m_CpuProfilerModule.SetSelection(currentFrameIndex,
                            rawFrameDataView.threadGroupName, rawFrameDataView.threadName, markerName,
                            threadId: rawFrameDataView.threadId))
                        {
                            m_ProfilerWindow.Repaint();
                            m_SendingSelectionEventToProfilerWindowInProgress = false;
                            return true; // setting the selection was successful, nothing more to do here.
                        }
                    }
                }
                // selection couldn't be found, so clear the current one to avoid confusion
                m_CpuProfilerModule.ClearSelection();
                m_ProfilerWindow.Repaint();
            }
#else
            var timeLineGUI = GetTimeLineGUI();
            if (timeLineGUI == null)
            {
                m_SendingSelectionEventToProfilerWindowInProgress = false;
                return false;
            }

            if (m_SelectedEntryFieldInfo != null)
            {
                var selectedEntry = m_SelectedEntryFieldInfo.GetValue(timeLineGUI);
                if (selectedEntry != null)
                {
                    // Read profiler data direct from profile to find time/duration
                    int currentFrameIndex = (int)m_CurrentFrameFieldInfo.GetValue(m_ProfilerWindow);
                    float time;
                    float duration;
                    int instanceId;
                    int nativeIndex;
                    int threadIndex;
                    if (GetMarkerInfo(markerName, currentFrameIndex, threadFilters, out threadIndex, out nativeIndex, out time, out duration, out instanceId))
                    {
                        /*
                        Debug.Log(string.Format("Setting profiler to {0} on {1} at frame {2} at {3}ms for {4}ms ({5})",
                                                markerName, currentFrameIndex, threadFilter, time, duration, instanceId));
                         */

                        if (m_SelectedNameFieldInfo != null)
                            m_SelectedNameFieldInfo.SetValue(selectedEntry, markerName);
                        if (m_SelectedTimeFieldInfo != null)
                            m_SelectedTimeFieldInfo.SetValue(selectedEntry, time);
                        if (m_SelectedDurationFieldInfo != null)
                            m_SelectedDurationFieldInfo.SetValue(selectedEntry, duration);
                        if (m_SelectedInstanceIdFieldInfo != null)
                            m_SelectedInstanceIdFieldInfo.SetValue(selectedEntry, instanceId);
                        if (m_SelectedFrameIdFieldInfo != null)
                            m_SelectedFrameIdFieldInfo.SetValue(selectedEntry, currentFrameIndex);
                        if (m_SelectedNativeIndexFieldInfo != null)
                            m_SelectedNativeIndexFieldInfo.SetValue(selectedEntry, nativeIndex);
                        if (m_SelectedThreadIndexFieldInfo != null)
                            m_SelectedThreadIndexFieldInfo.SetValue(selectedEntry, threadIndex);

                        // TODO : Update to fill in the total and number of instances.
                        // For now we force Instance count to 1 to avoid the incorrect info showing.
                        if (m_SelectedInstanceCountFieldInfo != null)
                            m_SelectedInstanceCountFieldInfo.SetValue(selectedEntry, 1);
                        if (m_SelectedInstanceCountForThreadFieldInfo != null)
                            m_SelectedInstanceCountForThreadFieldInfo.SetValue(selectedEntry, 1);
                        if (m_SelectedInstanceCountForFrameFieldInfo != null)
                            m_SelectedInstanceCountForFrameFieldInfo.SetValue(selectedEntry, 1);
                        if (m_SelectedThreadCountFieldInfo != null)
                            m_SelectedThreadCountFieldInfo.SetValue(selectedEntry, 1);
                        if (m_SelectedMetaDataFieldInfo != null)
                            m_SelectedMetaDataFieldInfo.SetValue(selectedEntry, "");
                        if (m_SelectedCallstackInfoFieldInfo != null)
                            m_SelectedCallstackInfoFieldInfo.SetValue(selectedEntry, "");

                        m_ProfilerWindow.Repaint();
                        m_SendingSelectionEventToProfilerWindowInProgress = false;
                        return true;
                    }
                }
            }
#endif
            m_SendingSelectionEventToProfilerWindowInProgress = false;
            return false;
        }

        public bool JumpToFrame(int index)
        {
            if (m_ProfilerWindow == null)
                return false;

            if (index - 1 < ProfilerDriver.firstFrameIndex)
                return false;
            if (index - 1 > ProfilerDriver.lastFrameIndex)
                return false;

#if UNITY_2021_1_OR_NEWER
            m_ProfilerWindow.selectedFrameIndex = index - 1;
#else
            m_CurrentFrameFieldInfo.SetValue(m_ProfilerWindow, index - 1);
#endif
            m_ProfilerWindow.Repaint();
            return true;
        }

        public int selectedFrame
        {
            get
            {
                if (m_ProfilerWindow == null)
                    return 0;
#if UNITY_2021_1_OR_NEWER
                return (int)m_ProfilerWindow.selectedFrameIndex + 1;
#else
                return (int)m_CurrentFrameFieldInfo.GetValue(m_ProfilerWindow) + 1;
#endif
            }
        }

        public event Action<int> selectedFrameChanged = delegate {};

        public void PollSelectedFrameChanges()
        {
            var currentlySelectedFrame = selectedFrame;
            if (m_LastSelectedFrameInProfilerWindow != currentlySelectedFrame && !m_SendingSelectionEventToProfilerWindowInProgress)
            {
                m_LastSelectedFrameInProfilerWindow = currentlySelectedFrame;
                selectedFrameChanged(currentlySelectedFrame);
            }
        }

        public bool IsRecording()
        {
            return ProfilerDriver.enabled;
        }

        public void StopRecording()
        {
            // Stop recording first
            ProfilerDriver.enabled = false;
        }

        public void StartRecording()
        {
            // Stop recording first
            ProfilerDriver.enabled = true;
        }

        public void OnDisable()
        {
            if (m_ProfilerWindow != null)
            {
                m_ProfilerWindow = null;
            }

#if UNITY_2021_1_OR_NEWER
            if (m_CpuProfilerModule != null)
            {
                m_CpuProfilerModule.selectionChanged -= OnSelectionChangedInCpuProfilerModule;
                m_CpuProfilerModule = null;
            }
#endif
        }
    }
}