use std::path::Path;

use rustc_hash::FxHashMap;

use crate::{
	buffer::{Buffer, Cell},
	file::{FileManager, GameManifest},
	input::InputManager,
	scene::{preload_scene, switch_scenes},
	storage::StorageManager,
	time::TimeContext,
};

mod wasm;

pub struct ScriptManager<'a> {
	scripts: &'a [ScriptDeclaration],
	pub active_scripts: Vec<usize>,
	entities: FxHashMap<Box<str>, Box<[u8]>>,
	script_states: FxHashMap<usize, Box<[u8]>>,
}

pub struct WasmRunner {
	pub engine: wasmi::Engine,
	pub linker: wasmi::Linker<FullScriptContext<'static>>,
}

pub struct ScriptContext<'a> {
	pub manifest: &'a GameManifest,
	pub buffer: &'a mut Buffer,
	pub input: &'a InputManager,
	pub time: &'a TimeContext,
	pub storage: &'a mut StorageManager,
	pub operation_queue: Vec<Operation>,
}

pub struct FullScriptContext<'a> {
	pub script_id: usize,
	pub manifest: &'a GameManifest,
	pub buffer: &'a Buffer,
	pub input: &'a InputManager,
	pub time: &'a TimeContext,
	pub scripts: &'a ScriptManager<'a>,
	pub files: &'a FileManager,
	pub storage: &'a StorageManager,
	pub wasm_runner: &'a WasmRunner,
	pub operation_queue: &'a mut Vec<Operation>,
}

pub enum Operation {
	AddCell(Cell),
	PreloadScene(usize),
	SwitchScene(usize),
	PreloadScript(usize),
	UnloadScript(usize),
	ActivateScript(usize),
	DeactivateScript(usize),
	UpdateState {
		script_id: usize,
		new_state: Box<[u8]>,
	},
	UpdateEntity {
		name: Box<str>,
		new_state: Box<[u8]>,
	},
	UpdateStorage {
		new_save: Box<[u8]>,
	},
	Exit,
}

type StaticScriptFunction = Option<fn(&mut ScriptContext<'_>, &mut Box<[u8]>)>;

#[derive(Debug, Clone)]
pub enum ScriptDeclaration {
	Static {
		name: Box<str>,
		start: StaticScriptFunction,
		update: StaticScriptFunction,
		end: StaticScriptFunction,
	},
	Wasm {
		name: Box<str>,
		path: Box<Path>,
	},
}

impl<'a> ScriptContext<'a> {
	pub fn exit(&mut self) -> ! {
		let _ = self.buffer.finish();
		std::process::exit(0);
	}
}

fn get_script_state(states: &mut FxHashMap<usize, Box<[u8]>>, script_id: usize) -> &mut Box<[u8]> {
	states.entry(script_id).or_insert(Box::from([]))
}

impl Default for WasmRunner {
	fn default() -> Self {
		Self::new()
	}
}

impl WasmRunner {
	pub fn new() -> Self {
		let engine = wasmi::Engine::default();
		let linker = unsafe {
			std::mem::transmute::<
				wasmi::Linker<FullScriptContext<'_>>,
				wasmi::Linker<FullScriptContext<'_>>,
			>(wasm::linker(&engine).unwrap())
		};
		Self { engine, linker }
	}

	pub fn compile(&self, data: &[u8]) -> Result<wasmi::Module, wasmi::Error> {
		wasmi::Module::new(&self.engine, data)
	}

	#[allow(clippy::too_many_arguments)]
	pub fn run_function(
		&self,
		script_id: usize,
		module: &wasmi::Module,
		scripts: &ScriptManager,
		files: &FileManager,
		wasm_runner: &WasmRunner,
		context: &mut ScriptContext<'_>,
		function_name: &str,
	) -> Result<(), wasmi::Error> {
		// safety: the store won't be kept around after this function ends. Only the
		//         lifetimes are being transmuted
		let mut store = {
			puffin::profile_scope!("create store");
			wasmi::Store::new(&self.engine, unsafe {
				std::mem::transmute::<FullScriptContext<'_>, FullScriptContext<'_>>(
					FullScriptContext {
						script_id,
						manifest: context.manifest,
						buffer: context.buffer,
						input: context.input,
						time: context.time,
						storage: context.storage,
						scripts,
						files,
						wasm_runner,
						operation_queue: &mut context.operation_queue,
					},
				)
			})
		};
		let instance = {
			puffin::profile_scope!("instantiate");
			self.linker.instantiate_and_start(&mut store, module)?
		};
		let function = {
			puffin::profile_scope!("get function");
			instance.get_func(&store, function_name).ok_or_else(|| {
				wasmi::Error::new(format!("No function named {function_name} was exported"))
			})?
		};
		{
			puffin::profile_scope!("call function");
			function.call(&mut store, &[], &mut [])
		}
	}
}

impl<'a> ScriptManager<'a> {
	pub fn new(scripts: &'a [ScriptDeclaration]) -> Self {
		Self {
			scripts,
			active_scripts: Vec::new(),
			entities: FxHashMap::default(),
			script_states: FxHashMap::default(),
		}
	}

	pub fn script_id_by_name(&self, needle: &str) -> Option<usize> {
		for (i, script) in self.scripts.iter().enumerate() {
			match script {
				ScriptDeclaration::Static { name, .. } => {
					if &**name == needle {
						return Some(i);
					}
				}
				ScriptDeclaration::Wasm { name, .. } => {
					if &**name == needle {
						return Some(i);
					}
				}
			}
		}

		None
	}

	pub fn preload_script(
		&self,
		script_id: usize,
		files: &mut FileManager,
		wasm_runner: &WasmRunner,
	) {
		let script = &self.scripts[script_id];
		match script {
			ScriptDeclaration::Static { .. } => (),
			ScriptDeclaration::Wasm { path, .. } => {
				files.start_loading_file(path, &wasm_runner.engine)
			}
		}
	}

	pub fn is_script_loaded(&self, script_id: usize, files: &FileManager) -> bool {
		let script = &self.scripts[script_id];
		match script {
			ScriptDeclaration::Static { .. } => true,
			ScriptDeclaration::Wasm { path, .. } => files.is_file_loaded(path),
		}
	}

	pub fn unload_script(&self, script_id: usize, files: &mut FileManager) {
		let script = &self.scripts[script_id];
		match script {
			ScriptDeclaration::Static { .. } => (),
			ScriptDeclaration::Wasm { path, .. } => files.unload_file(path),
		}
	}

	pub fn handle_queue(
		&mut self,
		context: &mut ScriptContext<'_>,
		wasm_runner: &WasmRunner,
		files: &mut FileManager,
	) {
		for operation in &context.operation_queue {
			match operation {
				Operation::AddCell(cell) => context.buffer.cells.push(*cell),
				Operation::PreloadScene(id) => {
					preload_scene(&context.manifest.scenes, self, files, wasm_runner, *id)
				}
				Operation::SwitchScene(id) => switch_scenes(
					self,
					&mut ScriptContext {
						manifest: context.manifest,
						buffer: context.buffer,
						input: context.input,
						time: context.time,
						storage: context.storage,
						operation_queue: Vec::new(),
					},
					files,
					wasm_runner,
					*id,
				),
				Operation::PreloadScript(id) => self.preload_script(*id, files, wasm_runner),
				Operation::UnloadScript(id) => self.unload_script(*id, files),
				Operation::ActivateScript(id) => self.activate_script(
					*id,
					&mut ScriptContext {
						manifest: context.manifest,
						buffer: context.buffer,
						input: context.input,
						time: context.time,
						storage: context.storage,
						operation_queue: Vec::new(),
					},
					wasm_runner,
					files,
				),
				Operation::DeactivateScript(id) => self.deactivate_script(
					*id,
					&mut ScriptContext {
						manifest: context.manifest,
						buffer: context.buffer,
						input: context.input,
						time: context.time,
						storage: context.storage,
						operation_queue: Vec::new(),
					},
					wasm_runner,
					files,
				),
				Operation::UpdateState {
					script_id,
					new_state,
				} => *get_script_state(&mut self.script_states, *script_id) = new_state.clone(),
				Operation::UpdateEntity { name, new_state } => {
					self.entities.insert(name.clone(), new_state.clone());
				}
				Operation::UpdateStorage { new_save } => {
					context.storage.background_save(new_save.clone());
				}
				Operation::Exit => context.exit(),
			}
		}
		context.operation_queue.clear();
	}

	pub fn activate_script(
		&mut self,
		script_id: usize,
		context: &mut ScriptContext<'_>,
		wasm_runner: &WasmRunner,
		files: &mut FileManager,
	) {
		let Some(script_declaration) = self.scripts.get(script_id) else {
			unreachable!("The active script does not exist");
		};
		match script_declaration {
			ScriptDeclaration::Static { start, .. } => {
				start.map(|s| {
					s(
						context,
						get_script_state(&mut self.script_states, script_id),
					)
				});
			}
			ScriptDeclaration::Wasm { path, .. } => {
				files.load_file(path.clone(), &wasm_runner.engine).unwrap();
				let module = files.get_cached_file(path).unwrap().unwrap_wasm_module();
				wasm_runner.run_function(
					script_id,
					module,
					self,
					files,
					wasm_runner,
					context,
					"start",
				);
			}
		}
		self.active_scripts.push(script_id);
		self.handle_queue(context, wasm_runner, files);
	}

	pub fn deactivate_script(
		&mut self,
		script_id: usize,
		context: &mut ScriptContext<'_>,
		wasm_runner: &WasmRunner,
		files: &mut FileManager,
	) {
		for script_id in self
			.active_scripts
			.iter()
			.cloned()
			.filter(|element| *element == script_id)
		{
			let Some(script) = self.scripts.get(script_id) else {
				unreachable!("The active script does not exist");
			};
			self.script_states.remove(&script_id);
			match script {
				ScriptDeclaration::Static { end, .. } => {
					end.map(|s| {
						s(
							context,
							get_script_state(&mut self.script_states, script_id),
						);
					});
				}
				ScriptDeclaration::Wasm { path, .. } => {
					files.load_file(path.clone(), &wasm_runner.engine).unwrap();
					let module = files.get_cached_file(path).unwrap().unwrap_wasm_module();
					wasm_runner.run_function(
						script_id,
						module,
						self,
						files,
						wasm_runner,
						context,
						"end",
					);
				}
			};
		}
		self.active_scripts.retain(|element| *element != script_id);
		self.handle_queue(context, wasm_runner, files);
	}

	pub fn run_scripts(
		&mut self,
		context: &mut ScriptContext<'_>,
		wasm_runner: &WasmRunner,
		files: &mut FileManager,
	) {
		puffin::profile_function!();
		for script_id in &self.active_scripts {
			let Some(script) = self.scripts.get(*script_id) else {
				unreachable!("The active script does not exist");
			};
			match script {
				ScriptDeclaration::Static { update, .. } => {
					if let Some(s) = update {
						s(
							context,
							get_script_state(&mut self.script_states, *script_id),
						)
					}
				}
				ScriptDeclaration::Wasm { path, .. } => {
					let module = {
						puffin::profile_scope!("load module");
						files.load_file(path.clone(), &wasm_runner.engine).unwrap();
						files.get_cached_file(path).unwrap().unwrap_wasm_module()
					};
					wasm_runner.run_function(
						*script_id,
						module,
						self,
						files,
						wasm_runner,
						context,
						"update",
					);
				}
			}
		}
		self.handle_queue(context, wasm_runner, files);
	}
}