use std::{collections::HashMap, path::Path};

pub use vtable::VTableScript;
use wasmtime::{Engine, IntoFunc, Linker, Module, Store};

pub use wasm::InvalidWasmScript;
use wasm::{WasmScript, WasmScriptState};

mod libs;
mod vtable;
mod wasm;

/// A sturcture to contain and use any needed scripts.
///
/// # Performance
///
/// V-Table scripts are faster than WebAssembly scripts. WebAssembly scripting
/// is provided to make hot-reloading possible. Either way, scripts should be
/// reasonably fast.
///
/// A single long WebAssembly script is typically faster than lots of small
/// scripts. Try to keep the number of scripts small. No more than twenty
/// scripts should be enabled at once.
#[derive(Default)]
pub struct ScriptManager {
	script_map: HashMap<Box<str>, ScriptId>,

	vtable_scripts: Vec<Script<VTableScript>>,
	wasm_scripts: Vec<Script<WasmScript>>,

	relink_every_frame: bool,
	wasm_engine: Engine,
	wasm_imports: Linker<WasmScriptState>,
}

impl ScriptManager {
	/// Creates a new, empty script manager
	pub fn new() -> Self {
		let wasm_engine = Engine::default();
		let mut wasm_imports = Linker::new(&wasm_engine);
		wasm_imports.allow_shadowing(true);

		let mut this = Self {
			script_map: HashMap::new(),
			vtable_scripts: Vec::new(),
			wasm_scripts: Vec::new(),
			relink_every_frame: false,
			wasm_imports,
			wasm_engine,
		};
		libs::add_alligator_library(&mut this);

		this
	}

	/// If set to `true`, then every frame, the scripts will be relinked with
	/// it's dependencies on each call.
	///
	/// The main reason to do this would be to ensure that the state is reset
	/// each frame. However, the link is slow, so it's not recommended to use
	/// this setting for releasing a game. This is only recommended for
	/// debugging.
	pub fn set_relink_every_frame(&mut self, setting: bool) {
		self.relink_every_frame = setting;
	}

	/// Returns `true` if the scripts are set to be relinked each frame. See
	/// [`set_relink_every_frame`] for more details.
	pub fn relink_every_frame(&self) -> bool {
		self.relink_every_frame
	}

	/// Adds a script to this manager.
	///
	/// By  default, all scripts are disabled. To enable it, call
	/// [`enable_script`].
	pub fn add_vtable_script(&mut self, name: Box<str>, script: VTableScript) -> ScriptId {
		let idx = self.vtable_scripts.len();
		self.vtable_scripts.push(Script::new(script));
		let id = ScriptId {
			kind: ScriptKind::VTable,
			idx,
		};
		self.script_map.insert(name, id);
		id
	}

	/// Adds a WebAssembly script to this manager.
	///
	/// By  default, all scripts are disabled. To enable it, call
	/// [`enable_script`].
	///
	/// # Errors
	///
	/// This function returns an error if it could not use the given script.
	pub fn add_wasm_script(
		&mut self,
		name: Box<str>,
		path: impl AsRef<Path>,
		trusted: bool,
	) -> Result<ScriptId, InvalidWasmScript> {
		let idx = self.vtable_scripts.len();
		let script = WasmScript::new(
			path.as_ref(),
			&self.wasm_engine,
			&self.wasm_imports,
			trusted,
		)?;
		self.wasm_scripts.push(Script::new(script));
		let id = ScriptId {
			kind: ScriptKind::Wasm,
			idx,
		};
		self.script_map.insert(name, id);
		Ok(id)
	}

	/// Add a WebAssembly module which can be called by other WebAssembly
	/// scripts.
	///
	/// If there are two libraries with the same name, only the newest module
	/// is used. This feature can be used to allow libraries to be hot
	/// reloaded.
	///
	/// The `trusted` parameter refers to whether this library can call
	/// functions which require trust.
	///
	/// # Performance
	///
	/// Running this function relinks all WebAssembly scripts. For best
	/// performance, all WebAssembly libraries should be added before any
	/// scripts are loaded.
	pub fn add_wasm_library(
		&mut self,
		name: &str,
		path: impl AsRef<Path>,
		trusted: bool,
	) -> Result<(), InvalidWasmScript> {
		let module = Module::from_file(&self.wasm_engine, path)?;
		let mut store = Store::new(&self.wasm_engine, WasmScriptState::new(trusted));
		let instance = self.wasm_imports.instantiate(&mut store, &module)?;
		self.wasm_imports.instance(store, name, instance)?;

		for script in &mut self.wasm_scripts {
			if let Err(e) = script.inner.relink(&self.wasm_engine, &self.wasm_imports) {
				log::error!("{e}");
			}
		}

		Ok(())
	}

	/// Reloads a WebAssembly script from disk.
	pub fn reload_script(&mut self, name: &str) -> Option<Result<(), InvalidWasmScript>> {
		let id = self.script_map.get(name).unwrap();
		let result = match id.kind {
			ScriptKind::Wasm => self
				.wasm_scripts
				.get_mut(id.idx)
				.unwrap()
				.inner
				.reload(&self.wasm_engine, &self.wasm_imports),
			_ => return None,
		};
		Some(result)
	}

	/// Adds a library to the manager
	pub fn add_library_function<Params, Args>(
		&mut self,
		module: &str,
		name: &str,
		func: impl IntoFunc<WasmScriptState, Params, Args> + Clone,
	) -> Option<()> {
		self.wasm_imports.func_wrap(module, name, func).ok()?;
		Some(())
	}

	/// Checks if the script with the given name is enabled
	pub fn is_script_enabled(&self, name: &str) -> Option<bool> {
		let id = self.script_map.get(name)?;
		let enabled = match id.kind {
			ScriptKind::VTable => self.vtable_scripts.get(id.idx)?.is_enabled(),
			ScriptKind::Wasm => self.wasm_scripts.get(id.idx)?.is_enabled(),
		};
		Some(enabled)
	}

	/// Checks if the script with the given name is trusted
	pub fn is_script_trusted(&self, name: &str) -> Option<bool> {
		let id = self.script_map.get(name)?;
		let trusted = match id.kind {
			ScriptKind::VTable => true,
			ScriptKind::Wasm => self.wasm_scripts.get(id.idx)?.inner.is_trusted(),
		};
		Some(trusted)
	}

	/// This enables the script, allowing it to run each frame.
	///
	/// Calling this automatically calls the `begin` function for the script.
	pub fn enable_script(&mut self, name: &str) -> Option<()> {
		let id = self.script_map.get(name)?;
		match id.kind {
			ScriptKind::VTable => {
				let script = self.vtable_scripts.get_mut(id.idx)?;
				if script.is_enabled() {
					// avoid calling `begin` if the script is already enabled
					return Some(());
				}

				script.enable();
				script.inner.begin();
			}
			ScriptKind::Wasm => {
				let script = self.wasm_scripts.get_mut(id.idx)?;
				if script.is_enabled() {
					return Some(());
				}

				script.enable();
				if let Err(e) = script.inner.begin() {
					log::error!("{}", e);
				}
			}
		};
		Some(())
	}

	/// This disables the script, preventing it from running
	pub fn disable_script(&mut self, name: &str) -> Option<()> {
		let id = self.script_map.get(name)?;
		match id.kind {
			ScriptKind::VTable => self.vtable_scripts.get_mut(id.idx)?.disable(),
			ScriptKind::Wasm => self.wasm_scripts.get_mut(id.idx)?.disable(),
		};
		Some(())
	}

	/// This allows the script to run functions which require trust
	pub fn trust_script(&mut self, name: &str) -> Option<()> {
		let id = self.script_map.get(name)?;
		if id.kind == ScriptKind::Wasm {
			self.wasm_scripts.get_mut(id.idx)?.inner.trust();
		}
		Some(())
	}

	/// This prevents the script from running functions which require trust
	pub fn untrust_script(&mut self, name: &str) -> Option<()> {
		let id = self.script_map.get(name)?;
		if id.kind == ScriptKind::Wasm {
			self.wasm_scripts.get_mut(id.idx)?.inner.untrust();
		}
		Some(())
	}

	/// Runs the `update` function for all enabled scripts
	pub fn run_update_scripts(&mut self) {
		for script in &mut self.vtable_scripts {
			if script.is_enabled() {
				script.inner.update();
			}
		}

		for script in &mut self.wasm_scripts {
			if script.is_enabled() {
				if self.relink_every_frame {
					if let Err(e) = script.inner.relink(&self.wasm_engine, &self.wasm_imports) {
						log::error!("{e}");
					}
				}
				if let Err(e) = script.inner.update() {
					log::error!("{}", e);
				}
			}
		}
	}
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
enum ScriptKind {
	VTable,
	Wasm,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ScriptId {
	kind: ScriptKind,
	idx: usize,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct Script<S> {
	inner: S,
	enabled: bool,
}

impl<S> Script<S> {
	fn new(inner: S) -> Self {
		Self {
			inner,
			enabled: true,
		}
	}

	fn is_enabled(&self) -> bool {
		self.enabled
	}

	fn enable(&mut self) {
		self.enabled = true;
	}

	fn disable(&mut self) {
		self.enabled = false;
	}
}