// Commander X16 Emulator — source file discovery + caching for the debugger's

// native "Source" window. See source_view.h.

#include "source_view.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

// ─── Search paths ───────────────────────────────────────────────────

#define MAX_SEARCH_PATHS 32

static char *search_paths[MAX_SEARCH_PATHS];

static int   search_path_count = 0;

void source_view_add_path(const char *dir)

{

	if (!dir || !dir[0])

		return;

	// Already known: promote it rather than ignoring it. The insertion below

	// only means "most recently added is searched first" if re-adding a path

	// also counts as recent. Without this, loading A then B then A again leaves

	// B's directory ahead of A's, and two modules naming the same relative

	// source file would both resolve to B's copy.

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

		if (strcmp(search_paths[i], dir) == 0) {

			char *existing = search_paths[i];

			for (int j = i; j > 0; j--)

				search_paths[j] = search_paths[j - 1];

			search_paths[0] = existing;

			return;

		}

	}

	if (search_path_count >= MAX_SEARCH_PATHS)

		return;

	char *copy = malloc(strlen(dir) + 1);

	if (!copy)

		return;

	strcpy(copy, dir);

	// Insert at the front so the most-recently-added path is searched first.

	for (int i = search_path_count; i > 0; i--)

		search_paths[i] = search_paths[i - 1];

	search_paths[0] = copy;

	search_path_count++;

}

// ─── File cache ─────────────────────────────────────────────────────

#define MAX_CACHED_FILES 8

static source_file_t cache[MAX_CACHED_FILES];

static int           cache_count = 0;

static const char *basename_ptr(const char *path)

{

	const char *last = path;

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

		if (*p == '/' || *p == '\\')

			last = p + 1;

	}

	return last;

}

// Read an entire file into a NUL-terminated heap buffer. Returns NULL on failure.

static char *read_whole_file(const char *path)

{

	FILE *f;

#ifdef _WIN32

	if (fopen_s(&f, path, "rb") != 0 || !f)

		return NULL;

#else

	f = fopen(path, "rb");

	if (!f)

		return NULL;

#endif

	if (fseek(f, 0, SEEK_END) != 0) {

		fclose(f);

		return NULL;

	}

	long size = ftell(f);

	if (size < 0) {

		fclose(f);

		return NULL;

	}

	rewind(f);

	char *buf = malloc((size_t)size + 1);

	if (!buf) {

		fclose(f);

		return NULL;

	}

	size_t got = fread(buf, 1, (size_t)size, f);

	fclose(f);

	buf[got] = '\0';

	return buf;

}

// Try to open 'name' at 'dir/basename'. Returns a heap buffer or NULL.

static char *try_read_in_dir(const char *dir, const char *base)

{

	size_t need = strlen(dir) + 1 + strlen(base) + 1;

	char *path = malloc(need);

	if (!path)

		return NULL;

	snprintf(path, need, "%s/%s", dir, base);

	char *buf = read_whole_file(path);

	free(path);

	return buf;

}

// Split a NUL-terminated buffer into lines in place (rewrites \r\n / \n to NULs).

// Fills entry->lines / entry->count.

static void split_lines(source_file_t *entry)

{

	// First pass: count lines.

	int lines = 1;

	for (char *p = entry->text; *p; p++) {

		if (*p == '\n')

			lines++;

	}

	entry->lines = malloc((size_t)lines * sizeof(char *));

	if (!entry->lines) {

		entry->count = 0;

		return;

	}

	int idx = 0;

	char *start = entry->text;

	for (char *p = entry->text; ; p++) {

		if (*p == '\n' || *p == '\0') {

			// Trim a trailing CR for CRLF files.

			char *nl = p;

			if (nl > start && nl[-1] == '\r')

				nl[-1] = '\0';

			char terminator = *p;

			*p = '\0';

			if (idx < lines)

				entry->lines[idx++] = start;

			if (terminator == '\0')

				break;

			start = p + 1;

		}

	}

	entry->count = idx;

}

static void free_entry(source_file_t *entry)

{

	free(entry->name);

	free(entry->text);

	free(entry->lines);

	entry->name = NULL;

	entry->text = NULL;

	entry->lines = NULL;

	entry->count = 0;

	entry->found = false;

}

// Locate and read a source file by the name stored in the .dbg.

static void load_entry(source_file_t *entry, const char *name)

{

	entry->name = malloc(strlen(name) + 1);

	if (entry->name)

		strcpy(entry->name, name);

	entry->text = NULL;

	entry->lines = NULL;

	entry->count = 0;

	entry->found = false;

	char *buf = NULL;

	// 1) The path stored in the .dbg, as-is.

	buf = read_whole_file(name);

	// 2) Each registered search root + the file's basename.

	if (!buf) {

		const char *base = basename_ptr(name);

		for (int i = 0; i < search_path_count && !buf; i++)

			buf = try_read_in_dir(search_paths[i], base);

		// 3) Current working directory (basename only).

		if (!buf)

			buf = read_whole_file(base);

	}

	if (buf) {

		entry->text = buf;

		entry->found = true;

		split_lines(entry);

	}

}

const source_file_t *source_view_get(const char *name)

{

	if (!name || !name[0])

		return NULL;

	// Already cached?

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

		if (cache[i].name && strcmp(cache[i].name, name) == 0)

			return &cache[i];

	}

	// Evict the oldest entry if the cache is full (simple FIFO).

	if (cache_count >= MAX_CACHED_FILES) {

		free_entry(&cache[0]);

		for (int i = 1; i < cache_count; i++)

			cache[i - 1] = cache[i];

		cache_count--;

	}

	source_file_t *entry = &cache[cache_count++];

	memset(entry, 0, sizeof(*entry));

	load_entry(entry, name);

	return entry;

}

void source_view_invalidate(void)

{

	for (int i = 0; i < cache_count; i++)

		free_entry(&cache[i]);

	cache_count = 0;

}

void source_view_free(void)

{

	source_view_invalidate();

	for (int i = 0; i < search_path_count; i++)

		free(search_paths[i]);

	search_path_count = 0;

}