// Commander X16 Emulator

// Copyright (c) 2022, 2023 Michael Steil, et al

// All rights reserved. License: 2-clause BSD

// Commodore Bus emulation

// * L2: TALK/LISTEN layer: https://www.pagetable.com/?p=1031

// * L3: Commodore DOS: https://www.pagetable.com/?p=1038

// This is used from

// * serial.c: L1: Serial Bus emulation (low level)

// * main.c: IEEE KERNAL call hooks (high level)

#ifndef __APPLE__

#ifndef _MSC_VER

#define _XOPEN_SOURCE   600

#define _POSIX_C_SOURCE 1

#endif

#endif

#include <string.h>

#include <stdio.h>

#include <stdbool.h>

#include <sys/stat.h>

#include "dirent_win32.h"

#include "compat.h"

#include <stdlib.h>

#include <SDL.h>

#include <errno.h>

#include <time.h>

#include <limits.h>

#include "memory.h"

#include "ieee.h"

#include "io_trace.h"

#include "dbg_load.h"

#include "glue.h"

#include "utf8_encode.h"

#include "utf8.h"

#include "iso_8859_15.h"

#if defined(__MINGW32__) || defined(_MSC_VER)

#include <direct.h>

#ifndef _MSC_VER

// localtime_r and friends already defined in compat.h for MSVC

#define localtime_r(S,D) !localtime_s(D,S)

#endif

#include <io.h>

#ifndef F_OK

#define F_OK 0

#endif

#ifndef access

#define access _access

#endif

#endif

extern SDL_RWops *prg_file;

#define WILDCARD_ALL 0

#define WILDCARD_PRG 1

#define WILDCARD_DIR 2

// Globals

//bool log_ieee = true;

bool log_ieee = false;

bool ieee_initialized_once = false;

uint8_t error[256];

int error_len = 0;

int error_pos = 0;

uint8_t cmd[256];

int cmdlen = 0;

int namelen = 0;

int channel = 0;

bool listening = false;

bool talking = false;

bool opening = false;

bool overwrite = false;

bool path_exists = false;

bool prg_consumed = false;

int ieee_unit = 8;

uint8_t *hostfscwd = NULL;

uint8_t dirlist[1024]; // Plenty large to hold a single entry

int dirlist_len = 0;

int dirlist_pos = 0;

bool dirlist_cwd = false; // whether we're doing a cwd dirlist or a normal one

bool dirlist_eof = true;

bool dirlist_timestmaps = false;

bool dirlist_long = false;

DIR *dirlist_dirp;

uint8_t dirlist_wildcard[256];

uint8_t dirlist_type_filter;

uint16_t cbdos_flags = 0;

const char *blocks_free = "BLOCKS FREE.";

typedef struct {

	uint8_t name[80];

	bool read;

	bool write;

	SDL_RWops *f;

	uint32_t bytes_read;    // cumulative bytes read since channel was opened

	uint32_t bytes_written; // cumulative bytes written since channel was opened

} channel_t;

channel_t channels[16];

// ─── File-operation history ring buffer ──────────────────────────────────────

static uint32_t          hist_seq  = 0;                    // next sequence number

static int               hist_head = 0;                    // next write slot (ring)

static int               hist_used = 0;                    // entries written so far (caps at IEEE_HISTORY_MAX)

static uint32_t          hist_await_status = 0;            // seq of the entry expecting a DOS status

static ieee_history_entry_t hist[IEEE_HISTORY_MAX];

// Push a new entry and return a pointer to it so the caller can finish filling it.

static ieee_history_entry_t *

hist_push(void)

{

	ieee_history_entry_t *e = &hist[hist_head];

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

	e->seq     = ++hist_seq;

	e->channel = -1;

	hist_head  = (hist_head + 1) % IEEE_HISTORY_MAX;

	if (hist_used < IEEE_HISTORY_MAX) {

		hist_used++;

	}

	// A new operation ends the previous one's claim on the status line.

	hist_await_status = 0;

	return e;

}

// Say that this entry is the one the next DOS status belongs to. Called by the

// operations that actually produce a status; a close does not, and must not

// claim one.

static void

hist_expect_status(const ieee_history_entry_t *e)

{

	hist_await_status = e->seq;

}

// Stamp the current error string onto the entry that is waiting for one, and

// report whether it did.

//

// Only the operation that armed hist_await_status is stamped. Matching "the

// most recent entry with no status yet" instead would be wrong: a close

// produces no status of its own, so the next unrelated error -- often the

// failed open that follows it -- would be pinned to the close, showing a

// successful operation in red and leaving the real failure blank.

//

// The claim is NOT released after stamping, so a later status overwrites an

// earlier one. That is deliberate: a DOS command routinely clears the error

// and then sets a real one, and it is the state it ended in that describes it.

// hist_push() releases the claim when the next operation begins.

static bool

hist_stamp_status(void)

{

	if (hist_used == 0 || hist_await_status == 0) {

		return false;

	}

	int                   prev = (hist_head - 1 + IEEE_HISTORY_MAX) % IEEE_HISTORY_MAX;

	ieee_history_entry_t *e    = &hist[prev];

	if (e->seq != hist_await_status) {

		return false;

	}

	int elen = error_len < (int)(sizeof(e->status) - 1) ? error_len : (int)(sizeof(e->status) - 1);

	memcpy(e->status, error, (size_t)elen);

	e->status[elen] = '\0';

	// Trim trailing \r if present

	if (elen > 0 && e->status[elen - 1] == '\r') {

		e->status[elen - 1] = '\0';

	}

	return true;

}

#ifdef __MINGW32__

// realpath doesn't exist on Windows. This function implements its behavior.

static char *

realpath(const char *path, char *resolved_path) {

	char *ret = _fullpath(resolved_path, path, PATH_MAX);

	if (ret && _access(ret,0) && errno == ENOENT) {

		if (resolved_path == NULL)

			free(ret);

		return NULL;

	}

	return ret;

}

#endif

// Ensure S_ISDIR and S_ISREG macros are available on MSVC

#ifndef S_ISDIR

#define S_ISDIR(mode) (((mode) & _S_IFMT) == _S_IFDIR)

#endif

#ifndef S_ISREG

#define S_ISREG(mode) (((mode) & _S_IFMT) == _S_IFREG)

#endif

#define u8strchr(A,B) (uint8_t *)strchr((char *)A,B)

#define u8strrchr(A,B) (uint8_t *)strrchr((char *)A,B)

#define u8strcpy(A,B) strcpy((char *)A,(char *)B)

#define u8strcmp(A,B) strcmp((char *)A,(char *)B)

#define u8strncmp(A,B,C) strncmp((char *)A,(char *)B,C)

#define u8strncpy(A,B,C) strncpy((char *)A,(char *)B,C)

#define u8strlen(A) strlen((char *)A)

#define u8stat(A,B) stat((char *)A,B)

#define u8realpath(A,B) (uint8_t *)realpath((char *)A,(char *)B)

#define u8getcwd(A,B) (uint8_t *)getcwd((char *)A,B)

// Prototypes for some of the static functions

static void clear_error();

static void set_error(int e, int t, int s);

static void cchdir(uint8_t *dir);

static int cgetcwd(uint8_t *buf, size_t len);

static void cseek(int channel, uint32_t pos);

static void ctell(int channel);

static void cmkdir(uint8_t *dir);

static void crmdir(uint8_t *dir);

static void cunlink(uint8_t *f);

static void crename(uint8_t *f);

// Functions

static void

set_kernal_cbdos_flags(uint8_t flags)

{

	if (cbdos_flags)

		write6502(cbdos_flags, 0, flags);

}

static uint8_t

get_kernal_cbdos_flags(void)

{

	if (cbdos_flags) {

		return read6502(cbdos_flags, 0);

	} else {

		return 0;

	}

}

static void

utf8_to_iso_string(uint8_t *dst, const uint8_t *src)

{

	int i;

	int e;

	uint32_t cp;

	// utf8_decode requires the source string be at least 4 bytes

	// longer than the string (IOW, 4 terminating nulls)

	uint8_t *s = malloc(u8strlen(src)+4);

	memset(s, 0, u8strlen(src)+4);

	u8strcpy(s, src);

	uint8_t *so = s;

	for (i = 0; *so; i++) {

		so = utf8_decode(so, &cp, &e);

		if (e) {

			dst[i] = '?';

		} else {

			switch (cp) {

				case ',':

				case '"':

				case '*':

				case ':':

				case '\\':

				case '<':

				case '>':

				case '|':

					// these are not valid in filenames on FAT32 but might be encountered on hostfs

					dst[i] = '?';

					break;

				default:

					dst[i] = iso8859_15_from_unicode(cp);

					break;

			}

		}

	}

	dst[i] = 0;

	free(s);

}

// Puts the emulated cwd in buf, up to the maximum length specified by len

// Turn null termination into a space

// This is for displaying in the directory header

static int

cgetcwd(uint8_t *buf, size_t len)

{

	int o = 0;

	uint8_t l = fsroot_path[u8strlen(fsroot_path)-1];

	if (l == '/' || l == '\\')

		o--;

	if (u8strlen(fsroot_path) == u8strlen(hostfscwd))

		u8strncpy(buf, "/", len);

	else 

		u8strncpy(buf, hostfscwd+u8strlen(fsroot_path)+o, len);

	// Turn backslashes into slashes

	for (o = 0; o < len; o++) {

		if (buf[o] == 0) buf[o] = ' ';

		if (buf[o] == '\\') buf[o] = '/';

	}

	return 0;

}

static uint32_t

case_fold_unicode(uint32_t cp)

{

	// ASCII letters, and most of the ISO letters

	if ((cp >= 0x41 && cp <= 0x5a) || (cp >= 0xc0 && cp <= 0xde)) cp += 0x20;

	// fold the Š

	else if (cp == 0x0160) cp = 0x0161;

	// fold the Ž

	else if (cp == 0x017d) cp = 0x017e;

	// fold the Œ

	else if (cp == 0x0152) cp = 0x0153;

	// fold the Ÿ

	else if (cp == 0x0178) cp = 0xff;

	return cp;

}

static uint8_t

case_fold_iso(uint8_t c) {

	uint8_t f = c;

	// ASCII letters, and most of the ISO letters

	if ((f >= 0x41 && f <= 0x5a) || (f >= 0xc0 && f <= 0xde)) f += 0x20;

	// fold the Š

	else if (f == 0xa6) f = 0xa8;

	// fold the Ž

	else if (f == 0xb4) f = 0xb8;

	// fold the Œ

	else if (f == 0xbc) f = 0xbd;

	// fold the Ÿ

	else if (f == 0xbe) f = 0xff;

	return f;

}

static uint32_t

utf8_to_codepoint(uint8_t *str, int *off)

{

	uint32_t cp;

	int e;

	// utf8_decode requires the source string be at least 4 bytes

	// longer than the string (IOW, 4 terminating nulls)

	uint8_t *s = malloc(u8strlen(str+(*off))+4);

	memset(s, 0, u8strlen(str+(*off))+4);

	u8strcpy(s, str+(*off));

	uint8_t *so = utf8_decode(s, &cp, &e);

	*off += (so - s) - 1;

	free(s);

	if (e) {

		cp = '?';

	}

	return cp;

}

// compare two characters in a UTF-8 string

// in a case-insensitive manner,

// return value is cp2 - cp1 after case folding

// hence will be zero on match

static int

u8compare_utf8_char_i(uint8_t *str1, uint8_t *str2, int *off1, int *off2)

{

	uint32_t cp1, cp2;

	// these functions will increment *off1/*off2 to the

	// byte before the next character if the UTF-8

	// strings are multi-byte

	cp1 = utf8_to_codepoint(str1, off1);

	cp2 = utf8_to_codepoint(str2, off2);

	return case_fold_unicode(cp2) - case_fold_unicode(cp1);

}

static uint8_t *

parse_dos_filename(const uint8_t *name, bool dirhandling)

{

	// in case the name starts with something with special meaning,

	// such as @0:

	uint8_t *name_ptr = NULL;

	uint8_t *newname = malloc(u8strlen(name)+1);

	int i, j;

	newname[u8strlen(name)] = 0;

	overwrite = false;

	// [[@][<media 0-9>][</relative_path/> | <//absolute_path/>]:]<file_path>[*]

	// Examples of valid dos filenames

	//   ":FILE.PRG"  (same as "FILE.PRG")

	//   "@:FILE.PRG"  (same as "FILE.PRG" but overwrite okay)

	//   "@0:FILE.PRG"  (same as above)

	//   "//DIR/:FILE.PRG"  (same as "/DIR/FILE.PRG")

	//   "/DIR/:FILE.PRG"  (same as "./DIR/FILE.PRG")

	//   "FILE*" (matches the first file in the directory which starts with "FILE")

	// This routine only parses the bits before the ':'

	// and normalizes directory parts by attaching them to the name part

	// resolve_path*() is responsible for resolving absolute and relative

	// paths, and for processing the wildcard option

	name_ptr = u8strchr(name,':');

	if (dirhandling && !name_ptr)

		name_ptr = (uint8_t *)(name+u8strlen(name));

	if (name_ptr) {

		name_ptr++;

		i = 0;

		j = 0;

		if (!dirhandling) {

			// @ is overwrite flag

			if (name[i] == '@') {

				overwrite = true;

				i++;

			}

			// Medium, we don't care what this number is

			while (name[i] >= '0' && name[i] <= '9')

				i++;

		}

		// Directory name

		if (name[i] == '/') {

			i++;

			for (; name+i+1 < name_ptr; i++, j++) {

				newname[j] = name[i];

			}

			// mangled directory name (single slash?)

			if (j == 0) {

				free(newname);

				return NULL;

			}

			// Directory portion must end with /

			if (newname[j-1] != '/') {

				free(newname);

				return NULL;

			}

		}

		u8strcpy(newname+j,name_ptr);

	} else {

		u8strcpy(newname,name);

	}

	return newname;

}

// Returns a ptr to malloc()ed space which must be free()d later, or NULL

static uint8_t *

resolve_path_utf8(const uint8_t *name, bool must_exist, int wildcard_filetype)

{

	path_exists = false;

	clear_error();

	// Resolve the filename in the context of the emulated cwd

	// allocate plenty of string space

	uint8_t *tmp = malloc(u8strlen(name)+u8strlen(hostfscwd)+2);

	uint8_t *tmp2 = malloc(u8strlen(name)+u8strlen(hostfscwd)+2);

	uint8_t *c;

	uint8_t *d;

	uint8_t *ret;

	DIR *dirp;

	struct dirent *dp;

	struct stat st;

	int i;

	int j;

	bool has_wildcard_chars = false;

	if (tmp == NULL || tmp2 == NULL) {

		if (tmp) free(tmp);

		if (tmp2) free(tmp2);

		set_error(0x70, 0, 0);

		return NULL;

	}

	// If the filename begins with /, simply append it to the fsroot_path,

	// slash(es) and all, otherwise append it to the cwd, but with a /

	// in between

	if (name[0] == '/' || name[0] == '\\') { // absolute

		u8strcpy(tmp, fsroot_path);

		u8strcpy(tmp+u8strlen(fsroot_path), name);

	} else { // relative

		u8strcpy(tmp, hostfscwd);

		tmp[u8strlen(hostfscwd)] = '/';

		u8strcpy(tmp+u8strlen(hostfscwd)+1, name);

	}

	// keep the original parsed name

	u8strcpy(tmp2, tmp);

	if (u8strchr(tmp,'*') || u8strchr(tmp,'?')) { // oh goodie, a wildcard

		has_wildcard_chars = true;

	}

	// We have to search the directory for the first occurrence

	// in directory order.

	c = u8strrchr(tmp,'\\');

	d = u8strrchr(tmp,'/');

	if (c == NULL && d == NULL) { // This should never happen

		free(tmp);

		free(tmp2);

		set_error(0x62, 0, 0);

		return NULL;

	}

	// Chop off ret at the last path separator

	// and set c to point at the element with the wildcard

	// pattern

	if (c > d) {

		*c = 0;

		c++;

	} else {

		*d = 0;

		c = d+1;

	}

	// XXX

	//

	// tmp could have been populated with path parts that have not been checked

	// this will fail on case-sensitive filesystems

	// but if the user did not specify a path part in their filename

	// we should be able to resolve the new part of the name

	// we'll probably want to fix this at some point

	// but it requires some thought

	if (!(dirp = opendir((char *)tmp))) { // Directory couldn't be opened

		free(tmp);

		free(tmp2);

		set_error(0x62, 0, 0);

		return NULL;

	}

	ret = NULL;

	bool found = false;

	while ((dp = readdir(dirp))) {

		// in a wildcard match that starts at first position, leading dot filenames are not considered

		if ((*c == '*' || *c == '?') && *(dp->d_name) == '.')

			continue;

		for (i = 0, j = 0; j < u8strlen(c) && i < u8strlen(dp->d_name); i++, j++) {

			if (c[j] == '*') {

				found = true;

				break;

			} else if (c[j] == '?') {

				// '?' needs to eat the extra UTF-8 bytes if applicable

				if (((dp->d_name)[i] & 0xe0) == 0xc0) i++;

				else if (((dp->d_name)[i] & 0xf0) == 0xe0) i+=2;

				else if (((dp->d_name)[i] & 0xf8) == 0xf0) i+=3;

				continue;

			} else if (u8compare_utf8_char_i(c, (uint8_t *)(dp->d_name), &j, &i)) {

				break;

			}

		}

		// If we reach the end of both strings, it's a match

		if (i == u8strlen(dp->d_name) && j == u8strlen(c))

			found = true;

		// If we reach the end of the filename, but the next char

		// in the search string is *, then it's also a match

		else if (i == u8strlen(dp->d_name) && c[j] == '*')

			found = true;

		if (found) { // simple wildcard match

			ret = malloc(u8strlen(tmp)+u8strlen(dp->d_name)+2);

			if (ret == NULL) { // memory allocation error

				free(tmp);

				free(tmp2);

				closedir(dirp);

				set_error(0x70, 0, 0);

				return NULL;

			}

			u8strcpy(ret, tmp);

			ret[u8strlen(tmp)] = '/';

			u8strcpy(ret+u8strlen(tmp)+1, dp->d_name);

			if (wildcard_filetype) {

				u8stat(ret, &st);

				// in a wildcard match where the filetype is wrong, mark as not found

				// and continue

				if (wildcard_filetype == WILDCARD_DIR && !S_ISDIR(st.st_mode)) {

					free(ret);

					ret = NULL;

					found = false;

					continue;