use crate::checksum::check_digit;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct Td3Fields {
pub document_code: String,
pub issuing_country: String,
pub document_number: String,
pub surname: String,
pub given_names: String,
pub nationality: String,
pub date_of_birth: String,
pub sex: String,
pub date_of_expiry: String,
pub personal_number: Option<String>,
}
impl Default for Td3Fields {
fn default() -> Self {
Self {
document_code: "P".to_string(),
issuing_country: String::new(),
document_number: String::new(),
surname: String::new(),
given_names: String::new(),
nationality: String::new(),
date_of_birth: String::new(),
sex: String::new(),
date_of_expiry: String::new(),
personal_number: None,
}
}
}
fn clean(s: &str) -> String {
s.chars()
.map(|c| {
let u = c.to_ascii_uppercase();
if u.is_ascii_alphanumeric() {
u
} else {
'<'
}
})
.collect()
}
fn field(s: &str, width: usize) -> String {
let cleaned = clean(s);
let mut chars = cleaned.chars();
let mut out = String::with_capacity(width);
for _ in 0..width {
out.push(chars.next().unwrap_or('<'));
}
out
}
fn clean_name_half(s: &str) -> String {
let mut out = String::with_capacity(s.len());
let mut last_was_sep = false;
for c in s.chars() {
for u in c.to_uppercase() {
if let Some(t) = crate::translit::transliterate_char(
u,
crate::translit::TransliterationStyle::Expanded,
) {
out.push_str(t);
last_was_sep = false;
} else if u.is_ascii_alphanumeric() {
out.push(u);
last_was_sep = false;
} else if u == '\'' {
} else if (u == '-' || u == ',' || u.is_whitespace()) && !last_was_sep {
out.push('<');
last_was_sep = true;
}
}
}
out.trim_matches('<').to_string()
}
fn truncate_name_components(primary: &str, secondary: &str, width: usize) -> String {
let mut parts: Vec<(&str, &str)> = Vec::new();
let mut primary_components = primary.split('<').filter(|c| !c.is_empty());
if let Some(first) = primary_components.next() {
parts.push(("", first));
}
for component in primary_components {
parts.push(("<", component));
}
let mut secondary_components = secondary.split('<').filter(|c| !c.is_empty());
if let Some(first) = secondary_components.next() {
parts.push(("<<", first));
}
for component in secondary_components {
parts.push(("<", component));
}
let mut out = String::with_capacity(width);
for (separator, component) in parts {
let remaining = width.saturating_sub(out.len());
if remaining == 0 {
break;
}
let full_len = separator.len() + component.len();
if full_len <= remaining {
out.push_str(separator);
out.push_str(component);
continue;
}
if separator.len() < remaining {
out.push_str(separator);
let take = remaining - separator.len();
out.push_str(&component[..take]);
} else {
let take = remaining.min(component.len());
out.push_str(&component[..take]);
}
break;
}
out
}
fn name_field(surname: &str, given_names: &str, width: usize) -> String {
let primary = clean_name_half(surname);
let secondary = clean_name_half(given_names);
let combined = format!("{primary}<<{secondary}");
if combined.len() <= width {
return field(&combined, width);
}
let truncated = truncate_name_components(&primary, &secondary, width);
field(&truncated, width)
}
struct DocNumber {
field: String,
check: char,
optional_prefix: String,
}
fn doc_number(number: &str, optional_width: usize) -> DocNumber {
let cleaned = clean(number);
let remainder_len = cleaned.len().saturating_sub(9);
if cleaned.len() > 9 && remainder_len + 2 <= optional_width {
let check = digit_char(&cleaned);
return DocNumber {
field: cleaned[0..9].to_string(),
check: '<',
optional_prefix: format!("{}{check}<", &cleaned[9..]),
};
}
let field = field(&cleaned, 9);
DocNumber {
check: digit_char(&field),
field,
optional_prefix: String::new(),
}
}
fn digit_char(field: &str) -> char {
char::from_digit(check_digit(field).expect("MRZ-charset field"), 10).expect("0-9")
}
pub fn format_td3(fields: &Td3Fields) -> String {
let doc_code = field(&fields.document_code, 2);
let issuing = field(&fields.issuing_country, 3);
let name = name_field(&fields.surname, &fields.given_names, 39);
let line1 = format!("{doc_code}{issuing}{name}");
let DocNumber {
field: doc_num,
check: doc_num_check,
optional_prefix,
} = doc_number(&fields.document_number, 14);
let nationality = field(&fields.nationality, 3);
let dob = field(&fields.date_of_birth, 6);
let dob_check = digit_char(&dob);
let sex = match fields.sex.to_ascii_uppercase().as_str() {
"M" => 'M',
"F" => 'F',
_ => '<',
};
let expiry = field(&fields.date_of_expiry, 6);
let expiry_check = digit_char(&expiry);
let personal = field(
&format!(
"{optional_prefix}{}",
clean(fields.personal_number.as_deref().unwrap_or(""))
),
14,
);
let personal_check = digit_char(&personal);
let line2_body = format!(
"{doc_num}{doc_num_check}{nationality}{dob}{dob_check}{sex}{expiry}{expiry_check}{personal}{personal_check}"
);
debug_assert_eq!(line2_body.len(), 43);
let composite_input = format!(
"{}{}{}",
&line2_body[0..10],
&line2_body[13..20],
&line2_body[21..43]
);
let composite_check = digit_char(&composite_input);
let line2 = format!("{line2_body}{composite_check}");
debug_assert_eq!(line1.len(), 44);
debug_assert_eq!(line2.len(), 44);
format!("{line1}\n{line2}")
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct Td2Fields {
pub document_code: String,
pub issuing_country: String,
pub document_number: String,
pub surname: String,
pub given_names: String,
pub nationality: String,
pub date_of_birth: String,
pub sex: String,
pub date_of_expiry: String,
pub optional_data: Option<String>,
}
impl Default for Td2Fields {
fn default() -> Self {
Self {
document_code: "I".to_string(),
issuing_country: String::new(),
document_number: String::new(),
surname: String::new(),
given_names: String::new(),
nationality: String::new(),
date_of_birth: String::new(),
sex: String::new(),
date_of_expiry: String::new(),
optional_data: None,
}
}
}
pub fn format_td2(fields: &Td2Fields) -> String {
let doc_code = field(&fields.document_code, 2);
let issuing = field(&fields.issuing_country, 3);
let name = name_field(&fields.surname, &fields.given_names, 31);
let line1 = format!("{doc_code}{issuing}{name}");
debug_assert_eq!(line1.len(), 36);
let DocNumber {
field: doc_num,
check: doc_num_check,
optional_prefix,
} = doc_number(&fields.document_number, 7);
let nationality = field(&fields.nationality, 3);
let dob = field(&fields.date_of_birth, 6);
let dob_check = digit_char(&dob);
let sex = match fields.sex.to_ascii_uppercase().as_str() {
"M" => 'M',
"F" => 'F',
_ => '<',
};
let expiry = field(&fields.date_of_expiry, 6);
let expiry_check = digit_char(&expiry);
let optional = field(
&format!(
"{optional_prefix}{}",
clean(fields.optional_data.as_deref().unwrap_or(""))
),
7,
);
let line2_body = format!(
"{doc_num}{doc_num_check}{nationality}{dob}{dob_check}{sex}{expiry}{expiry_check}{optional}"
);
debug_assert_eq!(line2_body.len(), 35);
let composite_input = format!(
"{}{}{}",
&line2_body[0..10],
&line2_body[13..20],
&line2_body[21..35]
);
let composite_check = digit_char(&composite_input);
let line2 = format!("{line2_body}{composite_check}");
debug_assert_eq!(line2.len(), 36);
format!("{line1}\n{line2}")
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct Td1Fields {
pub document_code: String,
pub issuing_country: String,
pub document_number: String,
pub optional_data_1: Option<String>,
pub surname: String,
pub given_names: String,
pub nationality: String,
pub date_of_birth: String,
pub sex: String,
pub date_of_expiry: String,
pub optional_data_2: Option<String>,
}
impl Default for Td1Fields {
fn default() -> Self {
Self {
document_code: "I".to_string(),
issuing_country: String::new(),
document_number: String::new(),
optional_data_1: None,
surname: String::new(),
given_names: String::new(),
nationality: String::new(),
date_of_birth: String::new(),
sex: String::new(),
date_of_expiry: String::new(),
optional_data_2: None,
}
}
}
pub fn format_td1(fields: &Td1Fields) -> String {
let doc_code = field(&fields.document_code, 2);
let issuing = field(&fields.issuing_country, 3);
let DocNumber {
field: doc_num,
check: doc_num_check,
optional_prefix,
} = doc_number(&fields.document_number, 15);
let optional1 = field(
&format!(
"{optional_prefix}{}",
clean(fields.optional_data_1.as_deref().unwrap_or(""))
),
15,
);
let line1 = format!("{doc_code}{issuing}{doc_num}{doc_num_check}{optional1}");
debug_assert_eq!(line1.len(), 30);
let dob = field(&fields.date_of_birth, 6);
let dob_check = digit_char(&dob);
let sex = match fields.sex.to_ascii_uppercase().as_str() {
"M" => 'M',
"F" => 'F',
_ => '<',
};
let expiry = field(&fields.date_of_expiry, 6);
let expiry_check = digit_char(&expiry);
let nationality = field(&fields.nationality, 3);
let optional2 = field(fields.optional_data_2.as_deref().unwrap_or(""), 11);
let line2_body = format!("{dob}{dob_check}{sex}{expiry}{expiry_check}{nationality}{optional2}");
debug_assert_eq!(line2_body.len(), 29);
let composite_input = format!(
"{}{}{}{}",
&line1[5..30],
&line2_body[0..7],
&line2_body[8..15],
&line2_body[18..29]
);
let composite_check = digit_char(&composite_input);
let line2 = format!("{line2_body}{composite_check}");
debug_assert_eq!(line2.len(), 30);
let line3 = name_field(&fields.surname, &fields.given_names, 30);
debug_assert_eq!(line3.len(), 30);
format!("{line1}\n{line2}\n{line3}")
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct MrvAFields {
pub document_code: String,
pub issuing_country: String,
pub document_number: String,
pub surname: String,
pub given_names: String,
pub nationality: String,
pub date_of_birth: String,
pub sex: String,
pub date_of_expiry: String,
pub optional_data: Option<String>,
}
impl Default for MrvAFields {
fn default() -> Self {
Self {
document_code: "V".to_string(),
issuing_country: String::new(),
document_number: String::new(),
surname: String::new(),
given_names: String::new(),
nationality: String::new(),
date_of_birth: String::new(),
sex: String::new(),
date_of_expiry: String::new(),
optional_data: None,
}
}
}
pub fn format_mrv_a(fields: &MrvAFields) -> String {
let doc_code = field(&fields.document_code, 2);
let issuing = field(&fields.issuing_country, 3);
let name = name_field(&fields.surname, &fields.given_names, 39);
let line1 = format!("{doc_code}{issuing}{name}");
debug_assert_eq!(line1.len(), 44);
let doc_num = field(&fields.document_number, 9);
let doc_num_check = digit_char(&doc_num);
let nationality = field(&fields.nationality, 3);
let dob = field(&fields.date_of_birth, 6);
let dob_check = digit_char(&dob);
let sex = match fields.sex.to_ascii_uppercase().as_str() {
"M" => 'M',
"F" => 'F',
_ => '<',
};
let expiry = field(&fields.date_of_expiry, 6);
let expiry_check = digit_char(&expiry);
let optional = field(fields.optional_data.as_deref().unwrap_or(""), 16);
let line2 = format!(
"{doc_num}{doc_num_check}{nationality}{dob}{dob_check}{sex}{expiry}{expiry_check}{optional}"
);
debug_assert_eq!(line2.len(), 44);
format!("{line1}\n{line2}")
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct MrvBFields {
pub document_code: String,
pub issuing_country: String,
pub document_number: String,
pub surname: String,
pub given_names: String,
pub nationality: String,
pub date_of_birth: String,
pub sex: String,
pub date_of_expiry: String,
pub optional_data: Option<String>,
}
impl Default for MrvBFields {
fn default() -> Self {
Self {
document_code: "V".to_string(),
issuing_country: String::new(),
document_number: String::new(),
surname: String::new(),
given_names: String::new(),
nationality: String::new(),
date_of_birth: String::new(),
sex: String::new(),
date_of_expiry: String::new(),
optional_data: None,
}
}
}
pub fn format_mrv_b(fields: &MrvBFields) -> String {
let doc_code = field(&fields.document_code, 2);
let issuing = field(&fields.issuing_country, 3);
let name = name_field(&fields.surname, &fields.given_names, 31);
let line1 = format!("{doc_code}{issuing}{name}");
debug_assert_eq!(line1.len(), 36);
let doc_num = field(&fields.document_number, 9);
let doc_num_check = digit_char(&doc_num);
let nationality = field(&fields.nationality, 3);
let dob = field(&fields.date_of_birth, 6);
let dob_check = digit_char(&dob);
let sex = match fields.sex.to_ascii_uppercase().as_str() {
"M" => 'M',
"F" => 'F',
_ => '<',
};
let expiry = field(&fields.date_of_expiry, 6);
let expiry_check = digit_char(&expiry);
let optional = field(fields.optional_data.as_deref().unwrap_or(""), 8);
let line2 = format!(
"{doc_num}{doc_num_check}{nationality}{dob}{dob_check}{sex}{expiry}{expiry_check}{optional}"
);
debug_assert_eq!(line2.len(), 36);
format!("{line1}\n{line2}")
}