//! 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;

pub trait Rational: Clone + Copy + Add<Output=Self> + Sub<Output=Self> + Mul<Output=Self> + Div<Output=Self> + From<f64> + PartialEq + std::fmt::Debug {
	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())
		}
	}
	
	/// 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)
	}
}

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.))
    }
		
		#[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
			);
		}
}