// YM2151 panel — live FM synthesis inspection for the Commander X16.

//

// Tabs:

//   * Channels  — the 8 OPM channels: note, pan, algorithm, key-on, EG and level.

//   * Operators — all parameters for the selected channel's M1/M2/C1/C2 slots.

//   * Algorithm — a live connection diagram for the selected channel's algorithm.

//   * Global    — LFO, noise, timers, CT pins, status and chip/sample clocks.

//   * Registers — all 256 accepted YM register shadows with compact decodes.

//   * Scope     — per-channel and summed waveforms using the shared scope widget.

//

// Technique: the panel reads only the debugger bridge's side-effect-free YM2151

// shadow/live accessors. Expensive work is gated by ImGui::BeginTabItem(), and

// YM_debug_scope_read() is called only from the Scope tab: reading it self-arms

// the audio core's per-channel capture for a short time, so hidden tabs do not

// keep ymfm doing extra per-sample output work.

#include "imgui.h"

#include "debug_ui_panels.h"

#include "debug_ui_bridge.h"

#include "debug_ui_widgets.h"

#include "debug_ui_scope.h"

#include <math.h>

#include <stdint.h>

#include <stdio.h>

#include <string.h>

namespace {

constexpr double YM_CLOCK_HZ = 3579545.0;

constexpr double YM_SAMPLE_HZ = YM_CLOCK_HZ / 64.0;

constexpr int    OP_COUNT = 4;

static int s_selected_ch = 0;

struct AlgorithmInfo {

    uint8_t inputs[4];      // opout source selector used for this operator's phase input

    uint8_t carriers_mask;  // bits 0..3: operator output is summed to the channel output

    const char *desc;

};

// Derived from fm_channel<RegisterType>::output_4op() in ymfm_fm.ipp, and kept

// in ymfm's own O1..O4 order so it can be re-checked against that table

// verbatim. ymfm's O order is NOT the OPM register-slot order: ymfm's

// operator_map() gives channel N the operator list (N, N+16, N+8, N+24), and an

// operator's registers live at base + index, so

//

//     O1 -> slot 0 (M1)   O2 -> slot 2 (C1)   O3 -> slot 1 (M2)   O4 -> slot 3 (C2)

//

// Everything else in this panel is slot-indexed (op_reg/op_index use

// base + slot*8 + ch), so `inputs` and `carriers_mask` are permuted through

// kOpToSlot at the point of use rather than being pre-swapped here.

static const AlgorithmInfo s_alg[8] = {

    {{0, 1, 2, 3}, 0x8, "M1 -> C1 -> M2 -> C2 -> out"},

    {{0, 0, 5, 3}, 0x8, "(M1 + C1) -> M2 -> C2 -> out"},

    {{0, 0, 2, 6}, 0x8, "(M1 + (C1 -> M2)) -> C2 -> out"},

    {{0, 1, 0, 7}, 0x8, "((M1 -> C1) + M2) -> C2 -> out"},

    {{0, 1, 0, 3}, 0xA, "(M1 -> C1) + (M2 -> C2) -> out"},

    {{0, 1, 1, 1}, 0xE, "M1 modulates C1, M2 and C2; all three out"},

    {{0, 1, 0, 0}, 0xE, "(M1 -> C1) + M2 + C2 -> out"},

    {{0, 0, 0, 0}, 0xF, "M1 + M2 + C1 + C2 -> out"},

};

// ymfm operator index (O1..O4) -> OPM register slot. Self-inverse.

static const int kOpToSlot[OP_COUNT] = { 0, 2, 1, 3 };

// Re-index a mask of ymfm O-indices into a mask of register slots.

inline uint8_t op_mask_to_slot_mask(uint8_t op_mask)

{

    uint8_t slots = 0;

    for (int o = 0; o < OP_COUNT; ++o) {

        if ((op_mask & (1u << o)) != 0) slots |= (uint8_t)(1u << kOpToSlot[o]);

    }

    return slots;

}

static const char *s_slot_names[OP_COUNT] = { "M1", "M2", "C1", "C2" };

static const char *s_eg_names[5] = { "-", "Attack", "Decay", "Sustain", "Release" };

static const char *s_lfo_waves[4] = { "saw", "square", "triangle", "noise" };

inline uint8_t ym_reg(int reg) { return YM_debug_get_reg((uint8_t)reg); }

inline uint8_t ch_reg(int base, int ch) { return ym_reg(base + ch); }

inline uint8_t op_reg(int base, int slot, int ch) { return ym_reg(base + slot * 8 + ch); }

inline int op_index(int slot, int ch) { return slot * 8 + ch; }

struct NoteInfo {

    bool valid;

    char text[48];

    double hz;

};

float clamp01(float v)

{

    if (v < 0.0f) return 0.0f;

    if (v > 1.0f) return 1.0f;

    return v;

}

uint8_t alg_for_ch(int ch) { return (uint8_t)(ch_reg(0x20, ch) & 0x07); }

// Carriers as a SLOT mask, so it can be indexed the same way as everything else

// in this panel. s_alg holds ymfm O-indices, hence the permutation.

uint8_t carriers_for_alg(int alg) { return op_mask_to_slot_mask(s_alg[alg & 7].carriers_mask); }

float operator_level(int slot, int ch)

{

    ym_debug_operator op = {};

    if (!YM_debug_get_operator(op_index(slot, ch), &op)) {

        return 0.0f;

    }

    return clamp01(1.0f - (float)op.eg_attenuation / 1023.0f);

}

float channel_carrier_level(int ch)

{

    const uint8_t carriers = carriers_for_alg(alg_for_ch(ch));

    float level = 0.0f;

    for (int slot = 0; slot < OP_COUNT; ++slot) {

        if ((carriers & (1u << slot)) != 0) {

            const float l = operator_level(slot, ch);

            if (l > level) level = l;

        }

    }

    return level;

}

bool channel_effectively_silent(int ch)

{

    for (int slot = 0; slot < OP_COUNT; ++slot) {

        ym_debug_operator op = {};

        if (YM_debug_get_operator(op_index(slot, ch), &op) && op.eg_attenuation < 0x3f0) {

            return false;

        }

    }

    return true;

}

ImU32 eg_color(uint8_t state)

{

    switch (state) {

    case YM_EG_ATTACK:  return IM_COL32(105, 220, 125, 255);

    case YM_EG_DECAY:   return IM_COL32(235, 205, 90, 255);

    case YM_EG_SUSTAIN: return IM_COL32(105, 170, 255, 255);

    case YM_EG_RELEASE: return IM_COL32(195, 130, 230, 255);

    default:            return IM_COL32(120, 126, 136, 255);

    }

}

void note_from_kc_kf(uint8_t kc, uint8_t kf, NoteInfo *out)

{

    static const char *names[12] = { "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B", "C" };

    const int oct = kc >> 4;

    const int low = kc & 0x0f;

    const int semi = (kc & 3) + 3 * ((kc >> 2) & 3);

    out->valid = (low != 3 && low != 7 && low != 11 && low != 15);

    if (!out->valid) {

        out->hz = 0.0;

        snprintf(out->text, sizeof(out->text), "invalid KC %02X", kc);

        return;

    }

    const double fine_semi = (double)(kf >> 2) / 64.0;

    const double midi = 12.0 * (double)(oct + 1) + 1.0 + (double)semi + fine_semi;

    out->hz = 440.0 * pow(2.0, (midi - 69.0) / 12.0);

    snprintf(out->text, sizeof(out->text), "%s%d %+d c  %.2f Hz", names[semi], oct, (int)(fine_semi * 100.0 + 0.5), out->hz);

}

void draw_key_mask(uint8_t mask)

{

    // YM_debug_get_keyon() is already repacked into slot order. Raw $08 bits are

    // M1,C1,M2,C2, which is why the Registers tab calls that out separately.

    for (int slot = 0; slot < OP_COUNT; ++slot) {

        if (slot != 0) ImGui::SameLine(0.0f, 4.0f);

        ImGui::TextColored((mask & (1u << slot)) ? ImVec4(0.45f, 1.0f, 0.55f, 1.0f)

                                                 : ImVec4(0.35f, 0.36f, 0.38f, 1.0f),

                           "%s", s_slot_names[slot]);

    }

}

void draw_eg_summary(int ch)

{

    for (int slot = 0; slot < OP_COUNT; ++slot) {

        ym_debug_operator op = {};

        uint8_t state = 0;

        if (YM_debug_get_operator(op_index(slot, ch), &op)) {

            state = op.eg_state;

        }

        const char c = (state == YM_EG_ATTACK) ? 'A' : (state == YM_EG_DECAY) ? 'D' :

                       (state == YM_EG_SUSTAIN) ? 'S' : (state == YM_EG_RELEASE) ? 'R' : '-';

        if (slot != 0) ImGui::SameLine(0.0f, 4.0f);

        ImGui::TextColored(ImColor(eg_color(state)), "%c", c);

    }

}

void draw_channels_tab()

{

    // Channels are numbered 0-7 throughout this panel, matching the register

    // offsets ($20+ch, $28+ch, ...) and the channel field of the $08 key-on

    // register — which is what you cross-reference while debugging. (The OPM

    // datasheet numbers them 1-8.)

    ImGui::TextDisabled("Channels are 0-7, matching the $20+ch / $28+ch register offsets "

                        "and the $08 key-on channel field.");

    if (ImGui::BeginTable("ym_channels", 11, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable)) {

        ImGui::TableSetupColumn("Ch", ImGuiTableColumnFlags_WidthFixed, dbgui_col_width("Ch", "00"));

        ImGui::TableSetupColumn("KC / note");

        ImGui::TableSetupColumn("KF", ImGuiTableColumnFlags_WidthFixed, dbgui_col_width("KF", "$FF"));

        ImGui::TableSetupColumn("ALG", ImGuiTableColumnFlags_WidthFixed, dbgui_col_width("ALG", "000"));

        ImGui::TableSetupColumn("FB", ImGuiTableColumnFlags_WidthFixed, dbgui_col_width("FB", "00"));

        ImGui::TableSetupColumn("Pan", ImGuiTableColumnFlags_WidthFixed, dbgui_col_width("Pan", "L+R"));

        ImGui::TableSetupColumn("PMS", ImGuiTableColumnFlags_WidthFixed, dbgui_col_width("PMS", "000"));

        ImGui::TableSetupColumn("AMS", ImGuiTableColumnFlags_WidthFixed, dbgui_col_width("AMS", "000"));

        ImGui::TableSetupColumn("Key-on");

        ImGui::TableSetupColumn("EG");

        ImGui::TableSetupColumn("Level", ImGuiTableColumnFlags_WidthFixed, dbgui_col_width("Level", "-00.0 dB"));

        ImGui::TableHeadersRow();

        for (int ch = 0; ch < YM_NUM_CHANNELS; ++ch) {

            const uint8_t r20 = ch_reg(0x20, ch);

            const uint8_t kc = ch_reg(0x28, ch) & 0x7f;

            const uint8_t kf = ch_reg(0x30, ch) & 0xfc;

            const uint8_t r38 = ch_reg(0x38, ch);

            NoteInfo note;

            note_from_kc_kf(kc, kf, &note);

            const bool silent = channel_effectively_silent(ch);

            ImGui::TableNextRow();

            if (silent) ImGui::BeginDisabled();

            ImGui::TableSetColumnIndex(0);

            char id[16];

            snprintf(id, sizeof(id), "Ch %d", ch);

            if (ImGui::Selectable(id, s_selected_ch == ch, ImGuiSelectableFlags_SpanAllColumns)) {

                s_selected_ch = ch;

            }

            ImGui::TableSetColumnIndex(1);

            ImGui::Text("$%02X  %s", kc, note.text);

            if (!note.valid) ImGui::SameLine(), ImGui::TextColored(ImVec4(1.0f, 0.45f, 0.35f, 1.0f), "!");

            ImGui::TableSetColumnIndex(2); ImGui::Text("%2u", (unsigned)(kf >> 2));

            ImGui::TableSetColumnIndex(3); ImGui::Text("%u", (unsigned)(r20 & 7));

            ImGui::TableSetColumnIndex(4); ImGui::Text("%u", (unsigned)((r20 >> 3) & 7));

            ImGui::TableSetColumnIndex(5); ImGui::Text("%c/%c", (r20 & 0x40) ? 'L' : '-', (r20 & 0x80) ? 'R' : '-');

            ImGui::TableSetColumnIndex(6); ImGui::Text("%u", (unsigned)((r38 >> 4) & 7));

            ImGui::TableSetColumnIndex(7); ImGui::Text("%u", (unsigned)(r38 & 3));

            ImGui::TableSetColumnIndex(8); draw_key_mask(YM_debug_get_keyon(ch));

            ImGui::TableSetColumnIndex(9); draw_eg_summary(ch);

            ImGui::TableSetColumnIndex(10);

            snprintf(id, sizeof(id), "##lev%d", ch);

            dbgui_level_meter(id, channel_carrier_level(ch), ImVec2(80.0f, 0.0f), IM_COL32(80, 190, 110, 255));

            if (silent) ImGui::EndDisabled();

        }

        ImGui::EndTable();

    }

}

void draw_env_shape(int slot, int ch, ImVec2 size)

{

    ImGui::PushID(slot * 16 + ch);

    ImGui::InvisibleButton("##env", size);

    const ImVec2 p0 = ImGui::GetItemRectMin();

    const ImVec2 p1 = ImGui::GetItemRectMax();

    ImGui::PopID();

    ImDrawList *dl = ImGui::GetWindowDrawList();

    dl->AddRectFilled(p0, p1, IM_COL32(16, 18, 22, 255));

    dl->AddRect(p0, p1, IM_COL32(70, 78, 90, 255));

    const uint8_t tl = op_reg(0x60, slot, ch) & 0x7f;

    const uint8_t ar = op_reg(0x80, slot, ch) & 0x1f;

    const uint8_t d1r = op_reg(0xa0, slot, ch) & 0x1f;

    const uint8_t d2r = op_reg(0xc0, slot, ch) & 0x1f;

    const uint8_t d1l = (op_reg(0xe0, slot, ch) >> 4) & 0x0f;

    const uint8_t rr = op_reg(0xe0, slot, ch) & 0x0f;

    const float w = p1.x - p0.x;

    const float h = p1.y - p0.y;

    const float loud = (float)tl / 127.0f;

    const float sustain = (float)d1l / 15.0f;

    const float x1 = p0.x + w * (0.12f + (31 - ar) * 0.0025f);

    const float x2 = x1 + w * (0.14f + (31 - d1r) * 0.003f);

    const float x3 = x2 + w * (0.18f + (31 - d2r) * 0.002f);

    const float x4 = p1.x - w * (0.08f + (15 - rr) * 0.004f);

    const float y0 = p1.y - 2.0f;

    const float y_peak = p0.y + 2.0f + h * loud;

    const float y_sus = p0.y + 2.0f + h * (loud + (1.0f - loud) * sustain);

    ImVec2 pts[5] = { ImVec2(p0.x + 2.0f, y0), ImVec2(x1, y_peak), ImVec2(x2, y_sus), ImVec2(x3, y_sus), ImVec2(x4, y0) };

    dl->AddPolyline(pts, 5, IM_COL32(120, 190, 255, 255), false, 1.5f);

}

void draw_operator_row(int ch, int slot)

{

    const uint8_t r40 = op_reg(0x40, slot, ch);

    const uint8_t r60 = op_reg(0x60, slot, ch);

    const uint8_t r80 = op_reg(0x80, slot, ch);

    const uint8_t ra0 = op_reg(0xa0, slot, ch);

    const uint8_t rc0 = op_reg(0xc0, slot, ch);

    const uint8_t re0 = op_reg(0xe0, slot, ch);

    ym_debug_operator op = {};

    YM_debug_get_operator(op_index(slot, ch), &op);

    ImGui::TableNextRow();

    ImGui::TableSetColumnIndex(0); ImGui::Text("Ch %d %s", ch, s_slot_names[slot]);

    ImGui::TableSetColumnIndex(1); ImGui::Text("%u", (unsigned)((r40 >> 4) & 7));

    ImGui::TableSetColumnIndex(2); ImGui::Text("%u", (unsigned)(r40 & 0x0f));

    ImGui::TableSetColumnIndex(3); ImGui::Text("%u", (unsigned)(r60 & 0x7f));

    ImGui::TableSetColumnIndex(4); ImGui::Text("%u", (unsigned)((r80 >> 6) & 3));

    ImGui::TableSetColumnIndex(5); ImGui::Text("%u", (unsigned)(r80 & 0x1f));

    ImGui::TableSetColumnIndex(6); ImGui::Text("%u", (unsigned)(ra0 & 0x1f));

    ImGui::TableSetColumnIndex(7); ImGui::Text("%u", (unsigned)((rc0 >> 6) & 3));

    ImGui::TableSetColumnIndex(8); ImGui::Text("%u", (unsigned)(rc0 & 0x1f));

    ImGui::TableSetColumnIndex(9); ImGui::Text("%u", (unsigned)((re0 >> 4) & 0x0f));

    ImGui::TableSetColumnIndex(10); ImGui::Text("%u", (unsigned)(re0 & 0x0f));

    ImGui::TableSetColumnIndex(11); ImGui::TextUnformatted((ra0 & 0x80) ? "yes" : "no");

    ImGui::TableSetColumnIndex(12); ImGui::TextColored(ImColor(eg_color(op.eg_state)), "%s", s_eg_names[(op.eg_state <= YM_EG_RELEASE) ? op.eg_state : 0]);

    ImGui::TableSetColumnIndex(13);

    char id[32];

    snprintf(id, sizeof(id), "##att%d_%d", ch, slot);

    dbgui_level_meter(id, operator_level(slot, ch), ImVec2(90.0f, 0.0f), IM_COL32(90, 170, 240, 255));

    ImGui::TableSetColumnIndex(14);

    draw_env_shape(slot, ch, ImVec2(110.0f, 28.0f));

}

void draw_operators_tab()

{

    static bool show_all = false;

    ImGui::Checkbox("Show all 32 operators grouped by channel", &show_all);

    ImGui::TextDisabled("Envelope sketches are qualitative ADSR/TL shapes, not cycle-accurate ymfm EG traces.");

    const int first_ch = show_all ? 0 : s_selected_ch;

    const int last_ch = show_all ? YM_NUM_CHANNELS : (s_selected_ch + 1);

    if (ImGui::BeginTable("ym_ops", 15, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable | ImGuiTableFlags_ScrollY, ImVec2(0.0f, 0.0f))) {

        const char *cols[15] = { "Slot", "DT1", "MUL", "TL", "KS", "AR", "D1R", "DT2", "D2R", "D1L", "RR", "AMS-EN", "EG state", "Atten", "ADSR sketch" };

        for (int i = 0; i < 15; ++i) ImGui::TableSetupColumn(cols[i]);

        ImGui::TableHeadersRow();

        for (int ch = first_ch; ch < last_ch; ++ch) {

            for (int slot = 0; slot < OP_COUNT; ++slot) draw_operator_row(ch, slot);

        }

        ImGui::EndTable();

    }

}

uint8_t source_mask(uint8_t selector)

{

    switch (selector) {

    case 1: return 0x1;

    case 2: return 0x2;

    case 3: return 0x4;

    case 5: return 0x3;

    case 6: return 0x5;

    case 7: return 0x6;

    default: return 0x0;

    }

}

void draw_arrow(ImDrawList *dl, ImVec2 a, ImVec2 b, ImU32 color)

{

    dl->AddLine(a, b, color, 2.0f);

    const float ang = atan2f(b.y - a.y, b.x - a.x);

    const float len = 8.0f;

    const ImVec2 p1(b.x - cosf(ang - 0.45f) * len, b.y - sinf(ang - 0.45f) * len);

    const ImVec2 p2(b.x - cosf(ang + 0.45f) * len, b.y - sinf(ang + 0.45f) * len);

    dl->AddTriangleFilled(b, p1, p2, color);

}

void draw_algorithm_tab()

{

    const int ch = s_selected_ch;

    const int alg = alg_for_ch(ch);

    const uint8_t fb = (ch_reg(0x20, ch) >> 3) & 7;