use fmt;
use os;
use fs;
use io;
use bufio;
use bytes;
use time;
use time::date;
use strings;

export type uxn = struct {
	pc: u16,
	console_vector: u16,
	screen_vector: u16,
	mouse_vector: u16,
	controller_vector: u16,
	ram: [BANKS_CAP] u8,
	dev: [0x100] u8,
	ptr: [2] u8,
	stk: [2][0x100] u8,
	running: bool,
	screen_size_changed: bool,
	screen_update: bool,
	screen: uxn_screen,
	palette: [4] u16,
	files: [2] uxnFile,
};

export def MAXWIDTH = 4096;
export def MAXHEIGHT = 2160;
export def SCREENRATE = 60;
//Screen consists of two layers of 2-bit pixels
export type uxn_screen = ([MAXWIDTH][MAXHEIGHT]u8, [MAXWIDTH][MAXHEIGHT]u8);

export type uxnFile = struct {
	file: io::handle,
	filepath: str,
	state: filestate,
	dir: bool,
	exists: bool,
	fappend: bool,
	
};
export type filestate = enum {
	IDLE,
	FILE_READ,
	FILE_WRITE,
	DIR_READ,
	DIR_WRITE
};


def NUMBANKS: u16 = 0x10;
def BANKSIZE: u32 = 0x10000;
def BANKS_CAP = NUMBANKS * BANKSIZE;

const reset_vector: u16 = 0x0100;

const colormodes: [4][16] u8 = [
	[0, 0, 0, 0, 1, 0, 1, 1, 2, 2, 0, 2, 3, 3, 3, 0],
	[0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3],
	[1, 2, 3, 1, 1, 2, 3, 1, 1, 2, 3, 1, 1, 2, 3, 1],
	[2, 3, 1, 2, 2, 3, 1, 2, 2, 3, 1, 2, 2, 3, 1, 2]];

fn initialize_uxn_mem() *uxn = {
	return alloc(uxn{
		pc = reset_vector,
		console_vector = 0,
		screen_vector = 0,
		mouse_vector = 0,
		controller_vector = 0,
		ram = [0...],
		dev = [0...],
		ptr = [0...],
		stk = [[0...],[0...]],
		running = false,
		screen_size_changed = false,
		screen_update = true,
		screen = ([[0...]...],[[0...]...]),
		palette = [0...],
		files = [uxnFile {
			file = 	io::empty,
			filepath = "",
			state = filestate::IDLE,
			dir = false,
			exists = false,
			fappend = false,
		}...],
	})!;
};


export fn get_window_size(state: *uxn) struct{width: u16, height: u16} = {
	let width_high = state.dev[0x22];
	let width_low = state.dev[0x23];
	let height_high = state.dev[0x24];
	let height_low = state.dev[0x25];

	let result = struct {width: u16 = short_from_bytes(width_high,width_low),
			     height: u16 = short_from_bytes(height_high,height_low) };
	return result;
};

export fn set_window_size(w: u16, h: u16, state: *uxn) void = {

	state.dev[0x22] = (w >> 8): u8;
	state.dev[0x23] = (w): u8;
	state.dev[0x24] = (h >> 8): u8;
	state.dev[0x25] = (h): u8;
};

fn emu_dei(port: u8, state: *uxn) u8 = {
	switch(port) {
	case 0x04 =>
		return state.ptr[0];
	case 0x05 =>
		return state.ptr[1];
	case 0xc0 =>
		const date = time::date::localnow();
		const year = time::date::year(&date);
		return ((year) >> 8): u8;
	case 0xc1 =>
		const date = time::date::localnow();
		const year = time::date::year(&date);
		return year: u8;
	case 0xc2 =>
		const date = time::date::localnow();
		return time::date::month(&date): u8 - 1;
	case 0xc3 =>
		const date = time::date::localnow();
		return time::date::day(&date): u8;
	case 0xc4 =>
		const date = time::date::localnow();
		return time::date::hour(&date): u8;
	case 0xc5 =>
		const date = time::date::localnow();
		return time::date::minute(&date): u8;
	case 0xc6 =>
		const date = time::date::localnow();
		return time::date::second(&date): u8;
	case 0xc7 =>
		const date = time::date::localnow();
		return (time::date::weekday(&date): u8 + 1) % 7;
	case 0xc8 =>
		const date = time::date::localnow();
		const day = time::date::yearday(&date) - 1;
		return ((day) >> 8): u8;
	case 0xc9 =>
		const date = time::date::localnow();
		const day = time::date::yearday(&date) - 1;
		return day: u8;
	case 0xca =>
		const date = time::date::localnow();
		const zone = time::date::zone(&date);
		return if(zone.dst) {yield 1;} else {yield 0;}; //TODO this isn't tested
	case =>
		return state.dev[port];
	};
};


export fn emu_deo(port: u8, value: u8, state: *uxn) void = {
	state.dev[port] = value;
	switch(port) {
	case 0x03 =>
		const high = state.dev[0x02];
		const low = value;
		const eaddr = short_from_bytes(high,low);
		deo_expansion(eaddr,state);
	case 0x04 =>
		state.ptr[0] = value;
	case 0x05 =>
		state.ptr[1] = value;
	case 0x0e =>
		print_stack_debug(state);
	case 0x11 =>
		const high = state.dev[0x10];
		const low = value;
		state.console_vector = short_from_bytes(high,low);
	case 0x18 =>
		fmt::print(value: rune)!;
	case 0x19 =>
		fmt::error(value)!;
	case 0x21 =>
		const high = state.dev[0x20];
		const low = value;
		state.screen_vector = short_from_bytes(high,low);
	case 0x2e =>
		draw_pixel(value,state);
	case 0x2f =>
		draw_sprite(value,state);
	case 0x81 =>
		const high = state.dev[0x80];
		const low = value;
		state.controller_vector = short_from_bytes(high,low);
	case 0x91 =>
		const high = state.dev[0x90];
		const low = value;
		state.mouse_vector = short_from_bytes(high,low);
	case 0xa5 => // File/stat [0]
		filestat_to_addr(0,state);		
	case 0xa6 => // File/delete [0]
		delete_file(0,state);		
	case 0xa9 => // File/name [0]
		set_file_name(0,state);		
	case 0xad => // File/read [0]
		read_file_to_addr(0,state);
	case 0xaf => //File/write [0]
		write_file_from_addr(0,state);
	case 0xb5 => // File/stat [1]
		filestat_to_addr(1,state);		
	case 0xb6 => // File/delete [1]
		delete_file(1,state);		
	case 0xb9 => // File/name [1]
		set_file_name(1,state);		
	case 0xbd => // File/read [1]
		read_file_to_addr(1,state);
	case 0xbf => //File/write [1]
		write_file_from_addr(1,state);
	
	case =>
		if(	port == 0x22 ||
			port == 0x23 ||
			port == 0x24 ||
			port == 0x25 ) {
				state.screen_size_changed = true;
		}else if( port == 0x09 || //TODO maybe also trigger on high bytes
			  port == 0x0b ||
			  port == 0x0d ){
			regenerate_palettes(state);
					
		};
		
	};
};


fn deo_expansion(addr: u16, state: *uxn) void = {
	const op = state.ram[addr];
	const length = short_from_bytes(state.ram[addr+1],state.ram[addr+2]);
	switch(op) {
	case 0x00 => //fill
		const bank = short_from_bytes(state.ram[addr+3],state.ram[addr+4]): u32;
		const dstaddr = short_from_bytes(state.ram[addr+5],state.ram[addr+6]): u32;
		const value = state.ram[addr+7];
		// fmt::printfln("expansion fill: bank: {:x} addr: {:x} value: {:x} | length: {:x}",bank,dstaddr,value,length)!;
		if(bank < NUMBANKS) for(let i: u16 =0; i < length; i+=1){
			state.ram[bank * BANKSIZE + dstaddr + i] = value;	
		};
	case 0x01 => //cpyl
		const srcbank = short_from_bytes(state.ram[addr+3],state.ram[addr+4]): u32;
		const srcaddr = short_from_bytes(state.ram[addr+5],state.ram[addr+6]): u32;
		const dstbank = short_from_bytes(state.ram[addr+7],state.ram[addr+8]): u32;
		const dstaddr = short_from_bytes(state.ram[addr+9],state.ram[addr+10]): u32;
		// fmt::printfln("Cpyl: src: {:x} <-> {:x}  dst: {:x} <-> {:x} | length: {:x}",srcbank,srcaddr,dstbank,dstaddr,length)!;
		if(srcbank < NUMBANKS && dstbank < NUMBANKS) for(let i: u16 =0; i < length; i+=1){
			const readval = state.ram[srcbank * BANKSIZE + srcaddr + i];
			state.ram[dstbank * BANKSIZE + dstaddr + i] = readval;	
		};
	case 0x02 => //cpr  TODO are these actually different??  Either way need to not use for loop
		const srcbank = short_from_bytes(state.ram[addr+3],state.ram[addr+4]): u32;
		const srcaddr = short_from_bytes(state.ram[addr+5],state.ram[addr+6]): u32;
		const dstbank = short_from_bytes(state.ram[addr+7],state.ram[addr+8]): u32;
		const dstaddr = short_from_bytes(state.ram[addr+9],state.ram[addr+10]): u32;
		// fmt::printfln("Cpyr: src: {:x} <-> {:x}  dst: {:x} <-> {:x} | length: {:x}",srcbank,srcaddr,dstbank,dstaddr,length)!;
		if(srcbank < NUMBANKS && dstbank < NUMBANKS) for(let i: u16 =1; i <= length; i+=1){
			const readval = state.ram[srcbank * BANKSIZE + srcaddr + length - i];
			state.ram[dstbank * BANKSIZE + dstaddr + length - i] = readval;
		};
	case =>
		fmt::fatalf("Unknown expansion op: 0x{:x}",op);
	};

};

export type evalerror = !void;
export type unhandled = !u8;
export type quit = void;

export type error = !(evalerror | unhandled);

type simple_op = void;
type literal_op = struct { short: bool, ret: bool};
type normal_op = struct { short: bool, keep: bool, ret: bool};

type BRK = simple_op;
type JCI = simple_op;
type JMI = simple_op;
type JSI = simple_op;
type LIT = literal_op;
type INC = normal_op;
type POP = normal_op;
type NIP = normal_op;
type SWP = normal_op;
type ROT = normal_op;
type DUP = normal_op;
type OVR = normal_op;
type EQU = normal_op;
type NEQ = normal_op;
type GTH = normal_op;
type LTH = normal_op;
type JMP = normal_op;
type JCN = normal_op;
type JSR = normal_op;
type STH = normal_op;
type LDZ = normal_op;
type STZ = normal_op;
type LDR = normal_op;
type STR = normal_op;
type LDA = normal_op;
type STA = normal_op;
type DEI = normal_op;
type DEO = normal_op;
type ADD = normal_op;
type SUB = normal_op;
type MUL = normal_op;
type DIV = normal_op;
type AND = normal_op;
type ORA = normal_op;
type EOR = normal_op;
type SFT = normal_op;

type instruction = (BRK | JCI | JMI | JSI | LIT | INC | POP | NIP | SWP | ROT | DUP | OVR | EQU | NEQ
			| GTH | LTH | JMP | JCN | JSR | STH | LDZ | STZ | LDR | STR | LDA | STA | DEI
			| DEO | ADD | SUB | MUL | DIV | AND | ORA | EOR | SFT);


fn get_instruction(byte: u8) (instruction | error) = {
		let k: bool = (byte & (0b10000000) != 0 );
		let r: bool = (byte & (0b01000000) != 0 );
		let s: bool = (byte & (0b00100000) != 0 );
		let opcode: u8 = byte & (0b00011111);
		switch(opcode) {
		case 0x00 =>
			switch(byte){
			case 0x00 =>
				return void: BRK;
			case 0x20 =>
				return void: JCI;
			case 0x40 =>
				return void: JMI;
			case 0x60 =>
				return void: JSI;
			case 0x80 => // LIT
				return LIT {short=false, ret=false};
			case 0xa0 => // LIT2
				return LIT {short=true, ret=false};
			case 0xc0 => // LITr
				return LIT {short=false, ret=true};
			case 0xe0 => // LIT2r
				return LIT {short=true, ret=true};
			case =>
				return byte: unhandled;
			};
		case 0x01 =>
			return INC {short = s, keep = k, ret = r};
		case 0x02 =>
			return POP {short = s, keep = k, ret = r};
		case 0x03 =>
			return NIP {short = s, keep = k, ret = r};
		case 0x04 =>
			return SWP {short = s, keep = k, ret = r};
		case 0x05 =>
			return ROT {short = s, keep = k, ret = r};
		case 0x06 =>
			return DUP {short = s, keep = k, ret = r};
		case 0x07 =>
			return OVR {short = s, keep = k, ret = r};
		case 0x08 =>
			return EQU {short = s, keep = k, ret = r};
		case 0x09 =>
			return NEQ {short = s, keep = k, ret = r};
		case 0x0a =>
			return GTH {short = s, keep = k, ret = r};
		case 0x0b =>
			return LTH {short = s, keep = k, ret = r};
		case 0x0c =>
			return JMP {short = s, keep = k, ret = r};
		case 0x0d =>
			return JCN {short = s, keep = k, ret = r};
		case 0x0e =>
			return JSR {short = s, keep = k, ret = r};
		case 0x0f =>
			return STH {short = s, keep = k, ret = r};
		case 0x10 =>
			return LDZ {short = s, keep = k, ret = r};
		case 0x11 =>
			return STZ {short = s, keep = k, ret = r};
		case 0x12 =>
			return LDR {short = s, keep = k, ret = r};
		case 0x13 =>
			return STR {short = s, keep = k, ret = r};
		case 0x14 =>
			return LDA {short = s, keep = k, ret = r};
		case 0x15 =>
			return STA {short = s, keep = k, ret = r};
		case 0x16 =>
			return DEI {short = s, keep = k, ret = r};
		case 0x17 =>
			return DEO {short = s, keep = k, ret = r};
		case 0x18 =>
			return ADD {short = s, keep = k, ret = r};
		case 0x19 =>
			return SUB {short = s, keep = k, ret = r};
		case 0x1a =>
			return MUL {short = s, keep = k, ret = r};
		case 0x1b =>
			return DIV {short = s, keep = k, ret = r};
		case 0x1c =>
			return AND {short = s, keep = k, ret = r};
		case 0x1d =>
			return ORA {short = s, keep = k, ret = r};
		case 0x1e =>
			return EOR {short = s, keep = k, ret = r};
		case 0x1f =>
			return SFT {short = s, keep = k, ret = r};
		case =>
			return byte: unhandled;
		};
};

export fn print_stack_debug(state: *uxn) void = {
	//TODO follow standard form
	fmt::println("Working Stack:")!;
	print_stack(false,state);
	
	fmt::println("Return Stack:")!;
	print_stack(true,state);
};

fn print_stack(ret: bool, state: *uxn) void = {
	const p = switch(ret){
	case true =>
		yield 1;
	case false =>
		yield 0;
	};
	for(let i = state.ptr[p] - 8; i != state.ptr[p]; i+=1){
		fmt::printf("{:x} ",state.stk[p][i])!;
	};
	fmt::printf("\n")!;
};

fn short_from_bytes(high: u8, low: u8) u16 = {	
	return (high: u16) << 8 | (low: u16);
};

fn read_from_addr(short: bool, addr: u16, state: *uxn) (u8 | u16) = {
	switch(short){
	case true =>
		const high = state.ram[addr];
		const low = state.ram[addr+1];
		return short_from_bytes(high,low);

	case false =>
		return state.ram[addr];		
	};
};

fn write_to_addr(value: (u8 | u16), addr: u16, state: *uxn) void = {
	match(value){
	case let s: u16 =>
		const high = (s >> 8 ): u8;
		const low = s: u8;
		state.ram[addr] = high;
		state.ram[addr+1] = low;

	case let b: u8 =>
		state.ram[addr] = b;
	};
};

fn read_from_zaddr(short: bool, zaddr: u8, state: *uxn) (u8 | u16) = {
	switch(short){
	case true =>
		const high = state.ram[zaddr: u16];
		const low = state.ram[(zaddr+1): u16];
		return short_from_bytes(high,low);
	case false =>
		return state.ram[zaddr: u16];		
	};
};
fn write_to_zaddr(value: (u8 | u16), zaddr: u8, state: *uxn) void = {
	match(value){
	case let s: u16 =>
		const high = (s >> 8 ): u8;
		const low = s: u8;
		state.ram[zaddr: u16] = high;
		state.ram[(zaddr+1): u16] = low;
	case let b: u8 =>
		state.ram[zaddr: u16] = b;
	};
};

fn push_to_stack(ret: bool, val: (u8 | u16), state: *uxn) void = {
	const stack = switch(ret){
	case true =>
		yield 1;
	case false =>
		yield 0;
	};
	match(val) {
	case let bval: u8 =>
		state.stk[stack][state.ptr[stack]] = bval;
		state.ptr[stack] = state.ptr[stack] + 1;

	case let sval: u16 =>
		let low: u8 = (sval & 0xFF): u8;
		let high: u8 = (sval >> 8): u8;
		state.stk[stack][state.ptr[stack]] = high;
		state.ptr[stack] = state.ptr[stack] + 1;
		state.stk[stack][state.ptr[stack]] = low;
		state.ptr[stack] = state.ptr[stack] + 1;
	};
};

// Get value from stack, offset 0 is top of stack. offset depends on short or byte
fn get_stack_val(ret: bool, short: bool, off: u8, state: *uxn) (u8 | u16) = {
	const stack = switch(ret){
	case true =>
		yield 1;
	case false =>
		yield 0;
	};
	
	if(!short){
		let val: u8 = state.stk[stack][state.ptr[stack] - 1 - off];
		return val;
	} else {
		let low: u8 = state.stk[stack][state.ptr[stack]-1 - (off * 2)];
		let high: u8 = state.stk[stack][state.ptr[stack]-2 - (off * 2)];
		return short_from_bytes(high,low);		
	};
};

//peek offset is always byte offset
fn peek(ret: bool, short: bool, off: u8, state: *uxn) (u8 | u16 ) = {
	const stack = switch(ret){
	case true =>
		yield 1;
	case false =>
		yield 0;
	};
	
	if(!short){
		let val: u8 = state.stk[stack][state.ptr[stack] - 1 - off];
		return val;
	} else {
		let low: u8 = state.stk[stack][state.ptr[stack] - 1 - off];
		let high: u8 = state.stk[stack][state.ptr[stack] - 2 - off];
		return short_from_bytes(high,low);		
	};
	
};

fn increment_stack(ret: bool, short: bool, state: *uxn) void = {
	const stack = switch(ret){
	case true =>
		yield 1;
	case false =>
		yield 0;
	};
	if(short){
		state.ptr[stack] = state.ptr[stack] + 2;
	} else {
		state.ptr[stack] = state.ptr[stack] + 1;
	};	
};
fn decrement_stack(ret: bool, short: bool, state: *uxn) void = {
	const stack = switch(ret){
	case true =>
		yield 1;
	case false =>
		yield 0;
	};
	if(short){
		state.ptr[stack] = state.ptr[stack] - 2;
	} else {
		state.ptr[stack] = state.ptr[stack] - 1;
	};	
};

fn pop_from_stack(keep: bool, ret: bool, short: bool, state: *uxn) (u8 | u16) = {
	const val = get_stack_val(ret, short, 0, state);
	if(!keep) decrement_stack(ret, short, state);
	return val;
};

fn pop_or_get(inst: normal_op, off: u8, state: *uxn) (u8 | u16) = {
	return switch(inst.keep) {
	case false =>
		yield pop_from_stack(false,inst.ret,inst.short,state);
	case true =>
		yield get_stack_val(inst.ret,inst.short, off,state);
	};
};
//Offset is always byte aligned in peek
fn pop_or_peek(inst: normal_op, off: u8, state: *uxn) (u8 | u16) = {
	return switch(inst.keep) {
	case false =>
		yield pop_from_stack(false,inst.ret,inst.short,state);
	case true =>
		yield peek(inst.ret,inst.short, off,state);
	};
};
export fn uxn_eval(new_pc: u16, state: *uxn) (done | quit | error ) = {
	// let a: u16 = 0, b: u16 = 0, c: u16 = 0, x: [2]u16 = [0...], y: [2]u16 = [0...], z: [2]u16 = [0...];
	state.pc = new_pc;
	state.running = true;
	for(state.running){
		uxn_step(state)?;
	};
	if(state.dev[0x0f] != 0) return quit;
	return done;
};

export fn uxn_step(state: *uxn) (done | error) = {
	// fmt::printfln("Starting eval with pc: {:x}", pc)!;
	const readval = state.ram[state.pc];
	const inst: instruction = get_instruction(readval)?;
	state.pc += 1; //TODO verify all pc changes
	
	match(inst) {	
	case BRK =>
		// fmt::println("Break!")!;
		state.running = false;
		return done;
	case JCI =>
		const val: u8 = pop_from_stack(false, false, false, state): u8;
		if(val != 0) {
			state.pc += 2 + short_from_bytes(state.ram[state.pc],state.ram[state.pc+1]); //TODO, is this signed?
		}else{
			state.pc += 2;
		};
	case JMI =>
		state.pc = state.pc + 2 + short_from_bytes(state.ram[state.pc],state.ram[state.pc+1]); //TODO is this signed?
	case JSI =>
		push_to_stack(true, state.pc + 2, state);
		state.pc = state.pc + 2 + short_from_bytes(state.ram[state.pc],state.ram[state.pc+1]); //TODO is this signed?
	case let lit_inst: LIT =>
		push_to_stack(lit_inst.ret, state.ram[state.pc], state);
		state.pc = state.pc + 1;
		if(lit_inst.short) {
			push_to_stack(lit_inst.ret, state.ram[state.pc],state);
			state.pc = state.pc + 1;
		};
	case let inc_inst: INC =>
		const val = match(pop_from_stack(inc_inst.keep,inc_inst.ret,inc_inst.short,state)) {
			//TODO this whole match statement seems unnecessary
			case let byte: u8 =>
				yield byte + 1;
			case let short: u16 =>
				yield short + 1;
		};
		
		push_to_stack(inc_inst.ret,val,state);
	case let pop_inst: POP =>
		if(!pop_inst.keep){
			pop_from_stack(false,pop_inst.ret,pop_inst.short,state);	
		};
	case let nip_inst: NIP =>
		const top = pop_or_get(nip_inst,0,state);
		const bot = pop_or_get(nip_inst,1,state);
		push_to_stack(nip_inst.ret, top, state);
	case let swp_inst: SWP =>
		const top = pop_or_get(swp_inst,0,state);
		const bot = pop_or_get(swp_inst,1,state);

		push_to_stack(swp_inst.ret, top, state);
		push_to_stack(swp_inst.ret, bot, state);
	case let rot_inst: ROT =>
		const top = pop_or_get(rot_inst,0,state);
		const mid = pop_or_get(rot_inst,1,state);
		const bot = pop_or_get(rot_inst,2,state);

		push_to_stack(rot_inst.ret, mid, state);
		push_to_stack(rot_inst.ret, top, state);
		push_to_stack(rot_inst.ret, bot, state);
	case let dup_inst: DUP =>
		const val = pop_from_stack(dup_inst.keep, dup_inst.ret, dup_inst.short, state);
		push_to_stack(dup_inst.ret, val, state);
		push_to_stack(dup_inst.ret, val, state);
	case let ovr_inst: OVR =>
		const top = pop_or_get(ovr_inst,0,state);
		const bot = pop_or_get(ovr_inst,1,state);

		push_to_stack(ovr_inst.ret, bot, state);
		push_to_stack(ovr_inst.ret, top, state);
		push_to_stack(ovr_inst.ret, bot, state);
	case let equ_inst: EQU =>
		const top = pop_or_get(equ_inst,0,state);
		const bot = pop_or_get(equ_inst,1,state);

		//TODO, I think this works, but it feels unclean with the casting
		const val: u8 = if(top: u16 == bot: u16){
			yield 1;
		} else {
			yield 0;	
		};
		push_to_stack(equ_inst.ret, val, state);
	case let neq_inst: NEQ =>
		const top = pop_or_get(neq_inst,0,state);
		const bot = pop_or_get(neq_inst,1,state);

		//TODO, I think this works, but it feels unclean with the casting
		const val: u8 = if(top: u16 != bot: u16){
			yield 1;
		} else {
			yield 0;	
		};
		push_to_stack(neq_inst.ret, val, state);
	case let gth_inst: GTH =>
		const top = pop_or_get(gth_inst,0,state);
		const bot = pop_or_get(gth_inst,1,state);

		//TODO, I think this works, but it feels unclean with the casting
		const val: u8 = if(bot: u16 > top: u16){
			yield 1;
		} else {
			yield 0;	
		};
		push_to_stack(gth_inst.ret, val, state);
	case let lth_inst: LTH =>
		const top = pop_or_get(lth_inst,0,state);
		const bot = pop_or_get(lth_inst,1,state);

		//TODO, I think this works, but it feels unclean with the casting
		const val: u8 = if(bot: u16 < top: u16){
			yield 1;
		} else {
			yield 0;	
		};
		push_to_stack(lth_inst.ret, val, state);
	case let jmp_inst: JMP =>
		const addr = pop_or_get(jmp_inst,0,state);
		match(addr) {
			case let b: u8 =>
				let off = b: i8: i32;
				state.pc = (state.pc: i32 + off): u16; //TODO verify if pc changes are right

			case let s: u16 =>
				state.pc = s;
		};
	case let jcn_inst: JCN =>
		const addr = pop_or_get(jcn_inst,0,state);
		const cond: u8 = pop_or_peek(normal_op {keep = jcn_inst.keep,
						 ret = jcn_inst.ret,
						 short = false},
				      if(jcn_inst.short){ yield 2;} else { yield 1; }, state ): u8;
		if( cond != 0) {
			match(addr) {
				case let b: u8 =>
					let off = b: i8: i32;
					state.pc = (state.pc: i32 + off): u16; //TODO verify if pc changes are right
				case let s: u16 =>
					state.pc = s;
			};
		};
	case let jsr_inst: JSR =>
		let addr = pop_or_get(jsr_inst,0,state);
		push_to_stack(true, state.pc, state);
		match(addr) {
			case let b: u8 =>
				let off = b: i8: i32;
				state.pc = (state.pc: i32 + off): u16; //TODO verify if pc changes are right
			case let s: u16 =>
				state.pc = s;
		};
		
	case let sth_inst: STH =>
		const val = pop_from_stack(sth_inst.keep,sth_inst.ret,sth_inst.short,state);
		push_to_stack(!sth_inst.ret, val, state);
	case let ldz_inst: LDZ =>
		const addr: u8 = pop_from_stack(ldz_inst.keep, ldz_inst.ret, false, state): u8;
		const val = read_from_zaddr(ldz_inst.short,addr,state);
		push_to_stack(ldz_inst.ret, val, state);
	case let stz_inst: STZ =>
		const addr: u8 = pop_or_peek(normal_op{short = false, keep = stz_inst.keep, ret = stz_inst.ret}, 0, state): u8;
		const val = pop_or_peek(stz_inst,1,state);
		write_to_zaddr(val,addr,state);
	case let ldr_inst: LDR =>
		const reladdr = (pop_from_stack(ldr_inst.keep, ldr_inst.ret, false, state): u16): i8;
		const addr: u16 = (state.pc: u32: i32 + reladdr): u16;
		const val = read_from_addr(ldr_inst.short,addr,state);
		push_to_stack(ldr_inst.ret, val, state);
	case let str_inst: STR =>
		const reladdr = (pop_or_peek(normal_op{short = false, keep = str_inst.keep, ret = str_inst.ret}, 0, state): u16 & 0x00FF): u8: i8;
		const addr: u16 = (state.pc: u32: i32 + reladdr): u16;
		const val = pop_or_peek(str_inst,1,state);
		write_to_addr(val,addr,state);
	case let lda_inst: LDA =>
		const addr: u16 = pop_from_stack(lda_inst.keep, lda_inst.ret, true, state): u16;
		const val = read_from_addr(lda_inst.short,addr,state);
		push_to_stack(lda_inst.ret, val, state);
	case let sta_inst: STA =>
		const addr: u16 = pop_or_peek(normal_op{short = true, keep = sta_inst.keep, ret = sta_inst.ret}, 0, state): u16 ;
		const val = pop_or_peek(sta_inst,2,state);
		write_to_addr(val,addr,state);
	case let dei_inst: DEI =>
		const port: u8 = pop_from_stack(dei_inst.keep, dei_inst.ret, false, state): u8;
		const val = if(dei_inst.short){
			yield short_from_bytes(emu_dei(port,state),emu_dei(port+1,state));
		}else{
			yield emu_dei(port,state);
		};
		push_to_stack(dei_inst.ret,val,state);
	case let deo_inst: DEO =>
		const port: u8 = pop_or_get(normal_op{short = false, keep = deo_inst.keep, ret = deo_inst.ret}, 0, state): u8;
		const val = pop_or_peek(deo_inst,1,state);
		match(val){
		case let s: u16 =>
			const high: u8 = (s >> 8): u8;
			const low: u8 = s: u8;
			emu_deo(port,high,state);
			emu_deo(port+1,low,state);
		case let b: u8 =>
			emu_deo(port,b,state);
		};
	case let add_inst: ADD =>
		const top = pop_or_get(add_inst,0,state);
		const bot = pop_or_get(add_inst,1,state);
		const res = if(!add_inst.short){
			yield (top: u8 + bot: u8);
		} else {
			yield (top: u16 + bot: u16);
		};
		push_to_stack(add_inst.ret, res, state);
	case let sub_inst: SUB =>
		const top = pop_or_get(sub_inst,0,state);
		const bot = pop_or_get(sub_inst,1,state);
		const res = if(!sub_inst.short){
			yield (bot: u8 - top: u8);
		} else {
			yield (bot: u16 - top: u16);
		};
		push_to_stack(sub_inst.ret, res, state);
	case let mul_inst: MUL =>
		const top = pop_or_get(mul_inst,0,state);
		const bot = pop_or_get(mul_inst,1,state);
		const res = if(!mul_inst.short){
			yield (bot: u8 * top: u8);
		} else {
			yield (bot: u16 * top: u16);
		};
		push_to_stack(mul_inst.ret, res, state);
	case let div_inst: DIV =>
		const top = pop_or_get(div_inst,0,state);
		const bot = pop_or_get(div_inst,1,state);
		const res = if(!div_inst.short){
			assert(bot is u8);
			assert(top is u8);
			if(top: u8 == 0) yield top;
			yield (bot: u8 / top: u8): u8;
		} else {
			assert(bot is u16);
			assert(top is u16);
			if(top: u16 == 0) yield top;
			yield (bot: u16 / top: u16): u16;
		};
		push_to_stack(div_inst.ret, res, state);
	case let and_inst: AND =>
		const top = pop_or_get(and_inst,0,state);
		const bot = pop_or_get(and_inst,1,state);
		const res = if(!and_inst.short){
			yield (bot: u8 & top: u8);
		} else {
			yield (bot: u16 & top: u16);
		};
		push_to_stack(and_inst.ret, res, state);
	case let ora_inst: ORA =>
		const top = pop_or_get(ora_inst,0,state);
		const bot = pop_or_get(ora_inst,1,state);
		const res = if(!ora_inst.short){
			yield (bot: u8 | top: u8);
		} else {
			yield (bot: u16 | top: u16);
		};
		push_to_stack(ora_inst.ret, res, state);
	case let eor_inst: EOR =>
		let top = pop_or_get(eor_inst,0,state);
		let bot = pop_or_get(eor_inst,1,state);
		let res = if(!eor_inst.short){
			yield (bot: u8 ^ top: u8);
		} else {
			yield (bot: u16 ^ top: u16);
		};
		push_to_stack(eor_inst.ret, res, state);
	case let sft_inst: SFT =>
		const shifts: u8 = pop_or_peek(normal_op{short = false, keep = sft_inst.keep, ret = sft_inst.ret}, 0, state): u8;
		const rightshifts = shifts & 0b00001111;
		const leftshifts = ((shifts & 0b11110000) >> 4) & 0b00001111;
		const val = pop_or_peek(sft_inst,1,state);
		const res = match(val) {
		case let s: u16 =>
			yield (s >> rightshifts ) << leftshifts;
		case let b: u8 =>
			yield (b >> rightshifts ) << leftshifts;
		};
		push_to_stack(sft_inst.ret, res, state);

	case =>
		return readval: unhandled;		
	};
	return done;
};


// Converts an error into a user-friendly string
export fn strerror(err: error) str = {
	match (err) {
	case evalerror =>
		return "Reached unexpected part of eval code";
	case let val: unhandled =>
		return fmt::asprintf("Unknown Opcode read: {:x}", val: u8)!;
	};
};

export fn uxn_init(path: str) ( *uxn | error ) = {
	const romfile = match (os::open(path,fs::flag::RDONLY)) {
	case let file: io::file =>
		yield file;
	case let err: fs::error =>
		fmt::fatalf("Error opening {}: {}", path, fs::strerror(err));
	};
	const state: *uxn = initialize_uxn_mem();
	//Copy rom into ram
	const bytesread = match (io::read(romfile,state.ram[0x100..(BANKS_CAP - 0x100)])){
	case let bytes: size =>
		yield bytes;
	case let eof: io::EOF =>
		fmt::fatalf("Empty Rom");
	case let err: io::error =>
		fmt::fatalf("Error reading: {}", io::strerror(err));
	};
	io::close(romfile)!; //TODO, isn't there some kind of oversized roms?

	//Initialize default size
	state.dev[0x22] = 0x02;
	state.dev[0x23] = 0x80;
	state.dev[0x24] = 0x01;
	state.dev[0x25] = 0xe0;

	//Initialize default colors TODO look for .theme files
	state.dev[0x08] = 0xf0;
	state.dev[0x09] = 0x7f;
	state.dev[0x0a] = 0xf0;
	state.dev[0x0b] = 0xd6;
	state.dev[0x0c] = 0xf0;
	state.dev[0x0d] = 0xb2;
	regenerate_palettes(state);
	return state;
};
export fn uxn_reset(state: *uxn) void = {
	state.running = true;
	uxn_eval(reset_vector,state)!;
};