// Commander X16 Emulator — ImGui Disassembly panel.

//

// Renders an anchored, bank-aware 65C02/65C816 disassembly around the current

// PC using the code_map core (src/code_map.*): instruction boundaries are

// aligned from live-execution coverage + recorded M/X/E flags, so the listing

// stays correct even through variable-width 65C816 code. Features:

//   * follow-PC auto-centering (toggle) with current-instruction highlight,

//   * a clickable address gutter that toggles breakpoints (with markers),

//   * goto-address, mouse-wheel scrolling, and bytes + mnemonic + effective addr.

#include "imgui.h"

#include "debug_ui_panels.h"

#include "debug_ui_bridge.h"

#include "debug_ui_widgets.h" // dbgui_value_lines

#include "debug_ui_insn_tooltip.h" // dbgui_instruction_tooltip_body

#include <stdio.h>

#include <string.h>

#include <stdint.h>

#include <stdlib.h>

namespace {

bool     s_follow_pc = true;   // auto-scroll to the current instruction

uint16_t s_view_center = 0;    // address the listing is anchored on

bool     s_view_valid = false; // has s_view_center been initialised?

char     s_goto_buf[8] = "";   // hex goto input

char     s_sym_buf[64] = "";   // go-to-symbol (label name) input

bool     s_show_labels = true; // annotate the listing with .dbg labels

// The RAM/ROM bank window an address reads from (mirrors getCurrentBank()).

int

x16bank_for(uint16_t addr, uint8_t bank, uint8_t rambank, uint8_t rombank)

{

	if (addr >= 0xA000 && bank == 0)

		return addr < 0xC000 ? (int)rambank : (int)rombank;

	return -1;

}

// Index of a breakpoint at (pc, bank, x16bank), or -1.

//

// Delegates to the core rather than re-walking breakPoints[] here. Comparing pc

// and bank only -- which this did -- ignores the bank selector that identifies a

// breakpoint, so the gutter drew a dot for a breakpoint set in a different RAM

// bank; clicking it then failed to find one to remove and silently added a

// second, once per bank the machine happened to be in.

int

find_breakpoint(int pc, uint8_t bank, int x16bank)

{

	return debug_bp_find(pc, bank, x16bank);

}

void

toggle_breakpoint(uint16_t addr, uint8_t bank, int x16bank)

{

	if (!DEBUGRemoveBreakPoint((int)addr, bank, x16bank)) {

		struct breakpoint bp = {};

		bp.pc      = (int)addr;

		bp.bank    = bank;

		bp.x16Bank = x16bank;

		DEBUGAddBreakPoint(bp);

	}

}

// Advance `center` by `delta` instructions (negative = backward).

uint16_t

move_center(uint16_t center, int delta, uint8_t bank, uint8_t rambank, uint8_t rombank)

{

	while (delta < 0) {

		center = code_map_prev_instruction(center, bank, rambank, rombank);

		delta++;

	}

	while (delta > 0) {

		code_map_line_t ln;

		uint16_t        next = center;

		code_map_disasm_forward(center, bank, rambank, rombank, 1, &ln, 1, &next);

		center = next;

		delta--;

	}

	return center;

}

void

disasm_panel_render(bool *p_open)

{

	if (!ImGui::Begin("Disassembly", p_open)) {

		dbgui_window_end();

		return;

	}

	dbgui_window_zoom("disasm"); // Ctrl+wheel zooms this window's text only

	const uint16_t pc      = regs.pc;

	const uint8_t  bank    = regs.k;

	const uint8_t  rambank = memory_get_ram_bank();

	const uint8_t  rombank = memory_get_rom_bank();

	if (!s_view_valid) {

		s_view_center = pc;

		s_view_valid  = true;

	}

	// Honor a cross-panel goto request (from Symbols / Call Stack panels).

	{

		uint16_t gaddr;

		uint8_t  gbank;

		if (debug_ui_peek_goto(&gaddr, &gbank)) {

			s_view_center = gaddr;

			s_follow_pc   = false;

		}

	}

	// ── Toolbar ──────────────────────────────────────────────────────────

	ImGui::Checkbox("Follow PC", &s_follow_pc);

	ImGui::SameLine();

	if (ImGui::Button("Go to PC")) {

		s_view_center = pc;

		s_follow_pc   = true;

	}

	ImGui::SameLine();

	ImGui::SetNextItemWidth(70.0f);

	if (ImGui::InputText("Goto", s_goto_buf, sizeof(s_goto_buf),

	                     ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_EnterReturnsTrue)) {

		if (s_goto_buf[0] != '\0') {

			s_view_center = (uint16_t)strtoul(s_goto_buf, nullptr, 16);

			s_follow_pc   = false;

		}

	}

	ImGui::SameLine();

	ImGui::TextDisabled("K:%02X RAM:%02X ROM:%02X", bank, rambank, rombank);

	// Go-to-symbol + label toggle (cc65 .dbg labels).

	ImGui::SetNextItemWidth(120.0f);

	if (ImGui::InputTextWithHint("##sym", "label", s_sym_buf, sizeof(s_sym_buf),

	                             ImGuiInputTextFlags_EnterReturnsTrue)) {

		uint16_t sym_addr;

		if (s_sym_buf[0] != '\0' && debug_ui_label_to_addr(s_sym_buf, &sym_addr)) {

			s_view_center = sym_addr;

			s_follow_pc   = false;

		}

	}

	ImGui::SameLine();

	if (ImGui::Button("Go to sym")) {

		uint16_t sym_addr;

		if (s_sym_buf[0] != '\0' && debug_ui_label_to_addr(s_sym_buf, &sym_addr)) {

			s_view_center = sym_addr;

			s_follow_pc   = false;

		}

	}

	ImGui::SameLine();

	ImGui::Checkbox("Labels", &s_show_labels);

	if (s_follow_pc)

		s_view_center = pc;

	ImGui::Separator();

	// ── Listing ──────────────────────────────────────────────────────────

	ImGui::BeginChild("disasm_lines", ImVec2(0, 0), false, ImGuiWindowFlags_NoMove);

	// Fill the visible area: split the rows above/below the anchor so the

	// centered instruction sits in the middle.

	const float line_h = ImGui::GetTextLineHeightWithSpacing();

	int rows = (int)(ImGui::GetContentRegionAvail().y / (line_h > 0 ? line_h : 1.0f));

	if (rows < 8)

		rows = 8;

	if (rows > 500)

		rows = 500;

	const int before = rows / 2;

	const int after  = rows - before;

	static code_map_line_t lines[512];

	int center_index = -1;

	int n = code_map_disasm_window(s_view_center, bank, rambank, rombank,

	                               before, after, lines, 512, &center_index);

	(void)center_index;

	ImDrawList  *draw   = ImGui::GetWindowDrawList();

	const float  glyph  = ImGui::CalcTextSize("0").x;

	const float  gutter = glyph * 2.0f;

	bool cursor_set = false; // did the mouse hover an instruction row this frame?

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

		const code_map_line_t &ln = lines[i];

		const bool is_pc  = (ln.addr == pc);

		// Same bank the toggle below uses, so the dot and the click agree.

		const int  ln_x16 = x16bank_for(ln.addr, bank, rambank, rombank);

		const int  bpidx  = find_breakpoint((int)ln.addr, bank, ln_x16);

		const bool has_bp = (bpidx >= 0);

		ImGui::PushID(i);

		// Clickable gutter → toggle breakpoint on this address.

		const ImVec2 row_pos = ImGui::GetCursorScreenPos();

		if (ImGui::InvisibleButton("bp", ImVec2(gutter, line_h))) {

			toggle_breakpoint(ln.addr, bank, ln_x16);

		}

		if (has_bp) {

			const ImVec2 c(row_pos.x + gutter * 0.5f, row_pos.y + line_h * 0.5f);

			draw->AddCircleFilled(c, glyph * 0.45f, IM_COL32(230, 60, 60, 255));

		}

		// Build the fixed-width text: bytes + mnemonic (+ effective address).

		char bytes[16];

		int  bl = 0;

		for (int b = 0; b < ln.size && b < 4; b++)

			bl += snprintf(bytes + bl, sizeof(bytes) - (size_t)bl, "%02X ", ln.bytes[b]);

		for (; bl < 12 && bl < (int)sizeof(bytes) - 1; bl++)

			bytes[bl] = ' ';

		bytes[bl] = '\0';

		char eff[48] = "";

		if (ln.eff_addr >= 0) {

			const char *elabel = nullptr;

			if (s_show_labels && dbg_info_addr_to_label((uint16_t)ln.eff_addr, &elabel) && elabel) {

				snprintf(eff, sizeof(eff), "  =%04X %s", (unsigned)ln.eff_addr, elabel);

			} else {

				snprintf(eff, sizeof(eff), "  =%04X", (unsigned)ln.eff_addr);

			}

		}

		// Label at this instruction's own address, shown comment-style at the

		// end so the fixed-width columns stay aligned.

		char lbl[40] = "";

		const char *linelabel = nullptr;

		if (s_show_labels && dbg_info_addr_to_label(ln.addr, &linelabel) && linelabel) {

			snprintf(lbl, sizeof(lbl), "  ; %s", linelabel);

		}

		char text[160];

		snprintf(text, sizeof(text), "%04X: %s %-18s%s%s", ln.addr, bytes, ln.text, eff, lbl);

		// Row on the same line as the gutter; the Selectable also toggles the

		// breakpoint so clicking anywhere on the address line works.

		// Colour by whether the address carries live-execution evidence, not by

		// whether the row is a whole instruction. A row cut short by a boundary

		// carries start_recorded = true with recorded = false, and tinting it

		// as "inferred" would deny evidence that exists. The tint tracks a

		// currently believed anchor, which is the best signal available -- not

		// proof the code on screen is what ran.

		ImGui::SameLine(0.0f, 0.0f);

		ImVec4 col = is_pc             ? ImVec4(1.00f, 0.92f, 0.40f, 1.0f)   // current PC

		           : ln.start_recorded ? ImVec4(0.86f, 0.86f, 0.86f, 1.0f)   // anchored

		                               : ImVec4(0.55f, 0.55f, 0.58f, 1.0f);  // inferred

		ImGui::PushStyleColor(ImGuiCol_Text, col);

		if (ImGui::Selectable(text, is_pc)) {

			toggle_breakpoint(ln.addr, bank, x16bank_for(ln.addr, bank, rambank, rombank));

		}

		ImGui::PopStyleColor();

		// Publish the hovered instruction as the Ctrl+F10 "run to cursor" target.

		if (ImGui::IsItemHovered()) {

			debug_ui_set_cursor(ln.addr, bank, true);

			cursor_set = true;

			// Same instruction help the Source panel gives, so hovering here

			// explains the instruction and — on the PC's row — predicts what it

			// will do. Followed by the operand's live value.

			//

			// Gated on the row being an instruction at all, and on the lookup

			// succeeding -- not merely on a token being extracted. code_map

			// renders a row whose decode had to be cut short as its raw data

			// bytes (".byte $2c"), which yields a token that is not an

			// instruction. Opening a tooltip for it would show an empty box,

			// since the body returns immediately and those rows carry no

			// effective address either.

			//

			// This cannot hide a tooltip that had content: the body draws

			// nothing at all unless the lookup succeeds, and the operand-value

			// section below is gated on eff_addr independently. Swept the whole

			// opcode space (both CPUs, both width settings) for mnemonics the

			// table lacks: only "dbg" ($DB), which is implied and so has no

			// effective address -- it too used to open an empty box.

			char mnem[16];

			const bool have_mnem = ln.kind == CM_LINE_INSTRUCTION &&

			                       dbgui_mnemonic_of(ln.text, mnem, sizeof mnem) &&

			                       insn_info_lookup(mnem) != nullptr;

			if (have_mnem || ln.eff_addr >= 0) {

				ImGui::BeginTooltip();

				if (have_mnem) {

					dbgui_instruction_tooltip_body(mnem, ln.addr, bank, is_pc);

				}

				if (ln.eff_addr >= 0) {

					uint16_t ea = (uint16_t)ln.eff_addr;

					uint8_t  b  = debug_ui_read6502(ea, 0, DEBUG_UI_CURRENT_BANK);

					uint8_t  b2 = debug_ui_read6502((uint16_t)(ea + 1), 0, DEBUG_UI_CURRENT_BANK);

					uint16_t w  = (uint16_t)(b | (b2 << 8));

					const char *elabel = nullptr;

					if (have_mnem)

						ImGui::Separator();

					if (dbg_info_addr_to_label(ea, &elabel) && elabel)

						ImGui::Text("[$%04X]  %s", ea, elabel);

					else

						ImGui::Text("[$%04X]", ea);

					ImGui::Separator();

					ImGui::TextDisabled("byte");

					dbgui_value_lines(b, 1);

					ImGui::Separator();

					ImGui::TextDisabled("word (LE)");

					dbgui_value_lines(w, 2);

				}

				ImGui::EndTooltip();

			}

		}

		// Right-click an instruction → run to it (only meaningful while paused).

		if (ImGui::BeginPopupContextItem("disasm_ctx")) {

			ImGui::BeginDisabled(!DEBUGIsPaused());

			if (ImGui::MenuItem("Run to here")) {

				DEBUGRunTo(ln.addr, bank, DEBUG_OWNER_UI);

			}

			ImGui::EndDisabled();

			if (ImGui::MenuItem("Toggle breakpoint")) {

				toggle_breakpoint(ln.addr, bank, x16bank_for(ln.addr, bank, rambank, rombank));

			}

			ImGui::EndPopup();

		}

		if (is_pc && (s_follow_pc || ImGui::IsWindowAppearing()))

			ImGui::SetScrollHereY(0.5f);

		ImGui::PopID();

	}

	if (!cursor_set)

		debug_ui_set_cursor(0, 0, false); // nothing hovered → invalidate run-to-cursor

	// Mouse-wheel scrolling re-anchors the view (and drops follow-PC).

	if (ImGui::IsWindowHovered()) {

		const float wheel = ImGui::GetIO().MouseWheel;

		if (wheel != 0.0f) {

			s_follow_pc   = false;

			s_view_center = move_center(s_view_center, (int)(-wheel * 3.0f), bank, rambank, rombank);

		}

	}

	ImGui::EndChild();

	dbgui_window_end();

}

DebugPanelRegistration s_reg("Disassembly", disasm_panel_render, true);

} // namespace