// Breakpoints panel — central manager for the debugger's breakpoints, plus a

// "run to address" control. Complements the Disassembly/Source panels (which

// toggle breakpoints inline) by giving one place to add, review, enable/disable,

// and clear them.

//

// Enable/disable belongs to the core: a disabled breakpoint keeps its entry,

// its owners, its condition and its hit count, and simply does not stop the

// machine. This panel used to implement it by deleting the entry and

// remembering it in a list of its own, which meant a disabled breakpoint

// vanished from the table and so showed no gutter marker anywhere else.

//

// The list below is therefore a view of the core's table, rebuilt each frame,

// rather than a superset of it with a lifetime of its own.

//

// All state is reached through the shared bridge (debug_ui_bridge.h).

#include "imgui.h"

#include "debug_ui_panels.h"

#include "debug_ui_bridge.h"

#include "debug_ui_widgets.h"

#include <cstdint>

#include <cstdio>

#include <vector>

namespace {

struct TrackedBP {

	int     pc;

	uint8_t bank;

	int     x16Bank;

	bool    enabled;

};

std::vector<TrackedBP> s_tracked;    // a view of the core's table, rebuilt each frame

int                    s_runto_addr = 0; // hex address for the "Run to" box

// "Add breakpoint" row state. See add_breakpoint_row().

int  s_add_addr         = 0;

int  s_add_bank         = 0;

bool s_add_bank_touched = false; // has the user chosen a bank by hand?

// A breakpoint is identified by (pc, bank, x16Bank), because the same $A000 in

// two RAM banks is two different breakpoints. Keying on (pc, bank) alone

// collapsed them into one row: the count under-reported, "Clear All" left the

// other one armed and the list repopulated itself on the next frame, and the

// enable checkbox flipped back on by itself because the survivor was still

// found.

void

sync_tracked(void)

{

	s_tracked.clear();

	const int n = debug_bp_count();

	s_tracked.reserve((size_t)(n < 0 ? 0 : n));

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

		const struct breakpoint *b = debug_bp_at(i);

		if (!b) {

			break;

		}

		s_tracked.push_back(TrackedBP{b->pc, b->bank, b->x16Bank, b->enabled});

	}

}

void

set_enabled(TrackedBP &t, bool enable)

{

	if (DEBUGSetBreakpointEnabled(t.pc, t.bank, t.x16Bank, enable)) {

		t.enabled = enable;

	}

}

// ---- Conditional-breakpoint editor -----------------------------------------

const char *const kOperandNames[] = {"A", "X", "Y", "SP", "P", "byte[addr]", "word[addr]"};

const char *const kOpNames[]      = {"==", "!=", "<", "<=", ">", ">="};

struct CondEdit {

	int  pc      = 0;

	int  operand = 0;

	int  op      = 0;

	int  addr    = 0;

	int  value   = 0;

	int  ignore  = 0;

	bool loaded  = false;

};

CondEdit s_edit;

// One-line summary of a breakpoint's condition/ignore for the table cell.

void

cond_summary(char *out, size_t n, const TrackedBP &t)

{

	int      has = 0, operand = 0, op = 0;

	uint16_t oaddr = 0;

	uint32_t value = 0, ignore = 0;

	bool     have = DEBUGGetBreakpointCondition(t.pc, t.bank, t.x16Bank, &has, &operand, &oaddr, &op, &value, &ignore);

	if (have && has) {

		if (operand == BP_OPND_BYTE)

			snprintf(out, n, "byte[$%04X]%s$%X", oaddr, kOpNames[op], value);

		else if (operand == BP_OPND_WORD)

			snprintf(out, n, "word[$%04X]%s$%X", oaddr, kOpNames[op], value);

		else

			snprintf(out, n, "%s%s$%X", kOperandNames[operand], kOpNames[op], value);

	} else if (have && ignore > 0) {

		snprintf(out, n, "ignore %u", ignore);

	} else {

		snprintf(out, n, "set...");

	}

}

// Per-row popup to edit the condition + ignore count + reset hits.

void

cond_editor_popup(const TrackedBP &t)

{

	if (!ImGui::BeginPopup("cond_edit"))

		return;

	if (!s_edit.loaded) {

		int      has = 0, operand = 0, op = 0;

		uint16_t oaddr = 0;

		uint32_t value = 0, ignore = 0;

		DEBUGGetBreakpointCondition(t.pc, t.bank, t.x16Bank, &has, &operand, &oaddr, &op, &value, &ignore);

		s_edit.pc      = t.pc;

		s_edit.operand = operand;

		s_edit.op      = op;

		s_edit.addr    = oaddr;

		s_edit.value   = (int)value;

		s_edit.ignore  = (int)ignore;

		s_edit.loaded  = true;

	}

	ImGui::Text("Breakpoint $%04X", (unsigned)(t.pc & 0xFFFF));

	ImGui::Separator();

	ImGui::TextUnformatted("Stop only when:");

	ImGui::SetNextItemWidth(dbgui_combo_width("byte at $"));

	ImGui::Combo("##opnd", &s_edit.operand, kOperandNames, IM_ARRAYSIZE(kOperandNames));

	ImGui::SetItemTooltip("What to test: a CPU register, or the byte/word at an address.");

	ImGui::SameLine();

	if (s_edit.operand == BP_OPND_BYTE || s_edit.operand == BP_OPND_WORD) {

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

		ImGui::InputScalar("##caddr", ImGuiDataType_S32, &s_edit.addr, nullptr, nullptr, "%X",

		                   ImGuiInputTextFlags_CharsHexadecimal);

		ImGui::SetItemTooltip("Address to read, in HEX. \"10\" means $10 (16), not ten.");

		ImGui::SameLine();

	}

	ImGui::SetNextItemWidth(dbgui_combo_width(">="));

	ImGui::Combo("##op", &s_edit.op, kOpNames, IM_ARRAYSIZE(kOpNames));

	ImGui::SetItemTooltip("Comparison to apply.");

	ImGui::SameLine();

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

	ImGui::InputScalar("= $##cval", ImGuiDataType_S32, &s_edit.value, nullptr, nullptr, "%X",

	                   ImGuiInputTextFlags_CharsHexadecimal);

	ImGui::SetItemTooltip("Value to compare against, in HEX (hence the $).\n"

	                      "\"10\" means $10 (16), not ten.");

	ImGui::SameLine();

	ImGui::TextDisabled("(hex)");

	ImGui::SetItemTooltip("Both the address and value fields above are hexadecimal.");

	ImGui::SetNextItemWidth(dbgui_field_width("99999") + ImGui::GetFrameHeight() * 2.0f);

	ImGui::InputInt("ignore first N hits", &s_edit.ignore);

	ImGui::SetItemTooltip("Decimal, unlike the fields above. Let the breakpoint pass this\n"

	                      "many matching hits before it actually stops - useful for reaching\n"

	                      "a particular iteration of a loop.");

	if (s_edit.ignore < 0)

		s_edit.ignore = 0;

	ImGui::Text("Hit count: %u", DEBUGGetBreakpointHits(t.pc, t.bank, t.x16Bank));

	ImGui::SetItemTooltip("Times this breakpoint's condition has matched since it was set or\n"

	                      "last reset. Only counts while the machine is running - sitting at\n"

	                      "the breakpoint does not add to it.");

	ImGui::SameLine();

	if (ImGui::SmallButton("Reset hits"))

		DEBUGResetBreakpointHits(t.pc, t.bank, t.x16Bank);

	ImGui::Separator();

	if (ImGui::Button("Apply")) {

		DEBUGSetBreakpointCondition(t.pc, t.bank, t.x16Bank, s_edit.operand, (uint16_t)s_edit.addr,

		                            s_edit.op, (uint32_t)s_edit.value);

		DEBUGSetBreakpointIgnore(t.pc, t.bank, t.x16Bank, (uint32_t)s_edit.ignore);

		ImGui::CloseCurrentPopup();

	}

	ImGui::SameLine();

	if (ImGui::Button("Clear condition")) {

		DEBUGClearBreakpointCondition(t.pc, t.bank, t.x16Bank);

		DEBUGSetBreakpointIgnore(t.pc, t.bank, t.x16Bank, (uint32_t)s_edit.ignore);

		ImGui::CloseCurrentPopup();

	}

	ImGui::SameLine();

	if (ImGui::Button("Close"))

		ImGui::CloseCurrentPopup();

	ImGui::EndPopup();

}

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

// Breakpoints - break when execution reaches an address.

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

// Highest bank number that exists for the window `addr` falls in. RAM banking is

// sized at runtime by -ram, so this is a real limit, not a constant.

int

max_bank_for(uint16_t addr)

{

	const int n = (addr >= 0xC000) ? memory_get_num_rom_banks() : (int)num_ram_banks;

	return (n > 0 ? n : 1) - 1;

}

int

clamp_bank(int bank, uint16_t addr)

{

	const int hi = max_bank_for(addr);

	return bank < 0 ? 0 : (bank > hi ? hi : bank);

}

// Add a breakpoint by typing its address.

//

// Everywhere else in the debugger a breakpoint is set by pointing at a line -

// the gutter, or F9 on the cursor - which is no help for an address you cannot

// currently see: ROM, a bank that is not mapped in, or code that has not been

// reached yet and so has no disassembly to click. The Memory-writes section

// below has always had a row like this; execution breakpoints did not, and the

// only address box on this panel drove "Run to", which is a one-shot resume and

// not a breakpoint at all.

void

add_breakpoint_row(void)

{

	const uint16_t addr   = (uint16_t)(s_add_addr & 0xFFFF);

	const bool     banked = addr >= 0xA000;

	const int      live   = debug_current_x16_bank((int)addr, 0);

	// Until the user picks a bank the field tracks the mapping the machine is

	// in, so typing an address alone sets exactly the breakpoint clicking the

	// gutter would have set. Leaving the banked window forgets the choice; a

	// chosen bank is re-clamped because the address can move between the RAM

	// and ROM windows under it, and those are different depths.

	if (!banked) {

		s_add_bank_touched = false;

	} else if (!s_add_bank_touched) {

		s_add_bank = live >= 0 ? live : 0;

	} else {

		s_add_bank = clamp_bank(s_add_bank, addr);

	}

	ImGui::TextUnformatted("Break at $");

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

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

	ImGui::InputScalar("##bpaddr", ImGuiDataType_S32, &s_add_addr, nullptr, nullptr, "%04X",

	                   ImGuiInputTextFlags_CharsHexadecimal |

	                       ImGuiInputTextFlags_AutoSelectAll);

	const bool submit = dbgui_committed_with_enter();

	ImGui::SetItemTooltip("Address to break at, in HEX. \"10\" means $10 (16), not ten.\n"

	                      "Press Enter to add.");

	// $A000 and up is read through a bank window, so an address there is not one

	// breakpoint but one per bank. Below it there is nothing to choose.

	ImGui::SameLine();

	ImGui::BeginDisabled(!banked);

	ImGui::TextUnformatted("in bank");

	ImGui::SameLine();

	ImGui::SetNextItemWidth(dbgui_field_width("255") + ImGui::GetFrameHeight() * 2.0f);

	int bank = s_add_bank;

	if (ImGui::InputInt("##bpbank", &bank)) {

		s_add_bank         = clamp_bank(bank, addr);

		s_add_bank_touched = true;

	}

	ImGui::SetItemTooltip("Which bank the address lives in, in DECIMAL. Defaults to the bank\n"

	                      "mapped in right now - the one the gutter would have used.\n"

	                      "$A000-$BFFF selects a RAM bank, $C000-$FFFF a ROM bank.");

	ImGui::EndDisabled();

	ImGui::SameLine();

	const bool add = ImGui::Button("Add##bp") || submit;

	ImGui::SetItemTooltip("You can also click the gutter in the Disassembly or Source panel,\n"

	                      "or press F9 on the cursor line.");

	ImGui::SameLine();

	if (addr >= 0xC000) {

		ImGui::TextDisabled("(ROM)");

	} else if (banked) {

		ImGui::TextDisabled("(RAM)");

	} else {

		ImGui::TextDisabled("(unbanked)");

	}

	ImGui::SetItemTooltip("Addresses below $A000 are the same memory whatever is banked in,\n"

	                      "so the bank does not apply to them.");

	if (add) {

		struct breakpoint bp = {};

		bp.pc                = (int)addr;

		bp.bank              = 0;

		bp.x16Bank           = banked ? s_add_bank : DEBUG_BANK_ANY;

		DEBUGAddBreakPoint(bp);

		sync_tracked(); // show it in the table below this frame, not next

	}

}

void

draw_breakpoints()

{

	// --- Add by address ---------------------------------------------------

	add_breakpoint_row();

	ImGui::Separator();

	// --- Breakpoint list ------------------------------------------------

	ImGui::Text("Breakpoints: %d", (int)s_tracked.size());

	ImGui::SameLine();

	ImGui::BeginDisabled(s_tracked.empty());

	if (ImGui::SmallButton("Enable All")) {

		for (TrackedBP &t : s_tracked) set_enabled(t, true);

	}

	ImGui::SameLine();

	if (ImGui::SmallButton("Disable All")) {

		for (TrackedBP &t : s_tracked) set_enabled(t, false);

	}

	ImGui::SameLine();

	bool clear_all = ImGui::SmallButton("Clear All");

	ImGui::EndDisabled();

	int remove_idx = -1;  // deferred per-row delete

	if (ImGui::BeginTable("bp_table", 6,

	        ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingStretchProp |

	            DBGUI_TABLE_FLAGS_RESIZABLE)) {

		ImGui::TableSetupColumn("On",      ImGuiTableColumnFlags_WidthFixed,

		                        dbgui_col_fit("On", ImGui::GetFrameHeight()));

		ImGui::TableSetupColumn("Address", ImGuiTableColumnFlags_WidthFixed,

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

		ImGui::TableSetupColumn("Bank",    ImGuiTableColumnFlags_WidthFixed,

		                        dbgui_col_width("Bank", "255"));

		ImGui::TableSetupColumn("Hits",    ImGuiTableColumnFlags_WidthFixed,

		                        dbgui_col_width("Hits", "99999"));

		ImGui::TableSetupColumn("Condition", ImGuiTableColumnFlags_WidthStretch);

		ImGui::TableSetupColumn("",        ImGuiTableColumnFlags_WidthFixed,

		                        dbgui_col_fit("", dbgui_field_width("x")));

		ImGui::TableHeadersRow();

		for (int i = 0; i < (int)s_tracked.size(); i++) {

			TrackedBP &t = s_tracked[i];

			ImGui::TableNextRow();

			ImGui::PushID(i);

			ImGui::TableNextColumn();

			bool en = t.enabled;

			if (ImGui::Checkbox("##en", &en)) {

				set_enabled(t, en);

			}

			ImGui::TableNextColumn();

			if (t.enabled) {

				ImGui::Text("$%04X", (unsigned)(t.pc & 0xFFFF));

			} else {

				ImGui::TextDisabled("$%04X", (unsigned)(t.pc & 0xFFFF));

			}

			ImGui::TableNextColumn();

			if (t.x16Bank >= 0) {

				ImGui::Text("%d", t.x16Bank);

			} else {

				ImGui::TextDisabled("-");

			}

			ImGui::TableNextColumn();

			ImGui::Text("%u", DEBUGGetBreakpointHits(t.pc, t.bank, t.x16Bank));

			ImGui::TableNextColumn();

			char summary[48];

			cond_summary(summary, sizeof summary, t);

			if (ImGui::SmallButton(summary)) {

				s_edit.loaded = false;

				ImGui::OpenPopup("cond_edit");

			}

			cond_editor_popup(t);

			ImGui::TableNextColumn();

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

				remove_idx = i;

			}

			ImGui::PopID();

		}

		ImGui::EndTable();

	}

	if (s_tracked.empty()) {

		ImGui::TextDisabled("No breakpoints.");

		ImGui::SetItemTooltip("Type an address above, or click the gutter in the Disassembly\n"

		                      "or Source panel.");

	}

	// Apply deferred mutations after the table is built. Explicit deletes

	// also free the condition/hit entry (enable/disable must NOT).

	if (clear_all) {

		for (TrackedBP &t : s_tracked) {

			DEBUGRemoveBreakPoint(t.pc, t.bank, t.x16Bank);

			DEBUGForgetBreakpoint(t.pc, t.bank, t.x16Bank);

		}

		s_tracked.clear();

	} else if (remove_idx >= 0 && remove_idx < (int)s_tracked.size()) {

		DEBUGRemoveBreakPoint(s_tracked[remove_idx].pc, s_tracked[remove_idx].bank, s_tracked[remove_idx].x16Bank);

		DEBUGForgetBreakpoint(s_tracked[remove_idx].pc, s_tracked[remove_idx].bank, s_tracked[remove_idx].x16Bank);

		s_tracked.erase(s_tracked.begin() + remove_idx);

	}

	// --- Run to address ---------------------------------------------------

	// Sets a one-shot internal breakpoint and resumes; the CPU halts when it

	// reaches the address. Only meaningful while paused.

	//

	// Below the list, not above it: this leaves nothing behind and never

	// appears in the table, so leading with it made the panel's only address

	// box the one thing on it that does not set a breakpoint.

	ImGui::Separator();

	ImGui::TextUnformatted("Run to $");

	ImGui::SetItemTooltip("One-shot: resume, stop once at this address, and forget it.\n"

	                      "Nothing is added to the list above.");

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

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

	ImGui::InputScalar("##runto", ImGuiDataType_S32, &s_runto_addr,

	                   nullptr, nullptr, "%04X",

	                   ImGuiInputTextFlags_CharsHexadecimal |

	                       ImGuiInputTextFlags_AutoSelectAll);

	const bool runto_submit = dbgui_committed_with_enter();

	ImGui::SetItemTooltip("Address to run to, in HEX. Press Enter to go.");

	ImGui::SameLine();

	ImGui::BeginDisabled(!DEBUGIsPaused());

	if (ImGui::Button("Go") || (runto_submit && DEBUGIsPaused())) {

		DEBUGRunTo((uint16_t)(s_runto_addr & 0xFFFF), 0, DEBUG_OWNER_UI);

	}

	ImGui::EndDisabled();

	if (!DEBUGIsPaused()) {

		ImGui::SameLine();

		ImGui::TextDisabled("(pause first)");

	}

}

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

// Watchpoints — break when the program WRITES to an address or range.

//

// These are a different trigger from the PC breakpoints above (which fire when

// execution reaches an address), but they are the same idea to a user: a

// condition that stops the machine. They used to be creatable from the memory

// view with no way to see or manage them, which is why they live here now.

//

// Note the trigger is a write, not a change: storing the same value back still

// fires. The optional value filter narrows that.

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

const char *

wp_op_name(int op)

{

	static const char *names[] = { "==", "!=", "<", "<=", ">", ">=" };

	return (op >= 0 && op < 6) ? names[op] : "==";