use crate::{Format, MrzData};
const REPEATED_LINE_SIMILARITY: f64 = 0.6;
const NAME_FIELD_START: usize = 5;
pub(crate) fn flagged(data: &MrzData) -> bool {
flag_reason(data).is_some()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum FlagReason {
IssuerUnresolved,
RepeatedLine,
DigitInNameField,
}
pub(crate) fn flag_reason(data: &MrzData) -> Option<FlagReason> {
let lines: Vec<&str> = data.mrz_lines.lines().collect();
let &line1 = lines.first()?;
if issuer_unresolved(line1) {
Some(FlagReason::IssuerUnresolved)
} else if repeats_a_line(&lines) {
Some(FlagReason::RepeatedLine)
} else if digit_in_name_field(data.format, line1) {
Some(FlagReason::DigitInNameField)
} else {
None
}
}
fn issuer_unresolved(line1: &str) -> bool {
line1
.get(2..5)
.is_some_and(|issuer| !crate::parser::country_resolves(issuer))
}
fn repeats_a_line(lines: &[&str]) -> bool {
lines.iter().enumerate().any(|(i, a)| {
lines[i + 1..]
.iter()
.any(|b| similarity(a, b) >= REPEATED_LINE_SIMILARITY)
})
}
fn digit_in_name_field(format: Format, line1: &str) -> bool {
format != Format::Td1
&& line1
.bytes()
.skip(NAME_FIELD_START)
.any(|c| c.is_ascii_digit())
}
fn fold_lookalike(c: u8) -> u8 {
match c {
b'O' | b'Q' | b'D' => b'0',
b'I' | b'L' => b'1',
b'Z' => b'2',
b'S' => b'5',
b'B' => b'8',
b'G' => b'6',
b'T' => b'7',
other => other,
}
}
fn comparable(line: &str) -> Vec<u8> {
line.bytes()
.filter(|&c| c != b'<')
.map(fold_lookalike)
.collect()
}
fn similarity(a: &str, b: &str) -> f64 {
let a = comparable(a);
let b = comparable(b);
if a.is_empty() || b.is_empty() {
return 0.0;
}
let mut previous: Vec<usize> = (0..=b.len()).collect();
for (i, &ca) in a.iter().enumerate() {
let mut current = Vec::with_capacity(b.len() + 1);
current.push(i + 1);
for (j, &cb) in b.iter().enumerate() {
let substitution = previous[j] + usize::from(ca != cb);
current.push(substitution.min(previous[j + 1] + 1).min(current[j] + 1));
}
previous = current;
}
1.0 - previous[b.len()] as f64 / a.len().max(b.len()) as f64
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn filler_is_removed_before_comparing() {
assert_eq!(comparable("AM<<C<"), b"AMC".to_vec());
assert_eq!(comparable("<<<<"), Vec::<u8>::new());
assert_eq!(comparable("A<<A"), comparable("AA"));
assert!((similarity("A<<<<<A", "AA") - 1.0).abs() < f64::EPSILON);
}
#[test]
fn lookalikes_fold_to_one_character() {
for (from, to) in [
(b'O', b'0'),
(b'Q', b'0'),
(b'D', b'0'),
(b'I', b'1'),
(b'L', b'1'),
(b'Z', b'2'),
(b'S', b'5'),
(b'B', b'8'),
(b'G', b'6'),
(b'T', b'7'),
] {
assert_eq!(fold_lookalike(from), to, "{}", from as char);
}
for c in [b'A', b'M', b'0', b'5', b'<'] {
assert_eq!(fold_lookalike(c), c);
}
assert!((similarity("OQDILZSBGT", "0001125867") - 1.0).abs() < f64::EPSILON);
}
#[test]
fn similarity_is_one_minus_distance_over_longer_length() {
assert!((similarity("ABCDE", "ABCDE") - 1.0).abs() < f64::EPSILON);
assert!((similarity("ABCDE", "ABCDF") - 0.8).abs() < 1e-12);
assert!((similarity("ABC", "ABCDE") - 0.6).abs() < 1e-12);
assert!(similarity("AAAA", "MMMM").abs() < f64::EPSILON);
assert!(similarity("<<<<", "<<<<").abs() < f64::EPSILON);
assert!(similarity("ABC", "<<<").abs() < f64::EPSILON);
}
#[test]
fn similarity_threshold_has_a_case_on_each_side() {
let at = ["ABCDE", "ABCMM"];
assert!(similarity(at[0], at[1]) >= REPEATED_LINE_SIMILARITY);
assert!(repeats_a_line(&at));
let below = ["ABCDE", "ABMMM"];
assert!(similarity(below[0], below[1]) < REPEATED_LINE_SIMILARITY);
assert!(!repeats_a_line(&below));
}
#[test]
fn a_line_read_twice_is_a_repeat_whatever_the_slots() {
let twice = [
"P<UTOERIKSSON<<ANNA<MARIA<<<<<<<<<<<<<<<<<<<",
"P000000005UTO7408122F1204159<<<<<<<<<<<<<<04",
"P0OOOO0005UTO7408122F1204159<<<<<<<<<<<<<<04",
];
assert!(repeats_a_line(&twice));
assert!(!repeats_a_line(&twice[..2]));
assert!(!repeats_a_line(&twice[..1]));
assert!(!repeats_a_line(&[]));
}
#[test]
fn issuer_check_flags_only_an_unresolved_issuer() {
assert!(!issuer_unresolved("P<UTOERIKSSON<<ANNA"));
assert!(!issuer_unresolved("P<D<<MUSTERMANN<<ERIKA"));
assert!(issuer_unresolved("VISERINGVISASNE987654321"));
assert!(issuer_unresolved("AL<EKS<<<<<<"));
assert!(!issuer_unresolved("P<U"));
assert!(!issuer_unresolved(""));
}
#[test]
fn name_field_check_flags_a_digit_from_cell_5_on_two_line_formats() {
let visual = "P<UTO0ERIKSSON<<ANNA";
for format in [Format::Td3, Format::Td2, Format::MrvA, Format::MrvB] {
assert!(digit_in_name_field(format, visual), "{format:?}");
assert!(
!digit_in_name_field(format, "P<UTOERIKSSON<<ANNA"),
"{format:?}"
);
}
assert!(!digit_in_name_field(
Format::Td1,
"I<UTOD231458907<<<<<<<<<<<<<<<"
));
assert!(!digit_in_name_field(Format::Td3, "P1UTOERIKSSON"));
assert!(digit_in_name_field(Format::Td3, "P<UTO1RIKSSON"));
assert!(!digit_in_name_field(Format::Td3, "P<UT1ERIKSSON"));
}
}