use exmex::prelude::*;

lazy_static::lazy_static! {
	/// Function returns `f64::NaN` at every x value, which is not displayed.
	static ref EMPTY_FUNCTION: FlatEx<f64> = exmex::parse::<f64>("0/0").unwrap();
}
/// Function that includes f(x), f'(x), f'(x)'s string representation, and
/// f''(x)
#[derive(Clone)]
pub struct BackingFunction {
	/// f(x)
	function: FlatEx<f64>,
	/// f'(x)
	derivative_1: FlatEx<f64>,
	/// Mathematical representation of f'(x)
	derivative_1_str: String,
	/// f''(x)
	derivative_2: FlatEx<f64>,

	nth_derivative: Option<(usize, FlatEx<f64>, String)>,
}

impl BackingFunction {
	/// Create new [`BackingFunction`] instance
	pub fn new(func_str: &str) -> Result<Self, String> {
		let function = match func_str {
			"" => EMPTY_FUNCTION.clone(),
			_ => {
				let parse_result = exmex::parse::<f64>(func_str);

				match &parse_result {
					Err(e) => return Err(e.to_string()),
					Ok(_) => {
						let var_names = parse_result.as_ref().unwrap().var_names().to_vec();

						if var_names != ["x"] {
							let var_names_not_x: Vec<&String> = var_names
								.iter()
								.filter(|ele| ele != &"x")
								.collect::<Vec<&String>>();

							return Err(match var_names_not_x.len() {
								1 => {
									format!("Error: invalid variable: {}", var_names_not_x[0])
								}
								_ => {
									format!("Error: invalid variables: {:?}", var_names_not_x)
								}
							});
						}
					}
				}
				parse_result.unwrap()
			}
		};

		let derivative_1 = function
			.partial(0)
			.unwrap_or_else(|_| EMPTY_FUNCTION.clone());

		let derivative_1_str = prettyify_function_str(derivative_1.unparse());

		let derivative_2 = function
			.partial_iter([0, 0].iter())
			.unwrap_or_else(|_| EMPTY_FUNCTION.clone());

		Ok(Self {
			function,
			derivative_1,
			derivative_1_str,
			derivative_2,
			nth_derivative: None,
		})
	}

	/// Returns Mathematical representation of the function's derivative
	pub fn get_derivative_str(&self) -> &str { &self.derivative_1_str }

	/// Calculate f(x)
	pub fn get(&self, x: f64) -> f64 { self.function.eval(&[x]).unwrap_or(f64::NAN) }

	/// Calculate f'(x)
	pub fn get_derivative_1(&self, x: f64) -> f64 {
		self.derivative_1.eval(&[x]).unwrap_or(f64::NAN)
	}

	/// Calculate f''(x)
	pub fn get_derivative_2(&self, x: f64) -> f64 {
		self.derivative_2.eval(&[x]).unwrap_or(f64::NAN)
	}

	pub fn get_nth_derivative_str(&self) -> &str { &self.nth_derivative.as_ref().unwrap().2 }

	pub fn get_nth_derivative(&mut self, n: usize, x: f64) -> f64 {
		match n {
			0 => self.get(x),
			1 => self.get_derivative_1(x),
			2 => self.get_derivative_2(x),
			_ => {
				if let Some((curr_n, curr_n_func, _)) = &self.nth_derivative {
					if curr_n == &n {
						return curr_n_func.eval(&[x]).unwrap_or(f64::NAN);
					}
				}
				let new_func = self
					.function
					.partial_iter((1..=n).map(|_| 0).collect::<Vec<usize>>().iter())
					.unwrap_or_else(|_| EMPTY_FUNCTION.clone());

				self.nth_derivative = Some((
					n,
					new_func.clone(),
					prettyify_function_str(new_func.unparse()),
				));
				new_func.eval(&[x]).unwrap_or(f64::NAN)
			}
		}
	}
}

fn prettyify_function_str(func: &str) -> String {
	let new_str = func.to_owned().replace("{x}", "x");

	if &new_str == "0/0" {
		"Undefined".to_owned()
	} else {
		new_str
	}
}

pub const VALID_VARIABLES: [char; 5] = ['x', 'X', 'e', 'E', 'π'];

#[inline]
pub fn is_variable(c: &char) -> bool { VALID_VARIABLES.contains(&c) }

/// Adds asterisks where needed in a function
pub fn process_func_str(function_in: &str) -> String {
	if function_in.is_empty() {
		return String::new();
	}

	crate::suggestions::split_function(&function_in).join("*")
}

#[cfg(test)]
mod tests {
	use super::*;
	use crate::suggestions::SUPPORTED_FUNCTIONS;
	use std::collections::HashMap;

	/// Returns if function with string `func_str` is valid after processing through [`process_func_str`]
	fn func_is_valid(func_str: &str) -> bool {
		BackingFunction::new(&process_func_str(func_str)).is_ok()
	}

	/// Used for testing: passes function to [`process_func_str`] before running [`test_func`]. if `expect_valid` == `true`, it expects no errors to be created.
	fn test_func_helper(func_str: &str, expect_valid: bool) {
		let is_valid = func_is_valid(func_str);
		let string = format!(
			"function: {} (expected: {}, got: {})",
			func_str, expect_valid, is_valid
		);

		if is_valid == expect_valid {
			println!("{}", string);
		} else {
			panic!("{}", string);
		}
	}

	/// Tests to make sure functions that are expected to succeed, succeed.
	#[test]
	fn test_expected() {
		let values = HashMap::from([
			("", true),
			("x^2", true),
			("2x", true),
			("E^x", true),
			("log10(x)", true),
			("xxxxx", true),
			("sin(x)", true),
			("xsin(x)", true),
			("sin(x)cos(x)", true),
			("x/0", true),
			("(x+1)(x-3)", true),
			("(2x+1)x", true),
			("(2x+1)pi", true),
			("pi(2x+1)", true),
			("pipipipipipix", true),
			("e^sin(x)", true),
			("E^sin(x)", true),
			("e^x", true),
			("x**2", true),
			("a", false),
			("log222(x)", false),
			("abcdef", false),
			("log10(x", false),
			("x^a", false),
			("sin(cos(x)))", false),
			("0/0", false),
		]);

		for (key, value) in values {
			test_func_helper(key, value);
		}
	}

	/// Helps with tests of [`process_func_str`]
	#[cfg(test)]
	fn test_process_helper(input: &str, expected: &str) {
		assert_eq!(&process_func_str(input), expected);
	}

	/// Tests to make sure my cursed function works as intended
	#[test]
	fn func_process_test() {
		let values = HashMap::from([
			("2x", "2*x"),
			(")(", ")*("),
			("(2", "(2"),
			("log10(x)", "log10(x)"),
			("log2(x)", "log2(x)"),
			("pipipipipipi", "π*π*π*π*π*π"),
			("10pi", "10*π"),
			("pi10", "π*10"),
			("emax(x)", "e*max(x)"),
			("pisin(x)", "π*sin(x)"),
			("e^sin(x)", "e^sin(x)"),
			("x**2", "x^2"),
			("(x+1)(x-3)", "(x+1)*(x-3)"),
		]);

		for (key, value) in values {
			test_process_helper(key, value);
		}

		for func in SUPPORTED_FUNCTIONS.iter() {
			let func_new = format!("{}(x)", func);
			test_process_helper(&func_new, &func_new);
		}
	}
}
