use std::fmt;
use std::str::FromStr;
use crate::checksum::char_value;
use crate::dates::{century_for, date_completeness, Date, DateCompleteness};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct RawDateField([u8; 6]);
impl RawDateField {
pub fn as_str(&self) -> &str {
std::str::from_utf8(&self.0).unwrap_or_default()
}
}
impl TryFrom<&str> for RawDateField {
type Error = InvalidRawDateField;
fn try_from(field: &str) -> Result<Self, Self::Error> {
let bytes: [u8; 6] = field
.as_bytes()
.try_into()
.map_err(|_| InvalidRawDateField)?;
if field.chars().all(|c| char_value(c).is_some()) {
Ok(Self(bytes))
} else {
Err(InvalidRawDateField)
}
}
}
impl fmt::Display for RawDateField {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct InvalidRawDateField;
impl fmt::Display for InvalidRawDateField {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("an MRZ date field is exactly six characters of 0-9, A-Z and <")
}
}
impl std::error::Error for InvalidRawDateField {}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum DateRole {
Birth,
Expiry,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum MrzDate {
Calendar(Date),
OutOfCalendar(Date),
PartiallyUnknown(RawDateField),
Unknown,
Malformed(RawDateField),
}
impl MrzDate {
pub fn from_field(field: RawDateField, role: DateRole, pivot_yy: u32) -> MrzDate {
match date_completeness(field.as_str()) {
DateCompleteness::Complete => {
let pair =
|i: usize| u32::from(field.0[i] - b'0') * 10 + u32::from(field.0[i + 1] - b'0');
let yy = pair(0);
let century = century_for(yy, role == DateRole::Birth, pivot_yy);
let date = Date::new(century + yy as i32, pair(2), pair(4));
if date.is_well_formed() {
MrzDate::Calendar(date)
} else {
MrzDate::OutOfCalendar(date)
}
}
DateCompleteness::PartiallyUnknown => MrzDate::PartiallyUnknown(field),
DateCompleteness::Unknown => MrzDate::Unknown,
DateCompleteness::Malformed => MrzDate::Malformed(field),
}
}
pub fn completeness(self) -> DateCompleteness {
match self {
MrzDate::Calendar(_) | MrzDate::OutOfCalendar(_) => DateCompleteness::Complete,
MrzDate::PartiallyUnknown(_) => DateCompleteness::PartiallyUnknown,
MrzDate::Unknown => DateCompleteness::Unknown,
MrzDate::Malformed(_) => DateCompleteness::Malformed,
}
}
pub fn calendar(self) -> Option<Date> {
match self {
MrzDate::Calendar(date) => Some(date),
_ => None,
}
}
}
impl fmt::Display for MrzDate {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
MrzDate::Calendar(d) | MrzDate::OutOfCalendar(d) => {
write!(f, "{:04}-{:02}-{:02}", d.year, d.month, d.day)
}
MrzDate::PartiallyUnknown(raw) | MrzDate::Malformed(raw) => f.write_str(raw.as_str()),
MrzDate::Unknown => f.write_str("<<<<<<"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct ParseMrzDateError;
impl fmt::Display for ParseMrzDateError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(
"an MRZ date is YYYY-MM-DD, or six characters of 0-9, A-Z and < that are not all digits",
)
}
}
impl std::error::Error for ParseMrzDateError {}
impl FromStr for MrzDate {
type Err = ParseMrzDateError;
fn from_str(text: &str) -> Result<Self, Self::Err> {
let b = text.as_bytes();
let iso_shaped = b.len() == 10
&& b[4] == b'-'
&& b[7] == b'-'
&& [0, 1, 2, 3, 5, 6, 8, 9]
.iter()
.all(|&i| b[i].is_ascii_digit());
if iso_shaped {
let number = |range: std::ops::Range<usize>| {
text[range].parse::<u32>().map_err(|_| ParseMrzDateError)
};
let date = Date::new(number(0..4)? as i32, number(5..7)?, number(8..10)?);
return Ok(if date.is_well_formed() {
MrzDate::Calendar(date)
} else {
MrzDate::OutOfCalendar(date)
});
}
let field = RawDateField::try_from(text).map_err(|_| ParseMrzDateError)?;
match date_completeness(field.as_str()) {
DateCompleteness::Complete => Err(ParseMrzDateError),
DateCompleteness::PartiallyUnknown => Ok(MrzDate::PartiallyUnknown(field)),
DateCompleteness::Unknown => Ok(MrzDate::Unknown),
DateCompleteness::Malformed => Ok(MrzDate::Malformed(field)),
}
}
}
#[cfg(feature = "serde")]
#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
impl serde::Serialize for MrzDate {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.collect_str(self)
}
}
#[cfg(feature = "serde")]
#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
impl<'de> serde::Deserialize<'de> for MrzDate {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let text = String::deserialize(deserializer)?;
text.parse().map_err(serde::de::Error::custom)
}
}
#[cfg(feature = "zeroize")]
#[cfg_attr(docsrs, doc(cfg(feature = "zeroize")))]
impl zeroize::Zeroize for RawDateField {
fn zeroize(&mut self) {
self.0.zeroize();
}
}
#[cfg(feature = "zeroize")]
#[cfg_attr(docsrs, doc(cfg(feature = "zeroize")))]
impl zeroize::Zeroize for MrzDate {
fn zeroize(&mut self) {
match self {
MrzDate::Calendar(date) | MrzDate::OutOfCalendar(date) => date.zeroize(),
MrzDate::PartiallyUnknown(raw) | MrzDate::Malformed(raw) => raw.zeroize(),
MrzDate::Unknown => {}
}
}
}