use std::cmp;
use std::fmt;
use std::ops;

pub static ZERO: Fraction = Fraction { numerator: 0, denominator: 1, };

pub struct Fraction {
    /// The numerator
    pub numerator: i64,
    /// The denominator
    pub denominator: i64,
}

impl Fraction {
    /// Generates a new `Fraction`
    /// 
    /// It returns a `Fraction` in its fully reduced form,
    /// after calculating the greatest common divisor. 
    /// 
    /// # Panics
    /// Panics if `denominator` is zero (0). 
    /// 
    pub fn new(mut numerator: i64, mut denominator: i64) -> Fraction {
        if denominator == 0 {
            panic!("Zero is an invalid denominator!");
        }

        if denominator < 0 {
            numerator *= -1;
            denominator *= -1;
        }

        let greatest_common_divisor = Fraction::greatest_common_divisor(numerator, denominator);

        Fraction {
            numerator: numerator / greatest_common_divisor,
            denominator: denominator / greatest_common_divisor,
        }
    }

    /// Generates a new `Fraction` from an `f64`
    /// 
    /// It returns a `Fraction` in its fully reduced form,
    /// after calculating the greatest common divisor. 
    /// 
    /// Useful for when calculating square-roots,
    /// sine, cosine, tangent functions and more. 
    /// 
    /// # Panics
    /// Panics if the numerator is too large, 'attempt to multiply with overflow'. 
    /// 
    pub fn new_from_decimal(decimal: f64) -> Fraction {
        let denominator = 100_000_f64;
        let numerator = (decimal * denominator).round();

        Fraction::new(numerator as i64, denominator as i64)
    }

    /// Returns the greatest common divisor, as an `i64`. 
    /// 
    /// # Examples
    /// ```
    /// # extern crate oxygen_quark as quark;
    /// # use quark::fraction::Fraction;
    /// # fn main() {
    /// let n1 = 50;
    /// let n2 = 20;
    /// # assert_eq!(10, Fraction::greatest_common_divisor(n1, n2));
    /// # assert_eq!(10, Fraction::greatest_common_divisor(n2, n1));
    /// 
    /// // Prints out "10"
    /// println!("{}", Fraction::greatest_common_divisor(n1, n2));
    /// # }
    /// ```
    /// 
    pub fn greatest_common_divisor(numerator: i64, denominator: i64) -> i64 {
        let mut x = numerator;
        let mut y = denominator;
        while y != 0 {
            let t = y;
            y = x % y;
            x = t;
        }
        x
    }

    /// Returns the reciprocal of the `Fraction` it's called on.
    /// 
    /// Just moves the denominator to the numerator position and
    /// vice versa.
    /// 
    /// # Panics
    /// Panics when being called on a `Fraction` with numerator 0. 
    /// 
    pub fn reciprocal(self) -> Fraction {
        Fraction::new(self.denominator, self.numerator)
    }

    /// Returns the square-root of a `Fraction`. Result is a `Fraction`
    /// 
    pub fn sqrt(&self) -> Fraction {
        let mut decimal_mode = false;
        let numerator = match self.numerator {
            1 => 1,
            4 => 2,
            9 => 3,
            16 => 4,
            25 => 5,
            36 => 6,
            49 => 7,
            64 => 8,
            81 => 9,
            100 => 10,
            121 => 11,
            144 => 12,
            169 => 13,
            196 => 14,
            225 => 15,
            256 => 16,
            289 => 17,
            324 => 18,
            361 => 19,
            400 => 20,
            441 => 21,
            484 => 22,
            529 => 23,
            576 => 24,
            625 => 25,
            676 => 26,
            729 => 27,
            784 => 28,
            841 => 29,
            900 => 30,
            _ => {
                decimal_mode = true;
                self.numerator
            },
        };

        let denominator = match self.denominator {
            1 => 1,
            4 => 2,
            9 => 3,
            16 => 4,
            25 => 5,
            36 => 6,
            49 => 7,
            64 => 8,
            81 => 9,
            100 => 10,
            121 => 11,
            144 => 12,
            169 => 13,
            196 => 14,
            225 => 15,
            256 => 16,
            289 => 17,
            324 => 18,
            361 => 19,
            400 => 20,
            441 => 21,
            484 => 22,
            529 => 23,
            576 => 24,
            625 => 25,
            676 => 26,
            729 => 27,
            784 => 28,
            841 => 29,
            900 => 30,
            _ => {
                decimal_mode = true;
                self.denominator
            },
        };

        if decimal_mode {
            Fraction::new_from_decimal((numerator as f64 / denominator as f64).sqrt())
        } else {
            Fraction::new(numerator, denominator)
        }
    }

    /// Returns an approximated `Fraction` of the cosine (cos) of the `Fraction`
    /// 
    pub fn cosine(self) -> Fraction {
        let numerator = self.numerator as f64;
        let denominator = self.denominator as f64;
        Fraction::new_from_decimal((numerator / denominator).cos())
    }

    /// Returns an approximated `Fraction` of the arc cosine (cos^-1) of the `Fraction`
    /// 
    pub fn arc_cosine(self) -> Fraction {
        let numerator = self.numerator as f64;
        let denominator = self.denominator as f64;
        Fraction::new_from_decimal((numerator / denominator).acos())
    }

    /// Returns an approximated `Fraction` of the sine (sin) of the `Fraction`
    /// 
    pub fn sine(self) -> Fraction {
        let numerator = self.numerator as f64;
        let denominator = self.denominator as f64;
        Fraction::new_from_decimal((numerator / denominator).sin())
    }

    /// Returns an approximated `Fraction` of the arc sine (sin^-1) of the `Fraction`
    /// 
    pub fn arc_sine(self) -> Fraction {
        let numerator = self.numerator as f64;
        let denominator = self.denominator as f64;
        Fraction::new_from_decimal((numerator / denominator).asin())
    }

    /// Returns an approximated `Fraction` of the tangent (tan) of the `Fraction`
    /// 
    pub fn tangent(self) -> Fraction {
        let numerator = self.numerator as f64;
        let denominator = self.denominator as f64;
        Fraction::new_from_decimal((numerator / denominator).tan())
    }

    /// Returns an approximated `Fraction` of the arc tangent (tan^-1) of the `Fraction`
    /// 
    pub fn arc_tangent(self) -> Fraction {
        let numerator = self.numerator as f64;
        let denominator = self.denominator as f64;
        Fraction::new_from_decimal((numerator / denominator).atan())
    }
}

impl PartialEq for Fraction {
    fn eq(&self, other: &Fraction) -> bool {
        self.numerator == other.numerator && self.denominator == other.denominator
    }
}

impl Eq for Fraction {}

impl PartialOrd for Fraction {
    fn partial_cmp(&self, other: &Fraction) -> Option<cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for Fraction {
    fn cmp(&self, other: &Fraction) -> cmp::Ordering {
        if ((self.numerator == other.numerator || self.numerator < other.numerator) && self.denominator > other.denominator)
        || (self.numerator < other.numerator && self.denominator == other.denominator) {
            return cmp::Ordering::Less;
        } else if (self.numerator >= other.numerator && self.denominator == other.denominator)
                || ((self.numerator == other.numerator || self.numerator > other.numerator) && self.denominator < other.denominator) {
            return cmp::Ordering::Greater;
        }

        cmp::Ordering::Equal
    }
}

impl fmt::Debug for Fraction {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        if self.numerator == self.denominator || self.numerator == 0 || self.denominator == 1 {
            if self.numerator < 0 {
                write!(f, "{}", self.numerator)
            } else {
                write!(f, "+{}", self.numerator)
            }
        } else {
            if self.numerator < 0 {
                write!(f, "-[{}/{}]", self.numerator * -1, self.denominator)
            } else {
                write!(f, "+[{}/{}]", self.numerator, self.denominator)
            }
        }
    }
}

impl fmt::Display for Fraction {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        if self.numerator == self.denominator || self.numerator == 0 || self.denominator == 1 {
            if self.numerator < 0 {
                write!(f, "{}", self.numerator)
            } else {
                write!(f, "+{}", self.numerator)
            }
        } else {
            if self.numerator < 0 {
                write!(f, "-({}/{})", self.numerator * -1, self.denominator)
            } else {
                write!(f, "+({}/{})", self.numerator, self.denominator)
            }
        }
    }
}

impl ops::Add for Fraction {
    type Output = Fraction;
    fn add(self, other: Fraction) -> Fraction {
        if self.denominator == other.denominator {
            Fraction::new(self.numerator + other.numerator, self.denominator)
        } else {
            Fraction::new(self.numerator * other.denominator + other.numerator * self.denominator, self.denominator * other.denominator)
        }
    }
}

impl ops::AddAssign for Fraction {
    fn add_assign(&mut self, other: Fraction) {
        let numerator = self.numerator * other.denominator + other.numerator * self.denominator;
        let denominator = self.denominator * other.denominator;
        
        let greatest_common_divisor = Fraction::greatest_common_divisor(numerator, denominator);
        self.numerator = numerator / greatest_common_divisor;
        self.denominator = denominator / greatest_common_divisor;
    }
}

impl ops::Sub for Fraction {
    type Output = Fraction;
    fn sub(self, other: Fraction) -> Fraction {
        if self.denominator == other.denominator {
            Fraction::new(self.numerator - other.numerator, self.denominator)
        } else {
            Fraction::new(self.numerator * other.denominator - other.numerator * self.denominator, self.denominator * other.denominator)
        }
    }
}

impl ops::SubAssign for Fraction {
    fn sub_assign(&mut self, other: Fraction) {
        if self.denominator == other.denominator {
            let numerator = self.numerator - other.numerator;
            let greatest_common_divisor = Fraction::greatest_common_divisor(numerator, self.denominator);

            self.numerator = numerator / greatest_common_divisor;
            self.denominator /= greatest_common_divisor;
        } else {
            let numerator = self.numerator * other.denominator - other.numerator * self.denominator;
            let denominator = self.denominator * other.denominator;
            
            let greatest_common_divisor = Fraction::greatest_common_divisor(numerator, denominator);
            self.numerator = numerator / greatest_common_divisor;
            self.denominator = denominator / greatest_common_divisor;
        }
    }
}

impl ops::Mul for Fraction {
    type Output = Fraction;
    fn mul(self, other: Fraction) -> Fraction {
        Fraction::new(self.numerator * other.numerator, self.denominator * other.denominator)
    }
}

impl ops::MulAssign for Fraction {
    fn mul_assign(&mut self, other: Fraction) {
        let numerator = self.numerator * other.numerator;
        let denominator = self.denominator * other.denominator;

        let greatest_common_divisor = Fraction::greatest_common_divisor(numerator, denominator);

        self.numerator = numerator / greatest_common_divisor;
        self.denominator = denominator / greatest_common_divisor;
    }
}

impl ops::Div for Fraction {
    type Output = Fraction;
    fn div(self, other: Fraction) -> Fraction {
        Fraction::new(self.numerator * other.denominator, self.denominator * other.numerator)
    }
}

impl ops::DivAssign for Fraction {
    fn div_assign(&mut self, other: Fraction) {
        let numerator = self.numerator * other.denominator;
        let denominator = self.denominator * other.numerator;

        let greatest_common_divisor = Fraction::greatest_common_divisor(numerator, denominator);

        self.numerator = numerator / greatest_common_divisor;
        self.denominator = denominator / greatest_common_divisor;
    }
}

impl ops::Neg for Fraction {
    type Output = Fraction;
    fn neg(self) -> Fraction {
        Fraction::new(-self.numerator, self.denominator)
    }
}

impl Copy for Fraction {}

impl Clone for Fraction {
    fn clone(&self) -> Fraction {
        *self
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn new_test() {
        let fraction1 = Fraction {
            numerator: 23,
            denominator: 21,
        };

        let fraction2 = Fraction::new(23, 21);

        assert_eq!(fraction1, fraction2);
    }

    #[test]
    fn addition_test() {
        let fraction1 = Fraction::new(5, 2);
        let fraction2 = Fraction::new(4, 3);

        let result_fraction = Fraction::new(23, 6);

        assert_eq!(fraction1 + fraction2, result_fraction);
    }

    #[test]
    fn subtraction_test() {
        let fraction1 = Fraction::new(5, 2);
        let fraction2 = Fraction::new(4, 3);

        let result_fraction1 = Fraction::new(7, 6);
        let result_fraction2 = Fraction::new(-7, 6);

        assert_eq!(fraction1 - fraction2, result_fraction1);
        assert_eq!(fraction2 - fraction1, result_fraction2);
    }

    #[test]
    fn multiplication_test() {
        let fraction1 = Fraction::new(5, 2);
        let fraction2 = Fraction::new(4, 3);

        let result_fraction = Fraction::new(10, 3);

        assert_eq!(fraction1 * fraction2, result_fraction);
    }

    #[test]
    fn division_test() {
        let fraction1 = Fraction::new(5, 2);
        let fraction2 = Fraction::new(4, 3);

        let result_fraction = Fraction::new(15, 8);

        assert_eq!(fraction1 / fraction2, result_fraction);
    }

    #[test]
    fn greatest_common_divisor_test() {
        let numerator = 50;
        let denominator = 20;

        let greatest_common_divisor = Fraction::greatest_common_divisor(numerator, denominator);

        assert_eq!(10, greatest_common_divisor);
    }

    #[test]
    fn negation_test() {
        let fraction = -Fraction::new(5, 2);
        let result_fraction = Fraction::new(-5, 2);

        assert_eq!(fraction, result_fraction);
    }

    #[test]
    fn cosine_test() {
        let fraction1 = Fraction::new(3, 1);
        let fraction2 = Fraction::new(5, 1);

        let result = Fraction::new(41267, 50000);

        assert_eq!(result, (fraction1 / fraction2).cosine());
    }

    #[test]
    fn arc_cosine_test() {
        let fraction1 = Fraction::new(3, 1);
        let fraction2 = Fraction::new(5, 1);

        let result = Fraction::new(9273, 10000);

        assert_eq!(result, (fraction1 / fraction2).arc_cosine());
    }

    #[test]
    fn sine_test() {
        let fraction1 = Fraction::new(3, 1);
        let fraction2 = Fraction::new(5, 1);

        let result = Fraction::new(3529, 6250);

        assert_eq!(result, (fraction1 / fraction2).sine());
    }

    #[test]
    fn arc_sine_test() {
        let fraction1 = Fraction::new(3, 1);
        let fraction2 = Fraction::new(5, 1);

        let result = Fraction::new(1287, 2000);

        assert_eq!(result, (fraction1 / fraction2).arc_sine());
    }

    #[test]
    fn tangent_test() {
        let fraction1 = Fraction::new(3, 1);
        let fraction2 = Fraction::new(5, 1);

        let result = Fraction::new(34207, 50000);

        assert_eq!(result, (fraction1 / fraction2).tangent());
    }

    #[test]
    fn arc_tangent_test() {
        let fraction1 = Fraction::new(3, 1);
        let fraction2 = Fraction::new(5, 1);

        let result = Fraction::new(27021, 50000);

        assert_eq!(result, (fraction1 / fraction2).arc_tangent());
    }
}