// Commander X16 Emulator — shared oscilloscope / meter helpers for the audio
// debugger panels (PSG, YM2151, PCM).
//
// Header-only, like debug_ui_widgets.h, so it needs no CMake entry.
//
// Everything draws through ImDrawList (no ImPlot dependency). The traces are
// decimated to at most one column per pixel, so the cost is bounded by the
// widget's on-screen width rather than by the sample count: a 2048-sample
// window in a 200 px wide scope costs 200 columns, not 2048 line segments.
#ifndef DEBUG_UI_SCOPE_H
#define DEBUG_UI_SCOPE_H

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

// DEBUGIsPaused() — audio panels hold their display while the machine is
// stopped (see dbgui_audio_hold below).
#include "debug_ui_bridge.h"
#include "debug_ui_settings.h"

// Vertical gain sentinel: scale the trace to the window's own peak each frame.
#define DBGUI_SCOPE_AUTO_GAIN 0.0f

// Find a rising zero crossing so a periodic waveform stays still instead of
// sliding across the widget. Searches the part of `samples` that precedes the
// displayed window, newest crossing first, and returns the index the window
// should start at. Falls back to the newest `window` samples when the signal
// never crosses (DC, silence, or a period longer than the search range).
static inline int
dbgui_scope_trigger_offset(const int16_t *samples, int count, int window)
{
    int latest = count - window; // no trigger: show the newest `window` samples
    if (latest <= 0) {
        return 0;
    }
    for (int i = latest; i > 0; --i) {
        if (samples[i - 1] < 0 && samples[i] >= 0) {
            return i;
        }
    }
    return latest;
}

// Draw one oscilloscope trace.
//
//   samples/count : sample history, oldest first (as returned by *_scope_read)
//   size          : widget size in pixels; 0 in either axis fills the available
//                   width / uses a default height
//   window        : how many of the newest samples to display (clamped to count)
//   gain          : pixels per unit / 32768.0; DBGUI_SCOPE_AUTO_GAIN auto-scales
//   trigger       : align to a rising zero crossing
//   overlay       : optional text drawn in the top-left corner
//
// Returns the peak magnitude (0..32768) of the displayed window, which callers
// can reuse for a level readout without rescanning.
static inline int
dbgui_scope(const char *id, const int16_t *samples, int count, ImVec2 size,
            ImU32 color, int window, float gain, bool trigger, const char *overlay)
{
    if (size.x <= 0.0f) {
        size.x = ImGui::GetContentRegionAvail().x;
    }
    if (size.x < 16.0f) {
        size.x = 16.0f;
    }
    if (size.y <= 0.0f) {
        size.y = ImGui::GetTextLineHeight() * 4.0f;
    }

    ImGui::PushID(id);
    ImGui::InvisibleButton("##scope", size);
    const ImVec2 p0 = ImGui::GetItemRectMin();
    const ImVec2 p1 = ImGui::GetItemRectMax();
    ImGui::PopID();

    ImDrawList *dl = ImGui::GetWindowDrawList();
    dl->AddRectFilled(p0, p1, IM_COL32(12, 14, 18, 255));

    // Grid: 4 columns / 4 rows, with a brighter centre line for the zero axis.
    const ImU32 grid = IM_COL32(52, 58, 68, 255);
    const ImU32 axis = IM_COL32(90, 100, 115, 255);
    for (int i = 1; i < 4; ++i) {
        float x = p0.x + (p1.x - p0.x) * (float)i / 4.0f;
        float y = p0.y + (p1.y - p0.y) * (float)i / 4.0f;
        dl->AddLine(ImVec2(x, p0.y), ImVec2(x, p1.y), grid);
        dl->AddLine(ImVec2(p0.x, y), ImVec2(p1.x, y), (i == 2) ? axis : grid);
    }
    dl->AddRect(p0, p1, IM_COL32(70, 78, 90, 255));

    if (samples == NULL || count <= 0) {
        return 0;
    }
    if (window <= 0 || window > count) {
        window = count;
    }

    const int start = trigger ? dbgui_scope_trigger_offset(samples, count, window)
                              : (count - window);

    // Peak of the displayed window: drives auto-gain and the return value.
    int peak = 0;
    for (int i = 0; i < window; ++i) {
        int v = samples[start + i];
        if (v < 0) {
            v = -v;
        }
        if (v > peak) {
            peak = v;
        }
    }

    const float half = (p1.y - p0.y) * 0.5f - 1.0f;
    const float mid  = (p0.y + p1.y) * 0.5f;
    float       scale;
    if (gain > 0.0f) {
        scale = half * gain;
    } else {
        // Auto: fill the widget, but keep near-silence flat instead of
        // amplifying dither into a full-height mess.
        scale = (peak > 64) ? (half / (float)peak) : (half / 32768.0f);
    }

    dl->PushClipRect(p0, p1, true);

    const int columns = (int)(p1.x - p0.x);
    if (window <= columns) {
        // Fewer samples than pixels: draw the actual points.
        for (int i = 1; i < window; ++i) {
            float xa = p0.x + (p1.x - p0.x) * (float)(i - 1) / (float)(window - 1);
            float xb = p0.x + (p1.x - p0.x) * (float)i / (float)(window - 1);
            float ya = mid - (float)samples[start + i - 1] * scale;
            float yb = mid - (float)samples[start + i] * scale;
            dl->AddLine(ImVec2(xa, ya), ImVec2(xb, yb), color, 1.0f);
        }
    } else {
        // More samples than pixels: one min/max bar per column, the usual
        // waveform-envelope look, and bounded by the widget width.
        for (int c = 0; c < columns; ++c) {
            int lo = (int)((int64_t)c * window / columns);
            int hi = (int)((int64_t)(c + 1) * window / columns);
            if (hi <= lo) {
                hi = lo + 1;
            }
            int vmin = 32767, vmax = -32768;
            for (int i = lo; i < hi && i < window; ++i) {
                int v = samples[start + i];
                if (v < vmin) {
                    vmin = v;
                }
                if (v > vmax) {
                    vmax = v;
                }
            }
            float x  = p0.x + (float)c + 0.5f;
            float ya = mid - (float)vmax * scale;
            float yb = mid - (float)vmin * scale;
            if (yb - ya < 1.0f) {
                yb = ya + 1.0f;
            }
            dl->AddLine(ImVec2(x, ya), ImVec2(x, yb), color, 1.0f);
        }
    }

    dl->PopClipRect();

    if (overlay && overlay[0]) {
        dl->AddText(ImVec2(p0.x + 4.0f, p0.y + 2.0f), IM_COL32(190, 198, 210, 220), overlay);
    }
    return peak;
}

// A horizontal peak-level bar. `frac` is 0..1 (values above 1 are clamped and
// shown in red so clipping is obvious).
static inline void
dbgui_level_meter(const char *id, float frac, ImVec2 size, ImU32 color)
{
    if (size.x <= 0.0f) {
        size.x = 80.0f;
    }
    if (size.y <= 0.0f) {
        size.y = ImGui::GetTextLineHeight();
    }

    bool clipped = frac > 1.0f;
    if (clipped) {
        frac = 1.0f;
    }
    if (frac < 0.0f) {
        frac = 0.0f;
    }

    ImGui::PushID(id);
    ImGui::InvisibleButton("##meter", size);
    const ImVec2 p0 = ImGui::GetItemRectMin();
    const ImVec2 p1 = ImGui::GetItemRectMax();
    ImGui::PopID();

    ImDrawList *dl = ImGui::GetWindowDrawList();
    dl->AddRectFilled(p0, p1, IM_COL32(24, 26, 30, 255));
    if (frac > 0.0f) {
        ImVec2 fill(p0.x + (p1.x - p0.x) * frac, p1.y);
        dl->AddRectFilled(p0, fill, clipped ? IM_COL32(220, 80, 70, 255) : color);
    }
    dl->AddRect(p0, p1, IM_COL32(70, 78, 90, 255));
}

// Shared "Scope" tab controls: time base, vertical gain, trigger and freeze.
// Keeping them here means the three panels present identical controls, and each
// panel only has to own the state.
struct DbgScopeControls {
    int   window  = 512;   // samples displayed
    float gain    = DBGUI_SCOPE_AUTO_GAIN;
    bool  trigger = true;
    bool  freeze  = false;
};

// Draw the control row. `max_window` is the ring depth (PSG_SCOPE_SAMPLES etc).
static inline void
dbgui_scope_controls(DbgScopeControls *c, int max_window)
{
    ImGui::SetNextItemWidth(140.0f);
    ImGui::SliderInt("Window", &c->window, 32, max_window, "%d smp");
    ImGui::SameLine();

    bool autoscale = (c->gain <= 0.0f);
    if (ImGui::Checkbox("Auto gain", &autoscale)) {
        c->gain = autoscale ? DBGUI_SCOPE_AUTO_GAIN : 1.0f;
    }
    if (!autoscale) {
        ImGui::SameLine();
        ImGui::SetNextItemWidth(120.0f);
        ImGui::SliderFloat("Gain", &c->gain, 0.05f, 16.0f, "%.2fx",
                           ImGuiSliderFlags_Logarithmic);
    }
    ImGui::SameLine();
    ImGui::Checkbox("Trigger", &c->trigger);
    ImGui::SetItemTooltip("Align the trace to a rising zero crossing so a steady "
                          "tone stands still.");
    ImGui::SameLine();
    ImGui::Checkbox("Freeze", &c->freeze);
    ImGui::SetItemTooltip("Stop refreshing the traces. Capture also stops, since "
                          "it is only armed while the debugger reads it.");
}

// Should an audio panel keep showing its last captured state instead of
// re-reading?
//
// Pausing the machine silences audio: nothing is rendered, peak meters read
// back zero and the scope rings stop filling, so a panel that re-reads while
// paused wipes out exactly the state the user paused to look at. Holding the
// last live capture keeps the display meaningful, and is what you want from a
// debugger — the values shown are the ones in effect at the moment of the
// pause.
static inline bool
dbgui_audio_hold(void)
{
    return DEBUGIsPaused() && debug_ui_settings().audio_hold_on_pause;
}

// Note next to the controls explaining that the display is held. Call after the
// control row when dbgui_audio_hold() is true.
static inline void
dbgui_audio_hold_note(void)
{
    ImGui::SameLine();
    ImGui::TextColored(ImVec4(0.95f, 0.70f, 0.30f, 1.0f), "held (paused)");
    ImGui::SetItemTooltip("The machine is paused, so audio is silent and nothing new is\n"
                          "captured. These are the values from the moment it stopped.");
}

// Note next to the controls for traces computed from chip state rather than
// captured. Scope capture is self-arming and nothing renders audio while
// paused, so a scope first opened at a breakpoint has an empty ring; the sound
// chips' own state still describes what they are about to emit, so the panels
// project that instead of showing a dead display.
static inline void
dbgui_audio_predicted_note(const char *what)
{
    ImGui::SameLine();
    ImGui::TextColored(ImVec4(0.70f, 0.80f, 1.00f, 1.0f), "projected");
    ImGui::SetItemTooltip("Paused with no captured audio, so these traces are computed from\n"
                          "%s - what it would emit next, using the same\n"
                          "renderer live audio uses.\n\n"
                          "It is a projection, not a recording: change the chip state and it\n"
                          "updates immediately. Real captured audio replaces it on resume.",
                          what);
}

#endif // DEBUG_UI_SCOPE_H