use std::{
    cmp::min,
    iter::zip,
    ops::{Sub, SubAssign},
};

use super::{Number, Sign};

impl Sub for Number {
    type Output = Self;

    fn sub(self, rhs: Self) -> Self::Output {
        let self_len = self.digits.len();
        let rhs_len = rhs.digits.len();
        let mut self_digits = self.digits.clone();
        let mut rhs_digits = rhs.digits.clone();
        if self_len != rhs_len {
            let difference = (self_len).abs_diff(rhs_len);
            let pad = vec![0isize; difference];
            if min(self_len, rhs_len) == self_len {
                self_digits = [pad, self.digits].concat();
            } else {
                rhs_digits = [pad, rhs.digits].concat();
            }
        }
        let zipped = zip(self_digits.iter(), rhs_digits.iter());
        let added = zipped
            .map(|(self_digit, rhs_digit)| self_digit - rhs_digit)
            .collect();
        let mut underflown_number = Self {
            digits: added,
            sign: Sign::Positif,
        };
        underflown_number.handle_underflows();
        underflown_number
    }
}

impl SubAssign for Number {
    fn sub_assign(&mut self, rhs: Self) {
        let new = self.clone() - rhs;
        self.digits = new.digits;
        self.sign = new.sign;
    }
}