// CPU panel — live registers, status flags, stack, and address watches for the

// in-process ImGui debugger.

//

// Everything lives in the single "CPU" window (one CollapsingHeader per area)

// so the whole panel is contributed by this one already-registered .cpp.

#include <cstdint>

#include <cstdio>

#include <vector>

#include "imgui.h"

#include "debug_ui_panels.h"

#include "debug_ui_bridge.h" // extern "C" struct regs regs; debug_ui_read6502()

#include "debug_ui_widgets.h" // dbgui_hover_value_tooltip / dbgui_value_lines

#include "debug_ui_settings.h" // allow_breaking_changes

extern "C" {

#include "disasm.h" // decode whatever the native IRQ vector points at

}

namespace {

// Hex text-entry flags shared by every register/address input field.

const ImGuiInputTextFlags kHexFlags =

    ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_CharsUppercase;

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

// CPU-mode helpers. The X16 boots a 65C02; the 65C816 adds a native mode

// (regs.e == 0) with selectable 8/16-bit accumulator (M flag) and index (X

// flag) widths. In emulation mode (regs.e == 1) it behaves like the 6502, so

// the widths are forced to 8-bit regardless of the stored M/X status bits.

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

bool cpu_native() { return regs.is65c816 && !regs.e; }

bool acc_is16()   { return cpu_native() && !(regs.status & FLAG_MEMORY_WIDTH); }

bool idx_is16()   { return cpu_native() && !(regs.status & FLAG_INDEX_WIDTH); }

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

// Native-mode interrupt vector probe.

//

// interrupt6502() picks the vector base from E: $FFF0 in emulation, $FFE0 in

// native (+ the vector number, so IRQ is $FFFE vs $FFEE). A ROM written for a

// 6502-class machine has no reason to populate the native slots, and the stock

// X16 ROM does not - $FFEE just contains whatever code bytes live at that

// offset. Clearing E and resuming therefore runs off into garbage at the next

// IRQ, which is 60 Hz here.

//

// Rather than assert that from memory, read it live and show the user what is

// actually there, disassembled, so the warning is about *their* ROM.

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

struct VectorProbe {

    uint16_t native_irq;      // word at $FFEE

    uint16_t emu_irq;         // word at $FFFE

    char     native_disasm[64]; // first instruction at native_irq

    bool     looks_absent;    // heuristic: native slot is not a real vector

};

uint16_t read_word(uint16_t addr)

{

    return (uint16_t)debug_ui_read6502(addr, 0, -1) |

           ((uint16_t)debug_ui_read6502((uint16_t)(addr + 1), 0, -1) << 8);

}

VectorProbe probe_vectors()

{

    VectorProbe p{};

    p.native_irq = read_word(0xFFEE);

    p.emu_irq    = read_word(0xFFFE);

    p.native_disasm[0] = '\0';

    // eff_addr is dereferenced unconditionally by disasm(), so it must be real.

    int32_t eff = -1;

    disasm(p.native_irq, 0, nullptr, p.native_disasm, sizeof p.native_disasm, -1,

           (uint8_t)(FLAG_MEMORY_WIDTH | FLAG_INDEX_WIDTH), &eff);

    // Heuristic, and labelled as one in the UI. On a machine whose ROM really

    // handles native interrupts the two vectors would be set up alike - the X16

    // points its emulation IRQ at a RAM vector ($038B). A native slot pointing

    // into ROM while the emulation one points at RAM means the native slot was

    // never written and we are just reading ROM code.

    const bool emu_in_ram    = p.emu_irq < 0xC000;

    const bool native_in_rom = p.native_irq >= 0xC000;

    p.looks_absent = (emu_in_ram && native_in_rom) || (p.native_irq == 0x0000) ||

                     (p.native_irq == 0xFFFF);

    return p;

}

// Switch the emulation flag the way XCE does, so the machine is left in a state

// the core agrees with. Poking regs.e alone is not enough: while E is set the

// CPU force-sets M and X on every instruction, and emulation mode also pins the

// stack to page 1 and the index high bytes to zero.

void set_emulation_flag(bool emulation)

{

    if (!regs.is65c816 || (regs.e != 0) == emulation) {

        return;

    }

    regs.e = emulation ? 1 : 0;

    if (emulation) {

        regs.status |= FLAG_MEMORY_WIDTH | FLAG_INDEX_WIDTH; // 8-bit A and X/Y

        regs.xh = 0;

        regs.yh = 0;

        regs.sp = (uint16_t)(0x0100 | (regs.sp & 0x00FF));   // stack lives in page 1

    }

    // Leaving emulation deliberately leaves M/X set: real hardware does the

    // same, so A/X/Y stay 8-bit until the program (or the user) clears them.

}

// Changing E out from under a running program is a genuinely destructive poke —

// it is not just a display mode. Emulation and native disagree about the

// interrupt vectors ($FFFE vs $FFEE), about how many bytes an interrupt pushes

// (native also pushes PB, so a mismatched RTI returns to a garbage address),

// about whether the stack is confined to page 1, and — once M is cleared —

// about instruction lengths. So: only offer it while the machine is paused, and

// make the user confirm the first time.

bool s_emu_confirm_open   = false;  // a confirmation is queued for this frame

bool s_emu_confirm_target = false;  // value the user asked for

bool s_emu_skip_confirm   = false;  // "don't ask again" for this session

void draw_emulation_toggle(const char *label)

{

    if (!regs.is65c816) {

        return;

    }

    const bool paused   = DEBUGIsPaused();

    const bool unlocked = debug_ui_settings().allow_breaking_changes;

    const bool editable = paused && unlocked;

    bool e = regs.e != 0;

    ImGui::BeginDisabled(!editable);

    if (ImGui::Checkbox(label, &e)) {

        if (s_emu_skip_confirm) {

            set_emulation_flag(e);

        } else {

            s_emu_confirm_open   = true;

            s_emu_confirm_target = e;

        }

    }

    ImGui::EndDisabled();

    if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {

        if (editable) {

            ImGui::SetTooltip("E - Emulation flag\n"

                              "1 = 6502 emulation mode; 0 = 65C816 native.\n\n"

                              "Applies the same state changes as XCE. Editing is unlocked;\n"

                              "see the confirmation for what this will do to the ROM.");

        } else if (!unlocked) {

            ImGui::SetTooltip("E - Emulation flag (read-only)\n"

                              "1 = 6502 emulation mode; 0 = 65C816 native.\n\n"

                              "The running program owns this flag. Changing it moves interrupts\n"

                              "from $FFFE to $FFEE, and a 6502-era ROM has no handler there, so\n"

                              "the machine crashes at the next IRQ.\n\n"

                              "Enable System > Settings > Safety > \"Allow breaking\n"

                              "modifications\" if you are hand-driving the CPU.");

        } else {

            ImGui::SetTooltip("E - Emulation flag (pause to edit)\n"

                              "Switching CPU mode mid-stream breaks the running program's\n"

                              "stack frames and interrupt vectors.");

        }

    }

}

// Rendered once per frame from cpu_panel_render(), outside the PushID scopes of

// the two places that offer the toggle.

void draw_emulation_confirm_popup()

{

    static const char *kTitle = "Switch CPU mode?";

    if (s_emu_confirm_open) {

        ImGui::OpenPopup(kTitle);

        s_emu_confirm_open = false;

    }

    ImVec2 center = ImGui::GetMainViewport()->GetCenter();

    ImGui::SetNextWindowPos(center, ImGuiCond_Appearing, ImVec2(0.5f, 0.5f));

    if (!ImGui::BeginPopupModal(kTitle, nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {

        return;

    }

    const bool to_emulation = s_emu_confirm_target;

    ImGui::TextColored(ImVec4(0.95f, 0.70f, 0.30f, 1.0f),

                       "Switch to %s mode?", to_emulation ? "6502 emulation" : "65C816 native");

    ImGui::Separator();

    // Read the actual vectors out of the machine in front of the user, rather

    // than asserting what a ROM "usually" does.

    const VectorProbe vp = probe_vectors();

    if (!to_emulation) {

        ImGui::TextUnformatted("Interrupts vector by mode. On this machine, right now:");

        ImGui::Spacing();

        if (ImGui::BeginTable("vec_tbl", 3,

                              ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg |

                                  ImGuiTableFlags_SizingFixedFit)) {

            ImGui::TableSetupColumn("Mode");

            ImGui::TableSetupColumn("IRQ vector");

            ImGui::TableSetupColumn("Points to");

            ImGui::TableHeadersRow();

            ImGui::TableNextRow();

            ImGui::TableNextColumn(); ImGui::TextUnformatted("Emulation (now)");

            ImGui::TableNextColumn(); ImGui::TextUnformatted("$FFFE");

            ImGui::TableNextColumn(); ImGui::Text("$%04X", vp.emu_irq);

            ImGui::TableNextRow();

            ImGui::TableNextColumn();

            ImGui::TextColored(ImVec4(1.00f, 0.45f, 0.45f, 1.0f), "Native (after)");

            ImGui::TableNextColumn();

            ImGui::TextColored(ImVec4(1.00f, 0.45f, 0.45f, 1.0f), "$FFEE");

            ImGui::TableNextColumn();

            ImGui::TextColored(ImVec4(1.00f, 0.45f, 0.45f, 1.0f), "$%04X  %s",

                               vp.native_irq, vp.native_disasm);

            ImGui::EndTable();

        }

        ImGui::Spacing();

        if (vp.looks_absent) {

            ImGui::TextColored(ImVec4(1.00f, 0.45f, 0.45f, 1.0f),

                               "This ROM does not appear to provide a native IRQ handler.");

            ImGui::TextUnformatted(

                "$FFEE holds ROM code, not a vector, so the next IRQ - 60 times a\n"

                "second - will execute whatever is at the address above. Expect the\n"

                "machine to crash to the monitor almost immediately after resuming.");

            ImGui::TextDisabled("(Judged by the emulation vector pointing at RAM while the native\n"

                                "one points into ROM. Check the addresses yourself above.)");

        } else {

            ImGui::TextUnformatted("The native vector looks populated, but verify it is really a\n"

                                   "handler before resuming.");

        }

        ImGui::Spacing();

        ImGui::TextUnformatted("Also note:");

    } else {

        ImGui::TextUnformatted(

            "This changes the CPU out from under the running program. Unless it was\n"

            "about to make the same switch itself, expect it to break:");

    }

    ImGui::Bullet();

    ImGui::TextUnformatted("Native interrupts also push the program bank, so an RTI that\n"

                           "doesn't match its entry mode returns to a garbage address.");

    ImGui::Bullet();

    ImGui::TextUnformatted("Emulation confines the stack to page 1; native does not.");

    ImGui::Bullet();

    ImGui::TextUnformatted("In native, clearing M changes instruction lengths, so the PC\n"

                           "stream desyncs from the code that was assembled for 8-bit.");

    ImGui::Separator();

    ImGui::TextDisabled("Fine for experiments and for driving the CPU by hand; not something\n"

                        "a live program will survive.");

    ImGui::Spacing();

    ImGui::Checkbox("Don't ask again this session", &s_emu_skip_confirm);

    ImGui::Spacing();

    if (ImGui::Button("Switch anyway", ImVec2(130, 0))) {

        set_emulation_flag(to_emulation);

        ImGui::CloseCurrentPopup();

    }

    ImGui::SameLine();

    if (ImGui::Button("Cancel", ImVec2(90, 0))) {

        s_emu_skip_confirm = false;  // cancelling shouldn't arm the skip

        ImGui::CloseCurrentPopup();

    }

    ImGui::EndPopup();

}

// Direct-page base + offset, matching the CPU's direct_page_add() (support.h).

// The X16 r0-r15 pseudo-registers live at D+$02..D+$21; D is 0 under the KERNAL

// ABI but can be non-zero in 65C816 native (GS) code, so honor it.

uint16_t dp_add(uint16_t offset)

{

    if (regs.e && (regs.dp & 0x00FF) == 0)

        return (uint16_t)((regs.dp & 0xFF00) | (uint8_t)((uint8_t)(regs.dp & 0xFF) + (offset & 0xFF)));

    return (uint16_t)(regs.dp + offset);

}

char ascii_of(uint8_t b) { return (b >= 0x20 && b < 0x7f) ? (char)b : '.'; }

// Value of a single hex digit, or -1 if the character isn't one.

int hex_digit(char c)

{

    if (c >= '0' && c <= '9') return c - '0';

    if (c >= 'a' && c <= 'f') return c - 'a' + 10;

    if (c >= 'A' && c <= 'F') return c - 'A' + 10;

    return -1;

}

// Width (in pixels) sized to hold `digits` hex characters plus a little padding.

float hex_width(int digits)

{

    return ImGui::CalcTextSize("F").x * (float)(digits + 1) +

           ImGui::GetStyle().FramePadding.x * 2.0f + 4.0f;

}

bool reg_u8(const char *label, uint8_t *p, const char *desc = nullptr)

{

    ImGui::SetNextItemWidth(hex_width(2));

    bool changed = ImGui::InputScalar(label, ImGuiDataType_U8, p, nullptr, nullptr, "%02X", kHexFlags);

    dbgui_hover_value_tooltip(desc, *p, 1);

    return changed;

}

bool reg_u16(const char *label, uint16_t *p, const char *desc = nullptr)

{

    ImGui::SetNextItemWidth(hex_width(4));

    bool changed = ImGui::InputScalar(label, ImGuiDataType_U16, p, nullptr, nullptr, "%04X", kHexFlags);

    dbgui_hover_value_tooltip(desc, *p, 2);

    return changed;

}

// A single P-status flag rendered as a checkbox that reads/writes regs.status.

// `label` carries a "##id" suffix so single-letter flags keep unique ImGui IDs.

// `name`/`desc` drive a hover tooltip that explains what the flag means.

void flag_checkbox(const char *label, uint8_t mask, const char *name, const char *desc)

{

    bool v = (regs.status & mask) != 0;

    if (ImGui::Checkbox(label, &v)) {

        if (v) {

            regs.status |= mask;

        } else {

            regs.status = (uint8_t)(regs.status & ~mask);

        }

    }

    if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {

        int bit = 0;

        for (uint8_t m = mask; m > 1; m >>= 1) {

            bit++;

        }

        ImGui::BeginTooltip();

        ImGui::Text("%s  (bit %d, mask $%02X)", name, bit, mask);

        ImGui::Separator();

        ImGui::TextUnformatted(desc);

        ImGui::TextDisabled("current value: %d", (regs.status & mask) ? 1 : 0);

        ImGui::EndTooltip();

    }

}

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

// Registers

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

void draw_registers()

{

    if (!ImGui::CollapsingHeader("Registers", ImGuiTreeNodeFlags_DefaultOpen)) {

        return;

    }

    ImGui::PushID("registers");

    const bool is816  = regs.is65c816;

    const bool native = cpu_native();

    const char *mode = !is816 ? "65C02 (6502)"

                              : (regs.e ? "65C816 (emulation)" : "65C816 (native)");

    ImGui::Text("Mode: %s", mode);

    // Everything about *why* the register set looks the way it does lives here,

    // rather than as a row of grey annotations next to the fields.

    if (is816) {

        ImGui::SetItemTooltip(

            "M=%d  X=%d  E=%d\n\n"

            "The register set follows the CPU mode.\n"

            "%s\n\n"

            "M (P bit 5) picks the accumulator width, X (P bit 4) the index\n"

            "width; 1 = 8-bit. DP, DB and K are live in both modes.",

            (regs.status >> 5) & 1, (regs.status >> 4) & 1, regs.e ? 1 : 0,

            regs.e ? "Emulation mode re-asserts M and X before every instruction, so\n"

                     "A/X/Y are 8-bit and cannot be widened while E is set. The program\n"

                     "leaves emulation mode with XCE."

                   : "Native mode does not widen the registers by itself - exactly as on\n"

                     "hardware, the program selects the widths with REP/SEP.");

    } else {

        ImGui::SetItemTooltip("A/X/Y are 8-bit. The 65C816-only registers (C, B, DP, DB, K, E)\n"

                              "do not exist on the 65C02 and are not shown.");

    }

    ImGui::Separator();

    reg_u16("PC##rPC", &regs.pc, "PC — Program Counter\nAddress of the next instruction to execute.");

    // SP alongside PC rather than on its own row: it is one field and the two

    // are read together.

    ImGui::SameLine();

    {

        // regs.sp is the full 16-bit stack address in every mode - push8() does

        // write6502(regs.sp, ...) directly - and incsp()/decsp() only ever touch

        // the low byte while E is set. So outside 65C816 native the high byte

        // MUST stay $01, or an edit here would quietly move the stack into zero

        // page and the CPU would keep it there.

        uint16_t sp_disp = (uint16_t)(regs.sp | (is816 ? 0 : 0x0100));

        if (reg_u16("SP##rSP", &sp_disp,

                    native ? "SP - Stack Pointer (16-bit)\n65C816 native: the stack can live anywhere."

                           : "SP - Stack Pointer\nConfined to page 1 ($01xx): pushes and pulls wrap inside\n"

                             "the page. The high byte is held at $01 for you.")) {

            regs.sp = native ? sp_disp : (uint16_t)(0x0100 | (sp_disp & 0x00FF));

        }

    }

    // Accumulator, ordered A B C: the 8-bit accumulator, its hidden high byte,

    // then the two combined. All three are the same storage (LOW_HIGH_UNION), so

    // none of them is ever stale or read-only.

    //

    // C is deliberately shown in emulation mode too. 16-bit *arithmetic* needs

    // M=0 and so is native-only, but XBA, TCD, TDC, TCS and TSC all move the

    // full 16 bits with no M or E check (verified in instructions.h), so C is

    // live state in emulation as well.

    if (is816) {

        reg_u8("A##rA", &regs.a,

               "A - accumulator, low 8 bits of C.\n"

               "The whole accumulator when M selects 8-bit.");

        ImGui::SameLine();

        reg_u8("B##rB", &regs.b,

               "B - accumulator high byte.\n"

               "XBA swaps it with A - which works in emulation mode too, so B is\n"

               "real state whatever the accumulator width is.");

        ImGui::SameLine();

        char cdesc[288];

        snprintf(cdesc, sizeof cdesc,

                 "C - the full 16-bit accumulator, B:A = $%02X%02X\n\n"

                 "%s\n\n"

                 "Not native-only: XBA, TCD, TDC, TCS and TSC move all 16 bits\n"

                 "regardless of M, and work in emulation mode.",

                 regs.b, regs.a,

                 acc_is16() ? "M selects 16-bit, so C is the arithmetic accumulator."

                            : "16-bit arithmetic (LDA, ADC, ...) needs M=0, which needs\n"

                              "native mode, so right now arithmetic uses A alone.");

        reg_u16("C##rC", &regs.c, cdesc);

    } else {

        reg_u8("A##rA", &regs.a, "A - accumulator (8-bit)");

    }

    // Index registers X/Y widen with the X flag (16-bit in native when X=0).

    if (idx_is16()) {

        reg_u16("X##rX", &regs.x, "X — index register (16-bit)");

        ImGui::SameLine();

        reg_u16("Y##rY", &regs.y, "Y — index register (16-bit)");

    } else {

        reg_u8("X##rX", &regs.xl, "X — index register (8-bit)");

        ImGui::SameLine();

        reg_u8("Y##rY", &regs.yl, "Y — index register (8-bit)");

    }

    // Width is visible from the M/X checkboxes and explained on the Mode line, so

    // don't repeat it as a grey annotation. The one thing that needs a control is

    // the manual widen, and only when it is both possible and unlocked.

    if (is816 && native && (!acc_is16() || !idx_is16()) &&

        debug_ui_settings().allow_breaking_changes) {

        if (ImGui::SmallButton("Widen now (REP #$30)")) {

            regs.status &= (uint8_t)~(FLAG_MEMORY_WIDTH | FLAG_INDEX_WIDTH);

        }

        ImGui::SetItemTooltip(

            "Clear M and X, the same thing REP #$30 does, to give 16-bit\n"

            "A/X/Y. Real hardware only widens when the program asks;\n"

            "this is a manual poke, so the running code may not expect it.\n\n"

            "It also only sticks while E stays clear: setting E re-asserts\n"

            "M and X before every instruction.");

    }

    // 65C816-only registers appear only in 65C816 modes (not shown at all on the

    // 65C02). DP/DB/K/E all exist in emulation as well as native: emulation

    // narrows the register widths, it does not switch these off.

    if (is816) {

        ImGui::Separator();

        // Direct Page is live in BOTH modes - direct_page_add() reads regs.dp

        // either way. Emulation only changes how the offset wraps. Hiding it in

        // emulation would hide something that is actively moving the X16's

        // virtual registers R0-R15, which are direct-page relative.

        reg_u16("DP##rDP", &regs.dp,

                native ? "DP - Direct Page register\nBase of the direct (zero) page."

                       : "DP - Direct Page register\nBase of the direct (zero) page. Still live in emulation\n"

                         "mode: when its low byte is 0 the offset wraps inside the page\n"

                         "(6502 behaviour), otherwise it adds normally.");

        ImGui::SameLine();

        reg_u8("DB##rDB", &regs.db,

               "DB - Data Bank register\nHigh byte (bank) for data memory accesses.");

        ImGui::SameLine();