use sdl3;
use sdl3::image;
use sdl3::ttf;
use types::c;
use os;
use io;
use fmt;
use strings;
use uxn;

def WIDTH = 640;
def HEIGHT = 480;
def DEFAULT_SCALE = 3;

export fn main() void = {
	sdl3::Init(sdl3::InitFlags::VIDEO | sdl3::InitFlags::EVENTS)!;
	defer sdl3::Quit();

	let scale = DEFAULT_SCALE;
	const win = sdl3::CreateWindow(
		c::nulstr("Meadow\0"),
		WIDTH*scale, HEIGHT*scale, sdl3::WindowFlags::RESIZABLE |
				sdl3::WindowFlags::MOUSE_CAPTURE |
				sdl3::WindowFlags::INPUT_FOCUS |
				sdl3::WindowFlags::MOUSE_FOCUS
				)!;
	defer sdl3::DestroyWindow(win);

	sdl3::SetWindowMinimumSize(win,0,0)!;

	const render = sdl3::CreateRenderer(win, null)!;
	defer sdl3::DestroyRenderer(render);
	sdl3::SetRenderDrawColor(render, 0, 0, 128, 255)!;
	sdl3::SetRenderVSync(render,1)!;


	const screen_w = WIDTH;
	const screen_h = HEIGHT;
	//Create blank texture for screen
	const meadow_texture = sdl3::CreateTexture(render,
				sdl3::PixelFormat::XRGB4444,
				sdl3::TextureAccess::STATIC,
				screen_w,
				screen_h)!;
	defer sdl3::DestroyTexture(meadow_texture);
	sdl3::SetTextureScaleMode(meadow_texture, sdl3::ScaleMode::NEAREST)!;
	// const pixeldata: [WIDTH * HEIGHT]u32 = [0...];
	let pixeldata: *[uxn::MAXWIDTH * uxn::MAXHEIGHT]u16 = alloc([0...])!; //TODO figure out actual size
	defer free (pixeldata);

	let run = true;
	let ev = sdl3::Event { ... };
	if(len(os::args) < 2){
		fmt::printf("usage: %s file.rom [args..]\n")!;
		return;
	};
	let path = os::args[1];
	let state: *uxn::uxn = uxn::uxn_init(path)!;
	uxn::uxn_reset(state);
	let next_refresh: u64 = 0;
	const perf_freq: u64 = sdl3::GetPerformanceFrequency();
	const frame_interval = perf_freq / 60;
	const ms_interval = perf_freq / 1000;
	for (run) {
		const now: u64 = sdl3::GetPerformanceCounter();
		if(state.running){
			// fmt::printf("Next Step!\n")!;
			uxn::uxn_step(state)!;
		}else{
			 // fmt::printf("Not Running!\n")!;
			 if(state.console_vector != 0){
			 	let args = os::args[2..];
			 	let i: u8 = 0;
			 	let argcount = len(args): u8;
			 	for (let arg .. args){
			 		// fmt::println("Console input args")!;
			 		for(let char: u8 .. strings::toutf8(arg)){
			 			// fmt::printfln("Console input arg char: {:x}", char)!;
			 			match (uxn::console_input(char,2,state)) {
			 					case done =>
			 						yield done;
			 					case let val: u8  =>
			 						fmt::fatalf("Unhandled Opcode: {:x}", val);
			 				};
			 		};
			 		let ctype: u8 = if(i == (argcount - 1)){
			 			yield 4;
			 		} else {
			 			yield 3;
			 		};
			 		match (uxn::console_input('\n',ctype,state)) {
			 				case done =>
			 					yield done;
			 				case let val: u8  =>
			 					fmt::fatalf("Unhandled Opcode: {:x}", val);
			 			};
			 		i+=1; //TODO using i here seems inelegant
			 	};
			 	for( state.dev[0x0f] == 0; i+=1 ){
			 		let buf: [1]u8 = [0];
			 		let count = io::read(os::stdin, buf)!;
			 		// fmt::println("Read input")!;
			 		if(count != 0) {
			 			match (uxn::console_input(buf[0],1,state)) {
			 					case done =>
			 						yield done;
			 					case let val: u8  =>
			 						fmt::fatalf("Unhandled Opcode: {:x}", val);
			 				};
			 			// fmt::println("Retuned from console_input")!;
			 		};
			 	};
			 	match (uxn::console_input('\n',4,state)) { //TODO should this run?
			 			case done =>
			 				yield done;
			 			case let val: u8  =>
			 				fmt::fatalf("Unhandled Opcode: {:x}", val);
			 		};
			 };
		};

		if(now >= next_refresh){
			next_refresh = now + frame_interval;

			if(state.screen_vector != 0){
				// fmt::println("Executing screen vector")!;
				uxn::uxn_eval(state.screen_vector, state)!;
			};
		};
		if(state.screen_size_changed){
			let dims = uxn::get_window_size(state);
			// fmt::printfln("Setting window to width: {:x} height: {:x}", dims.width, dims.height)!;
			if((dims.width != 0) && (dims.height !=0)){
				sdl3::DestroyTexture(meadow_texture);
				free(pixeldata);
				pixeldata = alloc([0...])!; //TODO figure out actual size

				let w: int = dims.width: int;
				let h: int = dims.height: int;

				fmt::printfln("Setting window to width: {} height: {}", w, h)!;
				sdl3::SetWindowSize(win,w*scale,h*scale)!;
			
				meadow_texture = sdl3::CreateTexture(render,
						sdl3::PixelFormat::XRGB4444,
						sdl3::TextureAccess::STATIC,
						w,
						h)!;
				sdl3::SetTextureScaleMode(meadow_texture, sdl3::ScaleMode::NEAREST)!;
		
				state.screen_update = true;
			};


			state.screen_size_changed = false;	
		};

		if(state.screen_update){
			const dims = uxn::get_window_size(state);
			for(let y: u16 = 0; y <= dims.height: u16; y+=1 ){
				for(let x: u16 = 0; x <= dims.width: u16; x+=1 ){
					let colshort: u16 = uxn::get_color(x,y,state);
					// fmt::printfln("Pixel x: {} y: {} color: {:x} pcount: {:x}", x, y, colshort, pcount)!;
					const index: u32 = y: u32 * dims.width: u32 + x: u32;
					// if(index < 10) fmt::printfln("pcount: {} index: {} x: {} y: {}", pcount, index, x, y)!;
					pixeldata[index] = colshort;
				};
			};
			const pitch: int = dims.width: int * 2;
			// fmt::printfln("Pitch is {}", pitch)!;
			if(pitch > 0) sdl3::UpdateTexture(meadow_texture, null, pixeldata, pitch)!;
			sdl3::RenderClear(render)!;
			sdl3::RenderTexture(render, meadow_texture, null, null)!;

			sdl3::RenderPresent(render)!;
			state.screen_update = false;
		};
		

		//Render stuff
		for (sdl3::PollEvent(&ev)) {
			// fmt::println("Handling event")!;
			switch (ev.event_type) {
				case sdl3::EventType::QUIT =>
					run = false;
				case sdl3::EventType::WINDOW_RESIZED =>
					let dims = uxn::get_window_size(state);
					let w = ev.window.data1 / scale: i32;
					let h = ev.window.data2 / scale: i32;
					const wmod = w % scale: i32;
					const hmod = h % scale: i32;
					if((wmod !=0) || (hmod !=0)){
						w = w-wmod;
						h = h-hmod;
						sdl3::SetWindowSize(win,w,h)!;
					};
					
					if((dims.width != w: u16 / scale: u16) || (dims.height != h: u16 / scale: u16)){
						// fmt::println("Dimensions not allowed!")!;
						//TODO handle this maybe
						uxn::set_window_size(w: u16,h: u16,state);
						sdl3::DestroyTexture(meadow_texture);
						free(pixeldata);
						pixeldata = alloc([0...])!; //TODO figure out actual size
						let old_w: int = dims.width: int;
						let old_h: int = dims.height: int;

						// fmt::printfln("User setting window to width: {} height: {}", w, h)!;
						sdl3::SetWindowSize(win,w*scale: i32,h*scale: i32)!;
			
						meadow_texture = sdl3::CreateTexture(render,
								sdl3::PixelFormat::XRGB4444,
								sdl3::TextureAccess::STATIC,
								w,
								h)!;
						sdl3::SetTextureScaleMode(meadow_texture, sdl3::ScaleMode::NEAREST)!;
		
						state.screen_update = true;
					};
				
				case sdl3::EventType::MOUSE_MOTION =>
					// fmt::printfln("Mouse Event x: {} y: {}", ev.motion.x, ev.motion.y)!;
					const x = ev.motion.x / scale: f32;
					const y = ev.motion.y / scale: f32;
					uxn::set_mouse_motion(x: u16,y: u16,state);
					uxn::uxn_eval(state.mouse_vector,state)!;
				case sdl3::EventType::MOUSE_BUTTON_DOWN =>
					// fmt::printfln("Mouse Down: 0x{:x}", ev.button.button: u8 )!;
					const b = 1 << (ev.button.button: u8 - 1);
					uxn::set_mouse_down(b,state);
					uxn::uxn_eval(state.mouse_vector,state)!;
				case sdl3::EventType::MOUSE_BUTTON_UP =>
					// fmt::printfln("Mouse Up: 0x{:x}", ev.button.button: u8 )!;
					const b = 1 << (ev.button.button: u8 - 1);
					uxn::set_mouse_up(b,state);
					uxn::uxn_eval(state.mouse_vector,state)!;
				case sdl3::EventType::MOUSE_WHEEL =>
					fmt::printfln("Mouse Wheel!")!;
				case sdl3::EventType::WINDOW_EXPOSED =>
					sdl3::RenderClear(render)!;
					sdl3::RenderTexture(render, meadow_texture, null, null)!;
					sdl3::RenderPresent(render)!;
				case sdl3::EventType::WINDOW_SHOWN =>
					sdl3::RenderClear(render)!;
					sdl3::RenderTexture(render, meadow_texture, null, null)!;
					sdl3::RenderPresent(render)!;
				case sdl3::EventType::WINDOW_PIXEL_SIZE_CHANGED =>
					sdl3::RenderClear(render)!;
					sdl3::RenderTexture(render, meadow_texture, null, null)!;
					sdl3::RenderPresent(render)!;
				case sdl3::EventType::WINDOW_MOUSE_ENTER =>
					sdl3::RenderClear(render)!;
					sdl3::RenderTexture(render, meadow_texture, null, null)!;
					sdl3::HideCursor()!;
				case sdl3::EventType::WINDOW_MOUSE_LEAVE =>
					sdl3::RenderClear(render)!;
					sdl3::RenderTexture(render, meadow_texture, null, null)!;
					sdl3::ShowCursor()!;
				case =>
					// fmt::printfln("Unhandled SDL event: 0x{:x} , {}", ev.event_type, ev.event_type )!;
					yield;
			};
		};


		// sdl3::RenderClear(render)!;
		// sdl3::RenderTexture(render, meadow_texture, null, null)!;

		// sdl3::RenderPresent(render)!;
		// sdl3::Delay(1000 / 60);


		sdl3::get_error()!;
	};
};