// cargo run -- --script lunar_wave_vm/test_vectors/fizz_buzz.lua

use std::io::{
	Read,
	Write,
};

use lunar_wave_vm as lwvm;

fn main () -> Result <(), lwvm::StepError> {
	let args: Vec <_> = std::env::args ().collect ();
	lunar_wave (args)?;
	Ok (())
}

fn lunar_wave (args: Vec <String>) -> Result <Vec <lwvm::Value>, lwvm::StepError> {
	let mut list_bytecode = false;
	let mut breakpoints = vec![];
	let mut chunk = None;
	let mut lua_args = vec! [];
	
	let mut arg_iter = args.iter ();
	let _exe_name = arg_iter.next ().unwrap ();
	
	while let Some (arg) = arg_iter.next () {
		match arg.as_str () {
			"--break" => {
				let s = arg_iter.next ().unwrap ();
				let (block_idx, program_counter) = s.split_once (":").unwrap ();
				let block_idx = str::parse (block_idx).unwrap ();
				let program_counter = str::parse (program_counter).unwrap ();
				
				breakpoints.push (lwvm::Breakpoint {
					block_idx,
					program_counter,
				});
			},
			"--list-bytecode" => list_bytecode = true,
			"-" => {
				let mut buf = vec! [];
				std::io::stdin ().read_to_end (&mut buf).unwrap ();
				let bc = lwvm::ensure_bytecode (buf).unwrap ();
				chunk = Some (lwvm::parse_chunk (&bc).unwrap ());
				
				lua_args = vec! ["-".to_string ()];
			},
			"--" => break,
			x => {
				if x.starts_with ('-') {
					panic! ("Unknown flag `{x}`");
				}
				else if chunk.is_none () {
					let bc = lwvm::compile_bytecode_from_file (x);
					chunk = Some (lwvm::parse_chunk (&bc).unwrap ());
					
					lua_args = vec! [x.to_string ()];
				}
				else {
					lua_args.push (x.into ());
				}
			},
		}
	}
	
	match chunk {
		Some (chunk) => debugger (DebuggerParams {
			breakpoints,
			chunk,
			list_bytecode,
			lua_args,
		}),
		None => repl (ReplParams {
			list_bytecode,
			lua_args,
		}),
	}
}

struct DebuggerParams {
	breakpoints: Vec <lwvm::Breakpoint>,
	chunk: lwvm::Chunk,
	list_bytecode: bool,
	lua_args: Vec <String>,
}

struct ReplParams {
	list_bytecode: bool,
	lua_args: Vec <String>,
}

/// The interpreter mode, which has optional debugging abilities
/// sort of like a cut-down gdb.

fn debugger (params: DebuggerParams) -> Result <Vec <lwvm::Value>, lwvm::StepError> 
{
	if params.list_bytecode {
		dbg! (&params.chunk);
	}
	
	let upvalues = lwvm::State::upvalues_from_args (params.lua_args.into_iter ());
	
	let mut vm = lwvm::State::new (params.chunk, upvalues);
	if std::env::var("LWVM_DEBUG").is_ok() {
		vm.debug_print = true;
	}
	
	// Variables for interactive debugging
	
	let mut in_break = false;
	let mut last_input = String::new ();
	
	loop {
		if in_break || params.breakpoints.iter ().any (|bp| vm.at_breakpoint (bp)) {
			in_break = true;
			dbg! (&vm.stack);
			
			let mut input = Default::default ();
			std::io::stdin ().read_line (&mut input).unwrap ();
			
			let input = if input == "" {
				&last_input
			}
			else {
				last_input = input;
				&last_input
			};
			
			match input.as_str ().trim_end () {
				"c" => in_break = false,
				"q" => return Ok (vec! []),
				"registers" => {
					dbg! (&vm.registers);
					continue;
				}
				"s" => {
					match vm.step ()? {
						None => (),
						Some (lwvm::StepOutput::ChunkReturned (x)) => {
							return Ok (x);
						},
					}
					continue;
				},
				x => { dbg! (x); },
			}
		}
		
		match vm.step ()? {
			None => (),
			Some (lwvm::StepOutput::ChunkReturned (x)) => {
				return Ok (x);
			},
		}
	}
}

/// A REPL that's sort of like the PUC Lua or LuaJIT REPL, 
/// but with fewer features.
/// It still have to cheat and run `luac5.4` as a subprocess.

fn repl (params: ReplParams) -> Result <Vec <lwvm::Value>, lwvm::StepError> 
{
	let upvalues = lwvm::State::upvalues_from_args (params.lua_args.into_iter ());
	
	let mut vm = lwvm::State::new (lwvm::Chunk::default (), upvalues);
	
	println! ("Lunar Wave 0.1.0-modified  Copyright (C) 2023 ReactorScram (implements Lua 5.4  Copyright (C) 1994-2022 Lua.org, PUC-Rio");
	
	loop {
		{
			let mut stdout = std::io::stdout ().lock ();
			stdout.write_all (b"> ").unwrap ();
			stdout.flush ().unwrap ();
		}
		
		let mut input = Default::default ();
		std::io::stdin ().read_line (&mut input).unwrap ();
		if input.is_empty () {
			println! ();
			return Ok (vec! []);
		}
		
		let bytecode = match lwvm::compile_bytecode (input.into_bytes ()) {
			Ok (x) => x,
			Err (e) => {
				eprintln! ("Compile error from luac subprocess:");
				eprintln! ("{}", e);
				continue;
			},
		};
		let chunk = lwvm::parse_chunk (&bytecode).unwrap ();
		
		if params.list_bytecode {
			dbg! (&chunk);
		}
		
		vm.set_chunk (chunk);
		match vm.execute () {
			Ok (x) => if ! x.is_empty () {
				println! ("{x:?}")
			},
			Err (e) => println! ("{e:?}"),
		}
	}
}