pub struct Row {
    name: String,
    hut_type: String,
    path: String,
    tare: f64,
    mat_id: String,
    quantity: f64,
    lot_id: String,
    uom: String,
    lot_status: String,
    born: chrono::DateTime<chrono::Local>,
    expire: chrono::DateTime<chrono::Local>,
}

impl Row {
    pub fn new(
        name: &str,
        hut_type: &str,
        path: &str,
        tare: f64,
        mat_id: &str,
        quantity: f64,
        uom: &str,
        lot_status: &str,
        checksum: bool,
    ) -> Self {
        let born = chrono::Local::now();
        let expire = born
            .checked_add_days(chrono::Days::new(365))
            .expect("A valid date time");
        let name = match checksum {
            true => make_checksum(),
            false => name.to_ascii_uppercase(),
        };
        Self {
            name: name.clone(),
            hut_type: hut_type.to_ascii_uppercase(),
            path: path.to_ascii_uppercase(),
            tare,
            mat_id: mat_id.to_ascii_uppercase(),
            quantity,
            lot_id: format!("{}-{}", name, mat_id).to_ascii_uppercase(),
            uom: uom.to_ascii_uppercase(),
            lot_status: lot_status.to_ascii_uppercase(),
            born,
            expire,
        }
    }
}

fn make_checksum() -> String {
    let base = rand::random_range(10000..99999).to_string();
    let expect = "a valid character in the base checksum";

    let split = format!(
        "{}{}{}{}{}",
        base.chars().next().expect(expect),
        base.chars().nth(2).expect(expect),
        base.chars().nth(4).expect(expect),
        base.chars().nth(1).expect(expect),
        base.chars().nth(3).expect(expect)
    )
    .repeat(2);

    let sum: u32 = split
        .chars()
        .map(|c| c.to_digit(10).expect("a valid integer value"))
        .sum();

    let last = (10 - (sum % 10)) % 10;

    format!("{}{}", base, last)
}