// VERA PCM panel — FIFO sample playback debugger for the Commander X16.
//
// Tabs:
//   * Status — side-effect-free decode of AUDIO_CTRL/AUDIO_RATE, FIFO fill,
//              AFLOW, current raw samples and playback phase.
//   * FIFO   — non-consuming, ring-aware view of queued AUDIO_DATA bytes plus a
//              raw waveform preview of what is about to be fetched.
//   * Scope  — self-arming oscilloscope of the post-volume PCM output.
//
// Technique: this panel reads the PCM block through pcm_debug_get_state() and
// pcm_debug_peek_fifo() instead of polling VERA register $9F3B/AUDIO_CTRL.
// Reading AUDIO_CTRL via video_read(0x1B) runs audio_render() as a side effect,
// so a passive debugger panel must not do it. Only the active tab does work
// (ImGui::BeginTabItem gates each tab), and pcm_debug_scope_read() is called
// only from the Scope tab because that read arms capture for about half a second.
#include "imgui.h"
#include "debug_ui_panels.h"
#include "debug_ui_bridge.h"
#include "debug_ui_scope.h"
#include "debug_ui_widgets.h"

#include <stdint.h>
#include <stdio.h>

namespace {

constexpr double PCM_AUDIO_CLOCK = 25000000.0 / 512.0;
constexpr int    MAX_FIFO_BYTES  = PCM_FIFO_SIZE;
constexpr int    MAX_FIFO_FRAMES = PCM_FIFO_SIZE;

const uint8_t VOLUME_LUT[16] = {0, 1, 2, 3, 4, 5, 6, 8, 11, 14, 18, 23, 30, 38, 49, 64};

struct PcmFormat {
    const char *name;
    int         bytes_per_frame;
    bool        stereo;
    bool        bits16;
};

PcmFormat
pcm_format(uint8_t ctrl)
{
    static const PcmFormat formats[4] = {
        {"mono 8-bit", 1, false, false},
        {"stereo 8-bit", 2, true, false},
        {"mono 16-bit", 2, false, true},
        {"stereo 16-bit", 4, true, true},
    };
    return formats[(ctrl >> 4) & 3];
}

int16_t
decode_u8(uint8_t v)
{
    return (int16_t)((uint16_t)v << 8);
}

int16_t
decode_s16le(const uint8_t *p)
{
    uint16_t v = (uint16_t)p[0] | ((uint16_t)p[1] << 8);
    return (int16_t)v;
}

void
decode_frame(const uint8_t *p, const PcmFormat &fmt, int16_t *left, int16_t *right)
{
    if (!fmt.bits16) {
        *left = decode_u8(p[0]);
        *right = fmt.stereo ? decode_u8(p[1]) : *left;
        return;
    }

    *left = decode_s16le(p);
    *right = fmt.stereo ? decode_s16le(p + 2) : *left;
}

float
sample_level(int16_t v)
{
    int mag = (v < 0) ? -(int)v : (int)v;
    return (float)mag / 32768.0f;
}

double
effective_rate_hz(uint8_t rate)
{
    return PCM_AUDIO_CLOCK * (double)rate / 128.0;
}

void
text_ctrl_value(uint8_t ctrl)
{
    char bin[12];
    dbgui_format_binary(bin, sizeof bin, ctrl, 8);
    ImGui::Text("AUDIO_CTRL stored: $%02X  %s", ctrl, bin);
    dbgui_hover_value_tooltip("Stored bits 5-0: format + volume. Bits 7/6 are read-status/reset controls.", ctrl, 1);
}

void
draw_status_tab()
{
    pcm_debug_state s = {};
    pcm_debug_get_state(&s);

    const PcmFormat fmt = pcm_format(s.ctrl);
    const int volume = s.ctrl & 0x0f;
    const double rate_hz = effective_rate_hz(s.rate);
    const unsigned usable = (s.fifo_size > 0) ? (s.fifo_size - 1u) : 0u;
    const float fill_frac = (usable > 0) ? (float)s.fifo_cnt / (float)usable : 0.0f;
    const unsigned frames = s.fifo_cnt / (unsigned)fmt.bytes_per_frame;
    const double buffered_ms = (rate_hz > 0.0) ? ((double)frames * 1000.0 / rate_hz) : 0.0;

    text_ctrl_value(s.ctrl);
    ImGui::Text("Format: %s  (%d byte%s/frame)", fmt.name, fmt.bytes_per_frame,
                fmt.bytes_per_frame == 1 ? "" : "s");
    ImGui::Text("Volume: %d  LUT=%u/64  linear %.4f", volume, (unsigned)VOLUME_LUT[volume],
                (double)VOLUME_LUT[volume] / 64.0);
    ImGui::Text("Loop: %s", s.loop ? "enabled" : "disabled");
    ImGui::Separator();

    ImGui::Text("AUDIO_RATE effective divider: %u", (unsigned)s.rate);
    ImGui::Text("Playback rate: %s", s.rate == 0 ? "stopped" : "running");
    if (s.rate != 0) {
        ImGui::SameLine();
        ImGui::Text("(%.3f Hz)", rate_hz);
    }
    ImGui::TextDisabled("AUDIO_RATE writes above 128 are clamped as 256 - value; this is the already-clamped divider.");
    ImGui::Separator();

    char overlay[80];
    snprintf(overlay, sizeof overlay, "%u / %u usable bytes", s.fifo_cnt, usable);
    ImGui::ProgressBar(fill_frac, ImVec2(-1.0f, 0.0f), overlay);
    ImGui::Text("FIFO: %u queued / %u bytes physical (%u usable)", s.fifo_cnt, s.fifo_size, usable);
    ImGui::Text("Frames queued: %u   Buffered: %.3f ms", frames, buffered_ms);
    ImGui::Text("Read index: %u   Write index: %u", s.fifo_rdidx, s.fifo_wridx);

    ImVec4 aflow = s.almost_empty ? ImVec4(1.0f, 0.35f, 0.20f, 1.0f)
                                  : ImVec4(0.30f, 0.85f, 0.45f, 1.0f);
    ImGui::TextColored(aflow, "AFLOW / almost empty IRQ: %s (fifo_cnt < 1024)",
                       s.almost_empty ? "ASSERTED" : "clear");
    if (s.fifo_cnt > 0 && s.fifo_cnt < (unsigned)fmt.bytes_per_frame) {
        ImGui::TextColored(ImVec4(1.0f, 0.65f, 0.20f, 1.0f),
                           "Underrun risk: fewer bytes queued than one %s frame; emulator will reset the FIFO mid-frame.",
                           fmt.name);
    }
    ImGui::Separator();

    ImGui::Text("Current raw fetched sample (pre-volume): L=%d  R=%d", (int)s.cur_l, (int)s.cur_r);
    ImGui::TextUnformatted("L");
    ImGui::SameLine();
    dbgui_level_meter("cur_l", sample_level(s.cur_l), ImVec2(160.0f, 0.0f), IM_COL32(90, 190, 255, 255));
    ImGui::SameLine();
    ImGui::TextUnformatted("R");
    ImGui::SameLine();
    dbgui_level_meter("cur_r", sample_level(s.cur_r), ImVec2(160.0f, 0.0f), IM_COL32(255, 175, 80, 255));
    ImGui::Text("Phase accumulator: $%02X (%u)", (unsigned)s.phase, (unsigned)s.phase);

    ImGui::Spacing();
    ImGui::TextDisabled("This panel reads the PCM block directly, not VERA $9F3B/AUDIO_CTRL; reading AUDIO_CTRL renders audio.");
    ImGui::TextDisabled("cur_l/cur_r are raw fetched samples before volume scaling. Scope traces show post-volume output.");
}

unsigned
peek_fifo_bytes(uint8_t *bytes, unsigned fifo_cnt)
{
    unsigned want = fifo_cnt;
    if (want > (unsigned)MAX_FIFO_BYTES) {
        want = (unsigned)MAX_FIFO_BYTES;
    }
    return pcm_debug_peek_fifo(bytes, 0, want);
}

int
build_fifo_preview(const uint8_t *bytes, unsigned byte_count, const PcmFormat &fmt,
                   int16_t *left, int16_t *right)
{
    const unsigned frames = byte_count / (unsigned)fmt.bytes_per_frame;
    unsigned n = frames;
    if (n > (unsigned)MAX_FIFO_FRAMES) {
        n = (unsigned)MAX_FIFO_FRAMES;
    }
    for (unsigned i = 0; i < n; ++i) {
        decode_frame(bytes + i * (unsigned)fmt.bytes_per_frame, fmt, &left[i], &right[i]);
    }
    return (int)n;
}

void
draw_fifo_hex_table(const uint8_t *bytes, unsigned byte_count, const PcmFormat &fmt)
{
    const unsigned rows = (byte_count + (unsigned)fmt.bytes_per_frame - 1u) / (unsigned)fmt.bytes_per_frame;
    ImGuiTableFlags flags = ImGuiTableFlags_RowBg | ImGuiTableFlags_BordersInnerV |
                            ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_ScrollY |
                            DBGUI_TABLE_FLAGS_RESIZABLE;
    if (!ImGui::BeginTable("pcm_fifo_bytes", 4, flags, ImVec2(0.0f, 300.0f))) {
        return;
    }

    ImGui::TableSetupScrollFreeze(0, 1);
    ImGui::TableSetupColumn("Offset");
    ImGui::TableSetupColumn("Hex bytes");
    ImGui::TableSetupColumn("Left");
    ImGui::TableSetupColumn("Right");
    ImGui::TableHeadersRow();

    for (unsigned row = 0; row < rows; ++row) {
        const unsigned off = row * (unsigned)fmt.bytes_per_frame;
        const unsigned remain = byte_count - off;
        const bool complete = remain >= (unsigned)fmt.bytes_per_frame;

        ImGui::TableNextRow();
        ImGui::TableSetColumnIndex(0);
        ImGui::Text("+%04X", off);

        ImGui::TableSetColumnIndex(1);
        char hex[16] = {};
        char *out = hex;
        size_t left_chars = sizeof hex;
        for (int i = 0; i < fmt.bytes_per_frame && off + (unsigned)i < byte_count; ++i) {
            int wrote = snprintf(out, left_chars, "%s%02X", i == 0 ? "" : " ", (unsigned)bytes[off + (unsigned)i]);
            if (wrote <= 0 || (size_t)wrote >= left_chars) {
                break;
            }
            out += wrote;
            left_chars -= (size_t)wrote;
        }
        ImGui::TextUnformatted(hex);

        ImGui::TableSetColumnIndex(2);
        if (complete) {
            int16_t l = 0;
            int16_t r = 0;
            decode_frame(bytes + off, fmt, &l, &r);
            ImGui::Text("%d", (int)l);
            ImGui::TableSetColumnIndex(3);
            ImGui::Text("%d", (int)r);
        } else {
            ImGui::TextDisabled("(partial)");
            ImGui::TableSetColumnIndex(3);
            ImGui::TextDisabled("(partial)");
        }
    }
    ImGui::EndTable();
}

void
draw_fifo_tab()
{
    pcm_debug_state s = {};
    pcm_debug_get_state(&s);
    const PcmFormat fmt = pcm_format(s.ctrl);

    ImGui::Text("Queued FIFO bytes from read pointer. Format: %s (%d byte%s/frame).",
                fmt.name, fmt.bytes_per_frame, fmt.bytes_per_frame == 1 ? "" : "s");
    ImGui::TextDisabled("Preview decodes raw queued data about to be fetched; Scope shows what is playing after volume scaling.");

    if (s.fifo_cnt == 0) {
        ImGui::Spacing();
        ImGui::TextDisabled("FIFO is empty.");
        return;
    }

    static uint8_t bytes[MAX_FIFO_BYTES];
    static int16_t preview_l[MAX_FIFO_FRAMES];
    static int16_t preview_r[MAX_FIFO_FRAMES];

    const unsigned got = peek_fifo_bytes(bytes, s.fifo_cnt);
    const int preview_count = build_fifo_preview(bytes, got, fmt, preview_l, preview_r);
    const int preview_window = (preview_count < 512) ? preview_count : 512;

    if (preview_count > 0) {
        ImGui::Text("Waveform preview: %d complete frame%s decoded from %u queued byte%s.",
                    preview_count, preview_count == 1 ? "" : "s", got, got == 1 ? "" : "s");
        dbgui_scope("fifo_preview_l", preview_l, preview_count, ImVec2(0.0f, 90.0f),
                    IM_COL32(90, 190, 255, 255), preview_window, DBGUI_SCOPE_AUTO_GAIN, false, "queued L/raw");
        if (fmt.stereo) {
            dbgui_scope("fifo_preview_r", preview_r, preview_count, ImVec2(0.0f, 90.0f),
                        IM_COL32(255, 175, 80, 255), preview_window, DBGUI_SCOPE_AUTO_GAIN, false, "queued R/raw");
        }
    } else {
        ImGui::TextDisabled("Not enough queued bytes for one complete frame.");
    }

    ImGui::Separator();
    draw_fifo_hex_table(bytes, got, fmt);
}

void
draw_scope_tab()
{
    static DbgScopeControls ctl;
    static int16_t left[PCM_SCOPE_SAMPLES];
    static int16_t right[PCM_SCOPE_SAMPLES];
    static unsigned left_count = 0;
    static unsigned right_count = 0;
    static bool captured = false; // buffers hold real audio, not a projection

    dbgui_scope_controls(&ctl, PCM_SCOPE_SAMPLES);
    const bool held = dbgui_audio_hold();
    bool       predicted = false;

    if (!ctl.freeze && !held) {
        left_count = pcm_debug_scope_read(PCM_SCOPE_L, left, PCM_SCOPE_SAMPLES);
        right_count = pcm_debug_scope_read(PCM_SCOPE_R, right, PCM_SCOPE_SAMPLES);
        captured = (left_count > 0 || right_count > 0);
    } else if (held && !captured && !ctl.freeze) {
        // Nothing captured, but the FIFO already holds the samples that are
        // about to play, so show those rather than an empty display.
        left_count = right_count = pcm_debug_scope_predict(left, right, PCM_SCOPE_SAMPLES);
        predicted = true;
    }

    if (held) {
        if (predicted) {
            dbgui_audio_predicted_note("the samples queued in the PCM FIFO");
        } else {
            dbgui_audio_hold_note();
        }
    }
    ImGui::TextDisabled("Reading these traces arms PCM capture; when this tab is hidden, capture self-disarms after about 0.5 s.");

    int peak_l = dbgui_scope("pcm_scope_l", left, (int)left_count, ImVec2(0.0f, 120.0f),
                             IM_COL32(90, 190, 255, 255), ctl.window, ctl.gain, ctl.trigger, "PCM L post-volume");
    dbgui_level_meter("pcm_scope_l_meter", (float)peak_l / 32768.0f, ImVec2(-1.0f, 0.0f),
                      IM_COL32(90, 190, 255, 255));
    int peak_r = dbgui_scope("pcm_scope_r", right, (int)right_count, ImVec2(0.0f, 120.0f),
                             IM_COL32(255, 175, 80, 255), ctl.window, ctl.gain, ctl.trigger, "PCM R post-volume");
    dbgui_level_meter("pcm_scope_r_meter", (float)peak_r / 32768.0f, ImVec2(-1.0f, 0.0f),
                      IM_COL32(255, 175, 80, 255));
}

// ---------------------------------------------------------------------------
// Panel entry point
// ---------------------------------------------------------------------------
void
pcm_panel_render(bool *p_open)
{
    if (ImGui::Begin("PCM", p_open)) {
        dbgui_window_zoom("pcm");

        if (ImGui::BeginTabBar("pcm_tabs", ImGuiTabBarFlags_DrawSelectedOverline)) {
            if (ImGui::BeginTabItem("Status")) {
                draw_status_tab();
                ImGui::EndTabItem();
            }
            if (ImGui::BeginTabItem("FIFO")) {
                draw_fifo_tab();
                ImGui::EndTabItem();
            }
            if (ImGui::BeginTabItem("Scope")) {
                draw_scope_tab();
                ImGui::EndTabItem();
            }
            ImGui::EndTabBar();
        }
    }
    dbgui_window_end();
}

} // namespace

static DebugPanelRegistration s_reg("PCM", pcm_panel_render, true);