use std::{path::Path, sync::Arc, time::Duration};

use rustc_hash::FxHashMap;
use serde::{Deserialize, Serialize};

use crate::{
	buffer::{Buffer, Cell},
	file::FileManager,
	input::InputManager,
	manifest::{DeserializedGameManifest, GameManifest, GameManifestPatch},
	scene::switch_scenes,
	script::wasm::WasmModule,
	storage::StorageManager,
	time::TimeContext,
};

pub mod lua;
pub 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]>>,
}

#[derive(Clone)]
pub struct WasmRunner {
	pub engine: tinywasm::Engine,
	pub store: Arc<spin::Mutex<tinywasm::Store>>,
	pub linker: tinywasm::Imports,
}

pub struct ScriptContext<'a> {
	pub framerate_limit: &'a mut Option<Duration>,
	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: Box<[Box<Path>]>,
	pub storage: &'a StorageManager,
	pub wasm_runner: &'a WasmRunner,
	pub operation_queue: &'a mut Vec<Operation>,
}

pub enum Operation {
	AddCell(Cell),
	SetFrameLimit(Option<Duration>),
	SwitchScene(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]>,
	},
	UpdateConfig {
		new_save: Box<[u8]>,
	},
	Exit,
}

pub type StaticScriptFunction = Option<Arc<dyn Fn(FullScriptContext<'_>) + Send + Sync>>;

#[derive(Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "kebab-case")]
pub enum ScriptDeclaration {
	#[serde(skip)]
	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);
	}
}

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

impl WasmRunner {
	pub fn new() -> Self {
		let engine = tinywasm::Engine::default();
		let mut store = tinywasm::Store::new(engine.clone());
		let linker = wasm::linker(&mut store).unwrap();
		let store = Arc::new(spin::Mutex::new(store));
		Self {
			engine,
			store,
			linker,
		}
	}

	pub fn compile(&self, data: &[u8]) -> Result<WasmModule, tinywasm::Error> {
		let module = tinywasm::parse_bytes(data)?;
		let instance = tinywasm::ModuleInstance::instantiate(
			&mut self.store.lock(),
			&module,
			Some(self.linker.clone()),
		)?;
		Ok(WasmModule { instance })
	}

	pub fn manifest(
		&self,
		path: Box<Path>,
		module: &WasmModule,
	) -> Result<GameManifest, tinywasm::Error> {
		let mut store = self.store.lock();
		let offset = module
			.instance
			.func::<(), u32>(&store, "manifest_addr")?
			.call(&mut store, ())?;
		let length = module
			.instance
			.func::<(), u32>(&store, "manifest_len")?
			.call(&mut store, ())?;
		let manifest =
			module
				.instance
				.memory("memory")?
				.read_vec(&store, offset as usize, length as usize)?;
		let manifest =
			messagepack_serde::from_slice::<DeserializedGameManifest>(&manifest).unwrap();
		Ok(GameManifest::from_wasm(path, manifest))
	}

	pub fn patch(&self, module: &WasmModule) -> Result<GameManifestPatch, tinywasm::Error> {
		let mut store = self.store.lock();
		let offset = module
			.instance
			.func::<(), u32>(&store, "manifest_addr")?
			.call(&mut store, ())?;
		let length = module
			.instance
			.func::<(), u32>(&store, "manifest_len")?
			.call(&mut store, ())?;
		let manifest =
			module
				.instance
				.memory("memory")?
				.read_vec(&store, offset as usize, length as usize)?;
		let manifest = messagepack_serde::from_slice::<GameManifestPatch>(&manifest).unwrap();
		Ok(manifest)
	}

	#[expect(clippy::too_many_arguments)]
	pub fn run_function(
		&self,
		script_id: usize,
		module: &WasmModule,
		scripts: &ScriptManager,
		files: Box<[Box<Path>]>,
		wasm_runner: &WasmRunner,
		context: &mut ScriptContext<'_>,
		function_name: &str,
	) -> Result<(), tinywasm::Error> {
		puffin::profile_function!();

		let context = std::ptr::from_mut(Box::leak(Box::new(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 function = module
			.instance
			.func::<u64, ()>(&wasm_runner.store.lock(), function_name)?;
		let r = function.call(
			&mut wasm_runner.store.lock(),
			context.expose_provenance() as u64,
		);
		drop(unsafe { Box::from_raw(context) });
		r
	}
}

impl ScriptDeclaration {
	pub fn name(&self) -> &str {
		match self {
			Self::Static { name, .. } => name,
			Self::Wasm { name, .. } => name,
		}
	}
}

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 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::SetFrameLimit(duration) => *context.framerate_limit = *duration,
				Operation::SwitchScene(id) => switch_scenes(
					self,
					&mut ScriptContext {
						framerate_limit: context.framerate_limit,
						manifest: context.manifest,
						buffer: context.buffer,
						input: context.input,
						time: context.time,
						storage: context.storage,
						operation_queue: Vec::new(),
					},
					files,
					wasm_runner,
					*id,
				),
				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(),
						framerate_limit: context.framerate_limit,
					},
					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(),
						framerate_limit: context.framerate_limit,
					},
					wasm_runner,
					files,
				),
				Operation::UpdateState {
					script_id,
					new_state,
				} => {
					self.script_states.insert(*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_data(new_save.clone());
				}
				Operation::UpdateConfig { new_save } => {
					context.storage.background_save_config(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.as_ref().inspect(|s| {
					let loaded_files = files.loaded_files();
					s(FullScriptContext {
						script_id,
						manifest: context.manifest,
						buffer: context.buffer,
						input: context.input,
						time: context.time,
						scripts: self,
						files: loaded_files,
						storage: context.storage,
						wasm_runner,
						operation_queue: &mut context.operation_queue,
					})
				});
			}
			ScriptDeclaration::Wasm { path, .. } => {
				let module = files.load_file(path.clone(), wasm_runner);
				let module = module.as_ref().as_ref().unwrap();
				let loaded_files = files.loaded_files();
				if let Err(e) = wasm_runner.run_function(
					script_id,
					module,
					self,
					loaded_files,
					wasm_runner,
					context,
					"start_script",
				) {
					log::error!("{e}");
				}
			}
		}
		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.as_ref().inspect(|s| {
						let loaded_files = files.loaded_files();
						s(FullScriptContext {
							script_id,
							manifest: context.manifest,
							buffer: context.buffer,
							input: context.input,
							time: context.time,
							scripts: self,
							files: loaded_files,
							storage: context.storage,
							wasm_runner,
							operation_queue: &mut context.operation_queue,
						});
					});
				}
				ScriptDeclaration::Wasm { path, .. } => {
					let module = files.load_file(path.clone(), wasm_runner);
					let module = module.as_ref().as_ref().unwrap();
					let loaded_files = files.loaded_files();
					if let Err(e) = wasm_runner.run_function(
						script_id,
						module,
						self,
						loaded_files,
						wasm_runner,
						context,
						"end_script",
					) {
						log::error!("{e}");
					}
				}
			};
		}
		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 { name, update, .. } => {
					if let Some(s) = update {
						puffin::profile_scope!("run script", name);
						let loaded_files = files.loaded_files();
						s(FullScriptContext {
							script_id: *script_id,
							manifest: context.manifest,
							buffer: context.buffer,
							input: context.input,
							time: context.time,
							scripts: self,
							files: loaded_files,
							storage: context.storage,
							wasm_runner,
							operation_queue: &mut context.operation_queue,
						});
					}
				}
				ScriptDeclaration::Wasm { path, .. } => {
					let module = files.load_file(path.clone(), wasm_runner);
					let module = module.as_ref().as_ref().unwrap();
					let loaded_files = files.loaded_files();
					if let Err(e) = wasm_runner.run_function(
						*script_id,
						module,
						self,
						loaded_files,
						wasm_runner,
						context,
						"update_script",
					) {
						log::error!("Error while running scripts: {e}");
					}
				}
			}
		}
		self.handle_queue(context, wasm_runner, files);
	}
}