// Commander X16 Emulator — in-process Dear ImGui debugger implementation.

//

// Owns the ImGui context and the SDL2 + SDLRenderer2 backends. Each

// builds a full-window dock space and iterates the self-registered panel

// registry (debug_ui_panels.h), so panels are added purely by dropping a file

// under panels/.

#include "debug_ui.h"

#include "debug_ui_panels.h"

#include "debug_ui_bridge.h" // regs + execution-control (DEBUGContinue/…/DEBUGIsRunning)

#include "debug_ui_settings.h" // user preferences (System → Settings...)

#include "imgui.h"

#include "imgui_internal.h"   // DockBuilder* for the first-run default layout

#include "backends/imgui_impl_sdl2.h"

#include "backends/imgui_impl_sdlrenderer2.h"

#include <cstdarg>

#include <cstdio>

#include <cstring>

static SDL_Window   *s_window      = nullptr;

static SDL_Renderer *s_renderer    = nullptr;

static bool          s_initialized = false;

static bool          s_enabled     = false;

static bool          s_build_default_layout = false; // install a dock layout on first run

static bool          s_show_demo    = false;         // Help → ImGui Demo (vendored imgui_demo.cpp)

static bool          s_show_settings = false;        // System → Settings...

static void debug_ui_latch_goto(void); // defined below; called from debug_ui_render

static void debug_ui_follow_stop_location(void); // ditto

// ── Font ladder for per-window zoom ─────────────────────────────────────────

// ImGui's default font is rasterised once at a single size; scaling it (which

// SetWindowFontScale does) resamples the glyph bitmaps and looks awful. Build a

// ladder of real sizes instead, and have the zoom helper choose the nearest, so

// zoomed text is always rendered at its native size.

//

// The face matters as much as the size. ImGui's built-in ProggyClean is a

// pixel font: its outlines are drawn to land exactly on the pixel grid at 13px,

// where every stem is a solid, fully-opaque column. Rasterised at any other

// size the stems straddle pixel boundaries and get antialiased across two

// columns, so the text goes both soft AND dim - no pixel reaches full

// intensity. That is why zooming still looked washed out even once the

// resampling was gone.

//

// So prefer a genuinely scalable monospace face from the system, which is

// hinted to stay crisp at any size, and keep ProggyClean only as a fallback (in

// which case 100% still looks exactly as it always did).

static const char *s_mono_font_candidates[] = {

#if defined(_WIN32)

    "C:\\Windows\\Fonts\\consola.ttf",      // Consolas

    "C:\\Windows\\Fonts\\CascadiaMono.ttf",

    "C:\\Windows\\Fonts\\lucon.ttf",        // Lucida Console

#elif defined(__APPLE__)

    "/System/Library/Fonts/Menlo.ttc",

    "/System/Library/Fonts/Monaco.ttf",

#else

    "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf",

    "/usr/share/fonts/truetype/liberation/LiberationMono-Regular.ttf",

    "/usr/share/fonts/TTF/DejaVuSansMono.ttf",

#endif

};

// The base entry must be first so it stays the default font for anything that

// doesn't opt into zooming.

static const float s_font_sizes[] = {

    13.0f, // base

    9.0f, 10.0f, 11.0f, 12.0f, 14.0f, 15.0f, 16.0f, 18.0f,

    20.0f, 22.0f, 24.0f, 27.0f, 30.0f, 34.0f, 39.0f,

};

static ImFont *s_fonts[IM_ARRAYSIZE(s_font_sizes)] = {};

static bool    s_scalable_font = false;

static const char *

debug_ui_find_mono_font(void)

{

    for (int i = 0; i < IM_ARRAYSIZE(s_mono_font_candidates); i++) {

        if (FILE *f = fopen(s_mono_font_candidates[i], "rb")) {

            fclose(f);

            return s_mono_font_candidates[i];

        }

    }

    return nullptr;

}

static void

debug_ui_build_fonts(ImGuiIO &io)

{

    const char *path = debug_ui_find_mono_font();

    s_scalable_font  = (path != nullptr);

    for (int i = 0; i < IM_ARRAYSIZE(s_font_sizes); i++) {

        if (s_scalable_font) {

            ImFontConfig cfg;

            // Oversample horizontally so stems land cleanly; a real outline

            // font stays sharp when it is hinted onto the pixel grid.

            cfg.OversampleH = 2;

            cfg.OversampleV = 1;

            cfg.PixelSnapH  = false;

            s_fonts[i] = io.Fonts->AddFontFromFileTTF(path, s_font_sizes[i], &cfg);

        }

        if (!s_fonts[i]) {

            // Fallback: ImGui's built-in. Pixel-snapped, since ProggyClean is a

            // pixel font and snapping is the best it can do off its native size.

            ImFontConfig cfg;

            cfg.SizePixels = s_font_sizes[i];

            cfg.PixelSnapH = true;

            s_fonts[i]     = io.Fonts->AddFontDefault(&cfg);

            if (i == 0) {

                s_scalable_font = false;

            }

        }

    }

}

// Nearest built font to `size_px`, plus the size it actually is. Used by the

// zoom helper; returns nullptr before fonts are built.

ImFont *

debug_ui_font_for_size(float size_px, float *out_size)

{

    int   best  = 0;

    float bestd = 1e9f;

    for (int i = 0; i < IM_ARRAYSIZE(s_font_sizes); i++) {

        const float d = s_font_sizes[i] > size_px ? s_font_sizes[i] - size_px

                                                  : size_px - s_font_sizes[i];

        if (d < bestd) {

            bestd = d;

            best  = i;

        }

    }

    if (out_size) {

        *out_size = s_font_sizes[best];

    }

    return s_fonts[best];

}

float

debug_ui_font_base_size(void)

{

    // Per-window zoom stacks on top of the global interface scale, so the base

    // it multiplies is the already-scaled size.

    return s_font_sizes[0] * debug_ui_settings().ui_scale;

}

// ── Global interface scale ──────────────────────────────────────────────────

// Per-window zoom only affects a panel's contents; the menu bar, tab bars,

// buttons and all the spacing around them come from the style and the default

// font, so they stayed put no matter how far a panel was zoomed. Applying the

// scale to both makes the whole debugger grow together.

//

// The style is scaled from a pristine copy each time rather than repeatedly, so

// the metrics never drift, and the font is re-selected from the ladder rather

// than stretched, so it stays sharp.

static ImGuiStyle s_style_base;

static bool       s_style_base_valid = false;

static float      s_applied_ui_scale = -1.0f;

static void

debug_ui_apply_ui_scale(void)

{

    if (!s_style_base_valid) {

        return;

    }

    float want = debug_ui_settings().ui_scale;

    if (want < 0.5f) want = 0.5f;

    if (want > 4.0f) want = 4.0f;

    if (want == s_applied_ui_scale) {

        return;

    }

    s_applied_ui_scale = want;

    ImGuiStyle &style = ImGui::GetStyle();

    style             = s_style_base;   // undo any previous scaling

    style.ScaleAllSizes(want);

    // Default font for everything that doesn't opt into per-window zoom: the

    // menu bar, tab bars, popups and every panel that just uses the default.

    ImGui::GetIO().FontDefault = debug_ui_font_for_size(s_font_sizes[0] * want, nullptr);

}

extern "C" void

debug_ui_init(SDL_Window *win, SDL_Renderer *ren)

{

    if (s_initialized) {

        return;

    }

    s_window   = win;

    s_renderer = ren;

    IMGUI_CHECKVERSION();

    ImGui::CreateContext();

    ImGuiIO &io = ImGui::GetIO();

    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;      // dockable panels

    io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;  // keyboard nav

    // Our own imgui.ini section for user preferences. Must be installed before

    // ImGui loads the ini (i.e. before the first NewFrame) or the saved values

    // are discarded as unknown.

    debug_ui_settings_register();

    // Fonts for per-window zoom.

    //

    // SetWindowFontScale() stretches the glyph bitmaps that were rasterised at

    // one size, which is why zoomed text used to smear. Instead, rasterise the

    // font at a ladder of real sizes up front and let the zoom helper pick the

    // nearest one, so every zoom level is drawn at its native resolution.

    // Snapping to these sizes means there is never any resampling.

    debug_ui_build_fonts(io);

    ImGui::StyleColorsDark();

    // Tabs: the stock dark theme distinguishes selected from unselected tabs

    // only by a blue vs. slightly-lighter-blue fill, which is hard to read at a

    // glance — especially with several source-file tabs open. Give the selected

    // tab a much brighter, warmer fill with a bold accent overline, and push the

    // unselected tabs down to a dark neutral grey so the contrast is obvious.

    // Set on the style (not per-panel) so EVERY tab bar in the debugger matches.

    {

        ImGuiStyle &st = ImGui::GetStyle();

        const ImVec4 sel      (0.16f, 0.48f, 0.88f, 1.00f); // selected, focused

        const ImVec4 selDim   (0.17f, 0.42f, 0.72f, 1.00f); // selected, unfocused bar

        const ImVec4 idle     (0.16f, 0.17f, 0.19f, 1.00f); // unselected

        const ImVec4 idleDim  (0.12f, 0.13f, 0.14f, 1.00f); // unselected, unfocused bar

        const ImVec4 hover    (0.30f, 0.58f, 0.95f, 1.00f);

        const ImVec4 overline (1.00f, 0.72f, 0.25f, 1.00f); // amber accent bar

        st.Colors[ImGuiCol_Tab]                        = idle;

        st.Colors[ImGuiCol_TabHovered]                 = hover;

        st.Colors[ImGuiCol_TabSelected]                = sel;

        st.Colors[ImGuiCol_TabSelectedOverline]        = overline;

        st.Colors[ImGuiCol_TabDimmed]                  = idleDim;

        st.Colors[ImGuiCol_TabDimmedSelected]          = selDim;

        st.Colors[ImGuiCol_TabDimmedSelectedOverline]  = overline;

        st.TabBarOverlineSize = 3.0f;  // thicker accent bar on the selected tab

        st.TabRounding        = 3.0f;

    }

    // Remember the unscaled style: the interface-scale setting derives from

    // this each time it changes, so repeated changes can't compound and drift.

    s_style_base       = ImGui::GetStyle();

    s_style_base_valid = true;

    s_applied_ui_scale = -1.0f; // force the first apply

    // Detect first run (no imgui.ini yet) so we install a sensible default dock

    // layout once. After that ImGui persists the user's own arrangement and we

    // leave it alone.

    s_build_default_layout = true;

    if (const char *ini = io.IniFilename) {

        if (FILE *f = fopen(ini, "rb")) {

            fclose(f);

            s_build_default_layout = false;

        }

    }

    ImGui_ImplSDL2_InitForSDLRenderer(win, ren);

    ImGui_ImplSDLRenderer2_Init(ren);

    s_initialized = true;

    s_enabled     = true;

}

extern "C" void

debug_ui_process_event(const SDL_Event *ev)

{

    if (!s_initialized || ev == nullptr) {

        return;

    }

    ImGui_ImplSDL2_ProcessEvent(ev);

}

// Menu-bar text fields that always occupy the same width, so values that change

// every frame (run state, PC, cycle and instruction counters) don't shove

// everything after them sideways as they grow and shrink. `widest` is a

// template string sized to the largest value the field can hold.

static void

menubar_fixed_advance(const char *widest, float start_x)

{

    const float w = ImGui::CalcTextSize(widest).x;

    ImGui::SameLine();

    ImGui::SetCursorPosX(start_x + w + ImGui::GetStyle().ItemSpacing.x);

}

static void

menubar_fixed_value(const char *widest, const char *fmt, ...)

{

    char buf[64] = "";

    va_list args;

    va_start(args, fmt);

    vsnprintf(buf, sizeof buf, fmt, args);

    va_end(args);

    const float x = ImGui::GetCursorPosX();

    ImGui::TextUnformatted(buf);

    menubar_fixed_advance(widest, x);

}

static void

menubar_fixed_colored(const char *widest, ImVec4 color, const char *text)

{

    const float x = ImGui::GetCursorPosX();

    ImGui::PushStyleColor(ImGuiCol_Text, color);

    ImGui::TextUnformatted(text);

    ImGui::PopStyleColor();

    menubar_fixed_advance(widest, x);

}

// Execution-control button. The shortcut belongs in the tooltip because these

// are the actions people reach for constantly, and there is nowhere else in the

// UI that lists the keys.

//

// The tooltip deliberately survives the disabled state: these buttons are greyed

// out most of the time (stepping needs a halted CPU, Pause needs a running one),

// and "why can't I click this?" is exactly the question worth answering. Plain

// SetItemTooltip() would say nothing there, since ImGui does not consider a

// disabled item hovered unless asked.

static bool

ctrl_button(const char *label, bool enabled, const char *tip)

{

    ImGui::BeginDisabled(!enabled);

    const bool clicked = ImGui::Button(label);

    ImGui::EndDisabled();

    if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {

        ImGui::SetTooltip("%s", tip);

    }

    return clicked;

}

// Top main menu bar: View/Layout/Help menus plus the execution-control toolbar

// (Continue/Pause/Step*, a run-state indicator, and the live PC:bank). Buttons

// drive the shared debugger execution control (debugger.c) — the same

// transitions F5/F10/F11 and DAP use.

static void

debug_ui_draw_control_bar(void)

{

    if (!ImGui::BeginMainMenuBar()) {

        return;

    }

    // View: toggle each registered panel. This is the ONLY way to reopen a

    // panel after its window has been closed (the [x]), so it doubles as the

    // panel visibility manager. Iterates the self-registered registry, so new

    // panels appear here automatically.

    if (ImGui::BeginMenu("View")) {

        for (DebugPanel &panel : debug_ui_panels()) {

            ImGui::MenuItem(panel.name, nullptr, &panel.open);

        }

        ImGui::EndMenu();

    }

    // Layout: rebuild the default dock arrangement on demand (recovers from a

    // messy imgui.ini or a panel dragged somewhere unhelpful).

    if (ImGui::BeginMenu("Layout")) {

        if (ImGui::MenuItem("Reset to Default Layout")) {

            for (DebugPanel &panel : debug_ui_panels()) {

                panel.open = true;             // reopen everything so the reset is visible

            }

            s_build_default_layout = true;     // applied after DockSpaceOverViewport() this frame

        }

        ImGui::EndMenu();

    }

    // System: machine-level controls. Reset defers to the emulator loop via the

    // SMC reset flag (safe, == Ctrl-R). IRQ/NMI are edge-triggered.

    if (ImGui::BeginMenu("System")) {

        if (ImGui::MenuItem("Reset", "Ctrl+Shift+F5")) {

            smc_requested_reset = true;

        }

        ImGui::SetItemTooltip("Reset the machine, as the SMC would. Breakpoints are kept.");

        if (ImGui::MenuItem("Trigger IRQ")) {

            irq6502();

        }

        if (ImGui::MenuItem("Trigger NMI")) {

            machine_nmi();

        }

        ImGui::Separator();

        // Behavioural toggles live in Settings, not scattered through menus.

        ImGui::MenuItem("Settings...", nullptr, &s_show_settings);

        if (ImGui::IsItemHovered()) {

            ImGui::SetTooltip("Interrupt following, panel auto-switching, memory change\n"

                              "highlighting and other preferences.");

        }

        ImGui::EndMenu();

    }

    // Help: the vendored ImGui demo is handy while building/inspecting panels.

    if (ImGui::BeginMenu("Help")) {

        // Not every shortcut has a button - F9 and Ctrl+F10 in particular are

        // keyboard-only - so keep the full list somewhere findable.

        if (ImGui::BeginMenu("Keyboard Shortcuts")) {

            static const struct { const char *key, *what; } keys[] = {

                { "F5",            "Continue" },

                { "Break",         "Pause" },

                { "F11",           "Step Into" },

                { "Shift+F11",     "Step Out" },

                { "F10",           "Step Over" },

                { "Ctrl+F10",      "Run to cursor" },

                { "F9",            "Toggle breakpoint at PC" },

                { "Ctrl+Shift+F5", "Reset machine" },

                { "Ctrl+wheel",    "Zoom the panel under the cursor" },

            };

            if (ImGui::BeginTable("keys", 2, ImGuiTableFlags_SizingFixedFit)) {

                for (const auto &k : keys) {

                    ImGui::TableNextRow();

                    ImGui::TableNextColumn();

                    ImGui::TextUnformatted(k.key);

                    ImGui::TableNextColumn();

                    ImGui::TextDisabled("%s", k.what);

                }

                ImGui::EndTable();

            }

            ImGui::EndMenu();

        }

        ImGui::Separator();

        ImGui::MenuItem("Show ImGui Demo", nullptr, &s_show_demo);

        ImGui::Separator();

        ImGui::TextDisabled("Dear ImGui %s", IMGUI_VERSION);

        ImGui::EndMenu();

    }

    ImGui::Separator();

    const bool running = DEBUGIsRunning();

    const bool paused  = DEBUGIsPaused();

    if (ctrl_button("Continue", paused,

                    "Continue  (F5)\n"

                    "Run until the next breakpoint or pause.\n"

                    "Only while the machine is halted."))

        DEBUGContinue();

    ImGui::SameLine();

    if (ctrl_button("Pause", running,

                    "Pause  (Break key)\n"

                    "Halt the machine wherever it is.\n"

                    "Only while it is running."))

        DEBUGPause();

    ImGui::SameLine();

    if (ctrl_button("Step Into", paused,

                    "Step Into  (F11)\n"

                    "Execute one source line, entering any call. Without C debug\n"

                    "info, or with \"Step by line\" off, one instruction.\n"

                    "Only while the machine is halted."))

        DEBUGStepIntoAuto();

    ImGui::SameLine();

    if (ctrl_button("Step Over", paused,

                    "Step Over  (F10)\n"

                    "Execute one source line, running any call to completion.\n"

                    "Without C debug info, or with \"Step by line\" off, one\n"

                    "instruction. Ctrl+F10 runs to the cursor instead.\n"

                    "Only while the machine is halted."))

        DEBUGStepOverAuto(DEBUG_OWNER_UI);

    ImGui::SameLine();

    if (ctrl_button("Step Out", paused,

                    "Step Out  (Shift+F11)\n"

                    "Run until the current subroutine returns.\n"

                    "Only while the machine is halted."))

        DEBUGStepOut(DEBUG_OWNER_UI);

    // ── Speed ───────────────────────────────────────────────────────────────

    // Absolute target clock, not a bare percentage: the machine's own clock is

    // whatever -mhz selected at startup, so a percentage alone doesn't say how

    // fast anything is actually running. Warp disables the throttle entirely,

    // so the speed buttons are meaningless while it is on.

    ImGui::Separator();

    {

        const int khz    = timing_get_speed_khz();

        const int native = timing_native_khz();

        ImGui::BeginDisabled(warp_mode);

        if (ImGui::SmallButton("-")) {

            timing_step_speed(-1);

        }

        if (ImGui::IsItemHovered()) ImGui::SetTooltip("Slow emulation down");

        ImGui::SameLine();

        // Fixed width: this text changes constantly and anything after it would

        // otherwise shuffle sideways every frame.

        char speed_text[48];

        if (warp_mode) {

            snprintf(speed_text, sizeof speed_text, "warp");

        } else if (khz >= 1000) {

            snprintf(speed_text, sizeof speed_text, "%.2fMHz", khz / 1000.0);

        } else {

            snprintf(speed_text, sizeof speed_text, "%dkHz", khz);

        }

        const bool at_native = (khz == native);

        const bool too_fast  = (khz > native);

        // Blue below the machine's clock, red above it: running faster than the

        // hardware ever does is a legitimate thing to want, but the timing you

        // observe there is not what the real machine would do, so say so.

        const ImVec4 col = warp_mode   ? ImVec4(0.95f, 0.70f, 0.30f, 1.0f)

                           : too_fast  ? ImVec4(1.00f, 0.45f, 0.45f, 1.0f)

                           : at_native ? ImGui::GetStyle().Colors[ImGuiCol_Text]

                                       : ImVec4(0.55f, 0.85f, 1.00f, 1.0f);

        menubar_fixed_colored("888.88MHz", col, speed_text);

        if (ImGui::IsItemHovered()) {

            ImGui::SetTooltip(

                "Target CPU clock. This machine was started at %.2f MHz (-mhz %d),\n"

                "which is 100%%; the current target is %d%% of that.%s\n\n"

                "%.0f cycles/s, roughly %.0f instructions/s (a 6502-family\n"

                "instruction averages about 4 cycles).\n\n"

                "+/- step through real hardware clocks and the rates between them.",

                native / 1000.0, (int)MHZ, timing_get_speed_percent(),

                too_fast ? "\n\nFaster than this machine's clock: timing you measure here\n"

                           "is NOT what the real hardware would do."

                         : "",

                khz * 1000.0, khz * 1000.0 / 4.0);

        }

        ImGui::SameLine();

        if (ImGui::SmallButton("+")) {

            timing_step_speed(1);

        }

        if (ImGui::IsItemHovered()) ImGui::SetTooltip("Speed emulation up");

        // Only worth offering when it would actually change something.

        if (!at_native) {

            ImGui::SameLine();

            if (ImGui::SmallButton("1x")) {

                timing_reset_speed();

            }

            if (ImGui::IsItemHovered())

                ImGui::SetTooltip("Back to this machine's own clock (%.2f MHz).",

                                  native / 1000.0);

        }

        ImGui::EndDisabled();

        ImGui::SameLine();

        if (warp_mode) {

            ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.55f, 0.35f, 0.10f, 1.0f));

            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.70f, 0.45f, 0.15f, 1.0f));

        }

        if (ImGui::SmallButton("Warp")) {

            machine_toggle_warp();

        }

        if (warp_mode) {

            ImGui::PopStyleColor(2);

        }

        if (ImGui::IsItemHovered()) {

            ImGui::SetTooltip("Run with no speed limit (currently %s)", warp_mode ? "ON" : "off");

        }

    }

    // ── Status ──────────────────────────────────────────────────────────────

    // Everything from here on changes every frame while stepping, so each field

    // reserves the width of its widest value. Without that the whole right-hand

    // side of the bar jitters as the numbers grow and shrink.

    ImGui::Separator();

    if (running) {

        menubar_fixed_colored("RUNNING", ImVec4(0.40f, 0.85f, 0.40f, 1.0f), "RUNNING");

    } else if (paused) {

        menubar_fixed_colored("RUNNING", ImVec4(0.95f, 0.70f, 0.30f, 1.0f), "PAUSED");

    } else {

        menubar_fixed_value("RUNNING", "%s", "-");

    }

    // Interrupt context: make it obvious when the PC is inside a handler, since