#include <inttypes.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#ifdef _WIN32
# include <io.h>
# define read _read
# define write _write
#else
# include <unistd.h>
#endif
#include "gbi.h"
#include "gfxd.h"
#include "priv.h"

static TLOCAL struct gfxd_state state;

static int buffer_input_fn(void *buf, int count)
{
	if (count > config.input_buf_size)
		count = config.input_buf_size;
	memcpy(buf, config.input_buf, count);
	config.input_buf += count;
	config.input_buf_size -= count;
	return count;
}

static int buffer_output_fn(const char *buf, int count)
{
	if (count > config.output_buf_size)
		count = config.output_buf_size;
	memcpy(config.output_buf, buf, count);
	config.output_buf += count;
	config.output_buf_size -= count;
	return count;
}

static int fd_input_fn(void *buf, int count)
{
	return read(config.input_fd, buf, count);
}

static int fd_output_fn(const char *buf, int count)
{
	return write(config.output_fd, buf, count);
}

static void swap_words(Gfx *gfx)
{
	uint8_t b[8];
	uint8_t *pw = (void *) gfx;
	uint8_t *pb = b;

	int endian = config.endian;
	int wordsize = config.wordsize;

	for (int i = 0; i < 8 / wordsize; i++)
	{
		if (endian == gfxd_endian_host)
		{
			switch (wordsize)
			{
				case 1:
				{
					uint8_t w = *(uint8_t *) pw;
					*pb++ = w >> 0;
					break;
				}
				case 2:
				{
					uint16_t w = *(uint16_t *) pw;
					*pb++ = w >> 8;
					*pb++ = w >> 0;
					break;
				}
				case 4:
				{
					uint32_t w = *(uint32_t *) pw;
					*pb++ = w >> 24;
					*pb++ = w >> 16;
					*pb++ = w >> 8;
					*pb++ = w >> 0;
					break;
				}
				case 8:
				{
					uint64_t w = *(uint64_t *) pw;
					*pb++ = w >> 56;
					*pb++ = w >> 48;
					*pb++ = w >> 40;
					*pb++ = w >> 32;
					*pb++ = w >> 24;
					*pb++ = w >> 16;
					*pb++ = w >> 8;
					*pb++ = w >> 0;
					break;
				}
			}
		}
		else
		{
			for (int j = 0; j < wordsize; j++)
			{
				if (endian == gfxd_endian_little)
					*pb++ = pw[wordsize - 1 - j];
				else
					*pb++ = pw[j];
			}
		}
		pw += wordsize;
	}

	gfx->hi = ((uint32_t) b[0] << 24)
		| ((uint32_t) b[1] << 16)
		| ((uint32_t) b[2] << 8)
		| ((uint32_t) b[3] << 0);
	gfx->lo = ((uint32_t) b[4] << 24)
		| ((uint32_t) b[5] << 16)
		| ((uint32_t) b[6] << 8)
		| ((uint32_t) b[7] << 0);
}

static void get_more_input(void)
{
	if (state.end_input != 0)
		return;

	char *recv_buf = (void *) &state.gfx[0];

	while (state.n_gfx < sizeof(state.gfx) / sizeof(state.gfx[0]))
	{
		int n_read = sizeof(state.gfx) - state.n_byte;
		n_read = config.input_fn(&recv_buf[state.n_byte], n_read);
		if (n_read == 0)
			return;
		state.n_byte += n_read;

		while (state.n_gfx < state.n_byte / sizeof(Gfx))
		{
			Gfx gfx = state.gfx[state.n_gfx];
			gfxd_macro_t *m = &state.macro[state.n_gfx];

			swap_words(&gfx);

			int ret = config.ucode->disas_fn(m, gfx.hi, gfx.lo);
			if (ret != 0 && config.stop_on_invalid != 0)
			{
				state.end_input = 1;
				state.ret = ret;
				return;
			}

			state.n_gfx++;
		}
	}
}

static int32_t typed_arg_i(int type, int idx)
{
	const gfxd_value_t *v = gfxd_value_by_type(type, idx);
	if (v != NULL)
		return v->i;
	else
		return -1;
}

static uint32_t typed_arg_u(int type, int idx)
{
	const gfxd_value_t *v = gfxd_value_by_type(type, idx);
	if (v != NULL)
		return v->u;
	else
		return 0;
}


TLOCAL struct gfxd_config config =
{
	.ucode = NULL,
	.endian = gfxd_endian_big,
	.wordsize = 4,
	.arg = NULL,

	.stop_on_invalid = 1,
	.stop_on_end = 1,
	.emit_dec_color = 0,
	.emit_q_macro = 0,
	.emit_ext_macro = 0,

	.input_buf = NULL,
	.input_buf_size = 0,
	.input_fn = &buffer_input_fn,

	.output_buf = NULL,
	.output_buf_size = 0,
	.output_fn = &buffer_output_fn,

	.macro_fn = &gfxd_macro_dflt,
	.arg_fn = &gfxd_arg_dflt,

	.tlut_fn = NULL,
	.timg_fn = NULL,
	.cimg_fn = NULL,
	.zimg_fn = NULL,
	.dl_fn = NULL,
	.mtx_fn = NULL,
	.lookat_fn = NULL,
	.light_fn = NULL,
	.seg_fn = NULL,
	.vtx_fn = NULL,
	.vp_fn = NULL,
	.uctext_fn = NULL,
	.ucdata_fn = NULL,
	.dram_fn = NULL,
};

void gfxd_input_buffer(const void *buf, int size)
{
	config.input_buf = buf;
	config.input_buf_size = size;
	config.input_fn = &buffer_input_fn;
}

void gfxd_output_buffer(char *buf, int size)
{
	config.output_buf = buf;
	config.output_buf_size = size;
	config.output_fn = &buffer_output_fn;
}

void gfxd_input_fd(int fd)
{
	config.input_fd = fd;
	config.input_fn = &fd_input_fn;
}

void gfxd_output_fd(int fd)
{
	config.output_fd = fd;
	config.output_fn = &fd_output_fn;
}

void gfxd_input_callback(gfxd_input_fn_t *fn)
{
	if (fn != NULL)
		config.input_fn = fn;
	else
		gfxd_input_buffer(NULL, 0);
}

void gfxd_output_callback(gfxd_output_fn_t *fn)
{
	if (fn != NULL)
		config.output_fn = fn;
	else
		gfxd_output_buffer(NULL, 0);
}

void gfxd_macro_fn(gfxd_macro_fn_t *fn)
{
	if (fn != NULL)
		config.macro_fn = fn;
	else
		config.macro_fn = gfxd_macro_dflt;
}

void gfxd_arg_fn(gfxd_arg_fn_t *fn)
{
	if (fn != NULL)
		config.arg_fn = fn;
	else
		config.arg_fn = gfxd_arg_dflt;
}

int gfxd_write(const void *buf, int count)
{
	return config.output_fn(buf, count);
}

int gfxd_puts(const char *str)
{
	return gfxd_write(str, strlen(str));
}

int gfxd_printf(const char *fmt, ...)
{
	char s[256];

	va_list arg;
	va_start(arg, fmt);
	int n = vsnprintf(s, sizeof(s), fmt, arg);
	va_end(arg);

	if (n > sizeof(s) - 1)
		n = sizeof(s) - 1;

	return gfxd_write(s, n);
}

int gfxd_print_value(int type, const gfxd_value_t *value)
{
	return config.ucode->arg_tbl[type].fn(value);
}

int gfxd_macro_dflt(void)
{
	gfxd_macro_t *m = &state.macro[0];
	const gfxd_macro_type_t *t = &config.ucode->macro_tbl[m->id];

	const char *name = gfxd_macro_name();
	if (name == NULL)
	{
		if (config.arg != NULL)
		{
			gfxd_puts(config.arg);
			gfxd_puts(" = ");
		}

		gfxd_puts("(Gfx){");
	}
	else
	{
		gfxd_puts(name);
		gfxd_puts("(");

		if (config.arg != NULL)
		{
			gfxd_puts(config.arg);
			if (t->n_arg != 0)
				gfxd_puts(", ");
		}
	}

	for (int i = 0; i < t->n_arg; i++)
	{
		if (i != 0)
			gfxd_puts(", ");

		config.arg_fn(i);
	}

	if (name == NULL)
		gfxd_puts("}");
	else
		gfxd_puts(")");

	return 0;
}

int gfxd_arg_callbacks(int arg_num)
{
	int id = gfxd_macro_id();

	switch (gfxd_arg_type(arg_num))
	{
		case gfxd_Tlut:
		{
			if (config.tlut_fn != NULL)
			{
				int32_t num;
				if (id == gfxd_DPLoadTLUT_pal16)
					num = 16;
				else if (id == gfxd_DPLoadTLUT_pal256)
					num = 256;
				else
					num = typed_arg_i(gfxd_Num, 0);
				return config.tlut_fn(
					typed_arg_u(gfxd_Tlut, 0),
					typed_arg_i(gfxd_Pal, 0),
					num);
			}
			break;
		}
		case gfxd_Timg:
		{
			if (config.timg_fn != NULL)
			{
				int32_t siz = typed_arg_i(gfxd_Siz, 0);
				if (siz == -1)
					siz = G_IM_SIZ_4b;
				return config.timg_fn(
					typed_arg_u(gfxd_Timg, 0),
					typed_arg_i(gfxd_Fmt, 0),
					siz,
					typed_arg_i(gfxd_Dim, 0),
					typed_arg_i(gfxd_Dim, 1),
					typed_arg_i(gfxd_Pal, 0));
			}
			break;
		}
		case gfxd_Cimg:
		{
			if (config.cimg_fn != NULL)
			{
				return config.cimg_fn(
					typed_arg_u(gfxd_Cimg, 0),
					typed_arg_i(gfxd_Fmt, 0),
					typed_arg_i(gfxd_Siz, 0),
					typed_arg_i(gfxd_Dim, 0));
			}
			break;
		}
		case gfxd_Zimg:
		{
			if (config.zimg_fn != NULL)
			{
				return config.zimg_fn(
					typed_arg_u(gfxd_Zimg, 0));
			}
			break;
		}
		case gfxd_Dl:
		{
			if (config.dl_fn != NULL)
			{
				return config.dl_fn(
					typed_arg_u(gfxd_Dl, 0));
			}
			break;
		}
		case gfxd_Mtxptr:
		{
			if (config.mtx_fn != NULL)
			{
				return config.mtx_fn(
					typed_arg_u(gfxd_Mtxptr, 0));
			}
			break;
		}
		case gfxd_Lookatptr:
		{
			if (config.lookat_fn != NULL)
			{
				int32_t num;
				if (id == gfxd_SPLookAt)
					num = 2;
				else
					num = 1;
				return config.lookat_fn(
					typed_arg_u(gfxd_Lookatptr, 0),
					num);
			}
			break;
		}
		case gfxd_Lightptr:
		{
			if (config.light_fn != NULL)
			{
				int32_t num;
				if (id == gfxd_SPSetLights1)
					num = 1;
				else if (id == gfxd_SPSetLights2)
					num = 2;
				else if (id == gfxd_SPSetLights3)
					num = 3;
				else if (id == gfxd_SPSetLights4)
					num = 4;
				else if (id == gfxd_SPSetLights5)
					num = 5;
				else if (id == gfxd_SPSetLights6)
					num = 6;
				else if (id == gfxd_SPSetLights7)
					num = 7;
				else
					num = 1;
				return config.light_fn(
					typed_arg_u(gfxd_Lightptr, 0),
					num);
			}
			break;
			
		}
		case gfxd_Segptr:
		{
			if (config.seg_fn != NULL)
			{
				return config.seg_fn(
					typed_arg_u(gfxd_Segptr, 0),
					typed_arg_i(gfxd_Seg, 0));
			}
			break;
		}
		case gfxd_Vtxptr:
		{
			if (config.vtx_fn != NULL)
			{
				return config.vtx_fn(
					typed_arg_u(gfxd_Vtxptr, 0),
					typed_arg_i(gfxd_Num, 0));
			}
			break;
		}
		case gfxd_Vpptr:
		{
			if (config.vp_fn != NULL)
			{
				return config.vp_fn(
					typed_arg_u(gfxd_Vpptr, 0));
			}
			break;
		}
		case gfxd_Uctext:
		{
			if (config.uctext_fn != NULL)
			{
				return config.uctext_fn(
					typed_arg_u(gfxd_Uctext, 0),
					0x1000);
			}
			break;
		}
		case gfxd_Ucdata:
		{
			if (config.ucdata_fn != NULL)
			{
				uint32_t size;
				if (id == gfxd_SPLoadUcodeEx)
					size = typed_arg_u(gfxd_Size, 0);
				else
					size = 0x800;
				return config.ucdata_fn(
					typed_arg_u(gfxd_Ucdata, 0),
					size);
			}
			break;
		}
		case gfxd_Dram:
		{
			if (config.dram_fn != NULL)
			{
				return config.dram_fn(
					typed_arg_u(gfxd_Dram, 0),
					typed_arg_u(gfxd_Size, 0));
			}
			break;
		}
	}

	return 0;
}

void gfxd_arg_dflt(int arg_num)
{
	if (gfxd_arg_callbacks(arg_num) == 0)
	{
		gfxd_arg_t *a = &state.macro[0].arg[arg_num];

		gfxd_print_value(a->type, &a->value);
	}
}

void gfxd_tlut_callback(gfxd_tlut_fn_t *fn)
{
	config.tlut_fn = fn;
}

void gfxd_timg_callback(gfxd_timg_fn_t *fn)
{
	config.timg_fn = fn;
}

void gfxd_cimg_callback(gfxd_cimg_fn_t *fn)
{
	config.cimg_fn = fn;
}

void gfxd_zimg_callback(gfxd_zimg_fn_t *fn)
{
	config.zimg_fn = fn;
}

void gfxd_dl_callback(gfxd_dl_fn_t *fn)
{
	config.dl_fn = fn;
}

void gfxd_mtx_callback(gfxd_mtx_fn_t *fn)
{
	config.mtx_fn = fn;
}

void gfxd_lookat_callback(gfxd_lookat_fn_t *fn)
{
	config.lookat_fn = fn;
}

void gfxd_light_callback(gfxd_light_fn_t *fn)
{
	config.light_fn = fn;
}

void gfxd_seg_callback(gfxd_seg_fn_t *fn)
{
	config.seg_fn = fn;
}

void gfxd_vtx_callback(gfxd_vtx_fn_t *fn)
{
	config.vtx_fn = fn;
}

void gfxd_vp_callback(gfxd_vp_fn_t *fn)
{
	config.vp_fn = fn;
}

void gfxd_uctext_callback(gfxd_uctext_fn_t *fn)
{
	config.uctext_fn = fn;
}

void gfxd_ucdata_callback(gfxd_ucdata_fn_t *fn)
{
	config.ucdata_fn = fn;
}

void gfxd_dram_callback(gfxd_dram_fn_t *fn)
{
	config.dram_fn = fn;
}

void gfxd_target(gfxd_ucode_t ucode)
{
	config.ucode = ucode;
}

void gfxd_endian(int endian, int wordsize)
{
	config.endian = endian;
	config.wordsize = wordsize;
}

void gfxd_dynamic(const char *arg)
{
	config.arg = arg;
}

void gfxd_enable(int cap)
{
	switch (cap)
	{
		case gfxd_stop_on_invalid:
			config.stop_on_invalid = 1;
			break;

		case gfxd_stop_on_end:
			config.stop_on_end = 1;
			break;

		case gfxd_emit_dec_color:
			config.emit_dec_color = 1;
			break;

		case gfxd_emit_q_macro:
			config.emit_q_macro = 1;
			break;

		case gfxd_emit_ext_macro:
			config.emit_ext_macro = 1;
			break;
	}
}

void gfxd_disable(int cap)
{
	switch (cap)
	{
		case gfxd_stop_on_invalid:
			config.stop_on_invalid = 0;
			return;

		case gfxd_stop_on_end:
			config.stop_on_end = 0;
			return;

		case gfxd_emit_dec_color:
			config.emit_dec_color = 0;
			break;

		case gfxd_emit_q_macro:
			config.emit_q_macro = 0;
			break;

		case gfxd_emit_ext_macro:
			config.emit_ext_macro = 0;
			break;
	}
}

void gfxd_udata_set(void *ptr)
{
	config.udata = ptr;
}

void *gfxd_udata_get(void)
{
	return config.udata;
}

int gfxd_execute(void)
{
	state.macro_offset = 0;
	state.n_byte = 0;
	state.n_gfx = 0;
	state.end_input = 0;
	state.ret = 0;

	for (;;)
	{
		get_more_input();
		if (state.n_gfx == 0)
			break;

		gfxd_macro_t *m = &state.macro[0];
		config.ucode->combine_fn(m, state.n_gfx);

		const gfxd_macro_type_t *t = &config.ucode->macro_tbl[m->id];
		if (t->ext != 0 && config.emit_ext_macro == 0)
		{
			Gfx gfx = state.gfx[0];
			swap_words(&gfx);

			t = &config.ucode->macro_tbl[gfxd_Invalid];
			t->disas_fn(m, gfx.hi, gfx.lo);
		}

		int ret = config.macro_fn();
		if (ret != 0)
		{
			state.ret = ret;
			break;
		}

		if (config.stop_on_end != 0
			&& (m->id == gfxd_SPBranchList
				|| m->id == gfxd_SPEndDisplayList))
		{
			break;
		}

		int n_pop = config.ucode->macro_tbl[m->id].n_gfx;
		int n_rem = state.n_gfx - n_pop;
		{
			int n_byte = n_rem * sizeof(gfxd_macro_t);
			memmove(&state.macro[0], &state.macro[n_pop], n_byte);
			state.n_gfx = n_rem;
		}
		{
			int n_byte = n_rem * sizeof(Gfx);
			memmove(&state.gfx[0], &state.gfx[n_pop], n_byte);
			state.n_byte = n_byte;
		}
		state.macro_offset += n_pop * sizeof(Gfx);
	}

	return state.ret;
}

int gfxd_macro_offset(void)
{
	return state.macro_offset;
}

int gfxd_macro_packets(void)
{
	return config.ucode->macro_tbl[state.macro[0].id].n_gfx;
}

const void *gfxd_macro_data(void)
{
	return state.gfx;
}

int gfxd_macro_id(void)
{
	return state.macro[0].id;
}

const char *gfxd_macro_name(void)
{
	int id = state.macro[0].id;
	const gfxd_macro_type_t *t = &config.ucode->macro_tbl[id];

	if (t->prefix == NULL && t->suffix == NULL)
	{
		return NULL;
	}
	else
	{
		static TLOCAL char buf[32];

		char *p = buf;
		if (t->prefix != NULL)
		{
			const char *s = t->prefix;
			while (*s != '\0')
				*p++ = *s++;
		}
		*p++ = 'g';
		if (config.arg == NULL)
			*p++ = 's';
		if (t->suffix != NULL)
		{
			const char *s = t->suffix;
			while (*s != '\0')
				*p++ = *s++;
		}
		*p++ = '\0';

		return buf;
	}
}

int gfxd_arg_count(void)
{
	return config.ucode->macro_tbl[state.macro[0].id].n_arg;
}

int gfxd_arg_type(int arg_num)
{
	return state.macro[0].arg[arg_num].type;
}

const char *gfxd_arg_name(int arg_num)
{
	return state.macro[0].arg[arg_num].name;
}

int gfxd_arg_fmt(int arg_num)
{
	return config.ucode->arg_tbl[state.macro[0].arg[arg_num].type].fmt;
}

const gfxd_value_t *gfxd_arg_value(int arg_num)
{
	return &state.macro[0].arg[arg_num].value;
}

const gfxd_value_t *gfxd_value_by_type(int type, int idx)
{
	gfxd_macro_t *m = &state.macro[0];
	const gfxd_macro_type_t *t = &config.ucode->macro_tbl[m->id];

	for (int i = 0; i < t->n_arg; i++)
	{
		gfxd_arg_t *a = &m->arg[i];
		if (a->type == type)
		{
			if (idx == 0)
				return &a->value;
			else
				idx--;
		}
	}

	return NULL;
}

int gfxd_arg_valid(int arg_num)
{
	return state.macro[0].arg[arg_num].bad == 0;
}