// Commander X16 Emulator — debug info for programs the guest loads. See dbg_load.h.

#include "dbg_load.h"
#include "dbg_info.h"
#include "debug_server.h"
#include "source_view.h"

#include <stdlib.h>
#include <string.h>

// What a channel has told us so far. Kept per channel because two can be open
// at once, and the second one to be opened must not overwrite what the first is
// still in the middle of doing.
struct channel_load {
	char     path[DBG_LOAD_PATH_MAX];
	uint16_t addr;
	uint8_t  bank;
	uint32_t size;       // bytes reported; zero means no byte has landed yet
	bool     open;       // a path has been recorded
};

static struct channel_load channels[DBG_LOAD_CHANNELS];
static dbg_load_event_t    pending;
static bool                enabled;

// See dbg_load_set_policy(): the debugger can be switched on by the running
// machine, so what the command line asked for is kept separately from what the
// debugger is currently doing, and the two are resolved on every change.
static int  policy = -1;
static bool debugger_on;

static void
apply_policy(void)
{
	enabled = (policy >= 0) ? (policy > 0) : debugger_on;
}

// Configuration rather than state, so a machine reset does not clear it: the
// -prg file is still the -prg file afterwards.
static char prg_path[DBG_LOAD_PATH_MAX];

// Which .dbg files are currently merged into dbg_info, and over what range.
//
// dbg_info_load() is additive and dbg_info_unload_range() prunes only some of
// what it builds. File and equate records are never pruned by address; they are
// instead reused or replaced when the same .dbg is parsed again, so those no
// longer accumulate. Segment, span, line and label records still append, and
// they are pruned only by the address range handed to the unload -- so tracking
// which .dbg is live over which range is what keeps the two in step.
//
// But merging is also destructive: dbg_info_load_for_file() unloads everything
// in the incoming file's address range before reading it. Re-parsing is
// therefore how a module that was displaced gets its records back. So this
// tracks what is *live*, not what has *ever* been merged: when a new file
// evicts a range, the modules it overlaps are forgotten and will merge again
// the next time they load.
//
// Not cleared by dbg_load_reset(): a machine reset does not free dbg_info, so
// those records are still live afterwards.
// The registry grows rather than evicting. Evicting a live module would be
// unsound: dropping its entry does not drop its records, so the next load of
// that path would look like a first sighting and merge a second copy -- the
// exact duplication this exists to prevent. It stays small in practice because
// every merge forgets the modules it displaces, so entries only ever track
// modules that are genuinely resident at the same time.
struct parsed_entry {
	char       path[DBG_LOAD_PATH_MAX];
	dbg_addr_t start;
	dbg_addr_t end;
};

static struct parsed_entry *parsed;
static int                  parsed_count;
static int                  parsed_cap;

static bool
already_parsed(const char *path)
{
	for (int i = 0; i < parsed_count; i++) {
		if (strcmp(parsed[i].path, path) == 0)
			return true;
	}
	return false;
}

// Drop the tracking entries for every module overlapping [start,end], and
// return how many there were. The caller unloads the records, because what
// needs unloading differs between "something else is taking this range" and
// "this range is being overwritten by something we cannot describe at all".
static int
forget_overlapping(dbg_addr_t start, dbg_addr_t end)
{
	int keep    = 0;
	int dropped = 0;

	for (int i = 0; i < parsed_count; i++) {
		bool overlaps = parsed[i].start <= end && start <= parsed[i].end;
		if (overlaps) {
			dropped++;
		} else {
			if (keep != i)
				parsed[keep] = parsed[i];
			keep++;
		}
	}
	parsed_count = keep;
	return dropped;
}

// Make room for one more entry without adding it, so a merge is never done
// unless its result can be tracked. A merged-but-untracked module would be
// merged a second time on its next load, which is the duplication all this
// exists to prevent.
static bool
reserve_parsed_slot(const char *path)
{
	if (strlen(path) >= DBG_LOAD_PATH_MAX)
		return false;

	if (parsed_count < parsed_cap)
		return true;

	int new_cap = parsed_cap ? parsed_cap * 2 : 8;
	struct parsed_entry *grown = realloc(parsed, (size_t)new_cap * sizeof(*grown));
	if (!grown)
		return false;

	parsed     = grown;
	parsed_cap = new_cap;
	return true;
}

// Record a module as live. The caller must have reserved a slot first, so this
// cannot fail.
static void
remember_parsed(const char *path, dbg_addr_t start, dbg_addr_t end)
{
	size_t len = strlen(path);

	memcpy(parsed[parsed_count].path, path, len + 1);
	parsed[parsed_count].start = start;
	parsed[parsed_count].end   = end;
	parsed_count++;
}
static bool
valid_channel(int channel)
{
	return channel >= 0 && channel < DBG_LOAD_CHANNELS;
}

// Something we cannot describe landed at [addr, addr+size). Unload the debug
// info of any module it completely replaced, because that info now describes
// bytes which are gone, and a debugger confidently showing the wrong source is
// worse than one showing none.
//
// Only when the load covers a module *whole*. The envelope recorded for a
// module is the min/max across every segment in its .dbg -- including ZEROPAGE,
// DATA and BSS -- so for a typical cc65 program it spans most of low RAM. A
// partial overlap is therefore far more likely to be that same program loading
// data into one of its own buffers, which invalidates nothing; discarding its
// debug info for that would throw away the mapping for the code that is running.
//
// Modules this registry does not know about are left alone, so debug info the
// user named with -dbgfile survives: they asked for it explicitly, and guessing
// that a guest load invalidated it is a worse failure than leaving it.
static void
discard_range(uint16_t addr, uint32_t size)
{
	if (size == 0)
		return;

	dbg_addr_t start = addr;
	dbg_addr_t end   = addr + (size - 1);
	if (end > 0xFFFF)
		end = 0xFFFF;  // a transfer running off the top wraps; it cannot cover more

	int keep = 0;
	for (int i = 0; i < parsed_count; i++) {
		bool covered = start <= parsed[i].start && parsed[i].end <= end;
		if (covered) {
			dbg_info_unload_range(parsed[i].start, parsed[i].end);
		} else {
			if (keep != i)
				parsed[keep] = parsed[i];
			keep++;
		}
	}
	parsed_count = keep;
}

// Whether a host path names a .dbg file.
bool
dbg_load_path_is_dbg(const char *path)
{
	if (!path)
		return false;

	size_t n = strlen(path);
	if (n < 4)
		return false;

	const char *ext = path + n - 4;
	return ext[0] == '.'
	    && (ext[1] == 'd' || ext[1] == 'D')
	    && (ext[2] == 'b' || ext[2] == 'B')
	    && (ext[3] == 'g' || ext[3] == 'G');
}

void
dbg_load_set_policy(int new_policy)
{
	policy = new_policy;
	apply_policy();
}

void
dbg_load_note_debugger(bool on)
{
	debugger_on = on;
	apply_policy();
}

void
dbg_load_set_enabled(bool on)
{
	dbg_load_set_policy(on ? 1 : 0);
}

bool
dbg_load_is_enabled(void)
{
	return enabled;
}

void
dbg_load_begin(int channel, const char *host_path)
{
	if (!valid_channel(channel))
		return;

	struct channel_load *c = &channels[channel];
	memset(c, 0, sizeof(*c));

	// Nothing is collected at all unless auto-loading was asked for, which
	// leaves the per-byte reporting below doing nothing but testing a flag.
	if (!enabled || !host_path || !host_path[0])
		return;

	// A truncated path names a different file, or none. Rather than parse
	// whatever that turns out to be, ignore the load.
	size_t len = strlen(host_path);
	if (len >= sizeof(c->path))
		return;

	memcpy(c->path, host_path, len + 1);
	c->open = true;
}

// Publish a finished load and clear the channel. Static, and reached only from
// dbg_load_note_byte() below with an open channel whose final byte has already
// been counted -- which is what keeps the byte and the completion in the right
// order, and why there is nothing to check here.
static void
complete(int channel)
{
	struct channel_load *c = &channels[channel];

	memcpy(pending.path, c->path, sizeof(pending.path));
	pending.addr  = c->addr;
	pending.bank  = c->bank;
	pending.size  = c->size;
	pending.valid = true;

	memset(c, 0, sizeof(*c));
}

void
dbg_load_set_prg_path(const char *path)
{
	prg_path[0] = '\0';
	if (!path)
		return;

	size_t len = strlen(path);
	if (len >= sizeof(prg_path))
		return;  // truncation would name a different file; better to say nothing

	memcpy(prg_path, path, len + 1);
}

void
dbg_load_begin_prg(int channel)
{
	dbg_load_begin(channel, prg_path);
}

void
dbg_load_note_byte(int channel, uint16_t addr, uint8_t bank, bool last)
{
	if (!valid_channel(channel))
		return;

	struct channel_load *c = &channels[channel];
	if (!c->open)
		return;

	// The first byte is the one that says where the program starts and which
	// bank it started in. A load crossing $C000 moves the RAM bank on as it
	// goes, so a later byte would name a different segment.
	if (c->size == 0) {
		c->addr = addr;
		c->bank = bank;
	}
	c->size++;

	// Counted above before this runs, which is the whole point of the two being
	// a single call. A channel that never reports a byte -- a data file read
	// through GET#, or a stream-mode transfer into a hardware register -- never
	// reaches here at all, and so is never mistaken for a program load.
	if (last)
		complete(channel);
}

void
dbg_load_abandon(int channel)
{
	if (!valid_channel(channel))
		return;
	memset(&channels[channel], 0, sizeof(channels[channel]));
}

bool
dbg_load_take(dbg_load_event_t *out)
{
	if (!pending.valid)
		return false;
	if (out) {
		*out = pending;
	}
	memset(&pending, 0, sizeof(pending));
	return true;
}

bool
dbg_load_poll(void)
{
	dbg_load_event_t ev;
	if (!dbg_load_take(&ev))
		return false;
	if (!enabled || !ev.path[0])
		return false;

	// A .dbg loaded as if it were a program. A wildcard like LOAD"GAME*" can
	// match the debug info sitting beside GAME.PRG, and the machine will
	// happily read that text file into memory at whatever its first two bytes
	// spell out. Reading it as debug info for itself would then attribute its
	// segments to that nonsense address -- but the bytes did land, so anything
	// they completely replaced is still invalidated.
	if (dbg_load_path_is_dbg(ev.path)) {
		discard_range(ev.addr, ev.size);
		return false;
	}

	// Load first. dbg_info_load_for_file() unloads whatever already describes
	// the address range before reading the new file, so a bank annotation made
	// beforehand would be thrown away with the mappings it was attached to.
	//
	// Only if this file's records are not already live -- see the note on
	// `parsed` above. Note also that dbg_info_load_for_file() ignores the
	// address it is given, so a relocating load -- secondary address 0, which
	// lands at BASIC start rather than the address in the file's own header --
	// still describes the program at its link-time addresses. That is a
	// limitation of the debug info, not of the destination recorded here.
	if (!already_parsed(ev.path)) {
		dbg_addr_t new_start, new_end;
		if (!dbg_info_peek_file_range(ev.path, &new_start, &new_end)) {
			// Nothing describes this file, but it still landed in memory.
			discard_range(ev.addr, ev.size);
			return false;
		}

		// Make room before merging, so the result can definitely be tracked.
		if (!reserve_parsed_slot(ev.path)) {
			discard_range(ev.addr, ev.size);
			return false;
		}

		int rc = dbg_info_load_for_file(ev.path, ev.addr);

		// A DAP client's breakpoints are addresses resolved from debug info
		// that has just been replaced, so anything inside the range it covered
		// is now pointing at whatever used to be there.
		debug_server_invalidate_breakpoints_in_range(new_start, new_end);

		// Forgotten whether or not that succeeded. It unloads the range before
		// reading the file, so a failure part-way through still leaves those
		// modules' records gone -- and a registry claiming they are live would
		// then skip the merge that would bring them back. Forgetting one whose
		// records did survive costs only a re-merge next time, which replaces
		// them rather than duplicating them.
		forget_overlapping(new_start, new_end);

		if (rc != 0)
			return false;
		remember_parsed(ev.path, new_start, new_end);

		// Breakpoints set before the program was loaded could not be resolved
		// then. The debug info describing them has just arrived, so this is the
		// moment they can be armed.
		debug_server_retry_unverified_breakpoints();
	}

	// Now say which bank the program went into, every time, because the same
	// overlay can legitimately be loaded into a different bank than last time.
	// Several segments commonly start at $A000, one per bank, and the .dbg
	// records no bank at all, so this is the only thing that can tell them
	// apart. The bank is the one that was mapped when the first byte landed --
	// a load crossing $C000 moves the bank on as it goes, so the bank at the
	// end belongs to a different segment.
	if (ev.addr >= 0xA000 && ev.addr <= 0xBFFF && ev.size > 0) {
		dbg_info_note_bank_load(ev.addr, ev.size, ev.bank);
	}

	// Both the .dbg's own directory and the loaded file's are host paths worth
	// searching for the sources it names.
	source_view_add_path(dbg_info_get_dbg_dir());
	{
		char dir[DBG_LOAD_PATH_MAX];
		strncpy(dir, ev.path, sizeof(dir) - 1);
		dir[sizeof(dir) - 1] = '\0';
		char *s1  = strrchr(dir, '/');
		char *s2  = strrchr(dir, '\\');
		char *sep = (s2 > s1) ? s2 : s1;
		if (sep) {
			*sep = '\0';
			source_view_add_path(dir);
		}
	}

	// An overlay can reuse a file name at a different address, so anything
	// cached under that name has to be re-read rather than trusted.
	source_view_invalidate();
	return true;
}

void
dbg_load_reset(void)
{
	memset(channels, 0, sizeof(channels));
	memset(&pending, 0, sizeof(pending));
}