RUST: Format chemIDplus to valid CAS

use std::io;

fn chemidplus_convert(input: &str) -> Option<String> {
    // 1. Validate input length and characters:
    if input.len() != 10 || !input.chars().all(|c| c.is_digit(10)) {
        return None; // Return None for invalid input
    }

    // 2. Remove leading zeros:
    let trimmed = input.trim_start_matches('0');
    if trimmed.is_empty() {
        return Some("0-00-0".to_string()); // Handle all-zero input
    }

    // 3. Check if the trimmed string has at least 2 digits:
    let len = trimmed.len();
    if len < 2 {
        return None; // Return None if too short
    }

    // 4. Extract the expected check digit from the end of the trimmed string:
    let expected_check_digit = trimmed.chars().last().unwrap().to_digit(10).unwrap();

    // 5. Calculate the check digit from the trimmed string (excluding the last digit):
    let check_digit_from_calculation = calculate_cas_check_digit(&trimmed[..trimmed.len() - 1]);

    // 6. Verify the check digit:
    if expected_check_digit != check_digit_from_calculation {
        return None; // Return None if the check digit is incorrect
    }

    // 7. Split the trimmed string into three parts:
    let first_part_len = len - 3;
    let first_part = &trimmed[..first_part_len];
    let second_part = &trimmed[first_part_len..first_part_len + 2];

    // 8. Format and return the CAS number string:
    Some(format!(
        "{}-{}-{}",
        first_part, second_part, expected_check_digit
    ))
}

// Function to calculate the check digit based on the CAS number rules:
fn calculate_cas_check_digit(input: &str) -> u32 {
    let mut sum = 0;
    // Iterate through the input string in reverse order:
    for (i, c) in input.chars().rev().enumerate() {
        // Convert the character to a digit:
        let digit = c.to_digit(10).unwrap();
        // Multiply the digit by its position (1-based index) and add to the sum:
        sum += digit * (i as u32 + 1);
    }
    // Return the sum modulo 10:
    sum % 10
}

fn main() {
    println!("Enter a 10-digit number:");
    let mut input = String::new();
    io::stdin()
        .read_line(&mut input)
        .expect("Failed to read line");
    let input = input.trim();

    match chemidplus_convert(input) {
        Some(cas_number) => println!("Formatted CAS number: {}", cas_number),
        None => println!("Invalid CAS number."),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_valid_input() {
        assert_eq!(
            chemidplus_convert("00000773218"),
            Some("7732-18-5".to_string())
        );
        assert_eq!(chemidplus_convert("0000000001"), Some("1-00-1".to_string()));
        assert_eq!(
            chemidplus_convert("1234567890"),
            Some("1234567-89-0".to_string())
        );
        assert_eq!(
            chemidplus_convert("0000543908"),
            Some("543-90-8".to_string())
        );
    }

    #[test]
    fn test_all_zeros() {
        assert_eq!(chemidplus_convert("0000000000"), Some("0-00-0".to_string()));
    }

    #[test]
    fn test_invalid_length() {
        assert_eq!(chemidplus_convert("123456789"), None);
        assert_eq!(chemidplus_convert("12345678901"), None);
    }

    #[test]
    fn test_invalid_characters() {
        assert_eq!(chemidplus_convert("123456789a"), None);
    }

    #[test]
    fn test_invalid_checksum() {
        assert_eq!(chemidplus_convert("00000773219"), None);
        assert_eq!(chemidplus_convert("1234567891"), None);
    }
}