#include "common.h"
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#include "command.h"
#include "ff.h"
#include "z80-if.h"
#include "con-utils.h"
#include "print-utils.h"
#include "timer.h"
#include "debug.h"


#define MAX_MEMORY	(1ul << 20)

DWORD get_fattime (void)
{
	/* TODO: */
	return 0;
}


static const FLASH char * const FLASH rc_names[] = {
			FSTR("OK"),
			FSTR("DISK_ERR"),
			FSTR("INT_ERR"),
			FSTR("NOT_READY"),
			FSTR("NO_FILE"),
			FSTR("NO_PATH"),
			FSTR("INVALID_NAME"),
			FSTR("DENIED"),
			FSTR("EXIST"),
			FSTR("INVALID_OBJECT"),
			FSTR("WRITE_PROTECTED"),
			FSTR("INVALID_DRIVE"),
			FSTR("NOT_ENABLED"),
			FSTR("NO_FILE_SYSTEM"),
			FSTR("MKFS_ABORTED"),
			FSTR("TIMEOUT"),
			FSTR("LOCKED"),
			FSTR("NOT_ENOUGH_CORE"),
			FSTR("TOO_MANY_OPEN_FILES")
		};

static
void put_rc (FRESULT rc)
{
#if GCC_BUG_61443
	printf_P(PSTR("rc=%u FR_"), rc);
	my_puts_P(rc_names[rc]);
	my_puts_P(PSTR("\n"));
#else
	printf_P(PSTR("rc=%u FR_%S\n"), rc, rc_names[rc]);
#endif
}

/* Work register for fs command */
static DWORD AccSize;
static WORD AccFiles, AccDirs;
#if _USE_LFN
char Lfname[_MAX_LFN+1];
FILINFO Finfo = {
		.lfname = Lfname,
		.lfsize = sizeof Lfname
	};
#else
FILINFO Finfo;
#endif

static
FRESULT scan_files (
	char* path		/* Pointer to the working buffer with start path */
)
{
	DIR dirs;
	FRESULT res;
	int i;
	char *fn;

	res = f_opendir(&dirs, path);

	if (res == FR_OK) {
		i = strlen(path);
		while (((res = f_readdir(&dirs, &Finfo)) == FR_OK) && Finfo.fname[0]) {
			if (_FS_RPATH && Finfo.fname[0] == '.') continue;
#if _USE_LFN
			fn = *Finfo.lfname ? Finfo.lfname : Finfo.fname;
#else
			fn = Finfo.fname;
#endif
			if (Finfo.fattrib & AM_DIR) {
				AccDirs++;
				path[i] = '/'; strcpy(path+i+1, fn);
				res = scan_files(path);
				path[i] = '\0';
				if (res != FR_OK) break;
			} else {
//				printf_P(PSTR("%s/%s\n"), path, fn);
				AccFiles++;
				AccSize += Finfo.fsize;
			}
		}
	}

	return res;
}


/*
 * fatstat path - Show logical drive status
 *
 */
command_ret_t do_fat_stat(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	FATFS *FatFs, *fs;
	DWORD nfreeclst;
	FRESULT res;
	char *buffer;

	(void) cmdtp; (void) flag; (void) argc;

	FatFs = (FATFS *) malloc(sizeof (FATFS));
	buffer = (char *) malloc(512);
	if (FatFs == NULL || buffer == NULL) {
		printf_P(PSTR("fatstat: Out of Memory!\n"));
		free(FatFs);
		free(buffer);
		return CMD_RET_FAILURE;
	}

	res = f_mount(FatFs, argv[1], 0);
	if (!res) {
		res = f_getfree(argv[1], &nfreeclst, &fs);
		if (!res) {
			printf_P(PSTR(
						"FAT type:                %u\n"
						"Bytes/Cluster:           %lu\n"
						"Number of FATs:          %u\n"
						"Root DIR entries:        %u\n"
						"Sectors/FAT:             %lu\n"
						"Number of clusters:      %lu\n"
						"FAT start (lba):         %lu\n"
						"DIR start (lba,cluster): %lu\n"
						"Data start (lba):        %lu\n"),
					fs->fs_type, (DWORD)fs->csize * 512, fs->n_fats,
					fs->n_rootdir, fs->fsize, fs->n_fatent - 2,
					fs->fatbase, fs->dirbase, fs->database);

#if _USE_LABEL
			TCHAR label[12];
			DWORD serial;
			res = f_getlabel(argv[1], label, &serial);
			if (!res) {
				printf_P(PSTR(
							"Volume name:             %s\n"
							"Volume S/N:              %04X-%04X\n"),
						label, (WORD)(serial >> 16), (WORD)(serial & 0xFFFF));
			}
#endif
			if (!res) {
				my_puts_P(PSTR("\n..."));
				AccSize = AccFiles = AccDirs = 0;

				strcpy(buffer, argv[1]);

				res = scan_files(buffer);
			}
			if (!res) {
				printf_P(PSTR("\r%u files, %lu bytes.\n%u folders.\n"
							 "%lu KB total disk space.\n%lu KB available.\n"),
						AccFiles, AccSize, AccDirs,
						(fs->n_fatent - 2) * (fs->csize / 2), nfreeclst * (fs->csize / 2)
				);
			}
		}
	}

	f_mount(NULL, argv[1], 0);
	if (res) {
		put_rc(res);
		return CMD_RET_FAILURE;
	}
	return CMD_RET_SUCCESS;
}


/*
 * fatls path - Directory listing
 *
 */
command_ret_t do_fat_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	FATFS FatFs, *fs;
	DIR Dir;					/* Directory object */
	FILINFO Finfo;
	unsigned long p1;
	unsigned int s1, s2;
	FRESULT res;
#if _USE_LFN
	char Lfname[_MAX_LFN+1];
	Finfo.lfname = Lfname;
	Finfo.lfsize = sizeof Lfname;
#endif

	(void) cmdtp; (void) flag; (void) argc;

	res = f_mount(&FatFs, argv[1], 0);
	if (!res)
		res = f_opendir(&Dir, argv[1]);
	if (res) {
		put_rc(res);
		return CMD_RET_FAILURE;
	}

	p1 = s1 = s2 = 0;
	for(;;) {
		res = f_readdir(&Dir, &Finfo);
		if ((res != FR_OK) || !Finfo.fname[0])
			break;
		if (Finfo.fattrib & AM_DIR) {
			s2++;
		} else {
			s1++; p1 += Finfo.fsize;
		}
		printf_P(PSTR("%c%c%c%c%c %u/%02u/%02u %02u:%02u %9lu  %s"),
					(Finfo.fattrib & AM_DIR) ? 'D' : '-',
					(Finfo.fattrib & AM_RDO) ? 'R' : '-',
					(Finfo.fattrib & AM_HID) ? 'H' : '-',
					(Finfo.fattrib & AM_SYS) ? 'S' : '-',
					(Finfo.fattrib & AM_ARC) ? 'A' : '-',
					(Finfo.fdate >> 9) + 1980, (Finfo.fdate >> 5) & 15, Finfo.fdate & 31,
					(Finfo.ftime >> 11), (Finfo.ftime >> 5) & 63,
					Finfo.fsize, &(Finfo.fname[0]));
#if _USE_LFN
		for (int i = strlen(Finfo.fname); i < 14; i++)
			putchar(' ');
		printf_P(PSTR("%s\n"), Lfname);
#else
		putchar('\n');
#endif
	}

	if (res == FR_OK) {
		printf_P(PSTR("%4u File(s),%10lu bytes total\n%4u Dir(s)"), s1, p1, s2);
		if (f_getfree(argv[1], (DWORD*)&p1, &fs) == FR_OK)
			printf_P(PSTR(", %10luK bytes free\n"), p1 * fs->csize / 2);
	}

	if (res) {
		put_rc(res);
		return CMD_RET_FAILURE;
	}

	return CMD_RET_SUCCESS;
}


/*
 * fatread - load binary file from a dos filesystem
 *		<d:/path/filename> <addr> [bytes [pos]]
 */
command_ret_t do_fat_read(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	FATFS FatFs;
	FIL File;
	unsigned long bytes = 0x80000;
	unsigned long pos= 0;
	unsigned long bytes_read;
	uint32_t addr;
	FRESULT res;
	bool buserr = 0;
	uint32_t timer;
	uint8_t buffer[512];

	(void) cmdtp; (void) flag;

	if (argc < 3)
		return CMD_RET_USAGE;

	addr = strtoul(argv[2], 0, 16);
	if (argc > 3)
		bytes = strtoul(argv[3], 0, 16);
	if (argc > 4)
		pos = strtoul(argv[4], 0, 16);

	res = f_mount(&FatFs, argv[1], 0);
	if (!res) {
		res = f_open(&File, argv[1], FA_READ);

		if (!res) {
			res = f_lseek(&File, pos);
			if (!res) {
				bytes_read = 0;
				timer = get_timer(0);
				while (bytes) {
					unsigned int cnt, br;

					if (bytes >= sizeof buffer)	{
						cnt = sizeof buffer;
						bytes -= sizeof buffer;
					} else {
						cnt = bytes; bytes = 0;
					}
					res = f_read(&File, buffer, cnt, &br);
					if (res != FR_OK)
						break;
					if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
						buserr = 1;
						break;
					}
					z80_write_block(buffer, addr, br);
					z80_bus_cmd(Release);
					addr += br;

					bytes_read += br;
					if (cnt != br)
						break;
				}
				timer = get_timer(timer);
				printf_P(PSTR("%lu bytes read with %lu bytes/sec.\n"),
							bytes_read, timer ? (bytes_read * 1000 / timer) : 0);
			}
		}
		f_mount(NULL, argv[1], 0);
	}

	if (buserr)
		my_puts_P(PSTR("Bus timeout\n"));
	if (res)
		put_rc(res);
	if (buserr || res)
		return CMD_RET_FAILURE;

	return CMD_RET_SUCCESS;
}

/*
 * fatwrite - write file into a dos filesystem
 *		<d:/path/filename> <addr> <bytes>
 */
command_ret_t do_fat_write(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	FATFS FatFs;
	FIL File;
	unsigned long bytes;
	unsigned long bytes_written;
	uint32_t addr;
	FRESULT res;
	bool buserr = 0;
	uint32_t timer;
	uint8_t buffer[512];

	(void) cmdtp; (void) flag;

	if (argc < 4)
		return CMD_RET_USAGE;

	addr = strtoul(argv[2], 0, 16);
	bytes = strtoul(argv[3], 0, 16);

	res = f_mount(&FatFs, argv[1], 0);
	if (!res) {
		res = f_open(&File, argv[1], FA_CREATE_ALWAYS | FA_WRITE);
		if (!res) {
			bytes_written = 0;
			timer = get_timer(0);
			while (bytes) {
				unsigned int cnt, br;

				if (bytes >= sizeof buffer)	{
					cnt = sizeof buffer;
					bytes -= sizeof buffer;
				} else {
					cnt = bytes; bytes = 0;
				}
				if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
					buserr = 1;
					break;
				}
				z80_read_block(buffer, addr, cnt);
				z80_bus_cmd(Release);
				res = f_write(&File, buffer, cnt, &br);
				if (res != FR_OK)
					break;
				addr += br;
				bytes_written += br;
				if (cnt != br)
					break;
			}
			res = f_close(&File);
			timer = get_timer(timer);
			printf_P(PSTR("%lu bytes written with %lu bytes/sec.\n"),
						bytes_written, timer ? (bytes_written * 1000 / timer) : 0);
		}
		f_mount(NULL, argv[1], 0);
	}

	if (buserr)
		my_puts_P(PSTR("Bus timeout\n"));
	if (res)
		put_rc(res);
	if (buserr || res)
		return CMD_RET_FAILURE;

	return CMD_RET_SUCCESS;
}

/*
 * fatread/write - load binary file to/from a dos filesystem
 *		read  <d:/path/filename> <addr> [bytes [pos]]
 *		write <d:/path/filename> <addr> <bytes>
 */
command_ret_t do_fat_rw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	FATFS FatFs;
	FIL File;
	uint32_t addr;
	unsigned long bytes;
	unsigned long pos;
	unsigned long bytes_rw;

	bool dowrite = (argv[0][3] == 'w');
	FRESULT res;
	bool buserr = 0;
	uint32_t timer;
	uint8_t buffer[512];

	(void) cmdtp; (void) flag;

	if (argc < (dowrite ? 4 : 3))
		return CMD_RET_USAGE;

	addr = strtoul(argv[2], 0, 16);
	if (addr >= MAX_MEMORY) {
		printf_P(PSTR("address too high: 0x%0lx\n"), addr);
		return CMD_RET_FAILURE;
	}
	if (argc > 3)
		bytes = strtoul(argv[3], 0, 16);
	else
		bytes = MAX_MEMORY;
	if (argc > 4)
		pos = strtoul(argv[4], 0, 16);
	else
		pos = 0;

	if (addr + bytes > MAX_MEMORY)
		bytes = MAX_MEMORY - addr;

	res = f_mount(&FatFs, argv[1], 0);
	if (!res) {
		res = f_open(&File, argv[1], dowrite ? FA_WRITE | FA_CREATE_ALWAYS
											 : FA_READ );

		if (!res) {
			res = f_lseek(&File, pos);
			if (!res) {
				bytes_rw = 0;
				timer = get_timer(0);
				while (bytes) {
					unsigned int cnt, br;

					if (bytes >= sizeof buffer)	{
						cnt = sizeof buffer;
						bytes -= sizeof buffer;
					} else {
						cnt = bytes; bytes = 0;
					}
					if (dowrite) {
						if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
							buserr = 1;
							break;
						}
						z80_read_block(buffer, addr, cnt);
						z80_bus_cmd(Release);
						res = f_write(&File, buffer, cnt, &br);
						if (res != FR_OK)
							break;
					} else {
						res = f_read(&File, buffer, cnt, &br);
						if (res != FR_OK)
							break;
						if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
							buserr = 1;
							break;
						}
						z80_write_block(buffer, addr, br);
						z80_bus_cmd(Release);
					}
					addr += br;

					bytes_rw += br;
					if (cnt != br) {
						if (dowrite)
							printf_P(PSTR("Disk full?\n"));
						break;
					}
					if (ctrlc()) {
						printf_P(PSTR("Abort\n"));
						break;
					}
				}

				FRESULT fr = f_close(&File);
				if (!res)
					res = fr;
				timer = get_timer(timer);
				printf_P(PSTR("%lu (0x%lx) bytes read/written with %lu bytes/sec.\n"),
							bytes_rw, bytes_rw, timer ? (bytes_rw * 1000 / timer) : 0);
			}
		}
		f_mount(NULL, argv[1], 0);
	}

	if (buserr)
		my_puts_P(PSTR("Bus timeout\n"));
	if (res)
		put_rc(res);
	if (buserr || res)
		return CMD_RET_FAILURE;

	return CMD_RET_SUCCESS;
}