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

#include "SFrameTrack.h"

#include "Fonts/FontMeasure.h"
#include "Fonts/SlateFontInfo.h"
#include "Framework/Application/SlateApplication.h"
#include "Framework/MultiBox/MultiBoxBuilder.h"
#include "HAL/PlatformTime.h"
#include "Rendering/DrawElements.h"
#include "Styling/CoreStyle.h"
#include "TraceServices/AnalysisService.h"
#include "Widgets/Layout/SScrollBar.h"

// Insights
#include "Insights/Common/PaintUtils.h"
#include "Insights/Common/Stopwatch.h"
#include "Insights/Common/TimeUtils.h"
#include "Insights/InsightsManager.h"
#include "Insights/InsightsStyle.h"
#include "Insights/TimingProfilerCommon.h"
#include "Insights/TimingProfilerManager.h"
#include "Insights/ViewModels/FrameTrackHelper.h"
#include "Insights/Widgets/STimingProfilerWindow.h"
#include "Insights/Widgets/STimingView.h"

#include <limits>

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

#define LOCTEXT_NAMESPACE "SFrameTrack"

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

SFrameTrack::SFrameTrack()
{
    Reset();
}

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

SFrameTrack::~SFrameTrack()
{
}

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

void SFrameTrack::Reset()
{
    Viewport.Reset();
    FAxisViewportInt32& ViewportX = Viewport.GetHorizontalAxisViewport();
    ViewportX.SetScaleLimits(0.0001f, 16.0f);  // 10000 [sample/px] to 16 [px/sample]
    ViewportX.SetScale(16.0f);
    FAxisViewportDouble& ViewportY = Viewport.GetVerticalAxisViewport();
    ViewportY.SetScaleLimits(0.01, 1000000.0);
    ViewportY.SetScale(1500.0);
    bIsViewportDirty = true;

    SeriesMap.Reset();
    SeriesOrder.Reset();
    SeriesOrder.Add(TraceFrameType_Game);
    SeriesOrder.Add(TraceFrameType_Rendering);

    bIsStateDirty             = true;

    bShowGameFrames           = true;
    bShowRenderingFrames      = true;

    bIsAutoZoomEnabled        = true;
    AutoZoomViewportPos       = ViewportX.GetPos();
    AutoZoomViewportScale     = ViewportX.GetScale();
    AutoZoomViewportSize      = 0.0f;

    AnalysisSyncNextTimestamp = 0;

    MousePosition             = FVector2D::ZeroVector;

    MousePositionOnButtonDown = FVector2D::ZeroVector;
    ViewportPosXOnButtonDown  = 0.0f;

    MousePositionOnButtonUp   = FVector2D::ZeroVector;

    bIsLMB_Pressed            = false;
    bIsRMB_Pressed            = false;

    bIsScrolling              = false;

    HoveredSample.Reset();
    TooltipDesiredOpacity = 0.9f;
    TooltipOpacity        = 0.0f;

    // ThisGeometry

    CursorType       = ECursorType::Default;

    NumUpdatedFrames = 0;
    UpdateDurationHistory.Reset();
    DrawDurationHistory.Reset();
    OnPaintDurationHistory.Reset();
    LastOnPaintTime = FPlatformTime::Cycles64();
}

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

void SFrameTrack::Construct(const FArguments& InArgs)
{
    ChildSlot
        [SNew(SOverlay)
             .Visibility(EVisibility::SelfHitTestInvisible)

         + SOverlay::Slot()
               .VAlign(VAlign_Top)
               .Padding(FMargin(0, 0, 0, 0))
                   [SAssignNew(HorizontalScrollBar, SScrollBar)
                        .Orientation(Orient_Horizontal)
                        .AlwaysShowScrollbar(false)
                        .Visibility(EVisibility::Visible)
                        .Thickness(FVector2D(5.0f, 5.0f))
                        .RenderOpacity(0.75)
                        .OnUserScrolled(this, &SFrameTrack::HorizontalScrollBar_OnUserScrolled)]];

    UpdateHorizontalScrollBar();

    BindCommands();
}

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

void SFrameTrack::Tick(const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime)
{
    if (ThisGeometry != AllottedGeometry || bIsViewportDirty)
    {
        bIsViewportDirty       = false;
        const float ViewWidth  = AllottedGeometry.GetLocalSize().X;
        const float ViewHeight = AllottedGeometry.GetLocalSize().Y;
        Viewport.SetSize(ViewWidth, ViewHeight);
        bIsStateDirty = true;
    }

    ThisGeometry                  = AllottedGeometry;

    FAxisViewportInt32& ViewportX = Viewport.GetHorizontalAxisViewport();

    if (!bIsScrolling)
    {
        // Elastic snap to horizontal limits.
        if (ViewportX.UpdatePosWithinLimits())
        {
            bIsStateDirty = true;
        }
    }

    // Disable auto-zoom if viewport's position or scale has changed.
    if (AutoZoomViewportPos != ViewportX.GetPos() ||
        AutoZoomViewportScale != ViewportX.GetScale())
    {
        bIsAutoZoomEnabled = false;
    }

    // Update auto-zoom if viewport size has changed.
    bool bAutoZoom    = bIsAutoZoomEnabled && AutoZoomViewportSize != ViewportX.GetSize();

    const uint64 Time = FPlatformTime::Cycles64();
    if (Time > AnalysisSyncNextTimestamp)
    {
        const uint64 WaitTime                             = static_cast<uint64>(0.1 / FPlatformTime::GetSecondsPerCycle64());  // 100ms
        AnalysisSyncNextTimestamp                         = Time + WaitTime;

        TSharedPtr<const Trace::IAnalysisSession> Session = FInsightsManager::Get()->GetSession();
        if (Session.IsValid())
        {
            Trace::FAnalysisSessionReadScope SessionReadScope(*Session.Get());

            const Trace::IFrameProvider& FramesProvider = Trace::ReadFrameProvider(*Session.Get());

            for (int32 FrameType = 0; FrameType < TraceFrameType_Count; ++FrameType)
            {
                TSharedPtr<FFrameTrackSeries> SeriesPtr = FindOrAddSeries(FrameType);

                int32 NumFrames                         = FramesProvider.GetFrameCount(static_cast<ETraceFrameType>(FrameType));
                if (NumFrames > ViewportX.GetMaxValue())
                {
                    ViewportX.SetMinMaxInterval(0, NumFrames);
                    UpdateHorizontalScrollBar();
                    bIsStateDirty = true;

                    if (bIsAutoZoomEnabled)
                    {
                        bAutoZoom = true;
                    }
                }
            }
        }
    }

    if (bAutoZoom)
    {
        AutoZoom();
    }

    if (bIsStateDirty)
    {
        bIsStateDirty = false;
        UpdateState();
    }
}

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

TSharedRef<FFrameTrackSeries> SFrameTrack::FindOrAddSeries(int32 FrameType)
{
    TSharedPtr<FFrameTrackSeries>* SeriesPtrPtr = SeriesMap.Find(FrameType);
    if (SeriesPtrPtr)
    {
        ensure((**SeriesPtrPtr).FrameType == FrameType);
        return (*SeriesPtrPtr).ToSharedRef();
    }
    else
    {
        TSharedRef<FFrameTrackSeries> SeriesRef = MakeShared<FFrameTrackSeries>(FrameType);
        SeriesMap.Add(FrameType, SeriesRef);
        return SeriesRef;
    }
}

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

TSharedPtr<FFrameTrackSeries> SFrameTrack::FindSeries(int32 FrameType) const
{
    const TSharedPtr<FFrameTrackSeries>* SeriesPtrPtr = SeriesMap.Find(FrameType);
    if (SeriesPtrPtr)
    {
        ensure((**SeriesPtrPtr).FrameType == FrameType);
        return *SeriesPtrPtr;
    }
    else
    {
        return nullptr;
    }
}

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

void SFrameTrack::UpdateState()
{
    FStopwatch Stopwatch;
    Stopwatch.Start();

    // Reset stats.
    for (TPair<int32, TSharedPtr<FFrameTrackSeries>>& KeyValuePair: SeriesMap)
    {
        TSharedPtr<FFrameTrackSeries>& SeriesPtr = KeyValuePair.Value;
        SeriesPtr->NumAggregatedFrames           = 0;
    }
    NumUpdatedFrames                                  = 0;

    TSharedPtr<const Trace::IAnalysisSession> Session = FInsightsManager::Get()->GetSession();
    if (Session.IsValid())
    {
        Trace::FAnalysisSessionReadScope SessionReadScope(*Session.Get());

        const Trace::IFrameProvider& FramesProvider = Trace::ReadFrameProvider(*Session.Get());

        const FAxisViewportInt32& ViewportX         = Viewport.GetHorizontalAxisViewport();

        const uint64 StartIndex                     = static_cast<uint64>(FMath::Max(0, ViewportX.GetValueAtOffset(0.0f)));
        const uint64 EndIndex                       = static_cast<uint64>(ViewportX.GetValueAtOffset(ViewportX.GetSize()));

        for (int32 FrameType = 0; FrameType < TraceFrameType_Count; ++FrameType)
        {
            TSharedPtr<FFrameTrackSeries> SeriesPtr = FindOrAddSeries(FrameType);

            FFrameTrackSeriesBuilder Builder(*SeriesPtr, Viewport);

            FramesProvider.EnumerateFrames(static_cast<ETraceFrameType>(FrameType), StartIndex, EndIndex, [&Builder](const Trace::FFrame& Frame)
                                           {
                                               Builder.AddFrame(Frame);
                                           });

            NumUpdatedFrames += Builder.GetNumAddedFrames();
        }
    }

    Stopwatch.Stop();
    UpdateDurationHistory.AddValue(Stopwatch.AccumulatedTime);
}

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

FFrameTrackSampleRef SFrameTrack::GetSampleAtMousePosition(float X, float Y)
{
    if (!bIsStateDirty)
    {
        float SampleW     = Viewport.GetSampleWidth();
        int32 SampleIndex = FMath::FloorToInt(X / SampleW);
        if (SampleIndex >= 0)
        {
            // Search in reverse paint order.
            for (int32 SeriesIndex = SeriesOrder.Num() - 1; SeriesIndex >= 0; --SeriesIndex)
            {
                int32 FrameType = SeriesOrder[SeriesIndex];

                if ((FrameType == TraceFrameType_Rendering && !bShowRenderingFrames) ||
                    (FrameType == TraceFrameType_Game && !bShowGameFrames))
                {
                    continue;
                }

                const TSharedPtr<FFrameTrackSeries> SeriesPtr = FindSeries(FrameType);
                if (SeriesPtr.IsValid())
                {
                    if (SeriesPtr->NumAggregatedFrames > 0 &&
                        SampleIndex < SeriesPtr->Samples.Num())
                    {
                        const FFrameTrackSample& Sample = SeriesPtr->Samples[SampleIndex];
                        if (Sample.NumFrames > 0)
                        {
                            const FAxisViewportDouble& ViewportY = Viewport.GetVerticalAxisViewport();

                            const float ViewHeight               = FMath::RoundToFloat(Viewport.GetHeight());
                            const float BaselineY                = FMath::RoundToFloat(ViewportY.GetOffsetForValue(0.0));

                            float ValueY;
                            if (Sample.LargestFrameDuration == std::numeric_limits<double>::infinity())
                            {
                                ValueY = ViewHeight;
                            }
                            else
                            {
                                ValueY = FMath::RoundToFloat(ViewportY.GetOffsetForValue(Sample.LargestFrameDuration));
                            }

                            constexpr float ToleranceY = 3.0f;  // [pixels]

                            const float BottomY        = FMath::Min(ViewHeight, ViewHeight - BaselineY + ToleranceY);
                            const float TopY           = FMath::Max(0.0f, ViewHeight - ValueY - ToleranceY);

                            if (Y >= TopY && Y < BottomY)
                            {
                                return FFrameTrackSampleRef(SeriesPtr, MakeShared<FFrameTrackSample>(Sample));
                            }
                        }
                    }
                }
            }
        }
    }
    return FFrameTrackSampleRef(nullptr, nullptr);
}

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

void SFrameTrack::SelectFrameAtMousePosition(float X, float Y)
{
    FFrameTrackSampleRef SampleRef = GetSampleAtMousePosition(X, Y);
    if (!SampleRef.IsValid())
    {
        SampleRef = GetSampleAtMousePosition(X - 1.0f, Y);
    }
    if (!SampleRef.IsValid())
    {
        SampleRef = GetSampleAtMousePosition(X + 1.0f, Y);
    }

    if (SampleRef.IsValid())
    {
        TSharedPtr<STimingProfilerWindow> Window = FTimingProfilerManager::Get()->GetProfilerWindow();
        if (Window.IsValid())
        {
            TSharedPtr<STimingView> TimingView = Window->GetTimingView();
            if (TimingView.IsValid())
            {
                const double StartTime = SampleRef.Sample->LargestFrameStartTime;
                const double Duration  = SampleRef.Sample->LargestFrameDuration;
                TimingView->CenterOnTimeInterval(StartTime, Duration);
                TimingView->SelectTimeInterval(StartTime, Duration);
                FSlateApplication::Get().SetKeyboardFocus(TimingView);
            }
        }
    }
}

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

int32 SFrameTrack::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
    const bool bEnabled                = ShouldBeEnabled(bParentEnabled);
    const ESlateDrawEffect DrawEffects = bEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect;
    FDrawContext DrawContext(AllottedGeometry, MyCullingRect, InWidgetStyle, DrawEffects, OutDrawElements, LayerId);

    const TSharedRef<FSlateFontMeasure> FontMeasureService = FSlateApplication::Get().GetRenderer()->GetFontMeasureService();
    FSlateFontInfo SummaryFont                             = FCoreStyle::GetDefaultFontStyle("Regular", 8);

    const FSlateBrush* WhiteBrush                          = FInsightsStyle::Get().GetBrush("WhiteBrush");

    const float ViewWidth                                  = AllottedGeometry.Size.X;
    const float ViewHeight                                 = AllottedGeometry.Size.Y;

    int32 NumDrawSamples                                   = 0;

    //////////////////////////////////////////////////
    {
        FStopwatch Stopwatch;
        Stopwatch.Start();

        FFrameTrackDrawHelper Helper(DrawContext, Viewport);

        Helper.DrawBackground();

        // Draw the horizontal axis grid.
        DrawHorizontalAxisGrid(DrawContext, WhiteBrush, SummaryFont);

        // Draw frames, for each visible Series.
        for (int32 SeriesIndex = 0; SeriesIndex < SeriesOrder.Num(); ++SeriesIndex)
        {
            int32 FrameType = SeriesOrder[SeriesIndex];

            if ((FrameType == TraceFrameType_Rendering && !bShowRenderingFrames) ||
                (FrameType == TraceFrameType_Game && !bShowGameFrames))
            {
                continue;
            }

            const TSharedPtr<FFrameTrackSeries> SeriesPtr = FindSeries(FrameType);
            if (SeriesPtr.IsValid())
            {
                Helper.DrawCached(*SeriesPtr);
            }
        }

        NumDrawSamples = Helper.GetNumDrawSamples();

        // Highlight the mouse hovered sample (frame).
        if (HoveredSample.IsValid())
        {
            Helper.DrawHoveredSample(*HoveredSample.Sample);
        }

        // Draw the vertical axis grid.
        DrawVerticalAxisGrid(DrawContext, WhiteBrush, SummaryFont);

        // Draw tooltip for hovered sample (frame).
        if (HoveredSample.IsValid())
        {
            if (TooltipOpacity < TooltipDesiredOpacity)
            {
                TooltipOpacity = TooltipOpacity * 0.9f + TooltipDesiredOpacity * 0.1f;
            }
            else
            {
                TooltipOpacity = TooltipDesiredOpacity;
            }

            const FString Text                  = FString::Format(TEXT("{0} frame {1} ({2})"),
                                                                  {FFrameTrackDrawHelper::FrameTypeToString(HoveredSample.Series->FrameType),
                                                                   FText::AsNumber(HoveredSample.Sample->LargestFrameIndex).ToString(),
                                                                   TimeUtils::FormatTimeAuto(HoveredSample.Sample->LargestFrameDuration)});

            FVector2D TextSize                  = FontMeasureService->Measure(Text, SummaryFont);

            const float DX                      = 2.0f;
            const float W2                      = TextSize.X / 2 + DX;

            const FAxisViewportInt32& ViewportX = Viewport.GetHorizontalAxisViewport();

            float X1                            = ViewportX.GetOffsetForValue(HoveredSample.Sample->LargestFrameIndex);
            float CX                            = X1 + FMath::RoundToFloat(Viewport.GetSampleWidth() / 2);
            if (CX + W2 > ViewportX.GetSize())
            {
                CX = FMath::RoundToFloat(ViewportX.GetSize() - W2);
            }
            if (CX - W2 < 0)
            {
                CX = W2;
            }

            const float Y = 10.0f;
            const float H = 14.0f;
            DrawContext.DrawBox(CX - W2, Y, 2 * W2, H, WhiteBrush, FLinearColor(0.7, 0.7, 0.7, TooltipOpacity));
            DrawContext.LayerId++;
            DrawContext.DrawText(CX - W2 + DX, Y + 1.0f, Text, SummaryFont, FLinearColor(0.0, 0.0, 0.0, TooltipOpacity));
            DrawContext.LayerId++;
        }

        TSharedPtr<STimingProfilerWindow> Window = FTimingProfilerManager::Get()->GetProfilerWindow();
        if (Window)
        {
            TSharedPtr<STimingView> TimingView = Window->GetTimingView();
            if (TimingView)
            {
                TSharedPtr<FFrameTrackSeries> SeriesPtr = nullptr;
                for (const TPair<int32, TSharedPtr<FFrameTrackSeries>>& KeyValuePair: SeriesMap)
                {
                    SeriesPtr = KeyValuePair.Value;
                    break;  // stop at first enumerated Series
                }
                if (SeriesPtr.IsValid())
                {
                    // Highlight the area corresponding to viewport of Timing View.
                    const double StartTime = TimingView->GetViewport().GetStartTime();
                    const double EndTime   = TimingView->GetViewport().GetEndTime();
                    Helper.DrawHighlightedInterval(*SeriesPtr, StartTime, EndTime);
                }
            }
        }

        Stopwatch.Stop();
        DrawDurationHistory.AddValue(Stopwatch.AccumulatedTime);
    }
    //////////////////////////////////////////////////

    const bool bShouldDisplayDebugInfo = FInsightsManager::Get()->IsDebugInfoEnabled();
    if (bShouldDisplayDebugInfo)
    {
        const float MaxFontCharHeight = FontMeasureService->Measure(TEXT("!"), SummaryFont).Y;
        const float DbgDY             = MaxFontCharHeight;

        const float DbgW              = 280.0f;
        const float DbgH              = DbgDY * 4 + 3.0f;
        const float DbgX              = ViewWidth - DbgW - 20.0f;
        float DbgY                    = 7.0f;

        DrawContext.LayerId++;

        DrawContext.DrawBox(DbgX - 2.0f, DbgY - 2.0f, DbgW, DbgH, WhiteBrush, FLinearColor(1.0, 1.0, 1.0, 0.9));
        DrawContext.LayerId++;

        FLinearColor DbgTextColor(0.0, 0.0, 0.0, 0.9);

        // Time interval since last OnPaint call.
        const uint64 CurrentTime     = FPlatformTime::Cycles64();
        const uint64 OnPaintDuration = CurrentTime - LastOnPaintTime;
        LastOnPaintTime              = CurrentTime;
        OnPaintDurationHistory.AddValue(OnPaintDuration);  // saved for last 32 OnPaint calls
        const uint64 AvgOnPaintDuration   = OnPaintDurationHistory.ComputeAverage();
        const uint64 AvgOnPaintDurationMs = FStopwatch::Cycles64ToMilliseconds(AvgOnPaintDuration);
        const double AvgOnPaintFps        = AvgOnPaintDurationMs != 0 ? 1.0 / FStopwatch::Cycles64ToSeconds(AvgOnPaintDuration) : 0.0;

        const uint64 AvgUpdateDurationMs  = FStopwatch::Cycles64ToMilliseconds(UpdateDurationHistory.ComputeAverage());
        const uint64 AvgDrawDurationMs    = FStopwatch::Cycles64ToMilliseconds(DrawDurationHistory.ComputeAverage());

        // Draw performance info.
        DrawContext.DrawText(
            DbgX, DbgY,
            FString::Printf(TEXT("U: %llu ms, D: %llu ms + %llu ms = %llu ms (%d fps)"),
                            AvgUpdateDurationMs,                       // caching time
                            AvgDrawDurationMs,                         // drawing time
                            AvgOnPaintDurationMs - AvgDrawDurationMs,  // other overhead to OnPaint calls
                            AvgOnPaintDurationMs,                      // average time between two OnPaint calls
                            FMath::RoundToInt(AvgOnPaintFps)),         // framerate of OnPaint calls
            SummaryFont, DbgTextColor);
        DbgY += DbgDY;

        // Draw number of draw calls.
        DrawContext.DrawText(
            DbgX, DbgY,
            FString::Printf(TEXT("U: %s frames, D: %s samples"),
                            *FText::AsNumber(NumUpdatedFrames).ToString(),
                            *FText::AsNumber(NumDrawSamples).ToString()),
            SummaryFont, DbgTextColor);
        DbgY += DbgDY;

        // Draw viewport's horizontal info.
        DrawContext.DrawText(
            DbgX, DbgY,
            Viewport.GetHorizontalAxisViewport().ToDebugString(TEXT("X"), TEXT("frame")),
            SummaryFont, DbgTextColor);
        DbgY += DbgDY;

        // Draw viewport's vertical info.
        DrawContext.DrawText(
            DbgX, DbgY,
            Viewport.GetVerticalAxisViewport().ToDebugString(TEXT("Y")),
            SummaryFont, DbgTextColor);
        DbgY += DbgDY;
    }

    return SCompoundWidget::OnPaint(Args, AllottedGeometry, MyCullingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled && IsEnabled());
}

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

void SFrameTrack::DrawVerticalAxisGrid(FDrawContext& DrawContext, const FSlateBrush* Brush, const FSlateFontInfo& Font) const
{
    const float ViewWidth                = Viewport.GetWidth();

    const FAxisViewportDouble& ViewportY = Viewport.GetVerticalAxisViewport();
    const float RoundedViewHeight        = FMath::RoundToFloat(ViewportY.GetSize());

    constexpr float TextH                = 14.0f;
    constexpr float MinDY                = 12.0f;  // min vertical distance between horizontal grid lines

    const FLinearColor GridColor(0.0f, 0.0f, 0.0f, 0.1f);
    const FLinearColor TextBgColor(0.05f, 0.05f, 0.05f, 1.0f);
    // const FLinearColor TextColor(1.0f, 1.0f, 1.0f, 1.0f);

    const TSharedRef<FSlateFontMeasure> FontMeasureService = FSlateApplication::Get().GetRenderer()->GetFontMeasureService();

    const double GridValues[] =
        {
            0.0,
            1.0 / 200.0,  //    5 ms (200 fps)
            1.0 / 120.0,  //  8.3 ms (120 fps)
            1.0 / 90.0,   // 11.1 ms (90 fps)
            1.0 / 72.0,   // 13.9 ms (72 fps)
            1.0 / 60.0,   // 16.7 ms (60 fps)
            1.0 / 30.0,   // 33.3 ms (30 fps)
            1.0 / 20.0,   //   50 ms (20 fps)
            1.0 / 15.0,   // 66.7 ms (15 fps)
            1.0 / 10.0,   //  100 ms (10 fps)
            1.0 / 5.0,    //  200 ms (5 fps)
            1.0,          // 1s
            10.0,         // 10s
            60.0,         // 1m
            600.0,        // 10m
            3600.0        // 1h
        };
    constexpr int32 NumGridValues = sizeof(GridValues) / sizeof(double);

    double PreviousY              = -MinDY;

    for (int32 Index = 0; Index < NumGridValues; ++Index)
    {
        const double Value         = GridValues[Index];

        constexpr double Time60fps = 1.0 / 60.0;
        constexpr double Time30fps = 1.0 / 30.0;

        FLinearColor TextColor;
        if (Value <= Time60fps)
        {
            TextColor = FLinearColor(0.5f, 1.0f, 0.5f, 1.0f);
        }
        else if (Value <= Time30fps)
        {
            TextColor = FLinearColor(1.0f, 1.0f, 0.5f, 1.0f);
            // const float U = (Value - Time60fps) * 0.5 / (Time30fps - Time60fps);
            // TextColor = FLinearColor(0.5f + U, 1.0f - U, 0.5f, 1.0f);
        }
        else
        {
            TextColor = FLinearColor(1.0f, 0.5f, 0.5f, 1.0f);
        }

        const float Y = RoundedViewHeight - FMath::RoundToFloat(ViewportY.GetOffsetForValue(Value));
        if (Y < 0)
        {
            break;
        }
        if (Y > RoundedViewHeight + TextH || FMath::Abs(PreviousY - Y) < MinDY)
        {
            continue;
        }
        PreviousY = Y;

        // Draw horizontal grid line.
        DrawContext.DrawBox(0, Y, ViewWidth, 1, Brush, GridColor);

        const FString LabelText       = (Value == 0.0) ? TEXT("0") :
                                        (Value <= 1.0) ? FString::Printf(TEXT("%s (%.0f fps)"), *TimeUtils::FormatTimeAuto(Value), 1.0 / Value) :
                                                         TimeUtils::FormatTimeAuto(Value);
        const FVector2D LabelTextSize = FontMeasureService->Measure(LabelText, Font);
        float LabelX                  = ViewWidth - LabelTextSize.X - 4.0f;
        float LabelY                  = FMath::Clamp(Y - TextH / 2, 0.0f, RoundedViewHeight - TextH);

        // Draw background for value text.
        DrawContext.DrawBox(LabelX, LabelY, LabelTextSize.X + 4.0f, TextH, Brush, TextBgColor);

        // Draw value text.
        DrawContext.DrawText(LabelX + 2.0f, LabelY + 1.0f, LabelText, Font, TextColor);
    }
    DrawContext.LayerId++;
}

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

void SFrameTrack::DrawHorizontalAxisGrid(FDrawContext& DrawContext, const FSlateBrush* Brush, const FSlateFontInfo& Font) const
{
    const FAxisViewportInt32& ViewportX = Viewport.GetHorizontalAxisViewport();

    const float RoundedViewWidth        = FMath::RoundToFloat(ViewportX.GetSize());

    constexpr float MinDX               = 125.0f;  // min horizontal distance between vertical grid lines

    const int32 LeftIndex               = ViewportX.GetValueAtOffset(0.0f);
    const int32 GridIndex               = ViewportX.GetValueAtOffset(MinDX);
    const int32 RightIndex              = ViewportX.GetValueAtOffset(RoundedViewWidth);
    const int32 Delta                   = GridIndex - LeftIndex;

    if (Delta > 0)
    {
        // Compute rounding based on magnitude of visible range of samples (Delta).
        int32 Power10 = 1;
        int32 Delta10 = Delta;
        while (Delta10 > 0)
        {
            Delta10 /= 10;
            Power10 *= 10;
        }
        if (Power10 >= 100)
        {
            Power10 /= 100;
        }
        else
        {
            Power10 = 1;
        }

        const int32 Grid = ((Delta + Power10 - 1) / Power10) * Power10;  // next value divisible with a multiple of 10

        // Skip grid lines for negative indices.
        double StartIndex = ((LeftIndex + Grid - 1) / Grid) * Grid;
        while (StartIndex < 0)
        {
            StartIndex += Grid;
        }

        const float ViewHeight = Viewport.GetHeight();

        const FLinearColor GridColor(0.0f, 0.0f, 0.0f, 0.1f);
        const FLinearColor TopTextColor(1.0f, 1.0f, 1.0f, 0.7f);

        for (int32 Index = StartIndex; Index < RightIndex; Index += Grid)
        {
            const float X = FMath::RoundToFloat(ViewportX.GetOffsetForValue(Index));

            // Draw vertical grid line.
            DrawContext.DrawBox(X, 0, 1, ViewHeight, Brush, GridColor);

            // Draw label.
            const FString LabelText = FText::AsNumber(Index).ToString();
            DrawContext.DrawText(X + 2.0f, 10.0f, LabelText, Font, TopTextColor);
        }
        DrawContext.LayerId++;
    }
}

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

FReply SFrameTrack::OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
    FReply Reply              = FReply::Unhandled();

    MousePositionOnButtonDown = MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition());
    ViewportPosXOnButtonDown  = Viewport.GetHorizontalAxisViewport().GetPos();

    if (MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton)
    {
        bIsLMB_Pressed = true;

        // Capture mouse.
        Reply = FReply::Handled().CaptureMouse(SharedThis(this));
    }
    else if (MouseEvent.GetEffectingButton() == EKeys::RightMouseButton)
    {
        bIsRMB_Pressed = true;

        // Capture mouse, so we can scroll outside this widget.
        Reply = FReply::Handled().CaptureMouse(SharedThis(this));
    }

    return Reply;
}

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

FReply SFrameTrack::OnMouseButtonUp(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
    FReply Reply                     = FReply::Unhandled();

    MousePositionOnButtonUp          = MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition());

    const bool bIsValidForMouseClick = MousePositionOnButtonUp.Equals(MousePositionOnButtonDown, MOUSE_SNAP_DISTANCE);

    if (MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton)
    {
        if (bIsLMB_Pressed)
        {
            if (bIsScrolling)
            {
                bIsScrolling = false;
                CursorType   = ECursorType::Default;
            }
            else if (bIsValidForMouseClick)
            {
                SelectFrameAtMousePosition(MousePositionOnButtonUp.X, MousePositionOnButtonUp.Y);
            }

            bIsLMB_Pressed = false;

            // Release the mouse.
            Reply = FReply::Handled().ReleaseMouseCapture();
        }
    }
    else if (MouseEvent.GetEffectingButton() == EKeys::RightMouseButton)
    {
        if (bIsRMB_Pressed)
        {
            if (bIsScrolling)
            {
                bIsScrolling = false;
                CursorType   = ECursorType::Default;
            }
            else if (bIsValidForMouseClick)
            {
                ShowContextMenu(MouseEvent);
            }

            bIsRMB_Pressed = false;

            // Release mouse as we no longer scroll.
            Reply = FReply::Handled().ReleaseMouseCapture();
        }
    }

    return Reply;
}

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

FReply SFrameTrack::OnMouseMove(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
    FReply Reply  = FReply::Unhandled();

    MousePosition = MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition());

    if (!MouseEvent.GetCursorDelta().IsZero())
    {
        if (MouseEvent.IsMouseButtonDown(EKeys::LeftMouseButton) ||
            MouseEvent.IsMouseButtonDown(EKeys::RightMouseButton))
        {
            if (HasMouseCapture())
            {
                if (!bIsScrolling)
                {
                    bIsScrolling = true;
                    CursorType   = ECursorType::Hand;

                    HoveredSample.Reset();
                }

                FAxisViewportInt32& ViewportX = Viewport.GetHorizontalAxisViewport();
                const float PosX              = ViewportPosXOnButtonDown + (MousePositionOnButtonDown.X - MousePosition.X);
                ViewportX.ScrollAtValue(ViewportX.GetValueAtPos(PosX));  // align viewport position with sample (frame index)
                UpdateHorizontalScrollBar();
                bIsStateDirty = true;
            }
        }
        else
        {
            if (!HoveredSample.IsValid())
            {
                TooltipOpacity = 0.0f;
            }
            HoveredSample = GetSampleAtMousePosition(MousePosition.X, MousePosition.Y);
            if (!HoveredSample.IsValid())
            {
                HoveredSample = GetSampleAtMousePosition(MousePosition.X - 1.0f, MousePosition.Y);
            }
            if (!HoveredSample.IsValid())
            {
                HoveredSample = GetSampleAtMousePosition(MousePosition.X + 1.0f, MousePosition.Y);
            }
        }

        Reply = FReply::Handled();
    }

    return Reply;
}

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

void SFrameTrack::OnMouseEnter(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
}

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

void SFrameTrack::OnMouseLeave(const FPointerEvent& MouseEvent)
{
    if (!HasMouseCapture())
    {
        bIsLMB_Pressed = false;
        bIsRMB_Pressed = false;

        HoveredSample.Reset();

        CursorType = ECursorType::Default;
    }
}

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

FReply SFrameTrack::OnMouseWheel(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
    MousePosition = MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition());

    if (MouseEvent.GetModifierKeys().IsShiftDown())
    {
        FAxisViewportDouble& ViewportY = Viewport.GetVerticalAxisViewport();

        // Zoom in/out vertically.
        const float Delta        = MouseEvent.GetWheelDelta();
        constexpr float ZoomStep = 0.25f;  // as percent
        float ScaleY;

        if (Delta > 0)
        {
            ScaleY = ViewportY.GetScale() * FMath::Pow(1.0f + ZoomStep, Delta);
        }
        else
        {
            ScaleY = ViewportY.GetScale() * FMath::Pow(1.0f / (1.0f + ZoomStep), -Delta);
        }

        ViewportY.SetScale(ScaleY);
        // UpdateVerticalScrollBar();
    }
    else  // if (MouseEvent.GetModifierKeys().IsControlDown())
    {
        // Zoom in/out horizontally.
        const float Delta = MouseEvent.GetWheelDelta();
        ZoomHorizontally(Delta, MousePosition.X);
    }

    return FReply::Handled();
}

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

void SFrameTrack::ZoomHorizontally(const float Delta, const float X)
{
    FAxisViewportInt32& ViewportX = Viewport.GetHorizontalAxisViewport();
    ViewportX.RelativeZoomWithFixedOffset(Delta, X);
    ViewportX.ScrollAtValue(ViewportX.GetValueAtPos(ViewportX.GetPos()));  // align viewport position with sample (frame index)
    UpdateHorizontalScrollBar();
    bIsStateDirty = true;
}

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

FReply SFrameTrack::OnMouseButtonDoubleClick(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
    return FReply::Unhandled();
}

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

FCursorReply SFrameTrack::OnCursorQuery(const FGeometry& MyGeometry, const FPointerEvent& CursorEvent) const
{
    FCursorReply CursorReply = FCursorReply::Unhandled();

    if (CursorType == ECursorType::Arrow)
    {
        CursorReply = FCursorReply::Cursor(EMouseCursor::ResizeLeftRight);
    }
    else if (CursorType == ECursorType::Hand)
    {
        CursorReply = FCursorReply::Cursor(EMouseCursor::GrabHand);
    }

    return CursorReply;
}

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

void SFrameTrack::ShowContextMenu(const FPointerEvent& MouseEvent)
{
    const bool bShouldCloseWindowAfterMenuSelection = true;
    FMenuBuilder MenuBuilder(bShouldCloseWindowAfterMenuSelection, NULL);

    MenuBuilder.BeginSection("Series", LOCTEXT("ContextMenu_Header_Series", "Series"));
    {
        struct FLocal
        {
            static bool ReturnFalse()
            {
                return false;
            }
        };

        FUIAction Action_ShowGameFrames(
            FExecuteAction::CreateSP(this, &SFrameTrack::ContextMenu_ShowGameFrames_Execute),
            FCanExecuteAction::CreateSP(this, &SFrameTrack::ContextMenu_ShowGameFrames_CanExecute),
            FIsActionChecked::CreateSP(this, &SFrameTrack::ContextMenu_ShowGameFrames_IsChecked));
        MenuBuilder.AddMenuEntry(
            LOCTEXT("ContextMenu_ShowGameFrames", "Game Frames"),
            LOCTEXT("ContextMenu_ShowGameFrames_Desc", "Show/hide the Game frames"),
            FSlateIcon(),
            Action_ShowGameFrames,
            NAME_None,
            EUserInterfaceActionType::ToggleButton);

        FUIAction Action_ShowRenderingFrames(
            FExecuteAction::CreateSP(this, &SFrameTrack::ContextMenu_ShowRenderingFrames_Execute),
            FCanExecuteAction::CreateSP(this, &SFrameTrack::ContextMenu_ShowRenderingFrames_CanExecute),
            FIsActionChecked::CreateSP(this, &SFrameTrack::ContextMenu_ShowRenderingFrames_IsChecked));
        MenuBuilder.AddMenuEntry(
            LOCTEXT("ContextMenu_ShowRenderingFrames", "Rendering Frames"),
            LOCTEXT("ContextMenu_ShowRenderingFrames_Desc", "Show/hide the Rendering frames"),
            FSlateIcon(),
            Action_ShowRenderingFrames,
            NAME_None,
            EUserInterfaceActionType::ToggleButton);
    }
    MenuBuilder.EndSection();

    MenuBuilder.BeginSection("Misc");
    {
        FUIAction Action_AutoZoom(
            FExecuteAction::CreateSP(this, &SFrameTrack::ContextMenu_AutoZoom_Execute),
            FCanExecuteAction::CreateSP(this, &SFrameTrack::ContextMenu_AutoZoom_CanExecute),
            FIsActionChecked::CreateSP(this, &SFrameTrack::ContextMenu_AutoZoom_IsChecked));
        MenuBuilder.AddMenuEntry(
            LOCTEXT("ContextMenu_AutoZoom", "Auto Zoom"),
            LOCTEXT("ContextMenu_AutoZoom_Desc", "Enable auto zoom. Makes entire session time range to fit into view."),
            FSlateIcon(),
            Action_AutoZoom,
            NAME_None,
            EUserInterfaceActionType::ToggleButton);
    }
    MenuBuilder.EndSection();

    TSharedRef<SWidget> MenuWidget      = MenuBuilder.MakeWidget();

    FWidgetPath EventPath               = MouseEvent.GetEventPath() != nullptr ? *MouseEvent.GetEventPath() : FWidgetPath();
    const FVector2D ScreenSpacePosition = MouseEvent.GetScreenSpacePosition();
    FSlateApplication::Get().PushMenu(SharedThis(this), EventPath, MenuWidget, ScreenSpacePosition, FPopupTransitionEffect::ContextMenu);
}

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

void SFrameTrack::ContextMenu_ShowGameFrames_Execute()
{
    bShowGameFrames = !bShowGameFrames;
}

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

bool SFrameTrack::ContextMenu_ShowGameFrames_CanExecute()
{
    return true;
}

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

bool SFrameTrack::ContextMenu_ShowGameFrames_IsChecked()
{
    return bShowGameFrames;
}

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

void SFrameTrack::ContextMenu_ShowRenderingFrames_Execute()
{
    bShowRenderingFrames = !bShowRenderingFrames;
}

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

bool SFrameTrack::ContextMenu_ShowRenderingFrames_CanExecute()
{
    return true;
}

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

bool SFrameTrack::ContextMenu_ShowRenderingFrames_IsChecked()
{
    return bShowRenderingFrames;
}

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

void SFrameTrack::ContextMenu_AutoZoom_Execute()
{
    bIsAutoZoomEnabled = !bIsAutoZoomEnabled;

    if (bIsAutoZoomEnabled)
    {
        AutoZoom();
    }
}

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

bool SFrameTrack::ContextMenu_AutoZoom_CanExecute()
{
    return true;
}

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

bool SFrameTrack::ContextMenu_AutoZoom_IsChecked()
{
    return bIsAutoZoomEnabled;
}

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

void SFrameTrack::AutoZoom()
{
    FAxisViewportInt32& ViewportX = Viewport.GetHorizontalAxisViewport();

    AutoZoomViewportPos           = ViewportX.GetMinPos();
    ViewportX.ScrollAtPos(AutoZoomViewportPos);

    AutoZoomViewportSize = ViewportX.GetSize();

    if (AutoZoomViewportSize > 0.0f &&
        ViewportX.GetMaxValue() - ViewportX.GetMinValue() > 0)
    {
        float DX = ViewportX.GetMaxPos() - ViewportX.GetMinPos();

        // Auto zoom in.
        while (DX < AutoZoomViewportSize)
        {
            const float OldScale = ViewportX.GetScale();
            ViewportX.RelativeZoomWithFixedOffset(+0.1f, 0.0f);
            ViewportX.ScrollAtPos(AutoZoomViewportPos);
            DX = ViewportX.GetMaxPos() - ViewportX.GetMinPos();
            if (OldScale == ViewportX.GetScale())
            {
                break;
            }
        }

        // Auto zoom out (until entire session frame range fits into view).
        while (DX > AutoZoomViewportSize)
        {
            const float OldScale = ViewportX.GetScale();
            ViewportX.RelativeZoomWithFixedOffset(-0.1f, 0.0f);
            ViewportX.ScrollAtPos(AutoZoomViewportPos);
            DX = ViewportX.GetMaxPos() - ViewportX.GetMinPos();
            if (OldScale == ViewportX.GetScale())
            {
                break;
            }
        }
    }

    AutoZoomViewportScale = ViewportX.GetScale();

    UpdateHorizontalScrollBar();
    bIsStateDirty = true;
}

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

void SFrameTrack::BindCommands()
{
}

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

void SFrameTrack::HorizontalScrollBar_OnUserScrolled(float ScrollOffset)
{
    Viewport.GetHorizontalAxisViewport().OnUserScrolled(HorizontalScrollBar, ScrollOffset);
    bIsStateDirty = true;
}

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

void SFrameTrack::UpdateHorizontalScrollBar()
{
    Viewport.GetHorizontalAxisViewport().UpdateScrollBar(HorizontalScrollBar);
}

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

#undef LOCTEXT_NAMESPACE