//
// File: foldhaus_panel_profiler.h
// Author: Peter Slattery
// Creation Date: 2020-01-01
//
#ifndef FOLDHAUS_PANEL_PROFILER_H

input_command ProfilerView_Commands[] = {{}};
s32 ProfilerView_CommandsCount = 0;

GSMetaTag(panel_init);
GSMetaTag(panel_type_profiler);
internal void
ProfilerView_Init(panel* Panel, app_state* State, context Context)
{
    
}

GSMetaTag(panel_cleanup);
GSMetaTag(panel_type_profiler);
internal void
ProfilerView_Cleanup(panel* Panel, app_state* State)
{
    
}

internal void
RenderProfiler_ScopeVisualization(ui_interface* Interface, ui_widget* Layout, debug_frame* VisibleFrame, gs_memory_arena* Transient)
{
    rect2 Bounds = ui_LayoutRemaining(*Layout);
    r32 Width = Rect2Width(Bounds);
    r32 DepthHeight = 32;
    
    s64 FrameStartCycles = VisibleFrame->FrameStartCycles;
    r32 FrameTotalCycles = (r32)(VisibleFrame->FrameEndCycles - VisibleFrame->FrameStartCycles);
    
    r32 NextThreadTop = Bounds.Max.y;
    
    for (s32 t = 0; t < VisibleFrame->ThreadCount; t++)
    {
        debug_scope_record_list ThreadCalls = VisibleFrame->ThreadCalls[t];
        
        gs_string String = PushString(Transient, 256);
        
        r32 ThreadScopeMin = Bounds.Max.y;
        
        //PrintF(&String, "Thread %d", ThreadCalls.ThreadId);
        //ui_Label(Interface, String, rect2{ThreadScopeMin);
        
        r32 Hue = (r32)(t) / (r32)(VisibleFrame->ThreadCount);
        Hue += (.5f * (t % 2));
        v4 ThreadHSV = v4{ 360.0f * Hue, .5f, 1.0f, 1.0f };
        v4 ThreadRGB = HSVToRGB(ThreadHSV);
        
        for (s32 i = 0; i < ThreadCalls.Count; i++)
        {
            scope_record* Record = ThreadCalls.Calls + i;
            scope_name* Name = GetOrAddNameHashEntry(VisibleFrame, Record->NameHash);
            s64 OffsetStart = Record->StartCycles - FrameStartCycles;
            s64 OffsetEnd = Record->EndCycles - FrameStartCycles;
            r32 PercentStart = (r32)(OffsetStart) / FrameTotalCycles;
            r32 PercentEnd = (r32)(OffsetEnd) / FrameTotalCycles;
            r32 PercentWidth = PercentEnd - PercentStart;
            
            rect2 ScopeBounds = {
                v2{0, 0},
                v2{PercentWidth * Width, DepthHeight - 4},
            };
            v2 Offset = {
                Bounds.Min.x + (PercentStart * Width),
                NextThreadTop - ((Record->CallDepth + 1) * DepthHeight)
            };
            ScopeBounds = Rect2Translate(ScopeBounds, Offset);
            ThreadScopeMin = Min(ScopeBounds.Min.y, ThreadScopeMin);
            
            if (Rect2Width(ScopeBounds) >= 1)
            {
                v4 Color = ThreadRGB;
                if (PointIsInRect(ScopeBounds, Interface->Mouse.Pos))
                {
                    Color = GreenV4;
                    
                    ui_BeginMousePopup(Interface, rect2{ 25, 25, 300, 57 }, LayoutDirection_TopDown, MakeString("Hover"));
                    {
                        s64 Cycles = (Record->EndCycles - Record->StartCycles);
                        r32 PercentFrame = (r32)(Cycles) / FrameTotalCycles;
                        PrintF(&String, "%S : %.2f%% frame | %dcy",
                               Name->Name,
                               PercentFrame,
                               Cycles);
                        ui_Label(Interface, String);
                    }
                    ui_EndMousePopup(Interface);
                }
                
                ui_FillRect(Interface, ScopeBounds, Color);
                ui_OutlineRect(Interface, ScopeBounds, 1, BlackV4);
            }
        }
        
        NextThreadTop = ThreadScopeMin;
    }
}

internal void
RenderProfiler_ListVisualization(ui_interface* Interface, ui_widget* Layout, debug_frame* VisibleFrame, gs_memory_arena* Memory)
{
    char Backbuffer[256];
    gs_string String = MakeString(Backbuffer, 0, 256);
    
    ui_column_spec ColumnWidths[] = {
        { UIColumnSize_Fixed, 256 },
        { UIColumnSize_Fixed, 128 },
        { UIColumnSize_Fixed, 128 },
        { UIColumnSize_Fixed, 128 },
        { UIColumnSize_Fixed, 128 }};
    ui_BeginRow(Interface, 5, &ColumnWidths[0]);
    {
        ui_Label(Interface, MakeString("Procedure"));
        ui_Label(Interface, MakeString("% Frame"));
        ui_Label(Interface, MakeString("Seconds"));
        ui_Label(Interface, MakeString("Cycles"));
        ui_Label(Interface, MakeString("Calls"));
    }
    ui_EndRow(Interface);
    
    s32 CountedScopes = 0;
    for (s32 n = 0; n < VisibleFrame->ScopeNamesMax; n++)
    {
        scope_name NameEntry = VisibleFrame->ScopeNamesHash[n];
        if (NameEntry.Hash != 0)
        {
            CountedScopes += 1;
        }
    }
    
    ui_BeginList(Interface, MakeString("Scope List"), 10, CountedScopes);
    ui_BeginRow(Interface, 5, &ColumnWidths[0]);
    for (s32 n = 0; n < VisibleFrame->ScopeNamesMax; n++)
    {
        scope_name NameEntry = VisibleFrame->ScopeNamesHash[n];
        if (NameEntry.Hash != 0)
        {
            collated_scope_record* CollatedRecord = VisibleFrame->CollatedScopes + n;
            
            PrintF(&String, "%S", NameEntry.Name);
            ui_Label(Interface, String);
            
            PrintF(&String, "%f%%", CollatedRecord->PercentFrameTime);
            ui_Label(Interface, String);
            
            PrintF(&String, "%fs", CollatedRecord->TotalSeconds);
            ui_Label(Interface, String);
            
            PrintF(&String, "%dcy", CollatedRecord->TotalCycles);
            ui_Label(Interface, String);
            
            PrintF(&String, "%d", CollatedRecord->CallCount);
            ui_Label(Interface, String);
        }
    }
    ui_EndRow(Interface);
    ui_EndList(Interface);
}

struct mem_amt
{
    u64 OrigSize;
    r64 Size;
    char* Units;
};

internal mem_amt
GetMemAmt (u64 BytesCount)
{
    mem_amt Result = {};
    Result.OrigSize = BytesCount;
    Result.Size = (r64)BytesCount;
    Result.Units = "bytes";
    
    u32 i = 0;
    char* UnitList[] = { "kb", "mb", "gb", "tb" };
    while (Result.Size > 1024) {
        Result.Size /= 1024.0;
        Result.Units = UnitList[i++];
    }
    
    return Result;
}

internal void
RenderProfiler_MemoryView(ui_interface* Interface, ui_widget* Layout, app_state* State, context Context, gs_memory_arena* Memory)
{
    gs_allocator_debug Debug = *Context.ThreadContext.Allocator.Debug;
    gs_string TempString = PushString(State->Transient, 256);
    
    mem_amt MemFootprint = GetMemAmt(Debug.TotalAllocSize);
    u64 AllocCount = Debug.AllocationsCount;
    
    
    PrintF(&TempString, "Total Memory Size: %.2f %s | Allocations: %lld", MemFootprint.Size, MemFootprint.Units, AllocCount);
    ui_Label(Interface, TempString);
    
    ui_column_spec ColumnWidths[] = {
        { UIColumnSize_Fill, 0 },
        { UIColumnSize_Fixed,256 },
    };
    ui_BeginRow(Interface, 2, &ColumnWidths[0]);
    {
        ui_Label(Interface, MakeString("Location"));
        ui_Label(Interface, MakeString("Alloc Size"));
    }
    ui_EndRow(Interface);
    
    ui_BeginList(Interface, MakeString("Alloc List"), 10, Debug.AllocationsCount);
    ui_BeginRow(Interface, 2, &ColumnWidths[0]);
    for (s32 n = 0; n < Debug.AllocationsCount; n++)
    {
        gs_debug_allocation A = Debug.Allocations[n];
        
        PrintF(&TempString, "%S", A.Location);
        ui_Label(Interface, TempString);
        
        mem_amt Amt = GetMemAmt(A.Size);
        
        PrintF(&TempString, "%.2f %s", Amt.Size, Amt.Units);
        ui_Label(Interface, TempString);
    }
    ui_EndRow(Interface);
    ui_EndList(Interface);
}

GSMetaTag(panel_render);
GSMetaTag(panel_type_profiler);
internal void
ProfilerView_Render(panel* Panel, rect2 PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context)
{
    gs_memory_arena* Memory = State->Transient;
    gs_string String = PushString(Memory, 256);
    
    v4 FrameColors[] = { GreenV4, YellowV4, RedV4, WhiteV4 };
    
    r32 FrameListHeight = 64;
    rect2 FrameListBounds, ProcListBounds;
    RectHSplitAtDistanceFromTop(PanelBounds, FrameListHeight, &FrameListBounds, &ProcListBounds);
    rect2 FrameListInner = RectInset(FrameListBounds, 4);
    
    s32 FramesToDisplay = DEBUG_FRAME_COUNT;
    if (FramesToDisplay != 0)
    {
        r32 SingleFrameStep = Rect2Width(FrameListInner) / FramesToDisplay;
        r32 SingleFrameWidth = (r32)((s32)SingleFrameStep - 2);
        
        ui_OutlineRect(&State->Interface, FrameListBounds, 2, WhiteV4);
        if (MouseButtonHeldDown(Context.Mouse.LeftButtonState))
        {
            if (PointIsInRect(FrameListBounds, Context.Mouse.Pos))
            {
                v2 LocalMouse = Rect2GetRectLocalPoint(FrameListBounds, Context.Mouse.Pos);
                s32 ClosestFrameIndex = (LocalMouse.x / SingleFrameStep);
                if (ClosestFrameIndex >= 0 && ClosestFrameIndex < FramesToDisplay)
                {
                    GlobalDebugServices->RecordFrames = false;
                    GlobalDebugServices->CurrentDebugFrame = ClosestFrameIndex;
                }
            }
        }
        
        rect2 FrameBounds = MakeRect2MinDim(FrameListInner.Min, v2{SingleFrameWidth, Rect2Height(FrameListInner)});
        for (s32 F = 0; F < DEBUG_FRAME_COUNT; F++)
        {
            rect2 PositionedFrameBounds = Rect2TranslateX(FrameBounds, F * SingleFrameStep);
            s32 FramesAgo = (GlobalDebugServices->CurrentDebugFrame - F);
            if (FramesAgo < 0) { FramesAgo += DEBUG_FRAME_COUNT; }
            v4 Color = FrameColors[Clamp(0, FramesAgo, 3)];
            ui_FillRect(&State->Interface, PositionedFrameBounds, Color);
        }
    }
    
    ui_widget* Layout = ui_PushLayout(&State->Interface, ProcListBounds, LayoutDirection_TopDown, MakeString("Profiler Layout"));
    
    debug_frame* VisibleFrame = GetLastDebugFrame(GlobalDebugServices);
    if (VisibleFrame)
    {
        ui_BeginRow(&State->Interface, 4);
        {
            s64 FrameStartCycles = VisibleFrame->FrameStartCycles;
            s64 FrameTotalCycles = VisibleFrame->FrameEndCycles - VisibleFrame->FrameStartCycles;
            u32 CurrentDebugFrame = GlobalDebugServices->CurrentDebugFrame - 1;
            PrintF(&String, "Frame %d", CurrentDebugFrame);
            ui_Label(&State->Interface, String);
            
            PrintF(&String, "Total Cycles: %lld", FrameTotalCycles);
            ui_Label(&State->Interface, String);
            
            // NOTE(NAME): Skipping a space for aesthetic reasons, not functional, and could
            // be removed, or used for something else
            ui_ReserveBounds(&State->Interface, Layout, true);
            
            if (ui_Button(&State->Interface, MakeString("Resume Recording")))
            {
                GlobalDebugServices->RecordFrames = true;
            }
        }
        ui_EndRow(&State->Interface);
    }
    
    ui_BeginRow(&State->Interface, 8);
    {
        if (ui_Button(&State->Interface, MakeString("Profiler")))
        {
            GlobalDebugServices->Interface.FrameView = DebugUI_Profiler;
        }
        if (ui_Button(&State->Interface, MakeString("List View")))
        {
            GlobalDebugServices->Interface.FrameView = DebugUI_ScopeList;
        }
        if (ui_Button(&State->Interface, MakeString("Memory")))
        {
            GlobalDebugServices->Interface.FrameView = DebugUI_MemoryView;
        }
    }
    ui_EndRow(&State->Interface);
    
    switch (GlobalDebugServices->Interface.FrameView)
    {
        case DebugUI_Profiler:
        {
            if (VisibleFrame) 
            {
                RenderProfiler_ScopeVisualization(&State->Interface, Layout, VisibleFrame, Memory);
            }
        }break;
        
        case DebugUI_ScopeList:
        {
            if (VisibleFrame)
            {
                RenderProfiler_ListVisualization(&State->Interface, Layout, VisibleFrame, Memory);
            }
        }break;
        
        case DebugUI_MemoryView:
        {
            RenderProfiler_MemoryView(&State->Interface, Layout, State, Context, Memory);
        }break;
        
        InvalidDefaultCase;
    }
    
    ui_PopLayout(&State->Interface, MakeString("Profiler Layout"));
}


#define FOLDHAUS_PANEL_PROFILER_H
#endif // FOLDHAUS_PANEL_PROFILER_H