use std::ops::{Mul, MulAssign};

use super::{Number, Sign};

impl Mul for Number {
    type Output = Self;

    fn mul(self, rhs: Self) -> Self::Output {
        let multiplied = self.digits.iter().rev().enumerate().map(|(pos, &digit)| {
            let mut mult = digit * rhs.clone();
            mult.digits = [mult.digits, vec![0; pos]].concat();
            mult
        });
        let mut overflown_number = multiplied.reduce(|acc, num| acc + num).unwrap();
        overflown_number.handle_overflows();
        overflown_number
    }
}

impl Mul<Number> for isize {
    type Output = Number;

    fn mul(self, rhs: Number) -> Self::Output {
        let multiplied = rhs.digits.iter().map(|digit| digit * self).collect();
        let mut overflown_number = Number {
            digits: multiplied,
            sign: Sign::Positif,
        };
        overflown_number.handle_overflows();
        overflown_number
    }
}

impl Mul<isize> for Number {
    type Output = Self;

    fn mul(self, rhs: isize) -> Self::Output {
        let multiplied = self.digits.iter().map(|digit| digit * rhs).collect();
        let mut overflown_number = Self {
            digits: multiplied,
            sign: Sign::Positif,
        };
        overflown_number.handle_overflows();
        overflown_number
    }
}

impl MulAssign for Number {
    fn mul_assign(&mut self, rhs: Self) {
        let new = self.clone() * rhs;
        self.digits = new.digits;
        self.sign = new.sign;
    }
}