automapper_validation/eval/

format_validators.rs

//! Format validation helpers for AHB 900-series conditions.
//!
//! These validate the FORMAT of data element values (decimal places, numeric ranges,
//! time patterns, ID formats, etc.). They operate on string values extracted from
//! EDIFACT segments and return `ConditionResult`.

use super::evaluator::ConditionResult;

// Re-export timezone helpers so generated code can use `use crate::eval::format_validators::*`
pub use super::timezone::{dst_transitions_between, is_mesz_utc, is_mez_utc, parse_dtm303};
pub use super::werktag::{
    compute_easter, is_german_holiday, is_werktag, parse_ccyymmdd_prefix, werktage_between,
};

// --- Decimal/digit place validation ---

/// Validate that a numeric string has at most `max` decimal places.
///
/// Returns `True` if the value has <= max decimal places (or no decimal point),
/// `False` if it has more, `Unknown` if the value is empty.
///
/// Example: `validate_max_decimal_places("123.45", 2)` → True
/// Example: `validate_max_decimal_places("123.456", 2)` → False
/// Example: `validate_max_decimal_places("123", 2)` → True (no decimal → 0 places)
pub fn validate_max_decimal_places(value: &str, max: usize) -> ConditionResult {
    if value.is_empty() {
        return ConditionResult::Unknown;
    }
    let decimal_places = match value.find('.') {
        Some(pos) => value.len() - pos - 1,
        None => 0,
    };
    ConditionResult::from(decimal_places <= max)
}

/// Validate that a numeric string has at most `max` integer digits (before decimal point).
///
/// Ignores leading minus sign.
pub fn validate_max_integer_digits(value: &str, max: usize) -> ConditionResult {
    if value.is_empty() {
        return ConditionResult::Unknown;
    }
    let s = value.strip_prefix('-').unwrap_or(value);
    let integer_part = match s.find('.') {
        Some(pos) => &s[..pos],
        None => s,
    };
    ConditionResult::from(integer_part.len() <= max)
}

// --- Numeric range validation ---

/// Validate a numeric value against a comparison.
///
/// `op` is one of: "==", "!=", ">", ">=", "<", "<="
/// An EDIFACT number is an optional sign, digits and at most one decimal mark
/// (`.` or `,`, which the UNA may set). Anything else is no possible value and
/// fails (`O5D2DXBG1A` is not "> 0"); only an empty value is `Unknown`.
///
/// Example: `validate_numeric(value, ">=", 0.0)` for "Wert >= 0"
/// Example: `validate_numeric(value, "==", 1.0)` for "Wert = 1"
pub fn validate_numeric(value: &str, op: &str, threshold: f64) -> ConditionResult {
    if value.is_empty() {
        return ConditionResult::Unknown;
    }
    let parsed = match edifact_number(value) {
        Some(v) => v,
        None => return ConditionResult::False,
    };
    let result = match op {
        "==" => (parsed - threshold).abs() < f64::EPSILON,
        "!=" => (parsed - threshold).abs() >= f64::EPSILON,
        ">" => parsed > threshold,
        ">=" => parsed >= threshold,
        "<" => parsed < threshold,
        "<=" => parsed <= threshold,
        _ => return ConditionResult::Unknown,
    };
    ConditionResult::from(result)
}

/// Whether `value` is an EDIFACT number — what a data element of numeric
/// format (`n..10`) may hold: an optional minus sign, at least one digit, and
/// at most one decimal mark (`.` or `,`).
pub fn is_edifact_number(value: &str) -> bool {
    edifact_number(value).is_some()
}

/// `value` as an EDIFACT number: an optional sign, at least one digit, and at
/// most one decimal mark (`.` or `,`). `None` for anything else (`1e3`, `NaN`).
fn edifact_number(value: &str) -> Option<f64> {
    let unsigned = value.strip_prefix('-').unwrap_or(value);
    let mut marks = 0;
    let mut digits = 0;
    for c in unsigned.chars() {
        match c {
            '0'..='9' => digits += 1,
            '.' | ',' => marks += 1,
            _ => return None,
        }
    }
    if digits == 0 || marks > 1 {
        return None;
    }
    value.replace(',', ".").parse().ok()
}

// --- DTM value against its format code ---

/// Whether a DTM value (C507 DE2380) has the shape its format code (DE2379)
/// gives it: `20250401` fits 102 `CCYYMMDD` but not 104 `MMWW-MMWW`, which
/// is two month-and-week pairs (`04010402`). `None` for a format code not
/// known here, which is not judged. Months, days, hours and minutes must be
/// in range; a time zone (303/304) is a sign and two digits.
pub fn fits_date_format(value: &str, format: &str) -> Option<bool> {
    let digits = |s: &str| !s.is_empty() && s.bytes().all(|b| b.is_ascii_digit());
    let num = |s: &str| s.parse::<u32>().unwrap_or(u32::MAX);
    let month = |s: &str| (1..=12).contains(&num(s));
    let day = |s: &str| (1..=31).contains(&num(s));
    let week = |s: &str| (1..=53).contains(&num(s));
    let time = |s: &str| num(&s[..2]) <= 23 && num(&s[2..]) <= 59;
    let date = |s: &str| digits(s) && s.len() == 8 && month(&s[4..6]) && day(&s[6..8]);
    let zone =
        |s: &str| s.is_empty() || (s.len() == 3 && matches!(&s[..1], "+" | "-") && digits(&s[1..]));
    // Every shape is ASCII, and slicing below relies on it.
    if !value.is_ascii() {
        return fits_date_format("", format);
    }
    let fits = match format {
        "102" => date(value),
        "104" => {
            digits(value)
                && value.len() == 8
                && month(&value[..2])
                && week(&value[2..4])
                && month(&value[4..6])
                && week(&value[6..])
        }
        "106" => digits(value) && value.len() == 4 && month(&value[..2]) && day(&value[2..]),
        "203" => value.len() == 12 && date(&value[..8]) && digits(&value[8..]) && time(&value[8..]),
        "303" => {
            value.len() >= 12
                && date(&value[..8])
                && digits(&value[8..12])
                && time(&value[8..12])
                && zone(&value[12..])
        }
        "304" => {
            value.len() >= 14
                && date(&value[..8])
                && digits(&value[8..14])
                && time(&value[8..12])
                && num(&value[12..14]) <= 59
                && zone(&value[14..])
        }
        "401" => digits(value) && value.len() == 4 && time(value),
        "501" => digits(value) && value.len() == 8 && time(&value[..4]) && time(&value[4..]),
        "602" => digits(value) && value.len() == 4,
        "610" => digits(value) && value.len() == 6 && month(&value[4..]),
        "802" | "803" | "804" => digits(value),
        // ZZRB (UTILMD Kündigungsfrist): a number, its unit (Tag, Woche,
        // Monat) and its reference point (Monats-, Quartals-, Halbjahres-,
        // Jahresende, Termin, rollierend): `03MM`.
        "Z01" => {
            let n = value.len().saturating_sub(2);
            (1..=2).contains(&n)
                && digits(&value[..n])
                && matches!(&value[n..n + 1], "T" | "W" | "M")
                && matches!(&value[n + 1..], "M" | "Q" | "H" | "J" | "T" | "R")
        }
        _ => return None,
    };
    Some(fits)
}

// --- DTM time/timezone validation ---

/// Validate that a DTM value's HHMM portion equals the expected value.
///
/// DTM format 303 is CCYYMMDDHHMM (12 chars) or CCYYMMDDHHMMZZZ (15 chars with timezone).
/// Extracts characters at positions 8..12 (HHMM) for comparison.
///
/// Example: `validate_hhmm_equals("202601012200+00", "2200")` → True
pub fn validate_hhmm_equals(dtm_value: &str, expected_hhmm: &str) -> ConditionResult {
    if dtm_value.len() < 12 {
        // Value too short — no HHMM component present, condition is not met
        return ConditionResult::False;
    }
    ConditionResult::from(&dtm_value[8..12] == expected_hhmm)
}

/// Validate that a DTM value's HHMM portion is within a range (inclusive).
///
/// Example: `validate_hhmm_range("202601011530+00", "0000", "2359")` → True
pub fn validate_hhmm_range(dtm_value: &str, min: &str, max: &str) -> ConditionResult {
    if dtm_value.len() < 12 {
        return ConditionResult::False;
    }
    let hhmm = &dtm_value[8..12];
    ConditionResult::from(hhmm >= min && hhmm <= max)
}

/// Validate that a DTM value's MMDDHHMM portion equals the expected value.
///
/// Extracts characters at positions 4..12 for comparison.
///
/// Example: `validate_mmddhhmm_equals("202612312300+00", "12312300")` → True
pub fn validate_mmddhhmm_equals(dtm_value: &str, expected: &str) -> ConditionResult {
    if dtm_value.len() < 12 {
        return ConditionResult::False;
    }
    ConditionResult::from(&dtm_value[4..12] == expected)
}

/// Validate that a DTM value's timezone portion ZZZ is "+00" (UTC).
///
/// The zone is the value's last three characters: format 303
/// `CCYYMMDDHHMMZZZ` (15 chars) and 304 `CCYYMMDDHHMMSSZZZ` (17 chars) both
/// end in it. Reading it at a fixed offset of 12 took 304's seconds for the
/// zone and failed every 304 value.
///
/// Example: `validate_timezone_utc("202601012200+00")` → True
/// Example: `validate_timezone_utc("20260101220000+00")` → True
/// Example: `validate_timezone_utc("202601012200+01")` → False
pub fn validate_timezone_utc(dtm_value: &str) -> ConditionResult {
    if dtm_value.len() < 15 || !dtm_value.is_char_boundary(dtm_value.len() - 3) {
        // Value too short — no timezone suffix present, condition is not met
        return ConditionResult::False;
    }
    ConditionResult::from(&dtm_value[dtm_value.len() - 3..] == "+00")
}

// --- Contact format validation ---

/// Validate email format: must contain both '@' and '.'.
///
/// Example: `validate_email("user@example.com")` → True
pub fn validate_email(value: &str) -> ConditionResult {
    if value.is_empty() {
        return ConditionResult::Unknown;
    }
    ConditionResult::from(value.contains('@') && value.contains('.'))
}

/// Validate phone format: must start with '+' followed by only digits.
///
/// Example: `validate_phone("+4930123456")` → True
/// Example: `validate_phone("030123456")` → False
pub fn validate_phone(value: &str) -> ConditionResult {
    if value.is_empty() {
        return ConditionResult::Unknown;
    }
    if !value.starts_with('+') || value.len() < 2 {
        return ConditionResult::from(false);
    }
    ConditionResult::from(value[1..].chars().all(|c| c.is_ascii_digit()))
}

// --- ID format validation ---

/// Validate Marktlokations-ID (MaLo-ID): exactly 11 digits with BDEW check digit.
///
/// This is **not** standard Luhn — per the BDEW "Anwendungshilfe MaLo-ID v1.0" spec
/// and the Hochfrequenz BO4E-dotnet reference implementation
/// (`BO4E/BO/Marktlokation.cs::GetChecksum`), digits 1–10 are numbered left-to-right
/// (1-based), digits at even positions are multiplied by 2 and **added as the full
/// value** (no digit-sum, no mod-by-9 step), digits at odd positions are added as-is.
/// Check digit = `(10 - (sum mod 10)) mod 10`.
///
/// Example: `"51238696781"` — odd (1,3,5,7,9): 5+2+8+9+7=31; even doubled
/// (2,4,6,8,10): 2*(1+3+6+6+8)=48; sum=79; check = (10-79%10)%10 = 1 ✓.
pub fn validate_malo_id(value: &str) -> ConditionResult {
    if value.len() != 11 {
        return ConditionResult::from(false);
    }
    if !value.chars().all(|c| c.is_ascii_digit()) {
        return ConditionResult::from(false);
    }
    let digits: Vec<u32> = value.chars().filter_map(|c| c.to_digit(10)).collect();
    let check = digits[10];
    let mut sum = 0u32;
    for (i, &d) in digits[..10].iter().enumerate() {
        // 1-based position is i+1; even positions are doubled, odd positions as-is.
        if (i + 1) % 2 == 0 {
            sum += 2 * d;
        } else {
            sum += d;
        }
    }
    let expected = (10 - (sum % 10)) % 10;
    ConditionResult::from(check == expected)
}

/// Validate Transaktionsreferenz-ID (TR-ID): 1-35 alphanumeric characters.
pub fn validate_tr_id(value: &str) -> ConditionResult {
    if value.is_empty() {
        return ConditionResult::Unknown;
    }
    ConditionResult::from(value.len() <= 35 && value.chars().all(|c| c.is_ascii_alphanumeric()))
}

/// A BDEW location ID of the lettered kind: `prefix` followed by ten ASCII
/// uppercase letters or digits (11 characters).
fn validate_prefixed_location_id(value: &str, prefix: char) -> ConditionResult {
    let mut chars = value.chars();
    ConditionResult::from(
        value.len() == 11
            && chars.next() == Some(prefix)
            && chars.all(|c| c.is_ascii_digit() || c.is_ascii_uppercase()),
    )
}

/// Validate Steuerbare-Ressource-ID (SR-ID): "C" + ten alphanumerics
/// (`C816417ST77`).
pub fn validate_sr_id(value: &str) -> ConditionResult {
    validate_prefixed_location_id(value, 'C')
}

/// Validate Netzlokations-ID: "E" + ten alphanumerics (`E1688117482`).
pub fn validate_nelo_id(value: &str) -> ConditionResult {
    validate_prefixed_location_id(value, 'E')
}

// --- OBIS code pattern matching ---

/// Parse an OBIS code of the form `A-B:C.D.E[*F]` and return `(C, D)`.
///
/// OBIS structure (IEC 62056-61, BDEW/DVGW usage):
/// - `A` — medium (1 = electricity, 7 = gas, 6 = heat, …)
/// - `B` — channel
/// - `C` — measurement type (1 = +A active energy import, 2 = -A active energy
///   export, 3 = +R reactive import, 4 = -R reactive export, …)
/// - `D` — measurement mode; for electricity the BDEW "Codeliste der
///   OBIS-Kennzahlen und Medien" (2.5c) uses 6 = Maximum, 8 = Zeitintegral 1
///   (Zählerstände), 9 = Zeitintegral 2 (Vorschübe, "Energiemenge für einen
///   beliebigen Zeitraum") and 29 = Zeitintegral 5 (Lastgang, "Energiemengen
///   für Zeitintervalle von äquidistanter Dauer")
/// - `E` — rate/tariff
/// - `F` — optional billing period marker
///
/// Returns `None` when the value doesn't fit the shape. Whitespace-tolerant.
pub fn parse_obis(value: &str) -> Option<(u32, u32)> {
    let value = value.trim();
    // Split at the colon between `A-B` and `C.D.E`.
    let (_ab, cde) = value.split_once(':')?;
    // Drop optional `*F` suffix.
    let cde = cde.split('*').next()?;
    let mut parts = cde.split('.');
    let c = parts.next()?.parse::<u32>().ok()?;
    let d = parts.next()?.parse::<u32>().ok()?;
    Some((c, d))
}

/// The tariff `E` of an OBIS code `A-B:C.D.E[*F]`; `None` when the value
/// doesn't fit the shape. UTILMD Strom `[391]` names it: "OBIS mit zugeordneter
/// Zählzeit (Tarif: e = 1 .. 62)".
pub fn obis_tariff(value: &str) -> Option<u32> {
    let (_ab, cde) = value.trim().split_once(':')?;
    let cde = cde.split('*').next()?;
    let mut parts = cde.split('.');
    parts.next()?.parse::<u32>().ok()?;
    parts.next()?.parse::<u32>().ok()?;
    parts.next()?.parse::<u32>().ok()
}

/// Is the OBIS code "Wirkarbeit kumuliert" — active energy as a cumulated
/// time integral (total or per billing period)?
///
/// Matches BDEW convention: `C ∈ {1, 2}` (active energy import/export) and
/// `D ∈ {8, 9}` (total time integral / billing-period integral).
pub fn is_obis_wirkarbeit_kumuliert(value: &str) -> bool {
    matches!(parse_obis(value), Some((1 | 2, 8 | 9)))
}

/// Is the OBIS code "Wirkarbeit 1/4 Stunde" — active energy 15-minute
/// interval (Lastgang) measurement?
///
/// Matches the BDEW code list's quarter-hour Lastgang: `C ∈ {1, 2}` (Wirkarbeit
/// Bezug / Lieferung) and `D = 29` (Zeitintegral 5, Lastgang; its example
/// "Vorschub (1/4 Std. Lastgang) elektrische Wirkarbeit" is `1-b:1.29.0`).
pub fn is_obis_wirkarbeit_quarter_hour(value: &str) -> bool {
    matches!(parse_obis(value), Some((1 | 2, 29)))
}

/// Is the electricity OBIS code an "Energiemenge" — a Vorschub (`D = 9`) or a
/// Lastgang (`D = 29`)? The BDEW code list tells "Messwerte (Energiemengen,
/// Zählerstände)" apart: a Zählerstand (`D = 8`) is not one.
pub fn is_obis_energiemenge(value: &str) -> bool {
    value.trim().starts_with("1-") && matches!(parse_obis(value), Some((_, 9 | 29)))
}

/// Is the electricity OBIS code a "Zählerstand" (`D = 8`, Zeitintegral 1)?
pub fn is_obis_zaehlerstand(value: &str) -> bool {
    value.trim().starts_with("1-") && matches!(parse_obis(value), Some((_, 8)))
}

/// Is the OBIS code a Wirkleistung maximum (`C ∈ {1, 2}`, `D = 6`), the code
/// list's "Wirkleistung Bezug (+) / Lieferung (-) Maximum" (`1-b:1.6.0`,
/// `1-b:2.6.0`) — the highest quarter hour's energy of a period?
pub fn is_obis_wirkleistung_maximum(value: &str) -> bool {
    value.trim().starts_with("1-") && matches!(parse_obis(value), Some((1 | 2, 6)))
}

/// Is the electricity OBIS code a Blindarbeit (`C` 3 to 8, reactive energy
/// and its quadrants) as a Zählerstand, Vorschub or Lastgang (`D ∈ {8, 9, 29}`)?
pub fn is_obis_blindarbeit(value: &str) -> bool {
    value.trim().starts_with("1-") && matches!(parse_obis(value), Some((3..=8, 8 | 9 | 29)))
}

/// Whether the OBIS code names a Zählzeit: tariff `e = 1 … 62` ("OBIS mit
/// zugeordneter Zählzeit"); `0` is "tariflos".
pub fn obis_has_zaehlzeit(value: &str) -> bool {
    obis_tariff(value).is_some_and(|e| (1..=62).contains(&e))
}

/// Is the OBIS code an energy register, `1-b:c.8.e` with `c` 1 to 8?
///
/// UTILMD Strom `[273]` lists exactly these: "1-b?:1.8.e / 1-b?:2.8.e / … /
/// 1-b?:8.8.e / 1-b?:1.8.63" (1.8.63 is a 1.8.e). A load profile
/// (`1-1:1.29.0`) or a register of another medium (`7-…`) is not one.
pub fn is_energy_register_obis(value: &str) -> bool {
    value.trim().starts_with("1-") && matches!(parse_obis(value), Some((1..=8, 8)))
}

/// Validate an X.509 certificate body per BSI TR-03109-4.
///
/// In EDIFACT messages (e.g. ORDERS/REQOTE for Smartmeter gateway config) the
/// certificate body is transmitted as base64-encoded DER — the PEM armoring
/// (`-----BEGIN CERTIFICATE-----` / `-----END CERTIFICATE-----` lines) may or
/// may not be present depending on the profile.
///
/// This validator performs a structural check only:
/// - non-empty
/// - composed exclusively of base64 characters (`A-Za-z0-9+/=`) plus
///   whitespace (`\n\r\t` and space — PEM lines wrap at 64 chars)
/// - decoded length plausible for a DER-encoded X.509 certificate (we allow a
///   loose lower bound — a minimal self-signed cert is ~400 bytes, so the
///   base64 form is ≥ ~540 chars; we use 100 as a sanity floor)
///
/// Cryptographic validation (signature, CA chain, TR-03109 certificate
/// extensions) is out of scope for static AHB validation — those require a
/// trust store and runtime context.
pub fn validate_x509_cert_body(value: &str) -> ConditionResult {
    let trimmed = value.trim();
    if trimmed.is_empty() {
        return ConditionResult::Unknown;
    }
    // Strip optional PEM armoring so the charset check operates on the
    // encoded body alone.
    let body = trimmed
        .trim_start_matches("-----BEGIN CERTIFICATE-----")
        .trim_end_matches("-----END CERTIFICATE-----")
        .trim();
    let chars_ok = body.chars().all(|c| {
        c.is_ascii_alphanumeric() || matches!(c, '+' | '/' | '=' | '\n' | '\r' | '\t' | ' ')
    });
    // Minimum plausible length for a base64-encoded X.509 body. Shorter
    // values are almost certainly not a real certificate.
    let len_ok = body.chars().filter(|c| !c.is_whitespace()).count() >= 100;
    ConditionResult::from(chars_ok && len_ok)
}

/// Validate Zahlpunktbezeichnung: exactly 33 alphanumeric characters.
pub fn validate_zahlpunkt(value: &str) -> ConditionResult {
    if value.len() != 33 {
        return ConditionResult::from(false);
    }
    ConditionResult::from(value.chars().all(|c| c.is_ascii_alphanumeric()))
}

/// Validate either MaLo-ID or Zahlpunktbezeichnung format.
pub fn validate_malo_or_zahlpunkt(value: &str) -> ConditionResult {
    if value.len() == 11 && validate_malo_id(value).is_true() {
        return ConditionResult::True;
    }
    if value.len() == 33 && validate_zahlpunkt(value).is_true() {
        return ConditionResult::True;
    }
    ConditionResult::False
}

// --- Artikelnummer pattern validation ---

/// Validate a dash-separated digit pattern like "n1-n2-n1-n3".
///
/// `segment_lengths` defines expected digit counts per dash-separated segment.
///
/// Example: `validate_artikel_pattern("1-23-4-567", &[1, 2, 1, 3])` → True
/// Example: `validate_artikel_pattern("1-23-4", &[1, 2, 1])` → True
pub fn validate_artikel_pattern(value: &str, segment_lengths: &[usize]) -> ConditionResult {
    if value.is_empty() {
        return ConditionResult::Unknown;
    }
    let parts: Vec<&str> = value.split('-').collect();
    if parts.len() != segment_lengths.len() {
        return ConditionResult::from(false);
    }
    let valid = parts
        .iter()
        .zip(segment_lengths.iter())
        .all(|(part, &expected_len)| {
            part.len() == expected_len && part.chars().all(|c| c.is_ascii_digit())
        });
    ConditionResult::from(valid)
}

// --- General string validation ---

/// Validate exact character length.
pub fn validate_exact_length(value: &str, expected: usize) -> ConditionResult {
    if value.is_empty() {
        return ConditionResult::Unknown;
    }
    ConditionResult::from(value.len() == expected)
}

/// Validate maximum character length.
pub fn validate_max_length(value: &str, max: usize) -> ConditionResult {
    if value.is_empty() {
        return ConditionResult::Unknown;
    }
    ConditionResult::from(value.len() <= max)
}

/// Validate that a string contains only digits (positive integer check).
pub fn validate_all_digits(value: &str) -> ConditionResult {
    if value.is_empty() {
        return ConditionResult::Unknown;
    }
    ConditionResult::from(value.chars().all(|c| c.is_ascii_digit()))
}

/// Current UTC date+time as a CCYYMMDDHHMM string (12 chars).
pub fn utc_now_ccyymmddhhmm() -> String {
    chrono::Utc::now().format("%Y%m%d%H%M").to_string()
}

/// A DTM format 303 value (`CCYYMMDDHHMMZZZ`, `202610312300+00`) as German
/// local time: CET, or CEST from the last Sunday of March to the last Sunday of
/// October (01:00 UTC each). `None` if it is no such value.
///
/// "0 Uhr gem. deutscher Zeit" (UTILMD [87]) is `…2300+00` in winter and
/// `…2200+00` in summer; the digits alone never show midnight.
pub fn german_local_time(value: &str) -> Option<chrono::NaiveDateTime> {
    use chrono::{Datelike, Duration, NaiveDate, NaiveDateTime, Weekday};
    let value = value.replace('?', "");
    let stamp = NaiveDateTime::parse_from_str(value.get(..12)?, "%Y%m%d%H%M").ok()?;
    let offset: i64 = match value.get(12..) {
        None | Some("") => 0,
        Some(zone) => zone.parse().ok()?,
    };
    let utc = stamp - Duration::hours(offset);
    let switch = |month: u32| {
        let mut day = NaiveDate::from_ymd_opt(utc.year(), month, 31)?;
        while day.weekday() != Weekday::Sun {
            day = day.pred_opt()?;
        }
        day.and_hms_opt(1, 0, 0)
    };
    let summer = utc >= switch(3)? && utc < switch(10)?;
    Some(utc + Duration::hours(if summer { 2 } else { 1 }))
}

#[cfg(test)]
mod tests {

    #[test]
    fn date_values_follow_their_format_code() {
        assert_eq!(fits_date_format("20250401", "102"), Some(true));
        assert_eq!(fits_date_format("20250401", "104"), Some(false));
        assert_eq!(fits_date_format("04010402", "104"), Some(true));
        assert_eq!(fits_date_format("20250401", "106"), Some(false));
        assert_eq!(fits_date_format("0401", "106"), Some(true));
        assert_eq!(fits_date_format("202503312200+00", "303"), Some(true));
        assert_eq!(fits_date_format("202503312200", "303"), Some(true));
        assert_eq!(fits_date_format("20250331", "303"), Some(false));
        assert_eq!(fits_date_format("20250331220000+00", "304"), Some(true));
        assert_eq!(fits_date_format("2025", "602"), Some(true));
        assert_eq!(fits_date_format("202513", "610"), Some(false));
        assert_eq!(fits_date_format("12", "802"), Some(true));
        assert_eq!(fits_date_format("06002200", "501"), Some(true));
        assert_eq!(fits_date_format("03MM", "Z01"), Some(true));
        assert_eq!(fits_date_format("20250401", "Z01"), Some(false));
        assert_eq!(fits_date_format("x", "999"), None);
        assert_eq!(fits_date_format("ä", "999"), None);
        assert_eq!(fits_date_format("2025040ä", "102"), Some(false));
    }

    /// The classes the BDEW "Codeliste der OBIS-Kennzahlen und Medien" 2.5c
    /// defines, on codes it lists.
    #[test]
    fn obis_classes_follow_the_code_list() {
        use super::*;
        // Zählerstand, Vorschub, Lastgang of Wirkarbeit Bezug.
        assert!(is_obis_zaehlerstand("1-1:1.8.0") && !is_obis_energiemenge("1-1:1.8.0"));
        assert!(is_obis_energiemenge("1-1:1.9.0") && !is_obis_zaehlerstand("1-1:1.9.0"));
        assert!(
            is_obis_energiemenge("1-1:1.29.0") && is_obis_wirkarbeit_quarter_hour("1-1:1.29.0")
        );
        assert!(!is_obis_wirkarbeit_quarter_hour("1-1:1.9.0"));
        // Wirkleistung Maximum, Blindarbeit.
        assert!(is_obis_wirkleistung_maximum("1-1:2.6.0"));
        assert!(!is_obis_wirkleistung_maximum("1-1:3.6.0"));
        assert!(is_obis_blindarbeit("1-1:3.9.0") && is_obis_blindarbeit("1-1:4.29.0"));
        assert!(!is_obis_blindarbeit("1-1:1.8.0"));
        // Tarif e = 1 … 62 names a Zählzeit, 0 is tariflos.
        assert!(obis_has_zaehlzeit("1-1:1.9.1") && obis_has_zaehlzeit("1-1:1.8.62"));
        assert!(!obis_has_zaehlzeit("1-1:1.9.0") && !obis_has_zaehlzeit("1-1:1.8.63"));
        // Gas is not electricity.
        assert!(!is_obis_energiemenge("7-0:3.9.0"));
    }

    #[test]
    fn the_tariff_is_the_e_of_c_d_e() {
        use super::obis_tariff;
        assert_eq!(obis_tariff("1-1:1.8.1"), Some(1));
        assert_eq!(obis_tariff("1-0:2.8.62*255"), Some(62));
        assert_eq!(obis_tariff("1-0:1.8.0"), Some(0));
        assert_eq!(obis_tariff("1-0:1.8"), None);
        assert_eq!(obis_tariff("x"), None);
    }

    #[test]
    fn energy_registers_are_c_8_e_with_c_one_to_eight() {
        use super::is_energy_register_obis;
        for obis in [
            "1-1:1.8.0",
            "1-0:2.8.1",
            "1-1:8.8.0",
            "1-1:1.8.63",
            "1-65:3.8.2",
        ] {
            assert!(is_energy_register_obis(obis), "{obis}");
        }
        for obis in [
            "1-1:1.29.0",
            "1-1:2.29.0",
            "1-1:9.8.0",
            "7-0:3.0.0",
            "1-1:1.9.0",
            "x",
        ] {
            assert!(!is_energy_register_obis(obis), "{obis}");
        }
    }

    use super::*;

    // --- Decimal places ---

    #[test]
    fn test_max_decimal_places() {
        assert_eq!(
            validate_max_decimal_places("123.45", 2),
            ConditionResult::True
        );
        assert_eq!(
            validate_max_decimal_places("123.456", 2),
            ConditionResult::False
        );
        assert_eq!(validate_max_decimal_places("123", 2), ConditionResult::True);
        assert_eq!(validate_max_decimal_places("0.1", 3), ConditionResult::True);
        assert_eq!(validate_max_decimal_places("", 2), ConditionResult::Unknown);
    }

    #[test]
    fn test_no_decimal_places() {
        assert_eq!(validate_max_decimal_places("100", 0), ConditionResult::True);
        assert_eq!(
            validate_max_decimal_places("100.5", 0),
            ConditionResult::False
        );
    }

    #[test]
    fn test_max_integer_digits() {
        assert_eq!(
            validate_max_integer_digits("1234", 4),
            ConditionResult::True
        );
        assert_eq!(
            validate_max_integer_digits("12345", 4),
            ConditionResult::False
        );
        assert_eq!(
            validate_max_integer_digits("-123.45", 4),
            ConditionResult::True
        );
        assert_eq!(validate_max_integer_digits("", 4), ConditionResult::Unknown);
    }

    // --- Numeric range ---

    #[test]
    fn test_validate_numeric() {
        assert_eq!(validate_numeric("5.0", ">=", 0.0), ConditionResult::True);
        assert_eq!(validate_numeric("-1.0", ">=", 0.0), ConditionResult::False);
        assert_eq!(validate_numeric("1", "==", 1.0), ConditionResult::True);
        assert_eq!(validate_numeric("2", "==", 1.0), ConditionResult::False);
        assert_eq!(validate_numeric("0", ">", 0.0), ConditionResult::False);
        assert_eq!(validate_numeric("1", ">", 0.0), ConditionResult::True);
        // Not a number is no "möglicher Wert" (mako-twin: RFF+Z60
        // `O5D2DXBG1A` passed `[914]` "> 0").
        assert_eq!(validate_numeric("abc", ">=", 0.0), ConditionResult::False);
        assert_eq!(
            validate_numeric("O5D2DXBG1A", ">", 0.0),
            ConditionResult::False
        );
        assert_eq!(validate_numeric("NaN", ">", 0.0), ConditionResult::False);
        assert_eq!(validate_numeric("inf", ">", 0.0), ConditionResult::False);
        assert_eq!(validate_numeric("1e3", ">", 0.0), ConditionResult::False);
        // A comma is a decimal mark the UNA may set.
        assert_eq!(validate_numeric("0,5", ">", 0.0), ConditionResult::True);
        assert_eq!(validate_numeric("-2", "<=", 0.0), ConditionResult::True);
        assert_eq!(validate_numeric("", ">", 0.0), ConditionResult::Unknown);
    }

    // --- DTM validation ---

    #[test]
    fn test_hhmm_equals() {
        assert_eq!(
            validate_hhmm_equals("202601012200+00", "2200"),
            ConditionResult::True
        );
        assert_eq!(
            validate_hhmm_equals("202601012300+00", "2200"),
            ConditionResult::False
        );
        assert_eq!(
            validate_hhmm_equals("short", "2200"),
            ConditionResult::False
        );
    }

    #[test]
    fn test_hhmm_range() {
        assert_eq!(
            validate_hhmm_range("202601011530+00", "0000", "2359"),
            ConditionResult::True
        );
        assert_eq!(
            validate_hhmm_range("202601010000+00", "0000", "2359"),
            ConditionResult::True
        );
        assert_eq!(
            validate_hhmm_range("202601012359+00", "0000", "2359"),
            ConditionResult::True
        );
    }

    #[test]
    fn test_mmddhhmm_equals() {
        assert_eq!(
            validate_mmddhhmm_equals("202612312300+00", "12312300"),
            ConditionResult::True
        );
        assert_eq!(
            validate_mmddhhmm_equals("202601012200+00", "12312300"),
            ConditionResult::False
        );
    }

    #[test]
    fn test_timezone_utc() {
        assert_eq!(
            validate_timezone_utc("202601012200+00"),
            ConditionResult::True
        );
        assert_eq!(
            validate_timezone_utc("202601012200+01"),
            ConditionResult::False
        );
        assert_eq!(
            validate_timezone_utc("202601012200"),
            ConditionResult::False
        );
        // Format 304 carries seconds before the zone.
        assert_eq!(
            validate_timezone_utc("20260101220000+00"),
            ConditionResult::True
        );
        assert_eq!(
            validate_timezone_utc("20260101220000+01"),
            ConditionResult::False
        );
    }

    // --- Contact validation ---

    #[test]
    fn test_email() {
        assert_eq!(validate_email("user@example.com"), ConditionResult::True);
        assert_eq!(validate_email("nope"), ConditionResult::False);
        assert_eq!(validate_email("has@but-no-dot"), ConditionResult::False);
        assert_eq!(validate_email(""), ConditionResult::Unknown);
    }

    #[test]
    fn test_phone() {
        assert_eq!(validate_phone("+4930123456"), ConditionResult::True);
        assert_eq!(validate_phone("030123456"), ConditionResult::False);
        assert_eq!(validate_phone("+"), ConditionResult::False);
        assert_eq!(validate_phone("+49 30 123"), ConditionResult::False); // spaces not allowed
        assert_eq!(validate_phone(""), ConditionResult::Unknown);
    }

    // --- ID validation ---

    #[test]
    fn test_malo_id() {
        // Valid MaLo-IDs — taken directly from the BO4E-dotnet reference test
        // suite (TestBO4E/TestMaLoMeLoId.cs), which uses the BDEW MaLo-ID spec
        // (no digit-sum on doubled products; see `validate_malo_id` docstring).
        assert_eq!(validate_malo_id("51238696781"), ConditionResult::True);
        assert_eq!(validate_malo_id("41373559241"), ConditionResult::True);
        assert_eq!(validate_malo_id("56789012345"), ConditionResult::True);
        assert_eq!(validate_malo_id("52935155442"), ConditionResult::True);

        // Negative cases from the same reference tests.
        assert_eq!(validate_malo_id("41373559240"), ConditionResult::False); // wrong check digit
        assert_eq!(validate_malo_id("512386967890"), ConditionResult::False); // 12 digits
        assert_eq!(validate_malo_id("1234567890"), ConditionResult::False); // too short
        assert_eq!(validate_malo_id("abcdefghijk"), ConditionResult::False); // not digits
    }

    #[test]
    fn test_zahlpunkt() {
        let valid = "DE0001234567890123456789012345678";
        assert_eq!(valid.len(), 33);
        assert_eq!(validate_zahlpunkt(valid), ConditionResult::True);
        assert_eq!(validate_zahlpunkt("tooshort"), ConditionResult::False);
    }

    // --- Artikelnummer pattern ---

    #[test]
    fn test_artikel_pattern() {
        assert_eq!(
            validate_artikel_pattern("1-23-4", &[1, 2, 1]),
            ConditionResult::True
        );
        assert_eq!(
            validate_artikel_pattern("1-23-4-567", &[1, 2, 1, 3]),
            ConditionResult::True
        );
        assert_eq!(
            validate_artikel_pattern("1-23-4-56", &[1, 2, 1, 3]),
            ConditionResult::False
        );
        assert_eq!(
            validate_artikel_pattern("1-AB-4", &[1, 2, 1]),
            ConditionResult::False
        );
        assert_eq!(
            validate_artikel_pattern("", &[1, 2, 1]),
            ConditionResult::Unknown
        );
    }

    // --- TR-ID / SR-ID validation ---

    #[test]
    fn test_tr_id() {
        assert_eq!(validate_tr_id("ABC123"), ConditionResult::True);
        assert_eq!(validate_tr_id("A"), ConditionResult::True);
        assert_eq!(validate_tr_id(&"A".repeat(35)), ConditionResult::True);
        assert_eq!(validate_tr_id(&"A".repeat(36)), ConditionResult::False);
        assert_eq!(validate_tr_id("has spaces"), ConditionResult::False);
        assert_eq!(validate_tr_id("has-dash"), ConditionResult::False);
        assert_eq!(validate_tr_id(""), ConditionResult::Unknown);
    }

    #[test]
    fn test_parse_obis() {
        assert_eq!(parse_obis("1-1:1.8.0"), Some((1, 8)));
        assert_eq!(parse_obis("1-1:2.29.0"), Some((2, 29)));
        assert_eq!(parse_obis("1-0:1.8.0*255"), Some((1, 8))); // star suffix
        assert_eq!(parse_obis(" 1-1:1.8.0 "), Some((1, 8))); // whitespace
        assert_eq!(parse_obis("no-colon"), None);
        assert_eq!(parse_obis("1-1:abc.8.0"), None);
        assert_eq!(parse_obis(""), None);
    }

    #[test]
    fn test_obis_wirkarbeit_kumuliert() {
        // Active energy import/export, total or billing-period integral.
        assert!(is_obis_wirkarbeit_kumuliert("1-1:1.8.0"));
        assert!(is_obis_wirkarbeit_kumuliert("1-1:2.8.0"));
        assert!(is_obis_wirkarbeit_kumuliert("1-1:1.9.0"));
        assert!(is_obis_wirkarbeit_kumuliert("1-1:2.9.0"));
        assert!(is_obis_wirkarbeit_kumuliert("1-0:1.8.0*255"));
        // Reactive energy — not Wirkarbeit.
        assert!(!is_obis_wirkarbeit_kumuliert("1-1:3.8.0"));
        assert!(!is_obis_wirkarbeit_kumuliert("1-1:4.8.0"));
        // 15-min partial value — not kumuliert.
        assert!(!is_obis_wirkarbeit_kumuliert("1-1:1.29.0"));
        // Actual value — not kumuliert.
        assert!(!is_obis_wirkarbeit_kumuliert("1-1:1.5.0"));
    }

    #[test]
    fn test_obis_wirkarbeit_quarter_hour() {
        // Active energy 15-min Lastgang.
        assert!(is_obis_wirkarbeit_quarter_hour("1-1:1.29.0"));
        assert!(is_obis_wirkarbeit_quarter_hour("1-1:2.29.0"));
        assert!(is_obis_wirkarbeit_quarter_hour("1-0:1.29.0*255"));
        // Cumulated — not 1/4h.
        assert!(!is_obis_wirkarbeit_quarter_hour("1-1:1.8.0"));
        assert!(!is_obis_wirkarbeit_quarter_hour("1-1:1.9.0"));
        // Reactive.
        assert!(!is_obis_wirkarbeit_quarter_hour("1-1:3.29.0"));
    }

    #[test]
    fn test_x509_cert_body() {
        // Valid: 600-char base64 body (well above 100-char floor).
        let body = "A".repeat(600);
        assert_eq!(validate_x509_cert_body(&body), ConditionResult::True);

        // Valid with base64 padding and newlines (PEM-style wrapping).
        let pem_body = "A".repeat(64) + "\n" + &"B".repeat(64) + "\n" + &"C".repeat(64);
        assert_eq!(validate_x509_cert_body(&pem_body), ConditionResult::True);

        // Valid with explicit PEM armoring — stripped before charset check.
        let armored = format!(
            "-----BEGIN CERTIFICATE-----\n{}\n-----END CERTIFICATE-----",
            "A".repeat(200)
        );
        assert_eq!(validate_x509_cert_body(&armored), ConditionResult::True);

        // Valid: base64 chars include +, /, =
        let with_punct = "AB+/==".to_string() + &"A".repeat(200);
        assert_eq!(validate_x509_cert_body(&with_punct), ConditionResult::True);

        // Too short — not a plausible cert.
        assert_eq!(validate_x509_cert_body("QUJD"), ConditionResult::False);

        // Non-base64 characters.
        let invalid_chars = "A".repeat(200) + "!@#";
        assert_eq!(
            validate_x509_cert_body(&invalid_chars),
            ConditionResult::False
        );

        // Empty is Unknown (consistent with other format validators).
        assert_eq!(validate_x509_cert_body(""), ConditionResult::Unknown);
        assert_eq!(validate_x509_cert_body("   \n  "), ConditionResult::Unknown);
    }

    /// SR-IDs are "C" + ten alphanumerics, not MaLo-shaped: every SR-ID in
    /// `example_market_communication_bo4e_transactions/` looks like this
    /// (`LOC+Z19+C816417ST77`), and a MaLo-ID check rejected all of them.
    #[test]
    fn test_sr_id() {
        for real in ["C816417ST77", "CZZ6M5DGSS5", "COPFWS2EX96"] {
            assert_eq!(validate_sr_id(real), ConditionResult::True, "{real}");
        }
        assert_eq!(
            validate_sr_id("51238696781"),
            ConditionResult::False,
            "a MaLo-ID"
        );
        assert_eq!(validate_sr_id("C12345"), ConditionResult::False);
        assert_eq!(validate_sr_id(""), ConditionResult::False);
    }

    /// Netzlokations-IDs are "E" + ten alphanumerics (`LOC+Z18+E1688117482`,
    /// `EU5UQAWW8D0` in the example transactions). The generated evaluators
    /// checked them as MaLo-IDs, so every real one failed `[960]`.
    #[test]
    fn test_nelo_id() {
        for real in ["E1688117482", "EU5UQAWW8D0", "EEW7TM7V906"] {
            assert_eq!(validate_nelo_id(real), ConditionResult::True, "{real}");
        }
        assert_eq!(
            validate_nelo_id("51238696781"),
            ConditionResult::False,
            "a MaLo-ID"
        );
        assert_eq!(validate_nelo_id("E123"), ConditionResult::False);
        assert_eq!(validate_nelo_id("e1688117482"), ConditionResult::False);
    }

    // --- String validation ---

    #[test]
    fn test_exact_length() {
        assert_eq!(
            validate_exact_length("1234567890123456", 16),
            ConditionResult::True
        );
        assert_eq!(validate_exact_length("123", 16), ConditionResult::False);
        assert_eq!(validate_exact_length("", 16), ConditionResult::Unknown);
    }

    #[test]
    fn test_all_digits() {
        assert_eq!(validate_all_digits("12345"), ConditionResult::True);
        assert_eq!(validate_all_digits("123a5"), ConditionResult::False);
        assert_eq!(validate_all_digits(""), ConditionResult::Unknown);
    }
}