//! Deserialize an iris structure from a string.

use crate::{Config, Plugin};

use serde::de;
use std::collections::HashSet;
use std::fmt;
use std::str::FromStr;

/// Errors that can occur when deserializing a type
#[derive(thiserror::Error, Debug)]
pub enum Error {
	/// Occurs when toml could not be deserialized
	#[error(transparent)]
	Toml(#[from] toml::de::Error),
}

macro_rules! error {
    ($($arg:tt)*) => {
        de::Error::custom(format!($($arg)*))
    };
}

struct PluginIDsVisitor;
impl<'de> de::Visitor<'de> for PluginIDsVisitor {
	type Value = Vec<String>;

	fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
		write!(f, "single or list of plugin ids")
	}

	fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
	where
		E: de::Error,
	{
		self.visit_string(v.to_string())
	}

	fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
	where
		E: de::Error,
	{
		Ok(vec![v])
	}

	fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
	where
		A: de::SeqAccess<'de>,
	{
		let mut values =
			seq.size_hint().map_or_else(Vec::new, Vec::with_capacity);
		while let Some(value) = seq.next_element::<String>()? {
			values.push(value);
		}
		Ok(values)
	}
}

struct PluginIDsSeed;
impl<'de> de::DeserializeSeed<'de> for PluginIDsSeed {
	type Value = HashSet<String>;

	fn deserialize<D>(self, d: D) -> Result<Self::Value, D::Error>
	where
		D: de::Deserializer<'de>,
	{
		let values = d.deserialize_any(PluginIDsVisitor)?;
		Ok(HashSet::from_iter(values))
	}
}

// plugin visitor with seeded plugin id
struct PluginVisitor(Option<String>);
impl<'de> de::Visitor<'de> for PluginVisitor {
	type Value = Plugin;

	fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
		match &self.0 {
			Some(id) => write!(f, "arguments for plugin '{id}'"),
			None => write!(f, "plugin id and arguments"),
		}
	}

	fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
	where
		E: de::Error,
	{
		self.visit_string(v.to_string())
	}

	fn visit_borrowed_str<E>(self, v: &'_ str) -> Result<Self::Value, E>
	where
		E: de::Error,
	{
		self.visit_string(v.to_string())
	}

	fn visit_string<E>(self, url: String) -> Result<Self::Value, E>
	where
		E: de::Error,
	{
		let Some(id) = self.0 else {
			return Err(de::Error::missing_field("id"));
		};
		Self::Value::new(id, &url).map_err(E::custom)
	}

	fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
	where
		A: de::MapAccess<'de>,
	{
		// parse each map value as a possbile field for the plugin
		let mut id = self.0; // plugin id (required)
		let mut url = None; // repository url (required)
		let mut commit = None; // commit to lock to
		let mut branch = None; // branch to lock to
		let mut run = None; // command to run on launch
		let mut before = HashSet::new(); // plugins to load before
		let mut after = HashSet::new(); // plugins to load after

		while let Some(key) = map.next_key::<String>()? {
			match key.as_str() {
				// plugin id
				"id" => {
					id = Some(map.next_value::<String>()?);
				}
				// repo url
				"url" => {
					url = Some(map.next_value::<String>()?);
				}
				// locked commit
				"commit" => {
					commit = Some(map.next_value::<String>()?);
				}
				// locked branch
				"branch" => {
					branch = Some(map.next_value::<String>()?);
				}
				// vim command to run on launch
				"run" => {
					run = Some(map.next_value::<String>()?);
				}
				// plugins to load before
				"before" => {
					before = map.next_value_seed(PluginIDsSeed)?;
				}
				// plugins to load after
				"after" => {
					after = map.next_value_seed(PluginIDsSeed)?;
				}
				// invalid key!
				key => return Err(error!("unknown plugin field '{key}'")),
			};
		}

		// id is a required field
		let Some(id) = id else {
			return Err(de::Error::missing_field("id"));
		};

		// url is a required field
		let Some(url) = url else {
			return Err(de::Error::missing_field("url"));
		};

		let mut plugin =
			Self::Value::new(id, &url).map_err(de::Error::custom)?;
		plugin.commit = commit;
		plugin.branch = branch;
		plugin.run = run;
		plugin.before = before;
		plugin.after = after;
		Ok(plugin)
	}
}

// deserialize plugin with possible id
struct PluginSeed(Option<String>);
impl<'de> de::DeserializeSeed<'de> for PluginSeed {
	type Value = Plugin;

	fn deserialize<D>(self, d: D) -> Result<Self::Value, D::Error>
	where
		D: de::Deserializer<'de>,
	{
		d.deserialize_any(PluginVisitor(self.0))
	}
}

// plugins visitor
struct PluginsVisitor;
impl<'de> de::Visitor<'de> for PluginsVisitor {
	type Value = Vec<Plugin>;

	fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
		f.write_str("map of plugin id's to their arguments")
	}

	fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
	where
		A: de::MapAccess<'de>,
	{
		let mut plugins =
			map.size_hint().map_or_else(Vec::new, Vec::with_capacity);
		while let Some(id) = map.next_key()? {
			let plugin = map.next_value_seed(PluginSeed(Some(id)))?;
			plugins.push(plugin);
		}
		Ok(plugins)
	}

	fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
	where
		A: de::SeqAccess<'de>,
	{
		let mut plugins =
			seq.size_hint().map_or_else(Vec::new, Vec::with_capacity);
		while let Some(plugin) = seq.next_element_seed(PluginSeed(None))? {
			plugins.push(plugin);
		}
		Ok(plugins)
	}
}

// plugins seed
struct PluginsSeed;
impl<'de> de::DeserializeSeed<'de> for PluginsSeed {
	type Value = Vec<Plugin>;

	fn deserialize<D>(self, d: D) -> Result<Self::Value, D::Error>
	where
		D: de::Deserializer<'de>,
	{
		d.deserialize_any(PluginsVisitor)
	}
}

// config visitor
struct ConfigVisitor;
impl<'de> de::Visitor<'de> for ConfigVisitor {
	type Value = Config;

	fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
		f.write_str("iris config value")
	}

	fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
	where
		A: de::MapAccess<'de>,
	{
		let mut plugins = None; // list of plugins (required)
		while let Some(key) = map.next_key::<String>()? {
			match key.as_str() {
				"plugins" => {
					plugins = Some(map.next_value_seed(PluginsSeed)?);
				}
				key => return Err(error!("unknown config field '{key}'")),
			};
		}
		// plugins is a required field
		let Some(mut plugins) = plugins else {
			return Err(de::Error::missing_field("plugins"));
		};
        plugins.sort();
		Ok(Config { plugins })
	}
}

impl<'de> de::Deserialize<'de> for Config {
	fn deserialize<D>(d: D) -> Result<Self, D::Error>
	where
		D: de::Deserializer<'de>,
	{
		d.deserialize_map(ConfigVisitor)
	}
}

impl Config {
	pub fn parse(s: &str) -> crate::Result<Self> {
		toml::from_str(s)
			.map_err(Error::from)
			.map_err(crate::Error::from)
	}
}

impl FromStr for Config {
	type Err = crate::Error;
	fn from_str(s: &str) -> Result<Self, Self::Err> {
		Self::parse(s)
	}
}