// Commander X16 Emulator — shared inline ImGui helpers for the debugger panels.
//
// Header-only (no CMake entry needed): value tooltips that show a number as hex,
// decimal, signed decimal, binary (nibble-grouped) and ASCII. Used by the CPU,
// Memory and VERA panels so hovering any value gives a quick multi-base view.
#ifndef DEBUG_UI_WIDGETS_H
#define DEBUG_UI_WIDGETS_H

// Font ladder used by dbgui_window_zoom (defined in debug_ui.cpp): zoom picks a
// font rasterised at the wanted size rather than scaling one bitmap.
ImFont *debug_ui_font_for_size(float size_px, float *out_size);
float   debug_ui_font_base_size(void);

#include "imgui.h"
#include <stdint.h>
#include <stddef.h>
#include <string.h>

// ── Font-relative sizing ────────────────────────────────────────────────────
// Widths must be derived from the font that is actually active, never written
// as pixel constants. The interface scale and per-window zoom both change the
// font size, so a literal width that fitted at 100% clips its contents once the
// UI is scaled up - which is exactly how the breakpoint/watchpoint headers
// ended up truncated.
//
// Pass the widest string the element has to hold ("$FFFF", "00:0000", ...) and
// these measure it in the current font.

// Plain text.
static inline float
dbgui_text_width(const char *sample)
{
    return ImGui::CalcTextSize(sample ? sample : "").x;
}

// InputText / InputScalar / InputInt: the text plus the frame's inner padding.
static inline float
dbgui_field_width(const char *sample)
{
    return dbgui_text_width(sample) + ImGui::GetStyle().FramePadding.x * 2.0f;
}

// Combo: a field plus the drop-down arrow ImGui draws inside the frame.
static inline float
dbgui_combo_width(const char *sample)
{
    return dbgui_field_width(sample) + ImGui::GetFrameHeight();
}

// ── Commit-on-Enter for numeric fields ──────────────────────────────────────
// ImGuiInputTextFlags_EnterReturnsTrue is only supported by the InputText
// family. InputScalar asserts on it (imgui_widgets.cpp:3666), and InputInt and
// friends wrap InputScalar, so a debug build aborts the moment such a field is
// drawn. Release builds compile the assert out and the flag happens to work,
// because InputScalar passes its flags straight through to InputText -- which
// makes this a combination that works only by accident and only where the
// assertion is disabled.
//
// Call this immediately after the field instead. Deactivation-after-edit plus
// an Enter in the same frame is the same condition, without the unsupported
// flag: ImGui deactivates the item when Enter commits it, and the key state is
// still readable that frame.
static inline bool
dbgui_committed_with_enter()
{
    return ImGui::IsItemDeactivatedAfterEdit() &&
           (ImGui::IsKeyPressed(ImGuiKey_Enter) || ImGui::IsKeyPressed(ImGuiKey_KeypadEnter));
}

// Table column sized to fit `content_w`, and its header text, plus the cell
// padding on both sides. Pass content_w from one of the helpers above (or
// ImGui::GetFrameHeight() for a lone checkbox).
static inline float
dbgui_col_fit(const char *header, float content_w)
{
    const float hw = dbgui_text_width(header);
    if (hw > content_w) {
        content_w = hw;
    }
    return content_w + ImGui::GetStyle().CellPadding.x * 2.0f;
}

// Column holding plain text, e.g. an address or a count.
static inline float
dbgui_col_width(const char *header, const char *sample)
{
    return dbgui_col_fit(header, dbgui_text_width(sample));
}

// Flags every data table should carry: let the user drag column borders (and
// get ImGui's header context menu, which offers "size all columns to fit").
// Default widths still track the font; an explicit resize overrides them.
#define DBGUI_TABLE_FLAGS_RESIZABLE (ImGuiTableFlags_Resizable | ImGuiTableFlags_ContextMenuInBody)

// Format the low `bits` of v as binary, grouped in nibbles: e.g. "1010 0101".
static inline void
dbgui_format_binary(char *out, size_t outsz, uint32_t v, int bits)
{
    size_t o = 0;
    for (int i = bits - 1; i >= 0 && o + 2 < outsz; i--) {
        out[o++] = ((v >> i) & 1u) ? '1' : '0';
        if (i != 0 && (i % 4) == 0 && o + 1 < outsz)
            out[o++] = ' ';
    }
    out[o] = '\0';
}

// Render the value lines (hex / decimal / signed / binary / ASCII). Does NOT
// open a tooltip window itself — call between BeginTooltip()/EndTooltip() or
// inline. `bytes` is the value width (1..4).
static inline void
dbgui_value_lines(uint32_t v, int bytes)
{
    if (bytes < 1)
        bytes = 1;
    if (bytes > 4)
        bytes = 4;
    int      bits = bytes * 8;
    uint32_t mask = (bits >= 32) ? 0xFFFFFFFFu : ((1u << bits) - 1u);
    v &= mask;

    int32_t s = (int32_t)v; // sign-extend from the value's width
    if (bits < 32 && (v & (1u << (bits - 1))))
        s = (int32_t)(v | ~mask);

    char bin[48];
    dbgui_format_binary(bin, sizeof bin, v, bits);

    ImGui::Text("Hex   : $%0*X", bytes * 2, (unsigned)v);
    ImGui::Text("Dec   : %u", (unsigned)v);
    ImGui::Text("Signed: %d", (int)s);
    ImGui::Text("Bin   : %s", bin);
    if (bytes == 1) {
        unsigned char c = (unsigned char)(v & 0xFF);
        if (c >= 0x20 && c < 0x7f)
            ImGui::Text("Char  : '%c'", c);
        else
            ImGui::Text("Char  : .");
    }
}

// If the LAST-submitted item is hovered, show a value tooltip, optionally
// prefixed with a name/description line. Call immediately after the widget.
static inline void
dbgui_hover_value_tooltip(const char *desc, uint32_t v, int bytes)
{
    if (!ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled))
        return;
    ImGui::BeginTooltip();
    if (desc && desc[0]) {
        ImGui::TextUnformatted(desc);
        ImGui::Separator();
    }
    dbgui_value_lines(v, bytes);
    ImGui::EndTooltip();
}

// Per-window font zoom. Call once immediately after Begin() (inside the window)
// and pass a stable key for that window. Ctrl+mouse-wheel over the window zooms
// its text only, leaving every other panel alone; Ctrl+middle-click resets to
// 100%. The wheel event is consumed while Ctrl is held so the window does not
// also scroll. Returns the active scale.
//
// Zoom selects a font that was rasterised at the wanted size rather than
// scaling one bitmap — which is what SetWindowFontScale does, and why zoomed
// text used to smear — so the requested scale snaps to the nearest built size.
// Frame padding is not scaled; that trade-off is fine for source/hex views.
//
// IMPORTANT: the pushed font must be popped before ImGui::End(), and panels have
// several early-exit paths, so panels call dbgui_window_end() instead of
// ImGui::End() and the pop is handled there.
static int dbgui_zoom_pushed = 0;

static inline float
dbgui_window_zoom(const char *key)
{
    // Small fixed table — a handful of debugger panels, no allocation needed.
    struct Entry { const char *key; float scale; };
    static Entry  entries[16];
    static int    count = 0;

    Entry *e = nullptr;
    for (int i = 0; i < count; i++) {
        if (entries[i].key == key || (entries[i].key && key && !strcmp(entries[i].key, key))) {
            e = &entries[i];
            break;
        }
    }
    if (!e && count < (int)(sizeof entries / sizeof entries[0])) {
        entries[count].key   = key;
        entries[count].scale = 1.0f;
        e = &entries[count++];
    }
    if (!e)
        return 1.0f;

    ImGuiIO &io = ImGui::GetIO();
    if (ImGui::IsWindowHovered(ImGuiHoveredFlags_ChildWindows |
                               ImGuiHoveredFlags_AllowWhenBlockedByActiveItem)) {
        if (io.KeyCtrl && io.MouseWheel != 0.0f) {
            e->scale += io.MouseWheel * 0.1f;
            if (e->scale < 0.5f) e->scale = 0.5f;
            if (e->scale > 3.0f) e->scale = 3.0f;
            io.MouseWheel = 0.0f; // consume: don't scroll the window too
        }
        if (io.KeyCtrl && ImGui::IsMouseClicked(ImGuiMouseButton_Middle))
            e->scale = 1.0f;
    }

    const float base = debug_ui_font_base_size();
    float       got  = base;
    ImFont     *font = debug_ui_font_for_size(base * e->scale, &got);
    if (font) {
        ImGui::PushFont(font);
        dbgui_zoom_pushed++;
        e->scale = got / base; // report what was actually applied
    }
    return e->scale;
}

// End a panel window. Pops any font dbgui_window_zoom() pushed, then calls
// ImGui::End(). Panels use this at EVERY exit path (including the one taken
// when Begin() returns false, where nothing was pushed).
static inline void
dbgui_window_end(void)
{
    while (dbgui_zoom_pushed > 0) {
        ImGui::PopFont();
        dbgui_zoom_pushed--;
    }
    ImGui::End();
}

// Show the current zoom as a small right-aligned hint (only when not 100%).
static inline void
dbgui_zoom_hint(float scale)
{
    if (scale == 1.0f)
        return;
    ImGui::SameLine();
    ImGui::TextDisabled("(%.0f%%)", scale * 100.0f);
}

#endif // DEBUG_UI_WIDGETS_H