Rodinify

use num_bigint::BigUint;

/// Convert a Unicode character to a number mapping {a-z} -> {1-26}
fn char_to_int(character: char) -> Option<u8> {
    if character.is_alphanumeric() && character.is_lowercase() {
        Some(character as u8 - b'a' + 1)
    } else {
        None
    }
}

/// Convert a number to a character mapping {1-26} -> {a-z}
fn int_to_char(integer: u8) -> Option<char> {
    if integer >= 1 && integer <= 26 {
        Some((integer - 1 + b'a').into())
    } else {
        None
    }
}

/// Rodinify the characters of a large number in single character mode
fn rodinify_singlechar(input_string: &str) -> String {
    input_string
        .chars()
        .filter_map(|x| x.to_digit(10))
        .map(|x| x as u8)
        .map(int_to_char)
        .filter_map(|x| x)
        .collect()
}

/// Rodinify the characters of a large number in multi character mode
fn rodinify_multichar(input_string: &str) -> String {
    let mut output_string = String::new();
    let mut digits = input_string
        .chars()
        .filter_map(|x| x.to_digit(10))
        .map(|x| x as u8)
        .skip_while(|x| int_to_char(*x).is_none());

    let mut last_digit = digits.next();

    for digit in digits {
        if let Some(some_last_digit) = last_digit {
            let combined_digits = (some_last_digit * 10) + digit;
            if combined_digits <= 26 {
                if let Some(valid_character) = int_to_char(combined_digits) {
                    output_string.push(valid_character);
                }
                last_digit = None;
            } else {
                if let Some(valid_character) = int_to_char(some_last_digit) {
                    output_string.push(valid_character);
                }
                last_digit = Some(digit);
            }
        } else {
            last_digit = Some(digit);
        }
    }

    if let Some(last_digit) = last_digit.and_then(int_to_char) {
        output_string.push(last_digit);
    }

    output_string
}

/// Map all characters {a-z} to the range {1-26} and multiply them from beginning to end
fn multiply_character_numbers(input_string: &str) -> BigUint {
    input_string
        .chars()
        .map(char_to_int)
        .filter_map(|x| x)
        .fold(BigUint::new(vec![1]), |x, val| x * val)
}

/// Map all characters {a-z} to the range {1-26} and multiply them from beginning to end
fn add_character_numbers(input_string: &str) -> BigUint {
    input_string
        .chars()
        .map(char_to_int)
        .filter_map(|x| x)
        .fold(BigUint::new(vec![0]), |x, val| x + val)
}

fn main() {
    if let Some(input_str) = std::env::args().nth(1) {
        let mul_string = multiply_character_numbers(&input_str.to_lowercase()).to_string();
        let add_string = add_character_numbers(&input_str.to_lowercase()).to_string();
        println!("Multiplying:");
        println!("\tNumber: {}", mul_string);
        println!("\tSingle: {}", rodinify_singlechar(&mul_string));
        println!("\tMulti: {}", rodinify_multichar(&mul_string));
        println!("Adding:");
        println!("\tNumber: {}", add_string);
        println!("\tSingle: {}", rodinify_singlechar(&add_string));
        println!("\tMulti: {}", rodinify_multichar(&add_string));
    }
}

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

    #[test]
    fn test_char_to_int() {
        assert_eq!(char_to_int('5'), None);
        assert_eq!(char_to_int('A'), None);
        assert_eq!(char_to_int('B'), None);
        assert_eq!(char_to_int('`'), None);
        assert_eq!(char_to_int('a'), Some(1));
        assert_eq!(char_to_int('b'), Some(2));
        assert_eq!(char_to_int('z'), Some(26));
        assert_eq!(char_to_int('{'), None);
    }

    #[test]
    fn test_int_to_char() {
        assert_eq!(int_to_char(0), None);
        assert_eq!(int_to_char(1), Some('a'));
        assert_eq!(int_to_char(2), Some('b'));
        assert_eq!(int_to_char(25), Some('y'));
        assert_eq!(int_to_char(26), Some('z'));
        assert_eq!(int_to_char(27), None);
    }

    #[test]
    fn test_multiply_character_numbers() {
        assert_eq!(
            multiply_character_numbers("vvv pec"),
            BigUint::new(vec![2555520])
        );
        assert_eq!(multiply_character_numbers("he"), BigUint::new(vec![40]));
    }

    #[test]
    fn test_add_character_numbers() {
        assert_eq!(
            add_character_numbers("big bara bois"),
            BigUint::new(vec![85])
        );
    }

    #[test]
    fn test_rodinify_single_char() {
        let mul_string = multiply_character_numbers("vvv pec").to_string();
        assert_eq!(rodinify_singlechar(&mul_string), String::from("beeeeb"));

        let add_string = add_character_numbers("big bara bois").to_string();
        assert_eq!(rodinify_multichar(&add_string), String::from("he"));
    }

    #[test]
    fn test_rodinify_multi_char() {
        let mul_string = multiply_character_numbers("vvv pec").to_string();
        assert_eq!(rodinify_multichar(&mul_string), String::from("yeeet"));

        assert_eq!(rodinify_multichar("21212"), String::from("uub"));
        assert_eq!(rodinify_multichar("20202"), String::from("ttb"));
        assert_eq!(rodinify_multichar("2020"), String::from("tt"));
        assert_eq!(rodinify_multichar("200"), String::from("t"));
        assert_eq!(rodinify_multichar("0200"), String::from("t"));
        assert_eq!(rodinify_multichar("0210"), String::from("u"));
        assert_eq!(rodinify_multichar("02121212"), String::from("uuub"));
        assert_eq!(rodinify_multichar("021021212"), String::from("ubll"));
        assert_eq!(rodinify_multichar("0210212122"), String::from("ubllb"));

        let mul_string = multiply_character_numbers("she").to_string();
        assert_eq!(rodinify_multichar(&mul_string), String::from("gf"));

        let mul_string = multiply_character_numbers("he").to_string();
        assert_eq!(rodinify_multichar(&mul_string), String::from("d"));
    }

}