// Commander X16 Emulator — ImGui debugger "Memory" panel.

//

// A hex/ASCII viewer + editor built on imgui_club's MemoryEditor. Because X16

// memory is banked/virtual there is no single contiguous buffer, so we use

// MemoryEditor's callback form (ReadFn/WriteFn) with a dummy base pointer and

// treat the byte offset as an address.

//

// Two views (tabs):

//   * CPU  — the 64K CPU address space, with RAM ($A000-$BFFF) and ROM

//            ($C000-$FFFF) bank selectors, a Goto box, PC + watchpoint

//            highlighting, and set/clear of memory-write watchpoints.

//   * VRAM — VERA video memory, 0..0x1FFFF.

//

// All emulator state is reached through debug_ui_bridge.h (never core headers).

#include <stddef.h>

#include <stdint.h>

#include <cctype>

#include <cstring>

#include <vector>

#include "imgui.h"

#include "debug_ui_panels.h"

#include "debug_ui_bridge.h"

#include "debug_ui_widgets.h"    // dbgui_value_lines

#include "debug_ui_settings.h"   // user preferences (highlight toggle + fade)

#include "imgui_memory_editor.h" // imgui_club MemoryEditor

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

// debug_ui_write6502 — declared (extern "C") in debug_ui_bridge.h. Defined here

// for now; wraps the core debug_write6502() so the edit updates the machine and

// does nothing else: no cycles spent, no watchpoint reported. The byte reads as

// though it had always been there. For banked RAM/ROM, the write targets the

// currently mapped bank, so we temporarily point the mapping at the bank the

// user is viewing and restore it. The emulator is paused in the debugger while

// editing, so this bank juggling is not observable by the running program.

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

extern "C" void

debug_ui_write6502(uint16_t address, uint8_t value, uint8_t bank, int16_t x16Bank)

{

    if (x16Bank >= 0 && address >= 0xA000 && address < 0xC000) { // banked RAM

        uint8_t saved = memory_get_ram_bank();

        memory_set_ram_bank((uint8_t)x16Bank);

        debug_write6502(address, bank, value);

        memory_set_ram_bank(saved);

    } else if (x16Bank >= 0 && address >= 0xC000) { // banked ROM / cartridge

        uint8_t saved = memory_get_rom_bank();

        memory_set_rom_bank((uint8_t)x16Bank);

        debug_write6502(address, bank, value);

        memory_set_rom_bank(saved);

    } else {

        debug_write6502(address, bank, value);

    }

}

namespace {

constexpr size_t   CPU_SIZE  = 0x10000;  // 64K CPU address space

constexpr size_t   VRAM_SIZE = 0x20000;  // 128K VERA video memory

constexpr int      MAX_WP    = MAX_WATCHPOINTS;

// Background for a selected / navigated-to byte range. The editor's default is

// white at 20% alpha, which reads as a washed-out grey and is easy to lose in a

// wall of hex. This is close to the Source panel's current-line blue so "this is

// what you picked" looks the same across panels, and stays translucent so the

// hex digits remain legible on top of it.

constexpr ImU32    SEL_HIGHLIGHT = IM_COL32(70, 130, 245, 140);

// UI-selected banks for the banked CPU regions. Lazily initialised to the CPU's

// current mapping so the view opens on what the machine is actually running.

int  g_ram_bank   = 0;

int  g_rom_bank   = 0;

bool g_banks_init = false;

// The 65C816 CPU bank byte for the CPU tab (X16 GS / gen2). 0 = the classic X16

// map (I/O + windowed $A000-$BFFF/$C000-$FFFF banks); 1..num_banks-1 = a flat

// 64K RAM page. Only meaningful/shown in gen2.

int  g_cpu_bank   = 0;

uint16_t g_cpu_goto  = 0x0000; // CPU goto target

uint32_t g_vram_goto = 0x00000; // VRAM goto target

// Which bank applies to a CPU address given the current selectors.

int16_t

cpu_bank_for(uint16_t addr)

{

    if (addr >= 0xA000 && addr < 0xC000) return (int16_t)g_ram_bank; // RAM bank

    if (addr >= 0xC000)                  return (int16_t)g_rom_bank; // ROM bank

    return DEBUG_UI_CURRENT_BANK;                                    // low RAM / I/O

}

// ---- Recent-write tracking -------------------------------------------------

// Stepping shows you the instruction but not its effect, so diff memory and

// pulse whatever changed, fading the tint out over a second or two (the

// Cheat-Engine idiom). The fade runs on wall-clock time rather than a count of

// stops, so it reads the same whether you are single-stepping or watching the

// machine run.

//

// Scope is the CPU address space including whichever banked window is mapped -

// i.e. what the program is actually touching. VRAM is deliberately excluded: it

// churns every frame and would be a solid wall of colour.

//

// Cost is bounded by only re-diffing on a new stop, or at a capped rate while

// running - never once per frame.

struct MemChangeTracker {

    uint8_t  prev[0x10000];

    float    when[0x10000];   // time the byte last changed; 0 = never

    bool     primed = false;

    uint32_t last_stop_cycle = 0;

    double   last_scan_time  = 0.0;

    // Which banks the baseline was captured through, so a change of viewpoint

    // can be told apart from the program writing memory.

    int      baseline_ram_bank = -1;

    int      baseline_rom_bank = -1;

    int      baseline_cpu_bank = -1;

    // The I/O page is not memory and does not belong in a "what changed"

    // sweep. Several registers report live hardware state that differs on

    // every read (the VERA scanline, VIA timers), so every pass would light

    // the whole page up as changed; and a read of one is not always passive --

    // $9F3E clocks the next byte out to the SD card. debug_ui_read6502() asks

    // the devices not to do that, but a debugger has no reason to be poking at

    // I/O to spot memory writes in the first place.

    static bool is_io_page(uint16_t a) { return a >= 0x9F00 && a <= 0x9FFF; }

    void scan(double now)

    {

        if (!primed) {

            for (int a = 0; a < 0x10000; ++a) {

                if (is_io_page((uint16_t)a)) continue;

                prev[a] = debug_ui_read6502((uint16_t)a, 0, cpu_bank_for((uint16_t)a));

            }

            memset(when, 0, sizeof when);

            primed = true;

            return;

        }

        for (int a = 0; a < 0x10000; ++a) {

            if (is_io_page((uint16_t)a)) continue;

            const uint8_t v = debug_ui_read6502((uint16_t)a, 0, cpu_bank_for((uint16_t)a));

            if (v != prev[a]) {

                prev[a] = v;

                when[a] = (float)now;

            }

        }

    }

    void update()

    {

        const double now = ImGui::GetTime();

        // Changing which bank the view reads makes the whole windowed region

        // look different from the baseline. That is a change of viewpoint, not

        // the program writing memory, so re-baseline silently instead of

        // flooding the view with red.

        if (g_ram_bank != baseline_ram_bank || g_rom_bank != baseline_rom_bank ||

            g_cpu_bank != baseline_cpu_bank) {

            baseline_ram_bank = g_ram_bank;

            baseline_rom_bank = g_rom_bank;

            baseline_cpu_bank = g_cpu_bank;

            reset();

        }

        if (DEBUGIsPaused()) {

            // One diff per stop: re-scanning every frame while parked would

            // find nothing and just burn cycles.

            if (primed && clockticks6502 == last_stop_cycle) {

                return;

            }

            last_stop_cycle = clockticks6502;

            last_scan_time  = now;

            scan(now);

            return;

        }

        // Free-running: often enough to look live, rarely enough that a 64K

        // compare cannot dominate the frame.

        if (now - last_scan_time < 0.05) {

            return;

        }

        last_scan_time  = now;

        last_stop_cycle = clockticks6502;

        scan(now);

    }

    // Tint for an address, or 0 once it has fully faded.

    ImU32 color(uint16_t addr, float fade_seconds) const

    {

        const float t0 = when[addr];

        if (t0 <= 0.0f || fade_seconds <= 0.0f) {

            return 0;

        }

        const float age = (float)ImGui::GetTime() - t0;

        if (age < 0.0f || age >= fade_seconds) {

            return 0;

        }

        const float k     = 1.0f - (age / fade_seconds);    // 1 at the moment of change

        const int   alpha = (int)(30.0f + 195.0f * k * k);  // ease out: a sharp pulse

        return IM_COL32(220, 40, 40, alpha);

    }

    void reset()

    {

        primed = false;

        memset(when, 0, sizeof when);

    }

};

MemChangeTracker g_mem_changes;

// ---- MemoryEditor callbacks -----------------------------------------------

ImU8

cpu_read_fn(const ImU8 *, size_t off, void *)

{

    uint16_t addr = (uint16_t)off;

    // gen2 flat RAM page (CPU bank byte != 0): read flat, bypassing the windows.

    if (g_cpu_bank != 0)

        return debug_ui_read6502(addr, (uint8_t)g_cpu_bank, DEBUG_UI_CURRENT_BANK);

    return debug_ui_read6502(addr, 0, cpu_bank_for(addr));

}

void

cpu_write_fn(ImU8 *, size_t off, ImU8 d, void *)

{

    uint16_t addr = (uint16_t)off;

    if (g_cpu_bank != 0)

        write6502(addr, (uint8_t)g_cpu_bank, d); // flat RAM page

    else

        debug_ui_write6502(addr, d, 0, cpu_bank_for(addr));

}

// Background tint: green for the current PC, red for watchpoint-covered bytes,

// amber for bytes written since the last stop (fading over the following stops).

ImU32

cpu_bg_color_fn(const ImU8 *, size_t off, void *)

{

    uint16_t addr = (uint16_t)off;

    // PC highlight only when the viewed CPU bank matches the program bank (K).

    if (addr == regs.pc && g_cpu_bank == regs.k) return IM_COL32(60, 140, 60, 140);

    // Watchpoints only apply to bank 0 (write watchpoints fire on bank-0 writes).

    if (g_cpu_bank == 0 && DEBUGCheckWatchPoint(addr)) return IM_COL32(170, 60, 60, 130);

    if (debug_ui_settings().mem_highlight_changes && g_cpu_bank == 0) {

        ImU32 c = g_mem_changes.color(addr, debug_ui_settings().mem_highlight_seconds);

        if (c) return c;

    }

    return 0;

}

ImU8

vram_read_fn(const ImU8 *, size_t off, void *)

{

    return video_space_read((uint32_t)off);

}

void

vram_write_fn(ImU8 *, size_t off, ImU8 d, void *)

{

    video_space_write((uint32_t)off, d);

}

// ---- Banked memory view (RAM or ROM) ---------------------------------------

// Browse any RAM/ROM bank's window directly, independent of the bank currently

// mapped into the CPU space. Assets (music/art) and code overlays live in

// banked RAM; this makes every bank viewable/searchable one at a time, plus an

// optional search across all banks at once.

int      g_bank_region = 0;      // 0 = RAM ($A000-$BFFF), 1 = ROM ($C000-$FFFF)

int      g_bank_sel    = 0;      // selected bank

uint16_t g_bank_goto   = 0xA000; // goto target (real address within the window)

bool     g_bank_all    = false;  // search across all banks at once

uint16_t bank_base() { return g_bank_region == 0 ? 0xA000 : 0xC000; }

size_t   bank_win()  { return g_bank_region == 0 ? 0x2000 : 0x4000; }

int

bank_count()

{

    if (g_bank_region == 0)

        return num_ram_banks > 0 ? (int)num_ram_banks : 1;

    int n = memory_get_num_rom_banks();

    return n > 0 ? n : 1;

}

ImU8

bank_read_fn(const ImU8 *, size_t off, void *)

{

    return debug_ui_read6502((uint16_t)(bank_base() + off), 0, (int16_t)g_bank_sel);

}

void

bank_write_fn(ImU8 *, size_t off, ImU8 d, void *)

{

    debug_ui_write6502((uint16_t)(bank_base() + off), d, 0, (int16_t)g_bank_sel);

}

ImU8

bank_read_at(uint32_t a)

{

    return debug_ui_read6502((uint16_t)(bank_base() + a), 0, (int16_t)g_bank_sel);

}

// Flat read across ALL banks of the current region: flat = bank*win + off.

ImU8

bank_read_at_flat(uint32_t flat)

{

    size_t   w    = bank_win();

    int      bank = (int)(flat / w);

    uint32_t off  = (uint32_t)(flat % w);

    return debug_ui_read6502((uint16_t)(bank_base() + off), 0, (int16_t)bank);

}

// A dummy base pointer for the callback-driven editors (never dereferenced:

// every access in MemoryEditor is guarded by ReadFn/WriteFn).

unsigned char g_dummy_base = 0;

MemoryEditor &

cpu_editor()

{

    static MemoryEditor ed;

    static bool init = false;

    if (!init) {

        ed.ReadFn            = cpu_read_fn;

        ed.WriteFn           = cpu_write_fn;

        ed.BgColorFn         = cpu_bg_color_fn;

        ed.HighlightColor    = SEL_HIGHLIGHT;

        ed.OptShowDataPreview = true;

        ed.OptShowOptions     = true;

        ed.PreviewDataType    = ImGuiDataType_U8; // default the data preview to uint8

        init = true;

    }

    return ed;

}

MemoryEditor &

vram_editor()

{

    static MemoryEditor ed;

    static bool init = false;

    if (!init) {

        ed.ReadFn             = vram_read_fn;

        ed.WriteFn            = vram_write_fn;

        ed.HighlightColor     = SEL_HIGHLIGHT;

        ed.OptShowDataPreview = true;

        ed.OptShowOptions     = true;

        ed.PreviewDataType    = ImGuiDataType_U8; // default the data preview to uint8

        ed.OptAddrDigitsCount = 5; // 0x1FFFF needs 5 hex digits

        init = true;

    }

    return ed;

}

MemoryEditor &

bank_editor()

{

    static MemoryEditor ed;

    static bool init = false;

    if (!init) {

        ed.ReadFn             = bank_read_fn;

        ed.WriteFn            = bank_write_fn;

        ed.HighlightColor     = SEL_HIGHLIGHT;

        ed.OptShowDataPreview = true;

        ed.OptShowOptions     = true;

        ed.PreviewDataType    = ImGuiDataType_U8;

        init = true;

    }

    return ed;

}

// ---- Search ----------------------------------------------------------------

// Find a hex-byte sequence ("A9 00 8D") or an ASCII string in the currently

// viewed space, with Find Next / Find Prev and match highlighting.

struct SearchState {

    char buf[64] = "";

    bool hex     = true;   // hex-bytes vs ASCII

    long last    = -1;     // address of the last match (start of the run)

    bool notfound = false; // last search failed

};

SearchState g_cpu_search;

SearchState g_vram_search;

SearchState g_bank_search;

// Plain-address readers for the search (bank-aware for CPU space).

ImU8 cpu_read_at(uint32_t a)  {

    if (g_cpu_bank != 0) return debug_ui_read6502((uint16_t)a, (uint8_t)g_cpu_bank, DEBUG_UI_CURRENT_BANK);

    return debug_ui_read6502((uint16_t)a, 0, cpu_bank_for((uint16_t)a));

}

ImU8 vram_read_at(uint32_t a) { return video_space_read(a); }

// Parse "A9 00 8D" / "A9008D" into bytes (whitespace ignored, nibbles paired).

bool

parse_hex_pattern(const char *s, std::vector<uint8_t> &out)

{

    out.clear();

    int hi = -1;

    for (const char *p = s; *p; ++p) {

        unsigned char c = (unsigned char)*p;

        if (isspace(c)) continue;

        if (!isxdigit(c)) return false;

        int v = (c <= '9') ? (c - '0') : (tolower(c) - 'a' + 10);

        if (hi < 0) {

            hi = v;

        } else {

            out.push_back((uint8_t)((hi << 4) | v));

            hi = -1;

        }

    }

    if (hi >= 0) out.push_back((uint8_t)hi); // trailing single nibble → low byte

    return !out.empty();

}

bool

parse_ascii_pattern(const char *s, std::vector<uint8_t> &out)

{

    out.clear();

    for (const char *p = s; *p; ++p) out.push_back((uint8_t)*p);

    return !out.empty();

}

// Scan for `pat` starting at candidate position `from`, wrapping over the whole

// space. dir >= 0 searches forward, dir < 0 backward. Returns the match start or

// -1. Only called on a button press, so a linear scan is fine.

long

mem_find(ImU8 (*readfn)(uint32_t), size_t size, const std::vector<uint8_t> &pat, long from, int dir)

{

    size_t m = pat.size();

    if (m == 0 || size < m) return -1;

    long span = (long)(size - m) + 1;   // candidate start positions [0, size-m]

    from = ((from % span) + span) % span;

    for (long k = 0; k < span; k++) {

        long i = (dir >= 0) ? ((from + k) % span) : (((from - k) % span + span) % span);

        bool ok = true;

        for (size_t j = 0; j < m; j++) {

            if (readfn((uint32_t)i + (uint32_t)j) != pat[j]) { ok = false; break; }

        }

        if (ok) return i;

    }

    return -1;

}

// Search UI row for one tab. Highlights the match in `ed` on success.

void

render_search(MemoryEditor &ed, SearchState &st, ImU8 (*readfn)(uint32_t), size_t size)

{

    ImGui::SetNextItemWidth(160);

    bool enter = ImGui::InputText("##search", st.buf, sizeof(st.buf),

                                  ImGuiInputTextFlags_EnterReturnsTrue);

    ImGui::SameLine();

    ImGui::Checkbox("hex", &st.hex);

    ImGui::SameLine();

    bool next = ImGui::Button("Find Next") || enter;

    ImGui::SameLine();

    bool prev = ImGui::Button("Find Prev");

    if (next || prev) {

        std::vector<uint8_t> pat;

        bool ok = st.hex ? parse_hex_pattern(st.buf, pat) : parse_ascii_pattern(st.buf, pat);

        st.notfound = false;

        if (ok) {

            long from = (st.last < 0) ? (next ? 0 : (long)size) : (next ? st.last + 1 : st.last - 1);

            long m = mem_find(readfn, size, pat, from, next ? +1 : -1);

            if (m >= 0) {

                st.last = m;

                ed.GotoAddrAndHighlight((size_t)m, (size_t)m + pat.size());

            } else {

                st.notfound = true;

            }

        } else {

            st.notfound = true;

        }

    }

    if (st.notfound) {

        ImGui::SameLine();

        ImGui::TextColored(ImVec4(0.95f, 0.55f, 0.35f, 1.0f), "no match");

    } else if (st.last >= 0) {

        ImGui::SameLine();

        ImGui::TextDisabled("@ $%lX", (unsigned long)st.last);

    }

}

// ---- Tabs ------------------------------------------------------------------

// Drag-selection over a memory view.

//

// The vendored MemoryEditor only tracks a single byte (DataPreviewAddr), but it

// does publish what the mouse is over, which is enough to build a range on top

// of it without forking the widget. A plain click still edits a byte as before;

// only an actual drag starts a selection.

struct MemSelection {

    bool     active  = false;  // a completed selection exists

    bool     dragging = false;

    size_t   anchor  = 0;

    size_t   lo      = 0;

    size_t   hi      = 0;      // inclusive

    size_t   count() const { return active ? (hi - lo + 1) : 0; }

    void clear() { active = false; dragging = false; }

    // Call every frame, after the editor has drawn (so MouseHovered is current).

    void update(const MemoryEditor &ed)

    {

        const bool over = ed.MouseHovered;

        const size_t at = ed.MouseHoveredAddr;

        if (over && ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {

            anchor   = at;

            dragging = true;

            active   = false; // a fresh click drops any previous selection

        }

        if (dragging && ImGui::IsMouseDragging(ImGuiMouseButton_Left)) {

            if (over) {

                lo     = anchor < at ? anchor : at;