// Copyright Epic Games, Inc. All Rights Reserved.

#include "Insights/TimingProfiler/Tracks/ThreadTimingTrack.h"
#include "ThreadTimingTrackPrivate.h"

#include "Async/TaskGraphInterfaces.h" // for ENamedThreads
#include "CborReader.h"
#include "Framework/MultiBox/MultiBoxBuilder.h"
#include "HAL/PlatformApplicationMisc.h"
#include "Serialization/MemoryReader.h"

// TraceServices
#include "TraceServices/Containers/Timelines.h"
#include "TraceServices/Model/AnalysisSession.h"
#include "TraceServices/Model/Threads.h"
#include "TraceServices/Model/TimingProfiler.h"

// TraceInsightsCore
#include "InsightsCore/Common/TimeUtils.h"
#include "InsightsCore/Filter/ViewModels/FilterConfigurator.h"
#include "InsightsCore/Filter/ViewModels/Filters.h"

// TraceInsights
#include "Insights/InsightsManager.h"
#include "Insights/TimingProfiler/TimingProfilerManager.h"
#include "Insights/TimingProfiler/Tracks/CpuTimingTrack.h"
#include "Insights/TimingProfiler/ViewModels/ThreadTimingSharedState.h"
#include "Insights/ViewModels/ThreadTrackEvent.h"
#include "Insights/ViewModels/TimingEvent.h"
#include "Insights/ViewModels/TimingEventSearch.h"
#include "Insights/ViewModels/TimingTrackViewport.h"
#include "Insights/ViewModels/TimingViewDrawHelper.h"
#include "Insights/ViewModels/TooltipDrawState.h"

#define LOCTEXT_NAMESPACE "UE::Insights::TimingProfiler::ThreadTiming"

namespace UE::Insights::TimingProfiler
{

INSIGHTS_IMPLEMENT_RTTI(FThreadTimingTrack);

////////////////////////////////////////////////////////////////////////////////////////////////////
// FThreadTimingTrackImpl
////////////////////////////////////////////////////////////////////////////////////////////////////

INSIGHTS_IMPLEMENT_RTTI(FThreadTimingTrackImpl)

////////////////////////////////////////////////////////////////////////////////////////////////////

static void AppendMetadataToTooltip(FTooltipDrawState& InOutTooltip, const TraceServices::FMetadataSpec* InMetadataSpec, TArrayView<const uint8>& InMetadata)
{
	FMemoryReaderView MemoryReader(InMetadata);
	FCborReader CborReader(&MemoryReader, ECborEndianness::StandardCompliant);
	FCborContext Context;

	if (InMetadataSpec == nullptr)
	{
		if (!CborReader.ReadNext(Context))
		{
			InOutTooltip.AddTitle(TEXTVIEW("<empty metadata>"), FLinearColor(1.0f, 0.5f, 0.5f, 1.0f));
			return;
		}

		if (Context.MajorType() == ECborCode::TextString)
		{
			InOutTooltip.AddTitle(TEXTVIEW("Metadata..."), FLinearColor(0.3f, 0.3f, 0.3f, 1.0f));
			InOutTooltip.AddNameValueTextLine(TEXTVIEW(""), Context.AsString());
			return;
		}

		if (Context.MajorType() != ECborCode::Map)
		{
			InOutTooltip.AddTitle(TEXTVIEW("<invalid metadata>"), FLinearColor(1.0f, 0.5f, 0.5f, 1.0f));
			return;
		}
	}

	InOutTooltip.AddTitle(TEXTVIEW("Metadata..."), FLinearColor(0.3f, 0.3f, 0.3f, 1.0f));

	for (uint32 Index = 0; true; ++Index)
	{
		FString Key;

		if (InMetadataSpec)
		{
			if (Index < static_cast<uint32>(InMetadataSpec->FieldNames.Num()))
			{
				Key = InMetadataSpec->FieldNames[Index];
				Key += TEXT(":");
			}
			else
			{
				Key = TEXT(""); // undefined field
			}
		}
		else
		{
			// Read key
			if (!CborReader.ReadNext(Context) || !Context.IsString())
			{
				break;
			}

			Key = FString::ConstructFromPtrSize(Context.AsCString(), static_cast<int32>(Context.AsLength()));
			Key += TEXT(":");
		}

		// Read value
		if (!CborReader.ReadNext(Context))
		{
			break;
		}

		switch (Context.MajorType())
		{

		case ECborCode::Int:
		{
			int64 Value = Context.AsInt();
			FString ValueStr;
			if (Value > 999'999'999LL)
			{
				ValueStr += FString::Printf(TEXT("0x%llX"), Value);
			}
			else
			{
				ValueStr += FString::Printf(TEXT("%lld"), Value);
			}
			InOutTooltip.AddNameValueTextLine(Key, ValueStr);
			continue;
		}

		case ECborCode::Uint:
		{
			uint64 Value = Context.AsUInt();
			FString ValueStr;
			if (Value > 999'999'999ULL)
			{
				ValueStr = FString::Printf(TEXT("0x%llX"), Value);
			}
			else
			{
				ValueStr = FString::Printf(TEXT("%llu"), Value);
			}
			InOutTooltip.AddNameValueTextLine(Key, ValueStr);
			continue;
		}

		case ECborCode::TextString:
		{
			FString Value = Context.AsString();
			InOutTooltip.AddNameValueTextLine(Key, Value);
			continue;
		}

		case ECborCode::ByteString:
		{
			FString ValueStr = FString::ConstructFromPtrSize(Context.AsCString(), static_cast<int32>(Context.AsLength()));
			InOutTooltip.AddNameValueTextLine(Key, ValueStr);
			continue;
		}

		} // switch

		if (Context.RawCode() == (ECborCode::Prim|ECborCode::Value_4Bytes))
		{
			float Value = Context.AsFloat();
			FString ValueStr = FString::Printf(TEXT("%f"), Value);
			InOutTooltip.AddNameValueTextLine(Key, ValueStr);
			continue;
		}

		if (Context.RawCode() == (ECborCode::Prim|ECborCode::Value_8Bytes))
		{
			double Value = Context.AsDouble();
			FString ValueStr = FString::Printf(TEXT("%g"), Value);
			InOutTooltip.AddNameValueTextLine(Key, ValueStr);
			continue;
		}

		if (Context.RawCode() == (ECborCode::Prim | ECborCode::False))
		{
			InOutTooltip.AddNameValueTextLine(Key, TEXTVIEW("false"));
			continue;
		}

		if (Context.RawCode() == (ECborCode::Prim | ECborCode::True))
		{
			InOutTooltip.AddNameValueTextLine(Key, TEXTVIEW("true"));
			continue;
		}

		InOutTooltip.AddNameValueTextLine(Key, TEXTVIEW("???")); // unknown field type

		if (Context.IsFiniteContainer())
		{
			CborReader.SkipContainer(ECborCode::Array);
		}
	}
}

////////////////////////////////////////////////////////////////////////////////////////////////////

static void AppendMetadataToString(FString& InOutStr, TArrayView<const uint8>& InMetadata)
{
	FMemoryReaderView MemoryReader(InMetadata);
	FCborReader CborReader(&MemoryReader, ECborEndianness::StandardCompliant);
	FCborContext Context;

	if (!CborReader.ReadNext(Context))
	{
		InOutStr += TEXTVIEW(" - <empty metadata>");
		return;
	}

	if (Context.MajorType() == ECborCode::TextString)
	{
		InOutStr += TEXTVIEW(" - ");
		InOutStr += Context.AsString();
		return;
	}

	if (Context.MajorType() != ECborCode::Map)
	{
		InOutStr += TEXTVIEW(" - <invalid metadata>");
		return;
	}

	for (uint32 Index = 0; true; ++Index)
	{
		// Read key
		if (!CborReader.ReadNext(Context) || !Context.IsString())
		{
			break;
		}

		if (Index == 0)
		{
			InOutStr += TEXTVIEW(" - ");
		}
		else
		{
			InOutStr += TEXTVIEW(", ");
		}

		//FString Key(Context.AsLength(), Context.AsCString());
		//InOutStr += Key;
		//InOutStr += TEXTVIEW(":");

		// Read value
		if (!CborReader.ReadNext(Context))
		{
			break;
		}

		switch (Context.MajorType())
		{

		case ECborCode::Int:
		{
			int64 Value = Context.AsInt();
			if (Value > 999'999'999LL)
			{
				InOutStr += FString::Printf(TEXT("0x%llX"), Value);
			}
			else
			{
				InOutStr += FString::Printf(TEXT("%lld"), Value);
			}
			continue;
		}

		case ECborCode::Uint:
		{
			uint64 Value = Context.AsUInt();
			if (Value > 999'999'999ULL)
			{
				InOutStr += FString::Printf(TEXT("0x%llX"), Value);
			}
			else
			{
				InOutStr += FString::Printf(TEXT("%llu"), Value);
			}
			continue;
		}

		case ECborCode::TextString:
		{
			InOutStr += Context.AsString();
			continue;
		}

		case ECborCode::ByteString:
		{
			InOutStr.AppendChars(Context.AsCString(), static_cast<int32>(Context.AsLength()));
			continue;
		}

		} // switch

		if (Context.RawCode() == (ECborCode::Prim | ECborCode::Value_4Bytes))
		{
			float Value = Context.AsFloat();
			InOutStr += FString::Printf(TEXT("%f"), Value);
			continue;
		}

		if (Context.RawCode() == (ECborCode::Prim | ECborCode::Value_8Bytes))
		{
			double Value = Context.AsDouble();
			InOutStr += FString::Printf(TEXT("%g"), Value);
			continue;
		}

		if (Context.RawCode() == (ECborCode::Prim | ECborCode::False))
		{
			InOutStr += TEXTVIEW("false");
			continue;
		}

		if (Context.RawCode() == (ECborCode::Prim | ECborCode::True))
		{
			InOutStr += TEXTVIEW("true");
			continue;
		}

		InOutStr += TEXTVIEW("???"); // unknown field type

		if (Context.IsFiniteContainer())
		{
			CborReader.SkipContainer(ECborCode::Array);
		}
	}
}

////////////////////////////////////////////////////////////////////////////////////////////////////

static void AppendMetadataToString(FString& InOutStr, const FString& InFormat, TArrayView<const uint8>& InMetadata)
{
	FMemoryReaderView MemoryReader(InMetadata);
	FCborReader CborReader(&MemoryReader, ECborEndianness::StandardCompliant);
	FCborContext Context;

	FString Format = InFormat;

	Format.TrimStartInline();
	if (Format.StartsWith(TEXT("- ")))
	{
		Format.RightChopInline(2);
	}

	const FString Specifiers = TEXT("diuoxXfFeEgGaAcspn");
	auto GetNextFormatSection = [&Format, &Specifiers]()
	{
		bool bIsInFormatSpecifier = false;
		for (int32 Index = 0; Index < Format.Len(); ++Index)
		{
			if (bIsInFormatSpecifier)
			{
				int32 SpecIndex = -1;
				if (Specifiers.FindChar(Format[Index], SpecIndex))
				{
					FString NextFormat = Format.Left(Index+1);
					Format.MidInline(Index+1);
					return NextFormat;
				}
			}

			if (Format[Index] == TEXT('%'))
			{
				bIsInFormatSpecifier = !bIsInFormatSpecifier;
			}
		}

		FString Copy = Format;
		Format.Empty();
		return Copy;
	};

	for (uint32 Index = 0; !Format.IsEmpty(); ++Index)
	{
		// Read key
		if (!CborReader.ReadNext(Context))
		{
			break;
		}

		if (Index == 0)
		{
			InOutStr += TEXTVIEW(" - ");
		}

		constexpr int MaxLength = 1024;
		TCHAR Data[MaxLength];

		auto AddValueToName = [&InOutStr](TCHAR* Dest, int MaxLength, const FString& Format, auto Value)
		{
			int32 Result = FCString::Snprintf(Dest, MaxLength, reinterpret_cast<TCHAR const(&)[1]>(**Format), Value);
			if (Result > 0)
			{
				InOutStr.Append(Dest);
			}
		};

		switch (Context.MajorType())
		{

		case ECborCode::Int:
		{
			int64 Value = Context.AsInt();
			AddValueToName(Data, MaxLength, GetNextFormatSection(), Value);
			continue;
		}

		case ECborCode::Uint:
		{
			uint64 Value = Context.AsUInt();
			AddValueToName(Data, MaxLength, GetNextFormatSection(), Value);
			continue;
		}

		case ECborCode::TextString:
		{
			AddValueToName(Data, MaxLength, GetNextFormatSection(), *Context.AsString());
			continue;
		}

		case ECborCode::ByteString:
		{
			AddValueToName(Data, FMath::Min(MaxLength, (int)Context.AsLength()), GetNextFormatSection(), Context.AsCString());
			continue;
		}

		} // switch

		if (Context.RawCode() == (ECborCode::Prim | ECborCode::Value_4Bytes))
		{
			AddValueToName(Data, MaxLength, GetNextFormatSection(), Context.AsFloat());
			continue;
		}

		if (Context.RawCode() == (ECborCode::Prim | ECborCode::Value_8Bytes))
		{
			AddValueToName(Data, MaxLength, GetNextFormatSection(), Context.AsDouble());
			continue;
		}

		if (Context.RawCode() == (ECborCode::Prim | ECborCode::False))
		{
			AddValueToName(Data, MaxLength, GetNextFormatSection(), false);
			continue;
		}

		if (Context.RawCode() == (ECborCode::Prim | ECborCode::True))
		{
			AddValueToName(Data, MaxLength, GetNextFormatSection(), true);
			continue;
		}

		GetNextFormatSection();
		AddValueToName(Data, MaxLength, FString(TEXT("%s")), TEXT("???")); // unknown field type

		if (Context.IsFiniteContainer())
		{
			CborReader.SkipContainer(ECborCode::Array);
		}
	}

	// Append what's left of the format string.
	InOutStr.Append(Format);
}

////////////////////////////////////////////////////////////////////////////////////////////////////

void AddTimingEventToBuilder(
	ITimingEventsTrackDrawStateBuilder& Builder,
	double EventStartTime,
	double EventEndTime,
	uint32 EventDepth,
	uint32 TimerIndex,
	const TraceServices::FTimingProfilerTimer* Timer,
	const TraceServices::ITimingProfilerProvider& TimingProfilerProvider,
	const TraceServices::ITimingProfilerTimerReader& TimerReader)
{
	if (EventDepth >= FTimingProfilerManager::Get()->GetEventDepthLimit())
	{
		return;
	}

	uint32 EventColor;
	switch (FTimingProfilerManager::Get()->GetColoringMode())
	{
		case ETimingEventsColoringMode::ByTimerName:
			EventColor = FTimingEvent::ComputeEventColor(Timer->Name);
			break;
		case ETimingEventsColoringMode::ByTimerId:
			EventColor = FTimingEvent::ComputeEventColor(Timer->Id);
			break;
		case ETimingEventsColoringMode::BySourceFile:
			EventColor = FTimingEvent::ComputeEventColor(Timer->File);
			break;
		case ETimingEventsColoringMode::ByDuration:
		{
			const double EventDuration = EventEndTime - EventStartTime;
			EventColor = (EventDuration >= 0.01)     ? 0xFF883333 : // red:    >= 10ms
						 (EventDuration >= 0.001)    ? 0xFF998833 : // yellow: [1ms .. 10ms)
						 (EventDuration >= 0.0001)   ? 0xFF338833 : // green:  [100us .. 1ms)
						 (EventDuration >= 0.00001)  ? 0xFF338888 : // cyan:   [10us .. 100us)
						 (EventDuration >= 0.000001) ? 0xFF333388 : // blue:   [1us .. 10us)
						                               0xFF888888;  // gray:   < 1us
			break;
		}
		default:
			EventColor = 0xFF000000;
	}

	Builder.AddEvent(EventStartTime, EventEndTime, EventDepth, EventColor,
		[TimerIndex, Timer, EventStartTime, EventEndTime, &TimingProfilerProvider, &TimerReader]
		(float Width)
		{
			FString EventName = Timer->Name;

			const float MinWidth = static_cast<float>(EventName.Len()) * 4.0f + 32.0f;
			if (Width > MinWidth)
			{
				//EventName = TEXT("*") + EventName; // for debugging

				const double Duration = EventEndTime - EventStartTime;
				FTimingEventsTrackDrawStateBuilder::AppendDurationToEventName(EventName, Duration);

				if (int32(TimerIndex) < 0) // has metadata?
				{
					//EventName = TEXT("!") + EventName; // for debugging

					TArrayView<const uint8> Metadata = TimerReader.GetMetadata(TimerIndex);

					if (Metadata.Num() > 0)
					{
						const TraceServices::FMetadataSpec* MetadataSpec = nullptr;
						if (Timer->HasValidMetadataSpecId())
						{
							MetadataSpec = TimingProfilerProvider.GetMetadataSpec(Timer->MetadataSpecId);
						}

						if (MetadataSpec)
						{
							AppendMetadataToString(EventName, MetadataSpec->Format, Metadata);
						}
						else
						{
							AppendMetadataToString(EventName, Metadata);
						}
					}
				}
			}

			return EventName;
		}
	); // Builder.AddEvent
}

////////////////////////////////////////////////////////////////////////////////////////////////////

void FThreadTimingTrackImpl::BuildDrawState(ITimingEventsTrackDrawStateBuilder& Builder, const ITimingTrackUpdateContext& Context)
{
	const FTimingTrackViewport& Viewport = Context.GetViewport();

	ReadTimers(
		[this, &Builder, &Viewport]
		(const TraceServices::ITimingProfilerProvider& TimingProfilerProvider, const TraceServices::ITimingProfilerTimerReader& TimerReader)
		{
			ReadTimeline(
				[this, &Builder, &Viewport, &TimingProfilerProvider, &TimerReader]
				(const TraceServices::ITimingProfilerProvider::Timeline& Timeline)
				{
					if (FTimingEventsTrack::bUseDownSampling)
					{
						const double SecondsPerPixel = 1.0 / Viewport.GetScaleX();
						Timeline.EnumerateEventsDownSampled(Viewport.GetStartTime(), Viewport.GetEndTime(), SecondsPerPixel,
							[this, &Builder, &TimingProfilerProvider, &TimerReader]
							(double StartTime, double EndTime, uint32 Depth, const TraceServices::FTimingProfilerEvent& Event)
							{
								const TraceServices::FTimingProfilerTimer* Timer = TimerReader.GetTimer(Event.TimerIndex);
								if (ensure(Timer != nullptr))
								{
									AddTimingEventToBuilder(Builder, StartTime, EndTime, Depth, Event.TimerIndex, Timer, TimingProfilerProvider, TimerReader);
								}
								else
								{
									Builder.AddEvent(StartTime, EndTime, Depth, 0xFF000000, [&Event](float) { return FString::Printf(TEXT("[%u]"), Event.TimerIndex); });
								}
								return TraceServices::EEventEnumerate::Continue;
							}
						);
					}
					else
					{
						Timeline.EnumerateEvents(Viewport.GetStartTime(), Viewport.GetEndTime(),
							[this, &Builder, &TimingProfilerProvider, &TimerReader]
							(double StartTime, double EndTime, uint32 Depth, const TraceServices::FTimingProfilerEvent& Event)
							{
								const TraceServices::FTimingProfilerTimer* Timer = TimerReader.GetTimer(Event.TimerIndex);
								if (ensure(Timer != nullptr))
								{
									AddTimingEventToBuilder(Builder, StartTime, EndTime, Depth, Event.TimerIndex, Timer, TimingProfilerProvider, TimerReader);
								}
								else
								{
									Builder.AddEvent(StartTime, EndTime, Depth, 0xFF000000, [&Event](float) { return FString::Printf(TEXT("[%u]"), Event.TimerIndex); });
								}
								return TraceServices::EEventEnumerate::Continue;
							}
						);
					}
				}
			); // ReadTimeline
		}
	); // ReadTimers
}

////////////////////////////////////////////////////////////////////////////////////////////////////

void FThreadTimingTrackImpl::BuildFilteredDrawState(ITimingEventsTrackDrawStateBuilder& Builder, const ITimingTrackUpdateContext& Context)
{
	struct FPendingEventInfo
	{
		double StartTime;
		double EndTime;
		uint32 Depth;
		uint32 TimerIndex;
	};

	const TSharedPtr<ITimingEventFilter> EventFilterPtr = Context.GetEventFilter();
	if (EventFilterPtr.IsValid() && EventFilterPtr->FilterTrack(*this))
	{
		bool bFilterOnlyByEventType = false; // this is the most often use case, so the below code tries to optimize it
		uint64 FilterEventType = 0;
		if (EventFilterPtr->Is<FTimingEventFilterByEventType>())
		{
			bFilterOnlyByEventType = true;
			const FTimingEventFilterByEventType& EventFilter = EventFilterPtr->As<FTimingEventFilterByEventType>();
			FilterEventType = EventFilter.GetEventType();
		}

		const FTimingTrackViewport& Viewport = Context.GetViewport();

		ReadTimers(
			[this, &Builder, &EventFilterPtr, bFilterOnlyByEventType, FilterEventType, &Viewport]
			(const TraceServices::ITimingProfilerProvider& TimingProfilerProvider, const TraceServices::ITimingProfilerTimerReader& TimerReader)
			{
				if (bFilterOnlyByEventType)
				{
					//TODO: Add a setting to switch this on/off
					if (true)
					{
						ReadTimeline(
							[this, &Builder, FilterEventType, &Viewport, &TimingProfilerProvider, &TimerReader]
							(const TraceServices::ITimingProfilerProvider::Timeline& Timeline)
							{
								TArray<TArray<FPendingEventInfo>> FilteredEvents;

								TraceServices::ITimeline<TraceServices::FTimingProfilerEvent>::EnumerateAsyncParams Params;
								Params.IntervalStart = Viewport.GetStartTime();
								Params.IntervalEnd = Viewport.GetEndTime();
								Params.Resolution = 0.0;
								Params.SetupCallback =
									[&FilteredEvents](uint32 NumTasks)
									{
										FilteredEvents.AddDefaulted(NumTasks);
									};
								Params.EventRangeCallback =
									[this, &Builder, FilterEventType, &TimerReader, &FilteredEvents]
									(double StartTime, double EndTime, uint32 Depth, const TraceServices::FTimingProfilerEvent& Event, uint32 TaskIndex)
									{
										const TraceServices::FTimingProfilerTimer* Timer = TimerReader.GetTimer(Event.TimerIndex);
										if (ensure(Timer != nullptr))
										{
											if (Timer->Id == FilterEventType)
											{
												FPendingEventInfo TimelineEvent;
												TimelineEvent.StartTime = StartTime;
												TimelineEvent.EndTime = EndTime;
												TimelineEvent.Depth = Depth;
												TimelineEvent.TimerIndex = Event.TimerIndex;
												FilteredEvents[TaskIndex].Add(TimelineEvent);
											}
										}
										return TraceServices::EEventEnumerate::Continue;
									};

								// Note: Enumerating events for filtering should not use downsampling.
								Timeline.EnumerateEventsDownSampledAsync(Params);

								for (TArray<FPendingEventInfo>& Array : FilteredEvents)
								{
									for (FPendingEventInfo& TimelineEvent : Array)
									{
										const TraceServices::FTimingProfilerTimer* Timer = TimerReader.GetTimer(TimelineEvent.TimerIndex);
										AddTimingEventToBuilder(Builder, TimelineEvent.StartTime, TimelineEvent.EndTime, TimelineEvent.Depth, TimelineEvent.TimerIndex, Timer, TimingProfilerProvider, TimerReader);
									}
								}
							}); // ReadTimeline
					}
					else
					{
						ReadTimeline(
							[this, &Builder, FilterEventType, &Viewport, &TimingProfilerProvider, &TimerReader]
							(const TraceServices::ITimingProfilerProvider::Timeline& Timeline)
							{
								// Note: Enumerating events for filtering should not use downsampling.
								Timeline.EnumerateEventsDownSampled(Viewport.GetStartTime(), Viewport.GetEndTime(), 0,
									[this, &Builder, FilterEventType, &TimingProfilerProvider, &TimerReader]
									(double StartTime, double EndTime, uint32 Depth, const TraceServices::FTimingProfilerEvent& Event)
									{
										const TraceServices::FTimingProfilerTimer* Timer = TimerReader.GetTimer(Event.TimerIndex);
										if (ensure(Timer != nullptr))
										{
											if (Timer->Id == FilterEventType)
											{
												AddTimingEventToBuilder(Builder, StartTime, EndTime, Depth, Event.TimerIndex, Timer, TimingProfilerProvider, TimerReader);
											}
										}
										return TraceServices::EEventEnumerate::Continue;
									}
								);
							}
						); // ReadTimeline
					}
				}
				else // generic filter
				{
					ReadTimeline(
						[this, &Builder, &EventFilterPtr, &Viewport, &TimingProfilerProvider, &TimerReader]
						(const TraceServices::ITimingProfilerProvider::Timeline& Timeline)
						{
							// Note: Enumerating events for filtering should not use downsampling.
							//const double SecondsPerPixel = 1.0 / Viewport.GetScaleX();
							//Timeline.EnumerateEventsDownSampled(Viewport.GetStartTime(), Viewport.GetEndTime(), SecondsPerPixel,
							Timeline.EnumerateEvents(Viewport.GetStartTime(), Viewport.GetEndTime(),
								[this, &Builder, &EventFilterPtr, &TimingProfilerProvider, &TimerReader]
								(double StartTime, double EndTime, uint32 Depth, const TraceServices::FTimingProfilerEvent& Event)
								{
									const TraceServices::FTimingProfilerTimer* Timer = TimerReader.GetTimer(Event.TimerIndex);
									if (ensure(Timer != nullptr))
									{
										FThreadTrackEvent TimingEvent(SharedThis(this), StartTime, EndTime, Depth);
										TimingEvent.SetTimerId(Timer->Id);
										TimingEvent.SetTimerIndex(Event.TimerIndex);

										if (EventFilterPtr->FilterEvent(TimingEvent))
										{
											AddTimingEventToBuilder(Builder, StartTime, EndTime, Depth, Event.TimerIndex, Timer, TimingProfilerProvider, TimerReader);
										}
									}
									return TraceServices::EEventEnumerate::Continue;
								}
							);
						}
					); // ReadTimeline
				}
			}
		); // ReadTimers
	}

	if (HasCustomFilter()) // Custom filter (from the filtering widget)
	{
		const FTimingTrackViewport& Viewport = Context.GetViewport();

		ReadTimers(
			[this, &Builder, &Viewport]
			(const TraceServices::ITimingProfilerProvider& TimingProfilerProvider, const TraceServices::ITimingProfilerTimerReader& TimerReader)
			{
				ReadTimeline(
					[this, &Builder, &Viewport, &TimingProfilerProvider, &TimerReader]
					(const TraceServices::ITimingProfilerProvider::Timeline& Timeline)
					{
						TArray<TArray<FPendingEventInfo>> FilteredEvents;
						TArray<FFilterContext> FilterContexts;

						TraceServices::ITimeline<TraceServices::FTimingProfilerEvent>::EnumerateAsyncParams Params;
						constexpr uint32 LargeTimelineThreshold = 50 * 1000 * 1000;
						if (Timeline.GetEventCount() > LargeTimelineThreshold)
						{
							if (FilterConfigurator->IsKeyUsed(static_cast<int32>(EFilterField::Metadata)))
							{
								Params.MaxOccupancy = 0.75f; // This filter can be slow so reduce occupancy to avoid starvation.
							}
						}
						Params.IntervalStart = Viewport.GetStartTime();
						Params.IntervalEnd = Viewport.GetEndTime();

						// Note: Enumerating events for filtering should not use downsampling.
						Params.Resolution = 0.0;
						Params.SetupCallback =
							[this, &FilteredEvents, &FilterContexts]
							(uint32 NumTasks)
							{
								FilteredEvents.AddDefaulted(NumTasks);
								FilterContexts.AddDefaulted(NumTasks);
								for (FFilterContext& Context : FilterContexts)
								{
									Context.SetReturnValueForUnsetFilters(false);
									Context.AddFilterData<double>(static_cast<int32>(EFilterField::StartTime), 0.0f);
									Context.AddFilterData<double>(static_cast<int32>(EFilterField::EndTime), 0.0f);
									Context.AddFilterData<double>(static_cast<int32>(EFilterField::Duration), 0.0f);
									Context.AddFilterData<FString>(static_cast<int32>(EFilterField::TrackName), this->GetName());
									Context.AddFilterData<int64>(static_cast<int32>(EFilterField::TimerId), 0);
									Context.AddFilterData<int64>(static_cast<int32>(EFilterField::TimerName), 0);
									Context.AddFilterData<int64>(static_cast<int32>(EFilterField::Metadata), 0);
								}
							};
						Params.EventRangeCallback =
							[this, &Builder, &TimerReader, &FilteredEvents, &FilterContexts]
							(double StartTime, double EndTime, uint32 Depth, const TraceServices::FTimingProfilerEvent& Event, uint32 TaskIndex)
							{
								const TraceServices::FTimingProfilerTimer* Timer = TimerReader.GetTimer(Event.TimerIndex);
								if (ensure(Timer != nullptr))
								{
									FFilterContext& Context = FilterContexts[TaskIndex];
									Context.SetFilterData<double>(static_cast<int32>(EFilterField::StartTime), StartTime);
									Context.SetFilterData<double>(static_cast<int32>(EFilterField::EndTime), EndTime);
									Context.SetFilterData<double>(static_cast<int32>(EFilterField::Duration), EndTime - StartTime);
									// The TimerName filter also translates to the numeric Id for performance reasons.
									Context.SetFilterData<int64>(static_cast<int32>(EFilterField::TimerId), Timer->Id);
									Context.SetFilterData<int64>(static_cast<int32>(EFilterField::TimerName), Timer->Id);
									Context.SetFilterData<int64>(static_cast<int32>(EFilterField::Metadata), Event.TimerIndex);

									if (FilterConfigurator->ApplyFilters(Context))
									{
										FPendingEventInfo TimelineEvent;
										TimelineEvent.StartTime = StartTime;
										TimelineEvent.EndTime = EndTime;
										TimelineEvent.Depth = Depth;
										TimelineEvent.TimerIndex = Event.TimerIndex;
										FilteredEvents[TaskIndex].Add(TimelineEvent);
									}
								}
								return TraceServices::EEventEnumerate::Continue;
							};

						Timeline.EnumerateEventsDownSampledAsync(Params);

						for (TArray<FPendingEventInfo>& Array : FilteredEvents)
						{
							for (FPendingEventInfo& TimelineEvent : Array)
							{
								const TraceServices::FTimingProfilerTimer* Timer = TimerReader.GetTimer(TimelineEvent.TimerIndex);
								AddTimingEventToBuilder(Builder, TimelineEvent.StartTime, TimelineEvent.EndTime, TimelineEvent.Depth, TimelineEvent.TimerIndex, Timer, TimingProfilerProvider, TimerReader);
							}
						}
					}
				); // ReadTimeline
			}
		); // ReadTimers
	}
}

////////////////////////////////////////////////////////////////////////////////////////////////////

void FThreadTimingTrackImpl::PostDraw(const ITimingTrackDrawContext& Context) const
{
	for (const TSharedRef<FBaseTimingTrack>& Track : GetChildTracks())
	{
		Track->PostDraw(Context);
	}

	const TSharedPtr<const ITimingEvent> SelectedEventPtr = Context.GetSelectedEvent();
	if (SelectedEventPtr.IsValid() &&
		SelectedEventPtr->CheckTrack(this) &&
		SelectedEventPtr->Is<FThreadTrackEvent>())
	{
		const FThreadTrackEvent& SelectedEvent = SelectedEventPtr->As<FThreadTrackEvent>();
		const ITimingViewDrawHelper& Helper = Context.GetHelper();

		ReadTimers(
			[this, &Context, &SelectedEvent, &Helper]
			(const TraceServices::ITimingProfilerProvider& TimingProfilerProvider, const TraceServices::ITimingProfilerTimerReader& TimerReader)
			{
				const TraceServices::FTimingProfilerTimer* Timer = TimerReader.GetTimer(SelectedEvent.GetTimerIndex());
				if (Timer != nullptr)
				{
					FString TimerName(Timer->Name);

					const double SelectedEventDuration = SelectedEvent.GetDuration();
					TStringBuilder<1024> StringBuilder;
					StringBuilder.Appendf(TEXT("  Incl.: %s"), *FormatTimeAuto(SelectedEventDuration, 2));
					if (SelectedEventDuration != std::numeric_limits<double>::infinity())
					{
						StringBuilder.Appendf(TEXT("   Excl.: %s"), *FormatTimeAuto(SelectedEvent.GetExclusiveTime(), 2));
					}
					FString StatsText(StringBuilder.ToView());

					if (Timer->File)
					{
						FString SourceFile = FPaths::GetCleanFilename(FString(Timer->File));
						FString SourceFileAndLine = FString::Printf(TEXT("%s (%d)"), *SourceFile, Timer->Line);
						DrawSelectedEventInfoEx(StatsText, TimerName, SourceFileAndLine, Context.GetViewport(), Context.GetDrawContext(), Helper.GetWhiteBrush(), Helper.GetEventFont());
					}
					else
					{
						DrawSelectedEventInfoEx(StatsText, TimerName, FString(), Context.GetViewport(), Context.GetDrawContext(), Helper.GetWhiteBrush(), Helper.GetEventFont());
					}
				}
			}
		); // ReadTimers
	}
}

////////////////////////////////////////////////////////////////////////////////////////////////////

void FThreadTimingTrackImpl::InitTooltip(FTooltipDrawState& InOutTooltip, const ITimingEvent& InTooltipEvent) const
{
	if (!IsChildTrack())
	{
		InOutTooltip.ResetContent();
	}

	if (InTooltipEvent.CheckTrack(this) && InTooltipEvent.Is<FThreadTrackEvent>())
	{
		const FThreadTrackEvent& TooltipEvent = InTooltipEvent.As<FThreadTrackEvent>();

		TSharedPtr<FThreadTrackEvent> ParentTimingEvent;
		TSharedPtr<FThreadTrackEvent> RootTimingEvent;
		GetParentAndRoot(TooltipEvent, ParentTimingEvent, RootTimingEvent);

		ReadTimers(
			[this, &InOutTooltip, &TooltipEvent, &ParentTimingEvent, &RootTimingEvent]
			(const TraceServices::ITimingProfilerProvider& TimingProfilerProvider, const TraceServices::ITimingProfilerTimerReader& TimerReader)
			{
				// Add the timer name.
				const uint32 TimerIndex = TooltipEvent.GetTimerIndex();
				const TraceServices::FTimingProfilerTimer* Timer = TimerReader.GetTimer(TimerIndex);
				const TCHAR* TimerName = (Timer != nullptr) ? Timer->Name : TEXT("N/A");
				InOutTooltip.AddTitle(TimerName);

				TArrayView<const uint8> Metadata;
				const TraceServices::FMetadataSpec* MetadataSpec = nullptr;
				if (int32(TimerIndex) < 0) // has metadata?
				{
					Metadata = TimerReader.GetMetadata(TimerIndex);
					if (Timer && Timer->HasValidMetadataSpecId())
					{
						MetadataSpec = TimingProfilerProvider.GetMetadataSpec(Timer->MetadataSpecId);
					}

#if 0 // for debugging
					// Add the full timer name (i.e. with formatting/metadata).
					FString TimerNameEx = TimerName;
					if (MetadataSpec)
					{
						AppendMetadataToString(TimerNameEx, MetadataSpec->Format, Metadata);
					}
					else
					{
						AppendMetadataToString(TimerNameEx, Metadata);
					}
					InOutTooltip.AddTitle(TimerNameEx, FLinearColor(1.0f, 1.0f, 1.0f, 1.0f));
#endif
				}

				const double TooltipEventDuration = TooltipEvent.GetDuration();

				if (TooltipEvent.GetDepth() > 0 &&
					ParentTimingEvent.IsValid() &&
					ParentTimingEvent->GetDuration() > 0.0 &&
					ParentTimingEvent->GetDuration() != std::numeric_limits<double>::infinity())
				{
					const TraceServices::FTimingProfilerTimer* ParentTimer = TimerReader.GetTimer(ParentTimingEvent->GetTimerIndex());
					const TCHAR* ParentTimerName = (ParentTimer != nullptr) ? ParentTimer->Name : TEXT("N/A");
					FNumberFormattingOptions FormattingOptions;
					FormattingOptions.MaximumFractionalDigits = 2;
					const FString ValueStr = FString::Printf(TEXT("%s %s"), *FText::AsPercent(TooltipEventDuration / ParentTimingEvent->GetDuration(), &FormattingOptions).ToString(), ParentTimerName);
					InOutTooltip.AddNameValueTextLine(TEXTVIEW("% of Parent:"), ValueStr);
				}

				if (TooltipEvent.GetDepth() > 1 &&
					RootTimingEvent.IsValid() &&
					RootTimingEvent->GetDuration() > 0.0 &&
					RootTimingEvent->GetDuration() != std::numeric_limits<double>::infinity())
				{
					const TraceServices::FTimingProfilerTimer* RootTimer = TimerReader.GetTimer(RootTimingEvent->GetTimerIndex());
					const TCHAR* RootTimerName = (RootTimer != nullptr) ? RootTimer->Name : TEXT("N/A");
					FNumberFormattingOptions FormattingOptions;
					FormattingOptions.MaximumFractionalDigits = 2;
					const FString ValueStr = FString::Printf(TEXT("%s %s"), *FText::AsPercent(TooltipEventDuration / RootTimingEvent->GetDuration(), &FormattingOptions).ToString(), RootTimerName);
					InOutTooltip.AddNameValueTextLine(TEXTVIEW("% of Root:"), ValueStr);
				}

				InOutTooltip.AddNameValueTextLine(TEXTVIEW("Inclusive Time:"), FormatTimeAuto(TooltipEventDuration, 2));

				if (TooltipEventDuration > 0.0 &&
					TooltipEventDuration != std::numeric_limits<double>::infinity())
				{
					const double ExclusiveTimePercent = TooltipEvent.GetExclusiveTime() / TooltipEventDuration;
					FNumberFormattingOptions FormattingOptions;
					FormattingOptions.MaximumFractionalDigits = 2;
					const FString ExclStr = FString::Printf(TEXT("%s (%s)"), *FormatTimeAuto(TooltipEvent.GetExclusiveTime(), 2), *FText::AsPercent(ExclusiveTimePercent, &FormattingOptions).ToString());
					InOutTooltip.AddNameValueTextLine(TEXTVIEW("Exclusive Time:"), ExclStr);
				}

				InOutTooltip.AddNameValueTextLine(TEXTVIEW("Depth:"), FString::Printf(TEXT("%d"), TooltipEvent.GetDepth()));

				// Add detailed metadata.
				if (int32(TimerIndex) < 0) // has metadata?
				{
					AppendMetadataToTooltip(InOutTooltip, MetadataSpec, Metadata);
				}

				TSharedPtr<const TraceServices::IAnalysisSession> Session = FInsightsManager::Get()->GetSession();
				if (Session.IsValid())
				{
					PostInitTooltip(InOutTooltip, TooltipEvent, *Session.Get(), TimerName);
				}
			}
		); // ReadTimers
	}
	else
	{
		for (const TSharedRef<FBaseTimingTrack>& Track : GetChildTracks())
		{
			Track->InitTooltip(InOutTooltip, InTooltipEvent);
		}
	}

	InOutTooltip.UpdateLayout();
}

////////////////////////////////////////////////////////////////////////////////////////////////////

void FThreadTimingTrackImpl::GetParentAndRoot(const FThreadTrackEvent& TimingEvent, TSharedPtr<FThreadTrackEvent>& OutParentTimingEvent, TSharedPtr<FThreadTrackEvent>& OutRootTimingEvent) const
{
	if (TimingEvent.GetDepth() > 0)
	{
		ReadTimeline(
			[this, &TimingEvent, &OutParentTimingEvent, &OutRootTimingEvent]
			(const TraceServices::ITimingProfilerProvider::Timeline& Timeline)
			{
				const double Time = (TimingEvent.GetStartTime() + TimingEvent.GetEndTime()) / 2;
				TimelineEventInfo EventInfo;
				if (Timeline.GetEventInfo(Time, 0, TimingEvent.GetDepth() - 1, EventInfo))
				{
					OutParentTimingEvent = CreateEvent(EventInfo, TimingEvent.GetTrack(), TimingEvent.GetDepth() - 1);
				}
				if (Timeline.GetEventInfo(Time, 0, 0, EventInfo))
				{
					OutRootTimingEvent = CreateEvent(EventInfo, TimingEvent.GetTrack(), 0);
				}
			}
		); // ReadTimeline
	}
}

////////////////////////////////////////////////////////////////////////////////////////////////////

const TSharedPtr<const ITimingEvent> FThreadTimingTrackImpl::GetEvent(float InPosX, float InPosY, const FTimingTrackViewport& Viewport) const
{
	TSharedPtr<FThreadTrackEvent> TimingEvent;

	const FTimingViewLayout& Layout = Viewport.GetLayout();

	float TopLaneY = GetPosY() + Layout.TimelineDY;
	float TrackLanesHeight = GetHeight();

	for (const TSharedRef<FBaseTimingTrack>& Track : GetChildTracks())
	{
		float HeaderDY = InPosY - Track->GetPosY();
		float TrackHeightWithPadding = Track->GetHeight() + Layout.ChildTimelineDY;
		if (HeaderDY >= 0.0f && HeaderDY < TrackHeightWithPadding)
		{
			return Track->GetEvent(InPosX, InPosY, Viewport);
		}

		TopLaneY += TrackHeightWithPadding;
		TrackLanesHeight -= TrackHeightWithPadding;
	}

	const float DY = InPosY - TopLaneY;

	// If mouse is not above first sub-track or below last sub-track...
	if (DY >= 0 && DY < TrackLanesHeight)
	{
		const int32 Depth = static_cast<int32>(DY / (Layout.EventH + Layout.EventDY));

		const double SecondsPerPixel = 1.0 / Viewport.GetScaleX();

		const double EventTime = Viewport.SlateUnitsToTime(InPosX);

		double SessionDuration = std::numeric_limits<double>::lowest();
		TSharedPtr<const TraceServices::IAnalysisSession> Session = FInsightsManager::Get()->GetSession();
		if (Session.IsValid())
		{
			TraceServices::FAnalysisSessionReadScope SessionReadScope(*Session.Get());
			SessionDuration = Session->GetDurationSeconds();
		}

		if (EventTime <= SessionDuration)
		{
			ReadTimeline(
				[this, &EventTime, &Depth, &TimingEvent, &SecondsPerPixel]
				(const TraceServices::ITimingProfilerProvider::Timeline& Timeline)
				{
					TimelineEventInfo EventInfo;
					if (Timeline.GetEventInfo(EventTime, 2 * SecondsPerPixel, Depth, EventInfo))
					{
						TimingEvent = CreateEvent(EventInfo, SharedThis(this), Depth);
					}
				}
			); // ReadTimeline
		}
	}

	return TimingEvent;
}

////////////////////////////////////////////////////////////////////////////////////////////////////

const TSharedPtr<const ITimingEvent> FThreadTimingTrackImpl::SearchEvent(const FTimingEventSearchParameters& InSearchParameters) const
{
	TSharedPtr<FThreadTrackEvent> FoundEvent;
	FindTimingProfilerEvent(InSearchParameters, [this, &FoundEvent](double InFoundStartTime, double InFoundEndTime, uint32 InFoundDepth, const TraceServices::FTimingProfilerEvent& InFoundEvent)
	{
		FoundEvent = MakeShared<FThreadTrackEvent>(SharedThis(this), InFoundStartTime, InFoundEndTime, InFoundDepth);
		FoundEvent->SetTimerIndex(InFoundEvent.TimerIndex);

		uint32 TimerId = 0;
		bool bIsValidTimerId = TimerIndexToTimerId(InFoundEvent.TimerIndex, TimerId);
		if (bIsValidTimerId)
		{
			FoundEvent->SetTimerId(TimerId);
		}
	});

	return FoundEvent;
}

////////////////////////////////////////////////////////////////////////////////////////////////////

void FThreadTimingTrackImpl::UpdateEventStats(ITimingEvent& InOutEvent) const
{
	if (InOutEvent.CheckTrack(this) && InOutEvent.Is<FThreadTrackEvent>())
	{
		FThreadTrackEvent& TrackEvent = InOutEvent.As<FThreadTrackEvent>();
		if (!TrackEvent.IsExclusiveTimeComputed())
		{
			ReadTimeline(
				[&TrackEvent]
				(const TraceServices::ITimingProfilerProvider::Timeline& Timeline)
				{
					TimelineEventInfo EventInfo;
					bool bIsFound = Timeline.GetEventInfo(TrackEvent.GetStartTime(), 0.0, TrackEvent.GetDepth(), EventInfo);
					if (bIsFound)
					{
						TrackEvent.SetExclusiveTime(EventInfo.ExclTime);
						TrackEvent.SetIsExclusiveTimeComputed(true);
					}
				}
			); // ReadTimeline
		}
	}
}

////////////////////////////////////////////////////////////////////////////////////////////////////

void FThreadTimingTrackImpl::OnEventSelected(const ITimingEvent& InSelectedEvent) const
{
	if (InSelectedEvent.CheckTrack(this) && InSelectedEvent.Is<FThreadTrackEvent>())
	{
		const FThreadTrackEvent& TrackEvent = InSelectedEvent.As<FThreadTrackEvent>();

		// Select the timer node corresponding to timing event type of selected timing event.
		FTimingProfilerManager::Get()->SetSelectedTimer(TrackEvent.GetTimerId());
	}
}

////////////////////////////////////////////////////////////////////////////////////////////////////

void FThreadTimingTrackImpl::OnClipboardCopyEvent(const ITimingEvent& InSelectedEvent) const
{
	if (InSelectedEvent.CheckTrack(this) && InSelectedEvent.Is<FThreadTrackEvent>())
	{
		const FThreadTrackEvent& TrackEvent = InSelectedEvent.As<FThreadTrackEvent>();

		ReadTimers(
			[this, &TrackEvent]
			(const TraceServices::ITimingProfilerProvider& TimingProfilerProvider, const TraceServices::ITimingProfilerTimerReader& TimerReader)
			{
				const TraceServices::FTimingProfilerTimer* TimerPtr = TimerReader.GetTimer(TrackEvent.GetTimerIndex());

				if (TimerPtr)
				{
					FString EventName(TimerPtr->Name);

					FTimingEventsTrackDrawStateBuilder::AppendDurationToEventName(EventName, TrackEvent.GetDuration());

					const uint32 TimerIndex = TrackEvent.GetTimerIndex();
					if (int32(TimerIndex) < 0) // has metadata?
					{
						TArrayView<const uint8> Metadata = TimerReader.GetMetadata(TimerIndex);

						const TraceServices::FMetadataSpec* MetadataSpec = nullptr;
						if (TimerPtr && TimerPtr->HasValidMetadataSpecId())
						{
							MetadataSpec = TimingProfilerProvider.GetMetadataSpec(TimerPtr->MetadataSpecId);
						}

						if (Metadata.Num() > 0)
						{
							if (MetadataSpec)
							{
								AppendMetadataToString(EventName, MetadataSpec->Format, Metadata);
							}
							else
							{
								AppendMetadataToString(EventName, Metadata);
							}
						}
					}

					// Copy name of selected timing event to clipboard.
					FPlatformApplicationMisc::ClipboardCopy(*EventName);
				}
			}
		); // ReadTimers
	}
}

////////////////////////////////////////////////////////////////////////////////////////////////////

void FThreadTimingTrackImpl::BuildContextMenu(FMenuBuilder& MenuBuilder)
{
	if (GetGroupName() != nullptr)
	{
		MenuBuilder.BeginSection("CpuThread", LOCTEXT("ContextMenu_Section_CpuThread", "CPU Thread"));
		{
			MenuBuilder.AddMenuEntry(
				FText::Format(LOCTEXT("CpuThreadGroupFmt", "Group: {0}"), FText::FromString(GetGroupName())),
				FText(),
				FSlateIcon(),
				FUIAction(FExecuteAction(), FCanExecuteAction::CreateLambda([]() { return false; })),
				NAME_None,
				EUserInterfaceActionType::Button
			);

			const FString ThreadIdStr = FString::Printf(TEXT("%s%u (0x%X)"), ThreadId & 0x70000000 ? TEXT("*") : TEXT(""), ThreadId & ~0x70000000, ThreadId);
			MenuBuilder.AddMenuEntry(
				FText::Format(LOCTEXT("CpuThreadIdFmt", "Thread Id: {0}"), FText::FromString(ThreadIdStr)),
				FText(),
				FSlateIcon(),
				FUIAction(FExecuteAction(), FCanExecuteAction::CreateLambda([]() { return false; })),
				NAME_None,
				EUserInterfaceActionType::Button
			);
		}
		MenuBuilder.EndSection();
	}

	for (const TSharedRef<FBaseTimingTrack>& Track : GetChildTracks())
	{
		Track->BuildContextMenu(MenuBuilder);
	}
}

////////////////////////////////////////////////////////////////////////////////////////////////////

bool FThreadTimingTrackImpl::FindTimingProfilerEvent(const FThreadTrackEvent& InTimingEvent, TFunctionRef<void(double, double, uint32, const TraceServices::FTimingProfilerEvent&)> InFoundPredicate) const
{
	auto MatchEvent = [&InTimingEvent](double InStartTime, double InEndTime, uint32 InDepth)
	{
		return InDepth == InTimingEvent.GetDepth()
			&& InStartTime == InTimingEvent.GetStartTime()
			&& InEndTime == InTimingEvent.GetEndTime();
	};

	const double Time = (InTimingEvent.GetStartTime() + InTimingEvent.GetEndTime()) / 2;
	FTimingEventSearchParameters SearchParameters(Time, Time, ETimingEventSearchFlags::StopAtFirstMatch, MatchEvent);
	SearchParameters.SearchHandle = &InTimingEvent.GetSearchHandle();
	return FindTimingProfilerEvent(SearchParameters, InFoundPredicate);
}

////////////////////////////////////////////////////////////////////////////////////////////////////

bool FThreadTimingTrackImpl::FindTimingProfilerEvent(const FTimingEventSearchParameters& InParameters, TFunctionRef<void(double, double, uint32, const TraceServices::FTimingProfilerEvent&)> InFoundPredicate) const
{
	FFilterContext FilterConfiguratorContext;
	FilterConfiguratorContext.SetReturnValueForUnsetFilters(false);
	FilterConfiguratorContext.AddFilterData<double>(static_cast<int32>(EFilterField::StartTime), 0.0f);
	FilterConfiguratorContext.AddFilterData<double>(static_cast<int32>(EFilterField::EndTime), 0.0f);
	FilterConfiguratorContext.AddFilterData<double>(static_cast<int32>(EFilterField::Duration), 0.0f);
	FilterConfiguratorContext.AddFilterData<FString>(static_cast<int32>(EFilterField::TrackName), this->GetName());
	FilterConfiguratorContext.AddFilterData<int64>(static_cast<int32>(EFilterField::TimerId), 0);
	FilterConfiguratorContext.AddFilterData<int64>(static_cast<int32>(EFilterField::TimerName), 0);
	FilterConfiguratorContext.AddFilterData<int64>(static_cast<int32>(EFilterField::Metadata), 0);

	return TTimingEventSearch<TraceServices::FTimingProfilerEvent>::Search(

		InParameters,

		// Search Predicate
		[this]
		(TTimingEventSearch<TraceServices::FTimingProfilerEvent>::FContext& InContext)
		{
			ReadTimeline(
				[&InContext]
				(const TraceServices::ITimingProfilerProvider::Timeline& Timeline)
				{
					auto Callback = [&InContext](double EventStartTime, double EventEndTime, uint32 EventDepth, const TraceServices::FTimingProfilerEvent& Event)
					{
						InContext.Check(EventStartTime, EventEndTime, EventDepth, Event);
						return InContext.ShouldContinueSearching() ? TraceServices::EEventEnumerate::Continue : TraceServices::EEventEnumerate::Stop;
					};

					if (InContext.GetParameters().SearchDirection == FTimingEventSearchParameters::ESearchDirection::Forward)
					{
						Timeline.EnumerateEvents(InContext.GetParameters().StartTime, InContext.GetParameters().EndTime, Callback);
					}
					else
					{
						Timeline.EnumerateEventsBackwards(InContext.GetParameters().EndTime, InContext.GetParameters().StartTime, Callback);
					}
				}
			); // ReadTimeline
		},

		// Filter Predicate
		[this, &FilterConfiguratorContext, &InParameters]
		(double EventStartTime, double EventEndTime, uint32 EventDepth, const TraceServices::FTimingProfilerEvent& Event)
		{
			if (!InParameters.FilterExecutor.IsValid())
			{
				return true;
			}

			FilterConfiguratorContext.SetFilterData<double>(static_cast<int32>(EFilterField::StartTime), EventStartTime);
			FilterConfiguratorContext.SetFilterData<double>(static_cast<int32>(EFilterField::EndTime), EventEndTime);
			FilterConfiguratorContext.SetFilterData<double>(static_cast<int32>(EFilterField::Duration), EventEndTime - EventStartTime);

			uint32 TimerId = ~0u;
			ReadTimers(
				[&Event, &TimerId]
				(const TraceServices::ITimingProfilerProvider& TimingProfilerProvider, const TraceServices::ITimingProfilerTimerReader& TimerReader)
				{
					const TraceServices::FTimingProfilerTimer* Timer = TimerReader.GetTimer(Event.TimerIndex);
					if (ensure(Timer != nullptr))
					{
						TimerId = Timer->Id;
					}
				});
			FilterConfiguratorContext.SetFilterData<int64>(static_cast<int32>(EFilterField::TimerId), TimerId);
			FilterConfiguratorContext.SetFilterData<int64>(static_cast<int32>(EFilterField::TimerName), TimerId);

			FilterConfiguratorContext.SetFilterData<int64>(static_cast<int32>(EFilterField::Metadata), Event.TimerIndex);

			return InParameters.FilterExecutor->ApplyFilters(FilterConfiguratorContext);
		},

		// Found Predicate
		InFoundPredicate,

		// Payload Matched Predicate
		TTimingEventSearch<TraceServices::FTimingProfilerEvent>::NoMatch,

		// Cache
		&SearchCache

	); // Search
}

////////////////////////////////////////////////////////////////////////////////////////////////////

TSharedRef<FThreadTrackEvent> FThreadTimingTrackImpl::CreateEvent(const TimelineEventInfo& InEventInfo, const TSharedRef<const FBaseTimingTrack> InTrack, int32 InDepth) const
{
	TSharedRef<FThreadTrackEvent> ThreadTrackEvent = MakeShared<FThreadTrackEvent>(InTrack, InEventInfo.StartTime, InEventInfo.EndTime, InDepth);
	FThreadTrackEvent& Event = *ThreadTrackEvent;

	Event.SetExclusiveTime(InEventInfo.ExclTime);
	Event.SetIsExclusiveTimeComputed(true);
	Event.SetTimerIndex(InEventInfo.Event.TimerIndex);

	uint32 TimerId = 0;
	bool bIsValidTimerId = TimerIndexToTimerId(InEventInfo.Event.TimerIndex, TimerId);
	if (bIsValidTimerId)
	{
		Event.SetTimerId(TimerId);
	}

	return ThreadTrackEvent;
}

////////////////////////////////////////////////////////////////////////////////////////////////////

bool FThreadTimingTrackImpl::TimerIndexToTimerId(uint32 InTimerIndex, uint32& OutTimerId) const
{
	bool bIsValidTimerId = false;

	ReadTimers(
		[&bIsValidTimerId, InTimerIndex, &OutTimerId]
		(const TraceServices::ITimingProfilerProvider& TimingProfilerProvider, const TraceServices::ITimingProfilerTimerReader& TimerReader)
		{
			const TraceServices::FTimingProfilerTimer* Timer = TimerReader.GetTimer(InTimerIndex);
			if (Timer)
			{
				OutTimerId = Timer->Id;
				bIsValidTimerId = true;
			}
		}
	); // ReadTimers

	return bIsValidTimerId;
}

////////////////////////////////////////////////////////////////////////////////////////////////////

bool FThreadTimingTrackImpl::HasCustomFilter() const
{
	return FilterConfigurator.IsValid() && !FilterConfigurator->IsEmpty();
}

////////////////////////////////////////////////////////////////////////////////////////////////////

int32 FThreadTimingTrackImpl::GetDepthAt(double Time) const
{
	int32 Depth = 0;

	ReadTimeline(
		[Time, &Depth]
		(const TraceServices::ITimingProfilerProvider::Timeline& Timeline)
		{
			Depth = Timeline.GetDepthAt(Time);
		}
	); // ReadTimeline

	return Depth;
}

////////////////////////////////////////////////////////////////////////////////////////////////////

void FThreadTimingTrackImpl::SetFilterConfigurator(TSharedPtr<FFilterConfigurator> InFilterConfigurator)
{
	if (FilterConfigurator != InFilterConfigurator)
	{
		FilterConfigurator = InFilterConfigurator;
		SetDirtyFlag();
	}
}

////////////////////////////////////////////////////////////////////////////////////////////////////

TSharedPtr<const ITimingEvent> FThreadTimingTrackImpl::FindMaxEventInstance(uint32 InTimerId, double InStartTime, double InEndTime) const
{
	TSharedPtr<FThreadTrackEvent> TimingEvent;

	ReadTimers(
		[this, InTimerId, InStartTime, InEndTime, &TimingEvent]
		(const TraceServices::ITimingProfilerProvider& TimingProfilerProvider, const TraceServices::ITimingProfilerTimerReader& TimerReader)
		{
			ReadTimeline(
				[this, InTimerId, InStartTime, InEndTime, &TimingEvent, &TimerReader]
				(const TraceServices::ITimingProfilerProvider::Timeline& Timeline)
				{
					struct FCandidateEvent
					{
						double StartTime = 0.0f;
						double EndTime = -1.0f;
						uint32 Depth = 0;
						uint32 TimerIndex = 0;
					};
					TArray<FCandidateEvent> CandidateEvents;

					TraceServices::ITimeline<TraceServices::FTimingProfilerEvent>::EnumerateAsyncParams Params;
					Params.IntervalStart = InStartTime;
					Params.IntervalEnd = InEndTime;
					Params.Resolution = 0.0;
					Params.SetupCallback =
						[&CandidateEvents](uint32 NumTasks)
						{
							CandidateEvents.AddDefaulted(NumTasks);
						};
					Params.EventRangeCallback =
						[InTimerId, &TimerReader, &CandidateEvents]
						(double StartTime, double EndTime, uint32 Depth, const TraceServices::FTimingProfilerEvent& Event, uint32 TaskIndex)
						{
							const TraceServices::FTimingProfilerTimer* Timer = TimerReader.GetTimer(Event.TimerIndex);
							if (ensure(Timer != nullptr))
							{
								if (Timer->Id == InTimerId)
								{
									double CandidateDuration = CandidateEvents[TaskIndex].EndTime - CandidateEvents[TaskIndex].StartTime;
									double EventDuration = EndTime - StartTime;

									if (EventDuration > CandidateDuration)
									{
										CandidateEvents[TaskIndex].StartTime = StartTime;
										CandidateEvents[TaskIndex].EndTime = EndTime;
										CandidateEvents[TaskIndex].Depth = Depth;
										CandidateEvents[TaskIndex].TimerIndex = Event.TimerIndex;
									}

								}
							}
							return TraceServices::EEventEnumerate::Continue;
						};

					// Note: Enumerating events for filtering should not use downsampling.
					Timeline.EnumerateEventsDownSampledAsync(Params);

					FCandidateEvent BestMatch;
					for (const FCandidateEvent& Event : CandidateEvents)
					{
						if ((Event.EndTime - Event.StartTime) > BestMatch.EndTime - BestMatch.StartTime)
						{
							BestMatch = Event;
						}
					}

					if (BestMatch.EndTime > BestMatch.StartTime)
					{
						TimingEvent = MakeShared<FThreadTrackEvent>(SharedThis(this), BestMatch.StartTime, BestMatch.EndTime, BestMatch.Depth);
						TimingEvent->SetTimerId(InTimerId);
						TimingEvent->SetTimerIndex(BestMatch.TimerIndex);
					}
				}
			); // ReadTimeline
		}
	); // ReadTimers

	return TimingEvent;
}

////////////////////////////////////////////////////////////////////////////////////////////////////

TSharedPtr<const ITimingEvent> FThreadTimingTrackImpl::FindMinEventInstance(uint32 InTimerId, double InStartTime, double InEndTime) const
{
	TSharedPtr<FThreadTrackEvent> TimingEvent;

	ReadTimers(
		[this, InTimerId, InStartTime, InEndTime, &TimingEvent]
		(const TraceServices::ITimingProfilerProvider& TimingProfilerProvider, const TraceServices::ITimingProfilerTimerReader& TimerReader)
		{
			ReadTimeline(
				[this, InTimerId, InStartTime, InEndTime, &TimingEvent, &TimerReader]
				(const TraceServices::ITimingProfilerProvider::Timeline& Timeline)
				{
					struct FCandidateEvent
					{
						double StartTime = -std::numeric_limits<double>::infinity();
						double EndTime = std::numeric_limits<double>::infinity();
						uint32 Depth = 0;
						uint32 TimerIndex = 0;
					};
					TArray<FCandidateEvent> CandidateEvents;

					TraceServices::ITimeline<TraceServices::FTimingProfilerEvent>::EnumerateAsyncParams Params;
					Params.IntervalStart = InStartTime;
					Params.IntervalEnd = InEndTime;
					Params.Resolution = 0.0;
					Params.SetupCallback =
						[&CandidateEvents](uint32 NumTasks)
						{
							CandidateEvents.AddDefaulted(NumTasks);
						};
					Params.EventRangeCallback =
						[InTimerId, &TimerReader, &CandidateEvents]
						(double StartTime, double EndTime, uint32 Depth, const TraceServices::FTimingProfilerEvent& Event, uint32 TaskIndex)
						{
							const TraceServices::FTimingProfilerTimer* Timer = TimerReader.GetTimer(Event.TimerIndex);
							if (ensure(Timer != nullptr))
							{
								if (Timer->Id == InTimerId)
								{
									double CandidateDuration = CandidateEvents[TaskIndex].EndTime - CandidateEvents[TaskIndex].StartTime;
									double EventDuration = EndTime - StartTime;

									if (EventDuration < CandidateDuration)
									{
										CandidateEvents[TaskIndex].StartTime = StartTime;
										CandidateEvents[TaskIndex].EndTime = EndTime;
										CandidateEvents[TaskIndex].Depth = Depth;
										CandidateEvents[TaskIndex].TimerIndex = Event.TimerIndex;
									}
								}
							}
							return TraceServices::EEventEnumerate::Continue;
						};

					// Note: Enumerating events for filtering should not use downsampling.
					Timeline.EnumerateEventsDownSampledAsync(Params);

					FCandidateEvent BestMatch;
					for (const FCandidateEvent& Event : CandidateEvents)
					{
						if ((Event.EndTime - Event.StartTime) < BestMatch.EndTime - BestMatch.StartTime)
						{
							BestMatch = Event;
						}
					}

					if (BestMatch.StartTime != -std::numeric_limits<double>::infinity())
					{
						TimingEvent = MakeShared<FThreadTrackEvent>(SharedThis(this), BestMatch.StartTime, BestMatch.EndTime, BestMatch.Depth);
						TimingEvent->SetTimerId(InTimerId);
						TimingEvent->SetTimerIndex(BestMatch.TimerIndex);
					}
				}
			); // ReadTimeline
		}
	); // ReadTimers

	return TimingEvent;
}

////////////////////////////////////////////////////////////////////////////////////////////////////

bool FThreadTimingTrackImpl::ReadTimers(TFunctionRef<void(const TraceServices::ITimingProfilerProvider&, const TraceServices::ITimingProfilerTimerReader&)> Callback) const
{
	TSharedPtr<const TraceServices::IAnalysisSession> Session = FInsightsManager::Get()->GetSession();
	if (Session.IsValid())
	{
		const TraceServices::ITimingProfilerProvider* TimingProfilerProvider = TraceServices::ReadTimingProfilerProvider(*Session.Get());
		if (TimingProfilerProvider)
		{
			TraceServices::FAnalysisSessionReadScope SessionReadScope(*Session.Get());
			TimingProfilerProvider->ReadTimers(
				[&Callback, TimingProfilerProvider]
				(const TraceServices::ITimingProfilerTimerReader& TimerReader)
				{
					Callback(*TimingProfilerProvider, TimerReader);
				});
			return true;
		}
	}
	return false;
}

////////////////////////////////////////////////////////////////////////////////////////////////////

bool FThreadTimingTrackImpl::ReadTimeline(TFunctionRef<void(const TraceServices::ITimingProfilerProvider::Timeline&)> Callback) const
{
	TSharedPtr<const TraceServices::IAnalysisSession> Session = FInsightsManager::Get()->GetSession();
	if (Session.IsValid())
	{
		const TraceServices::ITimingProfilerProvider* TimingProfilerProvider = TraceServices::ReadTimingProfilerProvider(*Session.Get());
		if (TimingProfilerProvider)
		{
			TraceServices::FAnalysisSessionReadScope SessionReadScope(*Session.Get());
			TimingProfilerProvider->ReadTimeline(GetTimelineIndex(),
				[&Callback]
				(const TraceServices::ITimingProfilerProvider::Timeline& Timeline)
				{
					Callback(Timeline);
				});
			return true;
		}
	}
	return false;
}

////////////////////////////////////////////////////////////////////////////////////////////////////

} // namespace UE::Insights::TimingProfiler

#undef LOCTEXT_NAMESPACE