path: root/src/lib.rs

use std::{borrow::Cow, cell::Cell, str::FromStr};

use formula::Formula;

pub mod formula;

pub struct Scurvy {
	free: Vec<String>,
	pairs: Vec<Pair>,
	unknown: Vec<(String, String)>,
	print_help: bool,
	print_version: bool,
	missing_string: Cell<Cow<'static, str>>,
}

struct Pair {
	key: Argument,
	values: Vec<String>,
}

impl Scurvy {
	pub fn make(args: Vec<Argument>) -> Self {
		let mut free = vec![];
		let mut pairs: Vec<Pair> = args.into_iter().map(|a| a.into()).collect();
		let mut unknown = vec![];

		let mut print_help = false;
		let mut print_version = false;

		for arg in std::env::args().skip(1) {
			if arg == "-h" || arg == "--help" || arg == "help=" {
				print_help = true;
			} else if arg == "-V" || arg == "--version" || arg == "version=" {
				print_version = true;
			}

			match arg.split_once('=') {
				None => free.push(arg),
				Some((key, value)) => {
					if let Some(pair) = pairs.iter_mut().find(|p| p.key.matches(key)) {
						pair.values.push(value.to_owned());
					} else {
						unknown.push((key.to_owned(), value.to_owned()));
					}
				}
			}
		}

		Self {
			free,
			pairs,
			unknown,
			print_help,
			print_version,
			missing_string: Cell::new(Cow::Borrowed("An argument for '[opt]' is required")),
		}
	}

	pub fn should_print_help(&self) -> bool {
		self.print_help
	}

	pub fn should_print_version(&self) -> bool {
		self.print_version
	}

	pub fn free(&self) -> &[String] {
		&self.free
	}

	fn get_pair(&self, key: &str) -> Option<&Pair> {
		self.pairs.iter().find(|p| p.key.matches(key))
	}

	pub fn get(&self, key: &str) -> Option<&str> {
		self.pairs
			.iter()
			.find(|p| p.key.matches(key))
			.map(|p| p.values.first().map(|s| s.as_str()))
			.flatten()
	}

	pub fn get_req(&self, key: &str) -> &str {
		match self.get(key) {
			None => {
				let pair = self.get_pair(key).unwrap();
				self.print_missing_and_die(pair.key.preferred_key());
			}
			Some(s) => s,
		}
	}

	pub fn parse<T: FromStr, F: Into<Formula<T>>>(&self, key: &str, formula: F) -> Option<T> {
		let formula = formula.into();
		let Some(got) = self.get(key) else {
			return None;
		};

		match got.parse::<T>() {
			Ok(o) => {
				if let Some((fail, mut check)) = formula.check_fn {
					if !check(&o) {
						let pair = self.get_pair(key).unwrap();
						let parsefail =
							format_parse_fail(fail.into(), pair.key.preferred_key(), got);

						eprintln!("{parsefail}");
						std::process::exit(-1);
					}

					return Some(o);
				};

				Some(o)
			}
			Err(_e) => {
				let pair = self.get_pair(key).unwrap();
				let fail = format_parse_fail(formula.failure.into(), pair.key.preferred_key(), got);

				eprintln!("{fail}");
				std::process::exit(-1);
			}
		}
	}

	/// Shorthand for [Scurvy::parse] followed by `unwrap_or()`
	pub fn parse_or<T: FromStr, F: Into<Formula<T>>>(
		&self,
		key: &str,
		formula: F,
		default: T,
	) -> T {
		self.parse(key, formula).unwrap_or(default)
	}

	pub fn parse_req<T: FromStr, F: Into<Formula<T>>>(&self, key: &str, formula: F) -> T {
		let formula = formula.into();
		let missing = formula.missing.clone();

		match self.parse(key, formula) {
			None => match missing {
				None => {
					let pair = self.get_pair(key).unwrap();
					self.print_missing_and_die(pair.key.preferred_key());
				}
				Some(misstr) => {
					let pair = self.get_pair(key).unwrap();
					let str = misstr.replace("[opt]", pair.key.preferred_key());

					eprintln!("{str}");
					std::process::exit(-1);
				}
			},
			Some(o) => o,
		}
	}

	pub fn set_missing_string<S: Into<Cow<'static, str>>>(&self, msg: S) {
		self.missing_string.set(msg.into());
	}

	fn print_missing_and_die(&self, key: &str) -> ! {
		// We can straight up take() here because of how we use this string,
		// because we exit right after it
		let str = self.missing_string.take().replace("[opt]", key);
		eprintln!("{str}");
		std::process::exit(-1);
	}
}

pub(crate) fn format_parse_fail(string: Cow<'static, str>, key: &str, arg: &str) -> String {
	string.replace("[opt]", key).replace("[arg]", arg)
}

pub struct Argument {
	keys: Vec<String>,
	arg_name: Option<&'static str>,
	help: &'static str,
}

impl Argument {
	pub fn new<'s, K: Into<SingleOrMultiple<'s>>>(key: K) -> Self {
		let keys = match key.into() {
			SingleOrMultiple::Single(s) => vec![s],
			SingleOrMultiple::Multiple(m) => m.to_vec(),
		};

		Self {
			keys: keys.into_iter().map(<_>::to_owned).collect(),
			arg_name: None,
			help: "",
		}
	}

	pub fn arg(mut self, name: &'static str) -> Self {
		self.arg_name = Some(name);
		self
	}

	pub fn help(mut self, help: &'static str) -> Self {
		self.help = help;
		self
	}

	fn matches(&self, key: &str) -> bool {
		self.keys.iter().find(|k| k.as_str() == key).is_some()
	}

	fn preferred_key(&self) -> &str {
		self.keys.first().unwrap().as_str()
	}
}

impl Into<Pair> for Argument {
	fn into(self) -> Pair {
		Pair {
			key: self,
			values: vec![],
		}
	}
}

pub enum SingleOrMultiple<'s> {
	Single(&'s str),
	Multiple(&'s [&'s str]),
}

impl<'s> From<&'s str> for SingleOrMultiple<'s> {
	fn from(value: &'s str) -> Self {
		Self::Single(value)
	}
}

impl<'s> From<&'s [&'s str]> for SingleOrMultiple<'s> {
	fn from(value: &'s [&'s str]) -> Self {
		Self::Multiple(value)
	}
}

impl<'s, const N: usize> From<&'s [&'s str; N]> for SingleOrMultiple<'s> {
	fn from(value: &'s [&'s str; N]) -> Self {
		Self::Multiple(value.as_slice())
	}
}