#include "sux.h"
#include "disasm.h"
#include <string.h>

void disasm(struct sux *cpu, uint8_t lines, uint8_t opcode, uint8_t prefix, uint8_t thread) {
	uint64_t value;
	uint64_t address = get_addr(cpu, opcode, prefix, 0, 0, thread);
	uint8_t rs = (prefix >> 4) & 3;
	char *postfix;
	char *of;
	char op[4];
	char *sign = "";
	char *ind  = "";
	uint8_t tmp = 0;
	union reg mask;
	mask.u64 = 0;
	memcpy(op, opname[opcode], 3);
	op[3] = 0;
	switch (rs) {
		case 0: postfix = ""; break;
		case 1: postfix = ".W"; break;
		case 2: postfix = ".D"; break;
		case 3: postfix = ".Q"; break;
	}
	if (prefix >> 6) {
		tmp = 0;
	}
	switch (prefix >> 6) {
		default: of = ""; break;
		case 1 : of = "SP"; break;
		case 2 : of = "PC"; break;
	}
	uint8_t addrsize = 0;
	char *idx;
	switch (optype[opcode]) {
		case IND : idx =    ")"; break;
		case INDX: idx = ", x)"; break;
		case INDY: idx = "), y"; break;
		case ZMX : idx =  ", x"; break;
		case ZMY : idx =  ", y"; break;
		default  : idx =     ""; break;
	}
	switch (optype[opcode]) {
		case ZM  :
		case ZMX :
		case ZMY :
		case IND :
		case INDX:
		case INDY: addrsize = get_addrsize(prefix,  ZM); break;
		case ABS : addrsize = get_addrsize(prefix, ABS); break;
		case IMM :
		case REL : addrsize = (1 << rs)-1; break;
	}

	for (uint8_t i = 0; i < addrsize+1; i++) {
		mask.u8[i] = (i == addrsize && addrsize != 0xFF) ? 0x7F : 0xFF;
	}
	value = read_value(cpu, cpu->pc, addrsize, 0, 0);
	if ((prefix >> 6) == 1 || (prefix >> 6) == 2 || optype[opcode] == REL) {
		switch (addrsize) {
			case 0 : sign = ((int8_t )value < 0) ? "-" : "+"; break;
			case 1 : sign = ((int16_t)value < 0) ? "-" : "+"; break;
			case 2 :
			case 3 : sign = ((int32_t)value < 0) ? "-" : "+"; break;
			case 4 :
			case 5 :
			case 6 :
			case 7 : sign = ((int64_t)value < 0) ? "-" : "+"; break;
		}
		value &= mask.u64;
	}
	switch (optype[opcode]) {
		case BREG:
		case IMPL: wprintw(scr, "%s%s" , opname[opcode], postfix); break;
		case IMM : wprintw(scr, "%s%s #$%0*"PRIX64 , op, postfix, (addrsize+1) << 1, value); break;
		case IND :
		case INDX:
		case INDY: ind = "("; /* Falls through. */
		case ZMX :
		case ZMY :
		case ZM  :
		case ABS : wprintw(scr, "%s%s %s%s%s$%0*" PRIX64"%s" , op, postfix, ind, of, sign, (addrsize+1) << 1, value, idx); break;
		case REL : wprintw(scr, "%s%s %s$%0*"PRIX64 , op, postfix, sign, (addrsize+1) << 1, value); break;
	}

	if (address == TX_ADDR || address == RX_ADDR) {
		wmove(scr, 27, 0);
		wprintw(scr, "TX_ADDR: $%02X, RX_ADDR: $%02X", addr[TX_ADDR], addr[RX_ADDR]);
	}
	wmove(scr, 29, 0);
	wclrtoeol(scr);
	wprintw(scr, "address: $%04"PRIX64, address);
	if (subdbg) {
		uint8_t ln = 33;
		uint16_t line_idx = 0;
		uint32_t tmpad = 0x31000;
		int row, col;
		uint8_t iscursor = 0;
		union reg ptr;
		uint32_t adr;
		if (address == CTRL_ADDR || addr[STEP_ADDR]) {
			adr = 0x30000;
			wprintw(scr, ", scr_row: %02u, scr_col: %02u, scr_str: %02u, scr_end: %02u", addr[0], addr[1], addr[2], addr[3]);
			wmove(scr, 32, 0);
			wprintw(scr, "bitabl: ");
			for (uint8_t i = 0; i < 16; i++) {
				wprintw(scr, "%s", showbits(addr[adr+i], 7, 0));
			}
			mvwprintw(scr, ln++, 0, "buffer: ");
			wmove(scr, ln++, 0);
			uint8_t maxrow = 10;
			int line_offset = (addr[0]-(maxrow-1) >= 0) ? addr[0]-(maxrow-1) : 0;
			for (uint8_t i = 0; i < maxrow; i++) {
				line_idx = (i+addr[2]+line_offset << 6) + (i+addr[2]+line_offset << 4);
				for (uint8_t j = 0; j < 0x50; j++) {
					wprintw(scr, "%02X", addr[tmpad+j+line_idx]);
						if ((addr[0] == i+line_offset) && addr[1] == j) {
							iscursor=1;
							getyx(scr,row, col);
							wmove(scr, ln++, 0);
							wclrtoeol(scr);
							wmove(scr, row+1, col-2);
							wprintw(scr, "/\\");
							wmove(scr, row, col);
						}
				}
				wprintw(scr, ", i: %02X", i);
				if (!iscursor) {
					wmove(scr, ln, 0);
					wclrtoeol(scr);
				}
				iscursor = 0;
				wmove(scr, ln++, 0);
			}
		}
		wmove(scr, 30, 0);
		wclrtoeol(scr);
		adr = 0x25;
		ptr.u8[0] = addr[adr+0]; ptr.u8[1] = addr[adr+1];
		ptr.u8[2] = addr[adr+2]; ptr.u8[3] = addr[adr+3];
		ptr.u8[4] = addr[adr+4]; ptr.u8[5] = addr[adr+5];
		ptr.u8[6] = addr[adr+6]; ptr.u8[7] = addr[adr+7];
		wprintw(scr, "ptr1: $%04"PRIX64, ptr.u64);
		adr = 0x2D;
		ptr.u8[0] = addr[adr+0]; ptr.u8[1] = addr[adr+1];
		ptr.u8[2] = addr[adr+2]; ptr.u8[3] = addr[adr+3];
		ptr.u8[4] = addr[adr+4]; ptr.u8[5] = addr[adr+5];
		ptr.u8[6] = addr[adr+6]; ptr.u8[7] = addr[adr+7];
		wprintw(scr, ", ptr2: $%04"PRIX64, ptr.u64);
		adr = 0x35;
		ptr.u8[0] = addr[adr+0]; ptr.u8[1] = addr[adr+1];
		ptr.u8[2] = addr[adr+2]; ptr.u8[3] = addr[adr+3];
		ptr.u8[4] = addr[adr+4]; ptr.u8[5] = addr[adr+5];
		ptr.u8[6] = addr[adr+6]; ptr.u8[7] = addr[adr+7];
		wprintw(scr, ", ptr3: $%04"PRIX64, ptr.u64);
		adr = 0x3349A;
		ptr.u8[0] = addr[adr+0]; ptr.u8[1] = addr[adr+1];
		ptr.u8[2] = addr[adr+2]; ptr.u8[3] = addr[adr+3];
		ptr.u8[4] = addr[adr+4]; ptr.u8[5] = addr[adr+5];
		ptr.u8[6] = addr[adr+6]; ptr.u8[7] = addr[adr+7];
		wprintw(scr, ", idx0: $%04"PRIX64, ptr.u64);
		adr = 0x334BA;
		ptr.u8[0] = addr[adr+0]; ptr.u8[1] = addr[adr+1];
		ptr.u8[2] = addr[adr+2]; ptr.u8[3] = addr[adr+3];
		ptr.u8[4] = addr[adr+4]; ptr.u8[5] = addr[adr+5];
		ptr.u8[6] = addr[adr+6]; ptr.u8[7] = addr[adr+7];
		wprintw(scr, ", valbuf: $%016"PRIX64, ptr.u64);
		/*
		wmove(scr, 47, 0);
		wclrtoeol(scr);
		wprintw(scr, "a: $%02X,",  addr[0x0A]);
		wprintw(scr, " b: $%02X,", addr[0x0B]);
		wprintw(scr, " c: $%02X,", addr[0x0C]);
		wprintw(scr, " d: $%02X,", addr[0x0D]);
		wprintw(scr, " e: $%02X,", addr[0x0E]);
		wprintw(scr, " f: $%02X",  addr[0x0F]);
		tmpad = 0x33000;
		line_idx = 0;
		wprintw(scr, "cmd_buf:");
		for (uint8_t i = 0; i < 1; i++) {
			wmove(scr, ln++, 0);
			wclrtoeol(scr);
			line_idx = (i << 4)+(i << 6);
			for (uint8_t j = 0; j < 0x50; j++) {
				wprintw(scr, "%02X", addr[tmpad+j+line_idx]);
			}
			wprintw(scr, ", i: %02X", i);
		}*/

	}
}