use std::{cmp::Ordering, iter::zip};

use super::{Number, Sign};

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

impl Ord for Number {
    fn cmp(&self, other: &Self) -> Ordering {
        if self.sign == Sign::Negatif && other.sign == Sign::Positif {
            return Ordering::Less;
        } else if self.sign == Sign::Positif && other.sign == Sign::Negatif {
            return Ordering::Greater;
        }
        match self.digits.len().cmp(&other.digits.len()) {
            Ordering::Less => match self.sign {
                Sign::Positif => Ordering::Less,
                Sign::Negatif => Ordering::Greater,
            },
            Ordering::Greater => match self.sign {
                Sign::Positif => Ordering::Greater,
                Sign::Negatif => Ordering::Less,
            },
            Ordering::Equal => {
                for pair in zip(&self.digits, &other.digits) {
                    return match pair.0.cmp(pair.1) {
                        Ordering::Less => match self.sign {
                            Sign::Positif => Ordering::Less,
                            Sign::Negatif => Ordering::Greater,
                        },
                        Ordering::Greater => match self.sign {
                            Sign::Positif => Ordering::Greater,
                            Sign::Negatif => Ordering::Less,
                        },
                        Ordering::Equal => continue,
                    };
                }
                Ordering::Equal
            }
        }
    }
}

#[cfg(test)]
mod test_number_ord {
    use crate::number::Number;

    #[test]
    fn test_cmp_eq_pos() {
        let a = Number::from(1);
        let b = Number::from(1);
        assert_eq!(a, b);
    }

    #[test]
    fn test_cmp_eq_neg() {
        let a = Number::from(-1);
        let b = Number::from(-1);
        assert_eq!(a, b);
    }

    #[test]
    fn test_cmp_pos_neg() {
        let a = Number::from(1);
        let b = Number::from(-1);
        assert!(a > b);
    }

    #[test]
    fn test_cmp_neg_pos() {
        let a = Number::from(-1);
        let b = Number::from(1);
        assert!(a < b);
    }

    #[test]
    fn test_cmp_short_neg() {
        let a = Number::from(-1);
        let b = Number::from(-10);
        assert!(a > b);
    }

    #[test]
    fn test_cmp_short_pos() {
        let a = Number::from(1);
        let b = Number::from(10);
        assert!(a < b);
    }

    #[test]
    fn test_cmp_long_neg() {
        let a = Number::from(-10);
        let b = Number::from(-1);
        assert!(a < b);
    }

    #[test]
    fn test_cmp_long_pos() {
        let a = Number::from(10);
        let b = Number::from(1);
        assert!(a > b);
    }
}