// I/O panel — what the machine is doing to its ports, and to files.

//

// The other panels answer "what is the state of X". This one mostly answers

// "what just happened", because I/O is a conversation: a command goes out, a

// status comes back, a block is read, a file is opened. A register dump of the

// SD card taken between commands tells you almost nothing; the sequence tells

// you everything.

//

// ON THE TWO FILE PATHS, because this is the panel where the difference bites:

// the emulator can serve files from the host filesystem OR from an attached SD

// card image, and by default those are mutually exclusive -- passing -sdcard

// turns host-filesystem access off unless -hostfsdev asks for it back. Only the

// host path knows filenames; an SD image is 512-byte blocks, with the

// filesystem parsed by ROM inside the emulated machine. So the SD half of the

// Files tab depends on sdcard_fat.c parsing the image on our behalf.

//

// ON TOOLTIPS: this panel describes hardware most people do not have memorised,

// and a bare hex byte with no way to find out what it means is not debugging

// information. Every label and every value is hoverable, and the pair share one

// explanation, so a reader can point at whichever half confused them.

#include "imgui.h"

#include "debug_ui_panels.h"

#include "debug_ui_bridge.h"

#include "debug_ui_settings.h"

#include "debug_ui_widgets.h"

#include "io_reg_info.h"

#include <stdarg.h>

#include <stdint.h>

#include <stdio.h>

#include <string.h>

namespace {

const ImVec4 COL_READ    = ImVec4(0.55f, 0.78f, 1.00f, 1.0f);

const ImVec4 COL_WRITE   = ImVec4(1.00f, 0.72f, 0.42f, 1.0f);

const ImVec4 COL_DECODED = ImVec4(0.62f, 0.90f, 0.62f, 1.0f);

const ImVec4 COL_DIM     = ImVec4(0.70f, 0.70f, 0.78f, 1.0f);

const ImVec4 COL_BAD     = ImVec4(0.95f, 0.55f, 0.45f, 1.0f);

const ImVec4 COL_ON      = ImVec4(0.45f, 0.95f, 0.50f, 1.0f);

// Tooltip on whatever widget was just submitted.

void

tip(const char *text)

{

    if (ImGui::IsItemHovered()) {

        ImGui::BeginTooltip();

        ImGui::PushTextWrapPos(ImGui::GetFontSize() * 32.0f);

        ImGui::TextUnformatted(text);

        ImGui::PopTextWrapPos();

        ImGui::EndTooltip();

    }

}

// Attaches an explanation to the item just drawn. Named `help` for the places

// that read as "explain this"; identical to tip().

//

// It deliberately does NOT draw a "(?)" marker. Thirty of those in one panel is

// clutter, and it puts the explanation on a decoration rather than on the thing

// being explained -- the label and the value are what a reader reaches for.

// Discoverability is handled once, by the hint at the top of the panel.

void

help(const char *text)

{

    tip(text);

}

// A heading that is itself hoverable, so the explanation is on the thing being

// explained rather than on a marker beside it.

void

heading(const char *text, const char *tip_text)

{

    ImGui::TextUnformatted(text);

    tip(tip_text);

}

// The tooltip for the row currently being drawn, so the value cell can carry

// the same explanation as its label without the caller repeating it.

const char *g_row_tip = nullptr;

// Start a label/value row. The label is hoverable; call row_end() after drawing

// the value to make that hoverable too.

void

row_begin(const char *label, const char *tip_text)

{

    ImGui::TableNextRow();

    ImGui::TableSetColumnIndex(0);

    ImGui::TextColored(COL_DIM, "%s", label);

    tip(tip_text);

    ImGui::TableSetColumnIndex(1);

    g_row_tip = tip_text;

}

void

row_end()

{

    tip(g_row_tip);

}

// The common case: a formatted value with the same tooltip on both cells.

void

row_kv(const char *label, const char *tip_text, const char *fmt, ...)

{

    row_begin(label, tip_text);

    va_list ap;

    va_start(ap, fmt);

    ImGui::TextV(fmt, ap);

    va_end(ap);

    row_end();

}

// A lit/unlit indicator, for things that are physically a lamp or a bus line.

void

lamp(bool on, const char *label)

{

    ImGui::TextColored(on ? COL_ON : COL_DIM, "%s %s", on ? "\xe2\x97\x8f" : "\xe2\x97\x8b", label);

}

// ---------------------------------------------------------------------------

// Capture gating

// ---------------------------------------------------------------------------

// The settings own the capture preferences; io_trace owns the mask the hot path

// actually tests. Pushing one into the other once per frame keeps the hot path

// reading a single word, rather than chasing the settings struct on every I/O

// access.

void

apply_capture_settings()

{

    const DebugUiSettings &s = debug_ui_settings();

    uint32_t mask = 0;

    if (s.io_cap_via) {

        mask |= IO_TRACE_BIT(IO_DEV_VIA1) | IO_TRACE_BIT(IO_DEV_VIA2);

    }

    if (s.io_cap_vera) {

        mask |= IO_TRACE_BIT(IO_DEV_VERA);

    }

    if (s.io_cap_spi) {

        mask |= IO_TRACE_BIT(IO_DEV_SPI);

    }

    if (s.io_cap_ym) {

        mask |= IO_TRACE_BIT(IO_DEV_YM);

    }

    if (s.io_cap_emu) {

        mask |= IO_TRACE_BIT(IO_DEV_EMU);

    }

    if (s.io_cap_midi) {

        mask |= IO_TRACE_BIT(IO_DEV_MIDI);

    }

    if (s.io_cap_openbus) {

        mask |= IO_TRACE_BIT(IO_DEV_OPENBUS);

    }

    if (s.io_cap_sd) {

        mask |= IO_TRACE_BIT(IO_DEV_SDCARD);

    }

    if (s.io_cap_files) {

        mask |= IO_TRACE_BIT(IO_DEV_IEEE);

    }

    if (s.io_cap_i2c) {

        mask |= IO_TRACE_BIT(IO_DEV_I2C);

    }

    if (s.io_cap_joy) {

        mask |= IO_TRACE_BIT(IO_DEV_JOYSTICK);

    }

    mask |= IO_TRACE_BIT(IO_DEV_SERIAL);

    io_trace_device_mask = mask;

    io_trace_enabled     = s.io_trace_capture;

    // The index is built by sdcard_attach(), which is C and cannot see the

    // settings struct; this flag is how the preference reaches it.

    sdcard_fat_autoindex = s.io_fat_autoindex;

    if (io_trace_capacity() != 0 && io_trace_capacity() != s.io_trace_capacity) {

        io_trace_init(s.io_trace_capacity);

        // io_trace clamps; write back what was actually allocated so the

        // settings field shows the real number rather than the wish.

        debug_ui_settings().io_trace_capacity = io_trace_capacity();

    }

}

// ---------------------------------------------------------------------------

// Activity

// ---------------------------------------------------------------------------

char s_filter[64]  = "";

bool s_autoscroll  = true;

bool s_show_reads  = true;

bool s_show_writes = true;

bool

event_matches(const io_event_t &ev)

{

    if (ev.kind == IO_EVENT_ACCESS) {

        if (ev.is_write && !s_show_writes) {

            return false;

        }

        if (!ev.is_write && !s_show_reads) {

            return false;

        }

    }

    if (s_filter[0] == '\0') {

        return true;

    }

    // Match against what the user can actually see in the row, so a filter that

    // hides a visible row would be a bug rather than a subtlety.

    char addr[16];

    snprintf(addr, sizeof(addr), "$%04X", ev.addr);

    return (strstr(io_trace_device_name((io_device_t)ev.device), s_filter) != nullptr) ||

           (ev.text[0] != '\0' && strstr(ev.text, s_filter) != nullptr) ||

           (ev.has_addr && strstr(addr, s_filter) != nullptr) ||

           (ev.has_addr && strstr(io_reg_name(ev.addr), s_filter) != nullptr);

}

struct DeviceToggle {

    const char *label;

    bool DebugUiSettings::*field;

    const char *tip;

};

// Every one of these is off by default. The tooltips exist because "should I

// tick VERA?" is only answerable if you know both what it adds over the VERA

// panel and what it costs.

const DeviceToggle RAW_TOGGLES[] = {

    {"VIA", &DebugUiSettings::io_cap_via,

     "$9F00-$9F1F. Both VIAs: the joystick latch and clock, the I2C lines to the "

     "SMC and RTC, the IEC serial lines, and the two timers.\n\n"

     "Adds over the VIA tab: the order and timing of accesses. The tab shows the "

     "registers as they are now; this shows the polling loop that got them there.\n\n"

     "Rate: moderate. The KERNAL touches the VIA every frame."},

    {"VERA", &DebugUiSettings::io_cap_vera,

     "$9F20-$9F3F. All 32 VERA registers.\n\n"

     "Adds over the VERA tab: that tab decodes current state, but says nothing "

     "about the sequence that produced it. Only the log shows the address-then-data "

     "handshake, a mid-frame register change, or a raster split as it happens.\n\n"

     "Rate: VERY HIGH. DATA0/DATA1 auto-increment, so a screen fill is one access "

     "per byte -- thousands per frame. Expect this alone to fill the ring."},

    {"SPI", &DebugUiSettings::io_cap_spi,

     "$9F3E/$9F3F only. These are VERA registers, but they are also the only path "

     "to the SD card, so they are captured separately -- ticking SPI does not drag "

     "in VERA's data ports.\n\n"

     "Adds over the SD Card tab: the raw byte stream, for when you need the SPI "

     "conversation itself rather than the decoded command.\n\n"

     "Rate: high while the card is busy -- one access per byte, 512 per block."},

    {"YM", &DebugUiSettings::io_cap_ym,

     "$9F40-$9F5F. The YM2151's register-select latch and data port.\n\n"

     "Adds over the YM2151 tab: which registers a music driver writes and in what "

     "order, per frame. The tab shows the resulting channel state.\n\n"

     "Rate: moderate; a music driver typically writes a burst every frame."},

    {"Emu", &DebugUiSettings::io_cap_emu,

     "$9FB0-$9FBF. The emulator's own control registers: debug toggles, the cycle "

     "counter, character output, and the \"16\" detection bytes.\n\n"

     "Nothing else shows these. Useful for watching a program probe for the "

     "emulator or drive its recording controls.\n\n"

     "Rate: very low."},

    {"MIDI", &DebugUiSettings::io_cap_midi,

     "The MIDI card, if one is fitted. Its base address is configurable, so this "

     "follows wherever it was placed.\n\n"

     "Rate: low, and zero when no card is fitted."},

    {"Open bus", &DebugUiSettings::io_cap_openbus,

     "Addresses in the I/O page that no device answers -- reads return $9F.\n\n"

     "Almost always noise, but it is the one way to catch a program reading a "

     "device it thinks exists and silently getting garbage back.\n\n"

     "Rate: normally zero."},

};

const DeviceToggle DECODED_TOGGLES[] = {

    {"SD", &DebugUiSettings::io_cap_sd,

     "Decoded SD card activity: each command by name (CMD17 READ_SINGLE_BLOCK), and "

     "every 512-byte block read or written -- resolved to a filename and offset when "

     "the image has been indexed.\n\n"

     "This is the one to leave on when you care about disk access.\n\n"

     "Rate: low. A handful per command, one per block."},

    {"Files", &DebugUiSettings::io_cap_files,

     "Host-filesystem file access with real filenames: opens, closes, directory "

     "listings, DOS commands and status codes.\n\n"

     "The Files tab keeps its own always-on history of these, so you do not need "

     "capture on to see them there. This only adds them to this log, in sequence "

     "with everything else.\n\n"

     "Rate: low -- bounded by real file operations."},

    {"I2C", &DebugUiSettings::io_cap_i2c,

     "One event per completed I2C transaction: which device, direction, and how many "

     "bytes moved.\n\n"

     "Rate: about 60/second and CONSTANT. The KERNAL polls the SMC for keyboard input "

     "every frame whether or not a key is pressed, so this will slowly push everything "

     "else out of the ring even on an idle machine."},

    {"Joystick", &DebugUiSettings::io_cap_joy,

     "One event each time the controllers are latched, with the sampled button masks.\n\n"

     "Rate: about 60/second and CONSTANT -- a game reads the pad every frame whether "

     "or not anything is pressed."},

};

void

draw_capture_controls()

{

    DebugUiSettings &s       = debug_ui_settings();

    bool             changed = false;

    changed |= ImGui::Checkbox("Capture", &s.io_trace_capture);

    tip("Record I/O events into the log below.\n\n"

        "Off by default. This is the only debugger feature the running machine pays "

        "for -- a test and a branch on every I/O access, and a copy on every captured "

        "one -- and the I/O page is the busiest address range in the system. Every "

        "other tab in this panel works without it.");

    ImGui::SameLine();

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

        io_trace_clear();

    }

    tip("Discard everything currently in the log.");

    ImGui::SameLine();

    ImGui::Checkbox("Auto-scroll", &s_autoscroll);

    tip("Follow the newest event. Scroll up to stop following; scroll back to the "

        "bottom to resume.");

    ImGui::SameLine(0, 16);

    ImGui::SetNextItemWidth(dbgui_field_width("wwwwwwwwwwww"));

    ImGui::InputTextWithHint("##iofilter", "filter", s_filter, sizeof(s_filter));

    tip("Show only rows whose device, address, register name or text contains this. "

        "Case-sensitive substring match, e.g. \"DATA0\", \"$9F23\", \"SD\".");

    ImGui::SameLine(0, 16);

    ImGui::Checkbox("R", &s_show_reads);

    tip("Show reads.");

    ImGui::SameLine();

    ImGui::Checkbox("W", &s_show_writes);

    tip("Show writes.");

    ImGui::TextUnformatted("Registers:");

    help("Raw register accesses, by address range. These overlap the dedicated tabs "

         "only in subject, not in content: a tab shows you state, this log shows you "

         "sequence and timing -- what was written, in what order, and from which PC.");

    for (const DeviceToggle &t : RAW_TOGGLES) {

        ImGui::SameLine();

        changed |= ImGui::Checkbox(t.label, &(s.*(t.field)));

        tip(t.tip);

    }

    ImGui::TextUnformatted("Decoded: ");

    help("Device-level events rather than register accesses -- an SD command by name, "

         "a file being opened, an I2C transaction. These are what the raw bytes mean.");

    for (const DeviceToggle &t : DECODED_TOGGLES) {

        ImGui::SameLine();

        changed |= ImGui::Checkbox(t.label, &(s.*(t.field)));

        tip(t.tip);

    }

    if (changed) {

        debug_ui_settings_mark_dirty();

    }

    if (!s.io_trace_capture) {

        ImGui::TextColored(COL_DIM, "Capture is off. Tick Capture, then pick at least one device.");

    } else if (io_trace_device_mask == IO_TRACE_BIT(IO_DEV_SERIAL)) {

        ImGui::TextColored(COL_DIM, "No devices selected, so nothing is being recorded.");

    } else {

        ImGui::TextColored(COL_DIM, "%d/%d events", io_trace_count(), io_trace_capacity());

        const uint32_t dropped = io_trace_dropped();

        if (dropped > 0) {

            ImGui::SameLine();

            ImGui::TextColored(COL_DIM, "\xc2\xb7 %u overwritten", dropped);

            tip("The ring wrapped and older events were discarded. Raise the capacity in "

                "System > Settings, or capture fewer devices.");

        }

    }

}

void

draw_activity_tab()

{

    draw_capture_controls();

    ImGui::Separator();

    if (ImGui::BeginTable("io_activity", 7,

                          ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY |

                              ImGuiTableFlags_BordersInnerV | DBGUI_TABLE_FLAGS_RESIZABLE)) {

        ImGui::TableSetupScrollFreeze(0, 1);

        ImGui::TableSetupColumn("Seq", ImGuiTableColumnFlags_WidthFixed,

                                dbgui_col_width("Seq", "8888888"));

        ImGui::TableSetupColumn("PC", ImGuiTableColumnFlags_WidthFixed,

                                dbgui_col_width("PC", "88:8888"));

        ImGui::TableSetupColumn("Device", ImGuiTableColumnFlags_WidthFixed,

                                dbgui_col_width("Device", "Joystick"));

        ImGui::TableSetupColumn("Addr", ImGuiTableColumnFlags_WidthFixed,

                                dbgui_col_width("Addr", "$FFFF"));

        ImGui::TableSetupColumn("Register", ImGuiTableColumnFlags_WidthFixed,

                                dbgui_col_width("Register", "L0_HSCROLL_L"));

        ImGui::TableSetupColumn("R/W", ImGuiTableColumnFlags_WidthFixed,

                                dbgui_col_width("R/W", "W"));

        ImGui::TableSetupColumn("Value / event", ImGuiTableColumnFlags_WidthStretch);

        ImGui::TableHeadersRow();

        // Oldest first, so the log reads downward like any other log and

        // auto-scroll means "follow the newest".

        const int total = io_trace_count();

        for (int i = 0; i < total; i++) {

            const io_event_t *evp = io_trace_at(i);

            if (evp == nullptr) {

                continue;

            }

            const io_event_t &ev = *evp;

            if (!event_matches(ev)) {

                continue;

            }

            const bool decoded = (ev.kind == IO_EVENT_DECODED);

            ImGui::TableNextRow();

            ImGui::TableSetColumnIndex(0);

            ImGui::TextColored(COL_DIM, "%u", ev.seq);

            if (ImGui::IsItemHovered()) {

                ImGui::SetTooltip("cycle %u", ev.cycles);

            }

            ImGui::TableSetColumnIndex(1);

            ImGui::TextColored(COL_DIM, "%02X:%04X", ev.pc_bank, ev.pc);

            tip("Where the CPU was when this happened.");

            ImGui::TableSetColumnIndex(2);

            ImGui::TextUnformatted(io_trace_device_name((io_device_t)ev.device));

            ImGui::TableSetColumnIndex(3);

            if (ev.has_addr) {

                ImGui::Text("$%04X", ev.addr);

                tip(io_reg_purpose(ev.addr));

            } else {

                ImGui::TextUnformatted("-");

            }

            ImGui::TableSetColumnIndex(4);

            if (ev.has_addr) {

                ImGui::TextColored(COL_DIM, "%s", io_reg_name(ev.addr));

                tip(io_reg_purpose(ev.addr));

            } else {

                ImGui::TextUnformatted(" ");

            }

            ImGui::TableSetColumnIndex(5);

            if (decoded && !ev.has_addr) {

                ImGui::TextUnformatted(" ");

            } else {

                ImGui::TextColored(ev.is_write ? COL_WRITE : COL_READ, "%s",

                                   ev.is_write ? "W" : "R");

            }

            ImGui::TableSetColumnIndex(6);

            if (decoded) {

                ImGui::TextColored(COL_DECODED, "%s", ev.text);

            } else {

                ImGui::Text("$%02X", ev.value);

                dbgui_hover_value_tooltip(io_reg_name(ev.addr), ev.value, 1);

            }

        }

        if (s_autoscroll && ImGui::GetScrollY() >= ImGui::GetScrollMaxY() - 1.0f) {

            ImGui::SetScrollHereY(1.0f);

        }

        ImGui::EndTable();

    }

}

// ---------------------------------------------------------------------------

// SD card

// ---------------------------------------------------------------------------

const char *

sd_command_name(uint8_t cmd, bool is_acmd)

{

    if (is_acmd) {

        return (cmd == 41) ? "ACMD41 SD_SEND_OP_COND" : nullptr;

    }

    switch (cmd) {

        case 0:  return "CMD0 GO_IDLE_STATE";

        case 1:  return "CMD1 SEND_OP_COND";

        case 8:  return "CMD8 SEND_IF_COND";

        case 9:  return "CMD9 SEND_CSD";

        case 10: return "CMD10 SEND_CID";

        case 12: return "CMD12 STOP_TRANSMISSION";

        case 16: return "CMD16 SET_BLOCKLEN";

        case 17: return "CMD17 READ_SINGLE_BLOCK";

        case 18: return "CMD18 READ_MULTIPLE_BLOCK";

        case 24: return "CMD24 WRITE_BLOCK";

        case 25: return "CMD25 WRITE_MULTIPLE_BLOCK";

        case 55: return "CMD55 APP_CMD";

        case 58: return "CMD58 READ_OCR";

        default: return nullptr;

    }