use crate::checksum::{fit_length, is_mrz_charset, verify};
use crate::dates::Date;
pub const UNKNOWN: char = '?';
pub const MRZ_ALPHABET: &str = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ<";
const MAX_UNKNOWNS: usize = 2;
const MAX_WIDTH_DEFICIT: usize = 2;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum FieldKind {
DocumentNumber,
Date,
PersonalNumber,
Other,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum Resolution {
Unique(String),
Ambiguous { candidates: Vec<String> },
Unresolvable,
}
impl Resolution {
pub fn unique(&self) -> Option<&str> {
match self {
Resolution::Unique(s) => Some(s.as_str()),
_ => None,
}
}
}
pub fn width_candidates(line: &str, target: usize) -> Vec<String> {
let n: String = line.chars().filter(|c| !c.is_whitespace()).collect();
if !n.is_ascii() || target == 0 {
return Vec::new();
}
let mut out: Vec<String> = Vec::new();
for candidate in fit_length(&n, target) {
push_unique(&mut out, candidate, target);
}
let len = n.len();
if len < target {
let deficit = target - len;
if deficit <= MAX_WIDTH_DEFICIT {
let bytes = n.as_bytes();
for at in 0..=len {
let mut s = String::with_capacity(target);
s.push_str(&n[..at]);
for _ in 0..deficit {
s.push(UNKNOWN);
}
s.push_str(&n[at..]);
debug_assert_eq!(bytes.len() + deficit, s.len());
push_unique(&mut out, s, target);
}
}
}
out
}
fn push_unique(out: &mut Vec<String>, candidate: String, target: usize) {
if candidate.len() == target && !out.contains(&candidate) {
out.push(candidate);
}
}
pub fn solve_field(field: &str, check: char, kind: FieldKind) -> Resolution {
if !field.is_ascii() || check == UNKNOWN {
return Resolution::Unresolvable;
}
let chars: Vec<char> = field.chars().collect();
let unknowns: Vec<usize> = chars
.iter()
.enumerate()
.filter(|(_, c)| **c == UNKNOWN)
.map(|(i, _)| i)
.collect();
if unknowns.len() > MAX_UNKNOWNS {
return Resolution::Unresolvable;
}
if chars
.iter()
.any(|c| *c != UNKNOWN && !is_mrz_charset(&c.to_string()))
{
return Resolution::Unresolvable;
}
let alphabet: Vec<char> = MRZ_ALPHABET.chars().collect();
let mut hits: Vec<String> = Vec::new();
let total = alphabet.len().pow(unknowns.len() as u32);
for combo in 0..total {
let mut candidate = chars.clone();
let mut rest = combo;
for &pos in &unknowns {
candidate[pos] = alphabet[rest % alphabet.len()];
rest /= alphabet.len();
}
let s: String = candidate.into_iter().collect();
if verify(&s, check) && satisfies(&s, kind) {
hits.push(s);
}
}
hits.sort();
match hits.len() {
0 => Resolution::Unresolvable,
1 => Resolution::Unique(hits.remove(0)),
_ => Resolution::Ambiguous { candidates: hits },
}
}
pub(crate) fn concrete_fillings(line: &str) -> Vec<String> {
if !line.is_ascii() {
return Vec::new();
}
let chars: Vec<char> = line.chars().collect();
let unknowns: Vec<usize> = chars
.iter()
.enumerate()
.filter(|(_, c)| **c == UNKNOWN)
.map(|(i, _)| i)
.collect();
if unknowns.is_empty() {
return vec![line.to_string()];
}
if unknowns.len() > MAX_UNKNOWNS {
return Vec::new();
}
let alphabet: Vec<char> = MRZ_ALPHABET.chars().collect();
let mut out = Vec::with_capacity(alphabet.len().pow(unknowns.len() as u32));
for combo in 0..alphabet.len().pow(unknowns.len() as u32) {
let mut candidate = chars.clone();
let mut rest = combo;
for &pos in &unknowns {
candidate[pos] = alphabet[rest % alphabet.len()];
rest /= alphabet.len();
}
out.push(candidate.into_iter().collect());
}
out
}
fn satisfies(field: &str, kind: FieldKind) -> bool {
match kind {
FieldKind::Other => true,
FieldKind::DocumentNumber | FieldKind::PersonalNumber => left_justified(field),
FieldKind::Date => is_plausible_yymmdd(field),
}
}
fn left_justified(field: &str) -> bool {
!field.trim_end_matches('<').contains('<')
}
fn is_plausible_yymmdd(field: &str) -> bool {
if field.len() != 6 || !field.bytes().all(|b| b.is_ascii_digit()) {
return false;
}
let yy: i32 = field[0..2].parse().expect("two ascii digits");
let month: u32 = field[2..4].parse().expect("two ascii digits");
let day: u32 = field[4..6].parse().expect("two ascii digits");
Date::new(1900 + yy, month, day).is_well_formed()
|| Date::new(2000 + yy, month, day).is_well_formed()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn width_candidates_are_all_target_width_and_deduplicated() {
for target in [30usize, 36, 44] {
let short: String = "A".repeat(target - 1);
let candidates = width_candidates(&short, target);
assert!(!candidates.is_empty());
for c in &candidates {
assert_eq!(c.len(), target, "candidate {c:?} is not {target} wide");
}
let mut sorted = candidates.clone();
sorted.sort();
sorted.dedup();
assert_eq!(sorted.len(), candidates.len(), "duplicate candidates");
}
}
#[test]
fn width_candidates_sweep_every_insertion_point() {
let candidates = width_candidates("ABCDE", 6);
assert!(candidates.contains(&"?ABCDE".to_string()));
assert!(candidates.contains(&"AB?CDE".to_string()));
assert!(candidates.contains(&"ABCDE?".to_string()));
}
#[test]
fn width_candidates_refuses_a_deficit_it_cannot_bound() {
let candidates = width_candidates("AB", 30);
assert!(
candidates.iter().all(|c| !c.contains(UNKNOWN)),
"a 28-character deficit must not be swept position by position"
);
}
#[test]
fn a_field_with_no_unknowns_is_just_verified() {
assert_eq!(
solve_field("L898902C<", '3', FieldKind::DocumentNumber),
Resolution::Unique("L898902C<".to_string())
);
assert_eq!(
solve_field("L898902C<", '4', FieldKind::DocumentNumber),
Resolution::Unresolvable
);
}
#[test]
fn an_unreadable_check_digit_proves_nothing() {
assert_eq!(
solve_field("6908?22", UNKNOWN, FieldKind::Other),
Resolution::Unresolvable
);
}
#[test]
fn too_many_unknowns_is_refused_not_attempted() {
assert_eq!(
solve_field("???????", '0', FieldKind::Other),
Resolution::Unresolvable
);
}
#[test]
fn left_justified_rejects_an_interior_filler() {
assert!(left_justified("B1987309"));
assert!(left_justified("B198730<"));
assert!(!left_justified("B<987309"));
}
#[test]
fn plausible_dates_reject_impossible_calendars() {
assert!(!is_plausible_yymmdd("890229")); assert!(is_plausible_yymmdd("000229")); assert!(is_plausible_yymmdd("301230"));
assert!(!is_plausible_yymmdd("301332"));
assert!(!is_plausible_yymmdd("D01230"));
assert!(!is_plausible_yymmdd("30123"));
}
}