promocrypt_core/

validator.rs

//! Code validation module.
//!
//! Provides functions for validating promotional codes, checking format,
//! character validity, and Damm check digits.

use crate::alphabet::Alphabet;
use crate::damm::DammTable;
use crate::error::ValidationResult;

/// Validate a promotional code and return detailed result.
///
/// This function checks:
/// 1. Code length matches expected length
/// 2. All characters are in the alphabet
/// 3. Damm check digit is correct
///
/// # Arguments
/// * `code` - The code to validate (including check digit)
/// * `alphabet` - The alphabet used for the code
/// * `expected_length` - Expected total length (code_length + 1 for check digit)
/// * `damm_table` - Damm table for check digit validation
///
/// # Returns
/// `ValidationResult` with detailed information about any validation failure.
///
/// # Example
///
/// ```
/// use promocrypt_core::{validate, Alphabet, DammTable, ValidationResult};
///
/// let alphabet = Alphabet::default_alphabet();
/// let damm = DammTable::new(alphabet.len());
///
/// let result = validate("INVALIDCODE", &alphabet, 10, &damm);
/// // result will indicate specific failure reason
/// ```
pub fn validate(
    code: &str,
    alphabet: &Alphabet,
    expected_length: usize,
    damm_table: &DammTable,
) -> ValidationResult {
    // 1. Check length
    let actual_length = code.chars().count();
    if actual_length != expected_length {
        return ValidationResult::InvalidLength {
            expected: expected_length,
            actual: actual_length,
        };
    }

    // 2. Check all characters are in alphabet
    for (pos, c) in code.chars().enumerate() {
        if !alphabet.contains(c) {
            return ValidationResult::InvalidCharacter {
                char: c,
                position: pos,
            };
        }
    }

    // 3. Validate Damm check digit
    if !damm_table.validate(code, alphabet) {
        return ValidationResult::InvalidCheckDigit;
    }

    ValidationResult::Valid
}

/// Quick boolean validation check.
///
/// Returns `true` if the code is valid, `false` otherwise.
/// Use `validate()` if you need details about why validation failed.
///
/// # Example
///
/// ```
/// use promocrypt_core::{is_valid, Alphabet, DammTable};
///
/// let alphabet = Alphabet::default_alphabet();
/// let damm = DammTable::new(alphabet.len());
///
/// let valid = is_valid("SOMECODE", &alphabet, 10, &damm);
/// ```
#[inline]
pub fn is_valid(
    code: &str,
    alphabet: &Alphabet,
    expected_length: usize,
    damm_table: &DammTable,
) -> bool {
    validate(code, alphabet, expected_length, damm_table).is_valid()
}

/// Validate code format only (length and characters), without checking the check digit.
///
/// Useful for quick format validation before more expensive operations.
pub fn validate_format(
    code: &str,
    alphabet: &Alphabet,
    expected_length: usize,
) -> ValidationResult {
    // 1. Check length
    let actual_length = code.chars().count();
    if actual_length != expected_length {
        return ValidationResult::InvalidLength {
            expected: expected_length,
            actual: actual_length,
        };
    }

    // 2. Check all characters are in alphabet
    for (pos, c) in code.chars().enumerate() {
        if !alphabet.contains(c) {
            return ValidationResult::InvalidCharacter {
                char: c,
                position: pos,
            };
        }
    }

    ValidationResult::Valid
}

/// Batch validation of multiple codes.
///
/// Returns a vector of validation results, one for each input code.
pub fn validate_batch(
    codes: &[&str],
    alphabet: &Alphabet,
    expected_length: usize,
    damm_table: &DammTable,
) -> Vec<ValidationResult> {
    codes
        .iter()
        .map(|code| validate(code, alphabet, expected_length, damm_table))
        .collect()
}

/// Count valid codes in a batch.
///
/// More efficient than validating all and counting, as it can short-circuit.
pub fn count_valid(
    codes: &[&str],
    alphabet: &Alphabet,
    expected_length: usize,
    damm_table: &DammTable,
) -> usize {
    codes
        .iter()
        .filter(|code| is_valid(code, alphabet, expected_length, damm_table))
        .count()
}

/// Partition codes into valid and invalid.
///
/// Returns (valid_codes, invalid_codes_with_reasons).
pub fn partition_codes<'a>(
    codes: &[&'a str],
    alphabet: &Alphabet,
    expected_length: usize,
    damm_table: &DammTable,
) -> (Vec<&'a str>, Vec<(&'a str, ValidationResult)>) {
    let mut valid = Vec::new();
    let mut invalid = Vec::new();

    for &code in codes {
        let result = validate(code, alphabet, expected_length, damm_table);
        if result.is_valid() {
            valid.push(code);
        } else {
            invalid.push((code, result));
        }
    }

    (valid, invalid)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::generator::{CheckPosition, generate_code};

    fn setup() -> (Alphabet, DammTable, [u8; 32]) {
        let alphabet = Alphabet::default_alphabet();
        let damm = DammTable::new(alphabet.len());
        let secret = [42u8; 32];
        (alphabet, damm, secret)
    }

    #[test]
    fn test_validate_generated_code() {
        let (alphabet, damm, secret) = setup();

        let code = generate_code(&secret, 0, &alphabet, 9, CheckPosition::End, &damm);
        let result = validate(&code, &alphabet, 10, &damm);

        assert!(result.is_valid());
    }

    #[test]
    fn test_validate_invalid_length_short() {
        let (alphabet, damm, _) = setup();

        let result = validate("ABC", &alphabet, 10, &damm);
        assert!(matches!(
            result,
            ValidationResult::InvalidLength {
                expected: 10,
                actual: 3
            }
        ));
    }

    #[test]
    fn test_validate_invalid_length_long() {
        let (alphabet, damm, _) = setup();

        let result = validate("ABCDEFGHIJKLMNO", &alphabet, 10, &damm);
        assert!(matches!(
            result,
            ValidationResult::InvalidLength {
                expected: 10,
                actual: 15
            }
        ));
    }

    #[test]
    fn test_validate_invalid_character() {
        let (alphabet, damm, _) = setup();

        // '!' is not in the default alphabet
        let result = validate("ABCDEFGH!J", &alphabet, 10, &damm);
        assert!(matches!(
            result,
            ValidationResult::InvalidCharacter {
                char: '!',
                position: 8
            }
        ));
    }

    #[test]
    fn test_validate_invalid_checkdigit() {
        let (alphabet, damm, secret) = setup();

        // Generate a valid code
        let code = generate_code(&secret, 0, &alphabet, 9, CheckPosition::End, &damm);

        // Modify one character (not the check digit) to make it invalid
        let mut chars: Vec<char> = code.chars().collect();
        chars[4] = if chars[4] == 'A' { 'B' } else { 'A' };
        let invalid_code: String = chars.iter().collect();

        let result = validate(&invalid_code, &alphabet, 10, &damm);
        assert!(matches!(result, ValidationResult::InvalidCheckDigit));
    }

    #[test]
    fn test_is_valid() {
        let (alphabet, damm, secret) = setup();

        let code = generate_code(&secret, 0, &alphabet, 9, CheckPosition::End, &damm);
        assert!(is_valid(&code, &alphabet, 10, &damm));

        assert!(!is_valid("INVALID!!!", &alphabet, 10, &damm));
    }

    #[test]
    fn test_validate_format() {
        let (alphabet, _, _) = setup();

        // Valid format but we're not checking check digit
        let result = validate_format("ABCDEFGHXY", &alphabet, 10);
        assert!(result.is_valid());

        // Invalid character
        let result = validate_format("ABCDEFGH!X", &alphabet, 10);
        assert!(matches!(result, ValidationResult::InvalidCharacter { .. }));
    }

    #[test]
    fn test_validate_batch() {
        let (alphabet, damm, secret) = setup();

        let code1 = generate_code(&secret, 0, &alphabet, 9, CheckPosition::End, &damm);
        let code2 = generate_code(&secret, 1, &alphabet, 9, CheckPosition::End, &damm);
        let invalid = "INVALID!!!";

        let codes: Vec<&str> = vec![&code1, &code2, invalid];
        let results = validate_batch(&codes, &alphabet, 10, &damm);

        assert!(results[0].is_valid());
        assert!(results[1].is_valid());
        assert!(!results[2].is_valid());
    }

    #[test]
    fn test_count_valid() {
        let (alphabet, damm, secret) = setup();

        let code1 = generate_code(&secret, 0, &alphabet, 9, CheckPosition::End, &damm);
        let code2 = generate_code(&secret, 1, &alphabet, 9, CheckPosition::End, &damm);
        let invalid = "INVALID!!!";

        let codes: Vec<&str> = vec![&code1, &code2, invalid];
        let count = count_valid(&codes, &alphabet, 10, &damm);

        assert_eq!(count, 2);
    }

    #[test]
    fn test_partition_codes() {
        let (alphabet, damm, secret) = setup();

        let code1 = generate_code(&secret, 0, &alphabet, 9, CheckPosition::End, &damm);
        let code2 = generate_code(&secret, 1, &alphabet, 9, CheckPosition::End, &damm);
        let invalid = "INVALID!!!";

        let codes: Vec<&str> = vec![&code1, &code2, invalid];
        let (valid, invalid_with_reasons) = partition_codes(&codes, &alphabet, 10, &damm);

        assert_eq!(valid.len(), 2);
        assert_eq!(invalid_with_reasons.len(), 1);
        assert_eq!(invalid_with_reasons[0].0, "INVALID!!!");
    }

    #[test]
    fn test_validation_result_error_code() {
        assert_eq!(ValidationResult::Valid.error_code(), 0);
        assert_eq!(
            ValidationResult::InvalidLength {
                expected: 10,
                actual: 5
            }
            .error_code(),
            1
        );
        assert_eq!(
            ValidationResult::InvalidCharacter {
                char: '!',
                position: 0
            }
            .error_code(),
            2
        );
        assert_eq!(ValidationResult::InvalidCheckDigit.error_code(), 3);
    }
}