//! This library allows you to do three things. It allows you to Create a function that
//! returns a constant f(x) -> 4, create a function that returns its input f(x) -> x, and
//! then do arithmatic with them and store the result f(x) -> x, g(x) -> 4, h = f*g => h ~= 4*x
//! then you can do whatever you want with the resulting Arc<Fn(T) -> T> where T is essentially
//! an f64 or other similar type

// #![feature(const_trait_impl)]

use std::ops::{
	Add,
	Sub,
	Mul,
	Div
};

use std::sync::Arc;

fn make_domain(start: i32, end: i32, step: f32) -> Vec<f64> {
	let start = (start as f32/step) as i64;
	let end = (end as f32/step) as i64;
	(start..=end).map(|x| {
		(x as f64)*step as f64
	}).collect()
}

pub trait Rational: Clone + Copy + Add<Output=Self> + Sub<Output=Self> + Mul<Output=Self> + Div<Output=Self>
 + From<f64> + PartialEq + std::fmt::Debug + std::cmp::PartialOrd {
	fn pow(self, rhs: Self) -> Self;
}

impl Rational for f64 {
	fn pow(self, rhs: Self) -> Self {
		self.powf(rhs)
	}
}

/// the main Function type of the library
#[derive(Clone)]
pub struct Function<T = f64> where T: Rational, {
	function: Arc<dyn Fn(T) -> T>
}

unsafe impl<T: Rational> Send for Function<T> {}

impl<T: Rational + 'static> Function<T> {
	/// return a contant function that returns the value of value
	pub fn new(value: f64) -> Self {
		Self {
			function: Arc::new(move |_x| value.into())
		}
	}
	
	pub fn new_t(value: T) -> Self {
		Self { function: Arc::new(move |_x| value)}
	}
	
	/// raise a function to the power of another
	pub fn pow(self, rhs: Self) -> Self {
		Self { function: Arc::new(move |x| (self.function)(x).pow((rhs.function)(x))) }
	}
	
	pub fn call(&self, x: T) -> T {
		(self.function)(x)
	}
	
	pub fn find_zeroes(&self, range: (i32, i32)) -> Vec<T> {
		// default run with a step size of 1/1000
		let domain = make_domain(range.0, range.1, 0.001);
		let mut zeroes: Vec<T> = vec![];
		
		// whether or not the previous call was greater than zero
		let mut g0 = self.call(domain[0].into())>T::from(0.);
		domain.into_iter().map(|x| {
			T::from(x)
		}).for_each(|x| {
			if g0 != (self.call(x) > T::from(0.)) {
				g0 = !g0;
				zeroes.push(x);
			}
		});
		
		zeroes
	}
	
	/// calling this function with an empty vec of roots returns f(x) -> 0
	pub fn polynomial_from_roots(roots: Vec<T>) -> Function<T> {
		let function_roots = roots.into_iter().map(|root| {
			Function::default()-Function::new_t(root)
		}).collect::<Vec<Function<T>>>();
		
		// println!("reached after function_roots: {:?}", function_roots.clone());
		
		match function_roots.len() > 0 {
			true => {
				let mut tmp = Function::new(1.);
				for func in function_roots.into_iter() {
					// println!("func: {:?}", func.clone());
					// println!("tmp: {:?}", tmp.clone());
					tmp = tmp*func;
					// println!("tmp*func: {:?}", tmp.clone());
				}
				// function_roots.into_iter().for_each(|func| {
					// tmp = tmp.clone()*func;
				// });
				// println!("final multiplied function: {:?}", tmp.clone());
				return tmp;
			},
			false => {
				return Function::new(0.);
			}
		}
		
	}
}

impl<T: Rational + 'static> std::fmt::Debug for Function<T> {
	// TODO implement better
	/// Warning this returns nothing
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		// Ok("TO BE IMPLEMENTED");
		// Ok("")
		// write!("f(-5)->{}|f(-4)->{}|f(-3)->{}f(-2)->{}|f(-1)->{}\nf(0)->{}|f(1)->{}|f(2)->{}|f(3)->{}|f(4)->{}|f(5)->{}", )
		write!(
			f,
			"f(-2) {:?}|f(-1) {:?}|f(0) {:?}|f(1) {:?}|f(2) {:?}",
			self.call((-2.).into()),
			self.call((-1.).into()),
			self.call((0.).into()),
			self.call((1.).into()),
			self.call((2.).into()),
		)
	}
}

impl<T: Rational> From<f64> for Function<T> {
	fn from(x: f64) -> Self {
		Self {
			function: Arc::new(move |_x| x.into())
		}
	}
}

impl<T: Rational> Default for Function<T> {
	/// return the function f(x) -> x
	/// or y = x if you want to think of it that way
	fn default() -> Self {
		Self {
			function: Arc::new(|x| x)
		}
	}
}

impl<T: Rational + 'static> Add for Function<T> {
	type Output = Self;
	fn add(self, rhs: Self) -> Self {
		Self { function: Arc::new(move |x| (self.function)(x)+(rhs.function)(x)) }
	}
}

impl<T: Rational + 'static> Sub for Function<T> {
	type Output = Self;
	fn sub(self, rhs: Self) -> Self {
		Self { function: Arc::new(move |x| (self.function)(x)-(rhs.function)(x)) }
	}
}

impl<T: Rational + 'static> Mul for Function<T> {
	type Output = Self;
	fn mul(self, rhs: Self) -> Self {
		Self { function: Arc::new(move |x| (self.function)(x)*(rhs.function)(x)) }
	}
}

impl<T: Rational + 'static> Div for Function<T> {
	type Output = Self;
	fn div(self, rhs: Self) -> Self {
		Self { function: Arc::new(move |x| (self.function)(x)/(rhs.function)(x)) }
	}
}

impl<T: Rational> PartialEq for Function<T> {
	fn eq(&self, rhs: &Self) -> bool {
		let mut roughly_equal = true;
		// check for equality in the range of all integers between -10 and 10
		// may not be the most rigerous but works
		for iter in -10..=10 {
			if (self.function)((iter as f64).into()) != (rhs.function)((iter as f64).into()) {roughly_equal = false;}
		}
		roughly_equal
	}
}


#[cfg(test)]
mod tests {
    use super::*;
    
    // because constant definitions are practically non-functional in rust
    fn define_shit() -> (Function, Function, Function, Function) {
    	return (Function::default(), Function::new(3.), Function::new(5.), Function::from(3.))
    }
    
    fn rounded_eq(a: Vec<f64>, b: Vec<f64>) {
    	let a = a.into_iter().map(|x| {
    		x.round()
    		// (x*1000.).round() / 1000.
    	}).collect::<Vec<f64>>();
    	let b = b.into_iter().map(|x| {
    		x.round()
    		// (x*1000.).round() / 1000.
    	}).collect::<Vec<f64>>();
    	
    	assert_eq!(a, b);
    }
    
    #[test]
    fn polynomial() {
    	assert_eq!(
    		Function::polynomial_from_roots(vec![2., 3.]),
    		(
    			(Function::default()+Function::new(-2.))*
    			(Function::default()+Function::new(-3.))
    		)
    	);
    	assert_eq!(
    		Function::polynomial_from_roots(vec![-2., -1., 3., 5.]),
    		(
    			(Function::default()+Function::new(2.))*
    			(Function::default()+Function::new(1.))*
    			(Function::default()+Function::new(-3.))*
    			(Function::default()+Function::new(-5.))
    		)
    	)
    }
    
    #[test]
    fn test_find_zeroes() {
    	rounded_eq(
    		vec![-1., 1.],
    		Function::polynomial_from_roots(vec![1., -1.]).find_zeroes((-10, 10))
    	);
    	rounded_eq(
    		vec![-3., 2., 5.],
    		Function::polynomial_from_roots(vec![-3., 2., 5.]).find_zeroes((-10, 10))
    	)
    }
		
		#[test]
		fn test_equality() {
			let (y, f ,g , h) = define_shit();
			assert_eq!(
				f,
				h
			);
			assert_eq!(
				Function::from(4.),
				Function::<f64>::new(4.),
			);
			let (y, f ,g , h) = define_shit();
			assert_eq!(
				Function::from(1.)/y.clone(),
				(f/h)/y,
			);
		}
		
		#[test]
		fn test_add() {
			let (y, f ,g , h) = define_shit();
			assert_eq!(
				g+Function::new(4.),
				f+Function::new(6.),
			);
			let (y, f ,g , h) = define_shit();
			assert_eq!(
				f+g.clone(),
				g+h
			);
		}
		
		#[test]
		fn test_sub() {
			let (y, f ,g , h) = define_shit();
			assert_eq!(
				g-h,
				Function::new(2.)
			);
			let (y, f ,g , h) = define_shit();
			assert_eq!(
				f-g,
				Function::new(-2.)
			);
		}
		
		#[test]
		fn test_mul() {
			let (y, f ,g , h) = define_shit();
			assert_eq!(
				g.clone()*h,
				f*g
			);
			let (y, f ,g , h) = define_shit();
			assert_eq!(
				f*g,
				Function::new(15.)
			);
		}
		
		#[test]
		fn test_div() {
			let (y, f ,g , h) = define_shit();
			assert_eq!(
				f/g,
				Function::new(3./5.),
			);
			assert_eq!(
				y/Function::new(1.),
				Function::default()
			);
		}
		
		#[test]
		fn test_call() {
			let (y, f, g, h) = define_shit();
			assert_eq!(
				g.call(2.),
				5.
			);
			assert_eq!(
				h.call(10000.47654),
				3.
			);
			assert_eq!(
				y.call(536.5),
				536.5
			);
		}
}