mig_bo4e/

model.rs

//! Output model types for the MIG-driven mapping pipeline.
//!
//! Public types `Interchange`, `Nachricht`, `DynamicInterchange`, `DynamicNachricht`,
//! `Interchangedaten`, `Nachrichtendaten` are re-exported from `bo4e-edifact-types`.
//!
//! Internal engine types `MappedMessage` and `MappedTransaktion` carry forward-mapping
//! results including `nesting_info` metadata that is not part of the public API.

use mig_assembly::assembler::AssembledSegment;
use mig_types::segment::OwnedSegment;
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, HashMap};

// Re-export public model types from bo4e-edifact-types
pub use bo4e_edifact_types::{
    is_wrapped_transaktion, DynamicInterchange, DynamicNachricht, DynamicTransaktion, Interchange,
    Interchangedaten, Nachricht, Nachrichtendaten, Transaktion, Uebermittlungsabschnitt,
};

/// Internal engine type for a forward-mapped transaction.
///
/// Contains all BO4E entities (including prozessdaten) in `stammdaten`,
/// plus nesting distribution info used by the reverse mapper.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MappedTransaktion {
    /// The business objects this transaction is about.
    /// Keys are entity names in camelCase (e.g. "marktlokation", "messlokation").
    pub stammdaten: serde_json::Value,

    /// Metadata about the transaction itself — the `Prozessdaten` entity,
    /// split out of `stammdaten` on the way out and merged back on the way in.
    ///
    /// This is the `transaktionsdaten` half of the BO4E market-communication
    /// shape. It is metadata, not a business object, so it does not belong
    /// among the BOs. Null when a transaction carries no process data.
    #[serde(default, skip_serializing_if = "serde_json::Value::is_null")]
    pub transaktionsdaten: serde_json::Value,

    /// Nesting distribution info for transaction-level entities.
    ///
    /// Maps entity key (camelCase) -> parent rep index for each child element.
    /// Used by the reverse mapper to distribute children among parent group reps
    /// within a transaction (e.g., SG36->SG40 in PRICAT).
    /// Derived from the tree structure during forward mapping; never serialized.
    #[serde(skip)]
    pub nesting_info: HashMap<String, Vec<usize>>,
}

/// Intermediate result from mapping a single message's assembled tree.
///
/// Contains message-level stammdaten and per-transaction results.
/// Used by `MappingEngine::map_interchange()` before wrapping into `Nachricht`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MappedMessage {
    /// Message-level BO4E entities (e.g. Marktteilnehmer from SG2).
    pub stammdaten: serde_json::Value,

    /// The `Nachricht` entity, split out of `stammdaten` on the way out.
    ///
    /// Engine-internal: [`MappedMessage::into_dynamic_nachricht`] folds it into
    /// [`Nachrichtendaten`], the message's one metadata slot. Deliberately not
    /// named `transaktionsdaten` — there is no transaction at message level.
    #[serde(default, skip_serializing_if = "serde_json::Value::is_null")]
    pub nachricht_meta: serde_json::Value,

    /// Per-transaction results (one per SG4 instance).
    pub transaktionen: Vec<MappedTransaktion>,

    /// Nesting distribution info for message-level entities.
    ///
    /// Maps entity key (camelCase) -> parent rep index for each child element.
    /// Used by the reverse mapper to distribute children among parent group reps.
    /// Derived from the tree structure during forward mapping; never serialized.
    #[serde(skip)]
    pub nesting_info: HashMap<String, Vec<usize>>,

    /// Inter-group segments captured by the assembler at message scope.
    ///
    /// Contains both schema-recognized root segments emitted between groups
    /// (e.g. UNS+S in MSCONS / ORDERS) and PID-foreign segments preserved by
    /// `skip_unknown_segments` mode (e.g. IMD in QUOTES 15005). Threaded
    /// through MappedMessage so that `map_interchange_reverse` can hand
    /// them back to the disassembler for byte-identical roundtrip — without
    /// this, BO4E forward + reverse drops anything not represented in a
    /// TOML mapping definition.
    #[serde(skip)]
    pub inter_group_segments: BTreeMap<usize, Vec<AssembledSegment>>,
}

impl MappedMessage {
    /// Convert this internal engine result into a public `DynamicNachricht`.
    ///
    /// Each `MappedTransaktion.stammdaten` becomes a transaction entry in the
    /// `DynamicNachricht.transaktionen` Vec.
    pub fn into_dynamic_nachricht(self, nachrichtendaten: Nachrichtendaten) -> DynamicNachricht {
        // Fold the message's `Nachricht` entity into its metadata slot. Moved,
        // not deserialized: a fallible conversion here could only fail by
        // dropping fields, and this is the public shape.
        let mut nachrichtendaten = nachrichtendaten;
        if let serde_json::Value::Object(fields) = self.nachricht_meta {
            nachrichtendaten.nachricht = fields;
        }

        Nachricht {
            nachrichtendaten,
            stammdaten: self.stammdaten,
            transaktionen: self
                .transaktionen
                .into_iter()
                .map(|t| Transaktion {
                    transaktionsdaten: t.transaktionsdaten,
                    stammdaten: t.stammdaten,
                })
                .collect(),
        }
    }
}

/// The entity key holding per-transaction process metadata.
///
/// Split out of `stammdaten` into `transaktionsdaten` on the way out and merged
/// back on the way in, so the reverse mapper keeps seeing the single flat entity
/// map it resolves definitions against. Naming it once here keeps the forward
/// split and the reverse merge from drifting apart.
pub const TX_METADATA_ENTITY: &str = "prozessdaten";

/// The entity key holding message-level document metadata.
pub const MSG_METADATA_ENTITY: &str = "nachricht";

/// Move `key` out of `from` and return it, leaving `from` without that key.
pub fn take_entity(from: &mut serde_json::Value, key: &str) -> serde_json::Value {
    from.as_object_mut()
        .and_then(|m| m.remove(key))
        .unwrap_or(serde_json::Value::Null)
}

/// Put `value` back under `key` — the inverse of [`take_entity`].
///
/// A no-op for a null value, so a message that never had the entity does not
/// gain an empty key on the way back.
pub fn restore_entity(into: &mut serde_json::Value, key: &str, value: &serde_json::Value) {
    if value.is_null() {
        return;
    }
    if let Some(m) = into.as_object_mut() {
        m.insert(key.to_string(), value.clone());
    }
}

/// Put the message's metadata entity back into `msg_stammdaten` for the reverse.
///
/// The forward pass moves `Nachricht` out of `stammdaten` and into
/// [`Nachrichtendaten`]. The reverse resolves definitions against a flat entity
/// map, so a caller holding a whole message must hand the entity back before
/// mapping or the BGM/DTM segments it feeds cannot be rebuilt.
pub fn restore_message_metadata(msg_stammdaten: &mut serde_json::Value, nd: &Nachrichtendaten) {
    if nd.nachricht.is_empty() {
        return;
    }
    let value = serde_json::Value::Object(nd.nachricht.clone());
    restore_entity(msg_stammdaten, MSG_METADATA_ENTITY, &value);
}

/// Extract message reference and message type from a UNH segment.
pub fn extract_unh_fields(unh: &OwnedSegment) -> (String, String) {
    let referenz = unh.get_element(0).to_string();
    let typ = unh.get_component(1, 0).to_string();
    (referenz, typ)
}

/// Read the whole UNH into the message's metadata slot.
///
/// [`extract_unh_fields`] reads the two elements the pipeline has always
/// needed — 0062 and S009/0065. The rest of the segment was dropped: 0068
/// (Allgemeine Zuordnungs-Referenz) and the S010 pair that says which
/// transmission of a split message this is. Fifty-three Pruefidentifikatoren
/// require one of those, so a message that lost them no longer satisfied its
/// own guide once it had been through BO4E (issue #166).
pub fn extract_message_header(unh: &OwnedSegment) -> Nachrichtendaten {
    let (unh_referenz, nachrichten_typ) = extract_unh_fields(unh);
    let non_empty = |s: &str| (!s.is_empty()).then(|| s.to_string());
    Nachrichtendaten {
        unh_referenz,
        nachrichten_typ,
        zuordnungsreferenz: non_empty(unh.get_element(2)),
        uebermittlungsfolgenummer: non_empty(unh.get_component(3, 0)),
        uebermittlungsabschnitt: Uebermittlungsabschnitt::from_code(unh.get_component(3, 1)),
        nachricht: Default::default(),
    }
}

/// Extract typed interchange-level metadata from envelope segments (UNB).
pub fn extract_interchangedaten(envelope: &[OwnedSegment]) -> Interchangedaten {
    let mut result = Interchangedaten::default();

    for seg in envelope {
        if seg.is("UNB") {
            let val = |s: &str| {
                if s.is_empty() {
                    None
                } else {
                    Some(s.to_string())
                }
            };
            result.syntax_kennung = val(seg.get_component(0, 0));
            result.absender_code = val(seg.get_component(1, 0));
            result.empfaenger_code = val(seg.get_component(2, 0));
            result.datum = val(seg.get_component(3, 0));
            result.zeit = val(seg.get_component(3, 1));
            result.interchange_ref = val(seg.get_element(4));
        }
    }

    result
}

/// Extract interchange-level metadata from envelope segments (UNB) as JSON.
///
/// Kept for backward compatibility. Prefer `extract_interchangedaten()` for typed access.
pub fn extract_nachrichtendaten(envelope: &[OwnedSegment]) -> serde_json::Value {
    let data = extract_interchangedaten(envelope);
    serde_json::to_value(&data).unwrap_or_default()
}

/// Normalize a date string to UNB S004 YYMMDD format (6 digits).
///
/// UNB with UNOC:3 syntax uses YYMMDD (6 digits), not CCYYMMDD (8 digits).
/// If an 8-digit CCYYMMDD date is provided, the century prefix is stripped.
fn normalize_unb_datum(datum: &str) -> &str {
    if datum.len() == 8 && datum.as_bytes().iter().all(|b| b.is_ascii_digit()) {
        &datum[2..]
    } else {
        datum
    }
}

/// Rebuild a UNB (interchange header) segment from typed `Interchangedaten`.
///
/// This is the inverse of `extract_interchangedaten()`.
/// Fields not present get sensible defaults (UNOC:3, "500" qualifier).
/// Dates in CCYYMMDD (8-digit) format are automatically normalized to YYMMDD (6-digit).
pub fn rebuild_unb_from_interchangedaten(data: &Interchangedaten) -> OwnedSegment {
    let syntax = data.syntax_kennung.as_deref().unwrap_or("UNOC");
    let sender = data.absender_code.as_deref().unwrap_or("");
    let receiver = data.empfaenger_code.as_deref().unwrap_or("");
    let datum = normalize_unb_datum(data.datum.as_deref().unwrap_or(""));
    let zeit = data.zeit.as_deref().unwrap_or("");
    let interchange_ref = data.interchange_ref.as_deref().unwrap_or("00000");

    OwnedSegment {
        id: "UNB".to_string(),
        elements: vec![
            vec![syntax.to_string(), "3".to_string()],
            vec![sender.to_string(), "500".to_string()],
            vec![receiver.to_string(), "500".to_string()],
            vec![datum.to_string(), zeit.to_string()],
            vec![interchange_ref.to_string()],
        ],
        segment_number: 0,
    }
}

/// Rebuild a UNB (interchange header) segment from nachrichtendaten JSON.
///
/// This is the inverse of `extract_nachrichtendaten()`.
/// Fields not present in the JSON get sensible defaults (UNOC:3, "500" qualifier).
/// Dates in CCYYMMDD (8-digit) format are automatically normalized to YYMMDD (6-digit).
pub fn rebuild_unb(nachrichtendaten: &serde_json::Value) -> OwnedSegment {
    let syntax = nachrichtendaten
        .get("syntaxKennung")
        .and_then(|v| v.as_str())
        .unwrap_or("UNOC");
    let sender = nachrichtendaten
        .get("absenderCode")
        .and_then(|v| v.as_str())
        .unwrap_or("");
    let receiver = nachrichtendaten
        .get("empfaengerCode")
        .and_then(|v| v.as_str())
        .unwrap_or("");
    let datum_raw = nachrichtendaten
        .get("datum")
        .and_then(|v| v.as_str())
        .unwrap_or("");
    let datum = normalize_unb_datum(datum_raw);
    let zeit = nachrichtendaten
        .get("zeit")
        .and_then(|v| v.as_str())
        .unwrap_or("");
    let interchange_ref = nachrichtendaten
        .get("interchangeRef")
        .and_then(|v| v.as_str())
        .unwrap_or("00000");

    OwnedSegment {
        id: "UNB".to_string(),
        elements: vec![
            vec![syntax.to_string(), "3".to_string()],
            vec![sender.to_string(), "500".to_string()],
            vec![receiver.to_string(), "500".to_string()],
            vec![datum.to_string(), zeit.to_string()],
            vec![interchange_ref.to_string()],
        ],
        segment_number: 0,
    }
}

/// Rebuild a UNH (message header) segment.
///
/// Produces `UNH+referenz+typ:D:{release}:UN:{association}`, followed by the
/// optional 0068 and S010 elements when `header` carries them.
///
/// `release` (S009 d0054) and `association` (S009 d0057) are message-type and
/// MIG-version specific — UTILMD Strom is `11A`/`S2.1`, UTILMD Gas `11A`/`G1.0a`,
/// MSCONS `04B`/`2.4c`. Hardcoding them makes every reverse-rendered message fail
/// the AHB code rule on S009 for every variant but UTILMD Strom, so callers pass
/// the values from the MIG they mapped against
/// ([`release_code_for_message_type`] and `MigSchema::version`).
pub fn rebuild_unh(header: &Nachrichtendaten, release: &str, association: &str) -> OwnedSegment {
    let mut elements = vec![
        vec![header.unh_referenz.clone()],
        vec![
            header.nachrichten_typ.clone(),
            "D".to_string(),
            release.to_string(),
            "UN".to_string(),
            association.to_string(),
        ],
    ];

    // 0068 and S010 are optional and trailing, so they are written only when
    // the message carries them — and 0068 has to be written as an empty
    // element when only S010 is present, because S010 is positional.
    let s010: Vec<String> = match (
        &header.uebermittlungsfolgenummer,
        header.uebermittlungsabschnitt,
    ) {
        (None, None) => Vec::new(),
        (folge, abschnitt) => vec![
            folge.clone().unwrap_or_default(),
            abschnitt.map(|a| a.code().to_string()).unwrap_or_default(),
        ],
    };
    if header.zuordnungsreferenz.is_some() || !s010.is_empty() {
        elements.push(vec![header.zuordnungsreferenz.clone().unwrap_or_default()]);
    }
    if !s010.is_empty() {
        elements.push(s010);
    }

    OwnedSegment {
        id: "UNH".to_string(),
        elements,
        segment_number: 0,
    }
}

/// UN/EDIFACT directory release code (UNH S009 d0054) for a message type.
///
/// Pinned against the AHB's allowed codes by
/// `edifact-mapper/tests/unh_release_codes.rs` — a wrong value here makes every
/// generated message fail the code rule on UNH S009. The values are the same
/// across all format versions the repo ships.
pub fn release_code_for_message_type(msg_type: &str) -> &'static str {
    match msg_type {
        "APERAK" => "07B",
        "COMDIS" => "17A",
        // CONTRL is versioned by syntax level, not by a UN/EDIFACT directory.
        "CONTRL" => "3",
        "IFTSTA" => "18A",
        "INSRPT" => "10A",
        "INVOIC" => "06A",
        "MSCONS" => "04B",
        "ORDCHG" => "20B",
        "ORDERS" => "09B",
        "ORDRSP" => "10A",
        "PARTIN" => "20B",
        "PRICAT" => "20B",
        "QUOTES" => "10A",
        "REMADV" => "05A",
        "REQOTE" => "10A",
        "UTILMD" => "11A",
        "UTILTS" => "18A",
        _ => "04B", // fallback
    }
}

/// Rebuild a UNT (message trailer) segment.
///
/// Produces: `UNT+count+referenz`
/// `segment_count` includes UNH and UNT themselves.
pub fn rebuild_unt(segment_count: usize, referenz: &str) -> OwnedSegment {
    OwnedSegment {
        id: "UNT".to_string(),
        elements: vec![vec![segment_count.to_string()], vec![referenz.to_string()]],
        segment_number: 0,
    }
}

/// Rebuild a UNZ (interchange trailer) segment.
///
/// Produces: `UNZ+count+ref`
pub fn rebuild_unz(message_count: usize, interchange_ref: &str) -> OwnedSegment {
    OwnedSegment {
        id: "UNZ".to_string(),
        elements: vec![
            vec![message_count.to_string()],
            vec![interchange_ref.to_string()],
        ],
        segment_number: 0,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_mapped_transaktion_serde_roundtrip() {
        let tx = MappedTransaktion {
            transaktionsdaten: serde_json::Value::Null,
            stammdaten: serde_json::json!({
                "prozessdaten": {
                    "vorgangId": "TX001",
                    "transaktionsgrund": "E01"
                },
                "marktlokation": { "marktlokationsId": "DE000111222333" }
            }),
            nesting_info: Default::default(),
        };

        let json = serde_json::to_string(&tx).unwrap();
        let de: MappedTransaktion = serde_json::from_str(&json).unwrap();
        assert_eq!(
            de.stammdaten["prozessdaten"]["vorgangId"].as_str().unwrap(),
            "TX001"
        );
        assert!(de.stammdaten["marktlokation"].is_object());
    }

    #[test]
    fn test_dynamic_nachricht_serde_roundtrip() {
        let msg: DynamicNachricht = Nachricht {
            nachrichtendaten: Nachrichtendaten {
                unh_referenz: "00001".to_string(),
                nachrichten_typ: "UTILMD".to_string(),
                nachricht: Default::default(),
                ..Default::default()
            },
            stammdaten: serde_json::json!({
                "marktteilnehmer": [
                    { "marktrolle": "MS", "rollencodenummer": "9900123" }
                ]
            }),
            transaktionen: vec![Transaktion {
                transaktionsdaten: serde_json::Value::Null,
                stammdaten: serde_json::json!({}),
            }],
        };

        let json = serde_json::to_string(&msg).unwrap();
        let de: DynamicNachricht = serde_json::from_str(&json).unwrap();
        assert_eq!(de.nachrichtendaten.unh_referenz, "00001");
        assert_eq!(de.nachrichtendaten.nachrichten_typ, "UTILMD");
        assert_eq!(de.transaktionen.len(), 1);
    }

    #[test]
    fn test_dynamic_interchange_serde_roundtrip() {
        let interchange: DynamicInterchange = Interchange {
            interchangedaten: Interchangedaten {
                absender_code: Some("9900123456789".to_string()),
                empfaenger_code: Some("9900987654321".to_string()),
                ..Default::default()
            },
            nachrichten: vec![Nachricht {
                nachrichtendaten: Nachrichtendaten {
                    unh_referenz: "00001".to_string(),
                    nachrichten_typ: "UTILMD".to_string(),
                    nachricht: Default::default(),
                    ..Default::default()
                },
                stammdaten: serde_json::json!({}),
                transaktionen: vec![],
            }],
        };

        let json = serde_json::to_string_pretty(&interchange).unwrap();
        let de: DynamicInterchange = serde_json::from_str(&json).unwrap();
        assert_eq!(de.nachrichten.len(), 1);
        assert_eq!(de.nachrichten[0].nachrichtendaten.unh_referenz, "00001");
    }

    #[test]
    fn test_extract_interchangedaten_from_segments() {
        let envelope = vec![OwnedSegment {
            id: "UNB".to_string(),
            elements: vec![
                vec!["UNOC".to_string(), "3".to_string()],
                vec!["9900123456789".to_string(), "500".to_string()],
                vec!["9900987654321".to_string(), "500".to_string()],
                vec!["210101".to_string(), "1200".to_string()],
                vec!["REF001".to_string()],
            ],
            segment_number: 0,
        }];

        let data = extract_interchangedaten(&envelope);
        assert_eq!(data.absender_code.as_deref(), Some("9900123456789"));
        assert_eq!(data.empfaenger_code.as_deref(), Some("9900987654321"));
        assert_eq!(data.interchange_ref.as_deref(), Some("REF001"));
        assert_eq!(data.syntax_kennung.as_deref(), Some("UNOC"));
        assert_eq!(data.datum.as_deref(), Some("210101"));
        assert_eq!(data.zeit.as_deref(), Some("1200"));
    }

    #[test]
    fn test_extract_envelope_from_segments_json() {
        let envelope = vec![OwnedSegment {
            id: "UNB".to_string(),
            elements: vec![
                vec!["UNOC".to_string(), "3".to_string()],
                vec!["9900123456789".to_string(), "500".to_string()],
                vec!["9900987654321".to_string(), "500".to_string()],
                vec!["210101".to_string(), "1200".to_string()],
                vec!["REF001".to_string()],
            ],
            segment_number: 0,
        }];

        let nd = extract_nachrichtendaten(&envelope);
        assert_eq!(nd["absenderCode"].as_str().unwrap(), "9900123456789");
        assert_eq!(nd["empfaengerCode"].as_str().unwrap(), "9900987654321");
        assert_eq!(nd["interchangeRef"].as_str().unwrap(), "REF001");
        assert_eq!(nd["syntaxKennung"].as_str().unwrap(), "UNOC");
        assert_eq!(nd["datum"].as_str().unwrap(), "210101");
        assert_eq!(nd["zeit"].as_str().unwrap(), "1200");
    }

    #[test]
    fn test_extract_unh_fields() {
        let unh = OwnedSegment {
            id: "UNH".to_string(),
            elements: vec![
                vec!["MSG001".to_string()],
                vec![
                    "UTILMD".to_string(),
                    "D".to_string(),
                    "11A".to_string(),
                    "UN".to_string(),
                    "S2.1".to_string(),
                ],
            ],
            segment_number: 0,
        };

        let (referenz, typ) = extract_unh_fields(&unh);
        assert_eq!(referenz, "MSG001");
        assert_eq!(typ, "UTILMD");
    }

    #[test]
    fn test_rebuild_unb_from_interchangedaten_typed() {
        let data = Interchangedaten {
            syntax_kennung: Some("UNOC".to_string()),
            absender_code: Some("9900123456789".to_string()),
            empfaenger_code: Some("9900987654321".to_string()),
            datum: Some("210101".to_string()),
            zeit: Some("1200".to_string()),
            interchange_ref: Some("REF001".to_string()),
        };

        let unb = rebuild_unb_from_interchangedaten(&data);
        assert_eq!(unb.id, "UNB");
        assert_eq!(unb.elements[0], vec!["UNOC", "3"]);
        assert_eq!(unb.elements[1][0], "9900123456789");
        assert_eq!(unb.elements[2][0], "9900987654321");
        assert_eq!(unb.elements[3], vec!["210101", "1200"]);
        assert_eq!(unb.elements[4], vec!["REF001"]);
    }

    #[test]
    fn test_rebuild_unb_from_nachrichtendaten() {
        let nd = serde_json::json!({
            "syntaxKennung": "UNOC",
            "absenderCode": "9900123456789",
            "empfaengerCode": "9900987654321",
            "datum": "210101",
            "zeit": "1200",
            "interchangeRef": "REF001"
        });

        let unb = rebuild_unb(&nd);
        assert_eq!(unb.id, "UNB");
        assert_eq!(unb.elements[0], vec!["UNOC", "3"]);
        assert_eq!(unb.elements[1][0], "9900123456789");
        assert_eq!(unb.elements[2][0], "9900987654321");
        assert_eq!(unb.elements[3], vec!["210101", "1200"]);
        assert_eq!(unb.elements[4], vec!["REF001"]);
    }

    #[test]
    fn test_rebuild_unb_defaults() {
        let nd = serde_json::json!({});
        let unb = rebuild_unb(&nd);
        assert_eq!(unb.id, "UNB");
        assert_eq!(unb.elements[0], vec!["UNOC", "3"]);
    }

    /// A message header carrying only the two elements every message has.
    fn header(referenz: &str, typ: &str) -> Nachrichtendaten {
        Nachrichtendaten {
            unh_referenz: referenz.to_string(),
            nachrichten_typ: typ.to_string(),
            ..Default::default()
        }
    }

    /// The whole UNH survives the hop, not just 0062 and S009.
    ///
    /// 0068 and S010 were dropped on the way in and never rebuilt on the way
    /// out, so 53 Pruefidentifikatoren lost a field their own guide requires
    /// (issue #166).
    #[test]
    fn the_optional_unh_elements_survive_extraction_and_rebuild() {
        let original = OwnedSegment {
            id: "UNH".to_string(),
            elements: vec![
                vec!["GENERATED00001".to_string()],
                vec![
                    "MSCONS".to_string(),
                    "D".to_string(),
                    "04B".to_string(),
                    "UN".to_string(),
                    "2.4c".to_string(),
                ],
                vec!["ZUORDNUNG1".to_string()],
                vec!["3".to_string(), "C".to_string()],
            ],
            segment_number: 0,
        };

        let header = extract_message_header(&original);
        assert_eq!(header.zuordnungsreferenz.as_deref(), Some("ZUORDNUNG1"));
        assert_eq!(header.uebermittlungsfolgenummer.as_deref(), Some("3"));
        assert_eq!(
            header.uebermittlungsabschnitt,
            Some(Uebermittlungsabschnitt::Beginn),
            "the BO4E carries the MIG's name for C, not the code"
        );

        let rebuilt = rebuild_unh(&header, "04B", "2.4c");
        assert_eq!(rebuilt.elements, original.elements);
    }

    /// A message without them renders the two-element UNH it always did.
    #[test]
    fn a_header_without_the_optional_elements_renders_as_before() {
        let unh = rebuild_unh(&header("00001", "UTILMD"), "11A", "S2.1");
        assert_eq!(unh.elements.len(), 2, "no empty trailing elements: {unh:?}");
    }

    /// S010 is positional, so 0068 has to hold its place when it is absent.
    #[test]
    fn s010_without_0068_keeps_its_position() {
        let mut h = header("00001", "UTILMD");
        h.uebermittlungsfolgenummer = Some("2".to_string());
        let unh = rebuild_unh(&h, "11A", "S2.1");
        assert_eq!(unh.elements[2], vec![""], "0068 holds S010's position");
        assert_eq!(unh.elements[3], vec!["2", ""]);
    }

    #[test]
    fn test_rebuild_unh() {
        let unh = rebuild_unh(&header("00001", "UTILMD"), "11A", "S2.1");
        assert_eq!(unh.id, "UNH");
        assert_eq!(unh.elements[0], vec!["00001"]);
        assert_eq!(unh.elements[1][0], "UTILMD");
        assert_eq!(unh.elements[1][1], "D");
        assert_eq!(unh.elements[1][2], "11A");
        assert_eq!(unh.elements[1][3], "UN");
        assert_eq!(unh.elements[1][4], "S2.1");
    }

    #[test]
    fn test_rebuild_unh_uses_the_given_release_and_association() {
        // UTILMD Gas rides on the same D:11A directory but a different MIG
        // version; hardcoding S2.1 fails the AHB code rule on UNH S009.
        let unh = rebuild_unh(&header("00001", "UTILMD"), "11A", "G1.0a");
        assert_eq!(unh.elements[1], vec!["UTILMD", "D", "11A", "UN", "G1.0a"]);

        let unh = rebuild_unh(
            &header("00001", "MSCONS"),
            release_code_for_message_type("MSCONS"),
            "2.4c",
        );
        assert_eq!(unh.elements[1], vec!["MSCONS", "D", "04B", "UN", "2.4c"]);
    }

    #[test]
    fn test_rebuild_unt() {
        let unt = rebuild_unt(25, "00001");
        assert_eq!(unt.id, "UNT");
        assert_eq!(unt.elements[0], vec!["25"]);
        assert_eq!(unt.elements[1], vec!["00001"]);
    }

    #[test]
    fn test_rebuild_unz() {
        let unz = rebuild_unz(1, "REF001");
        assert_eq!(unz.id, "UNZ");
        assert_eq!(unz.elements[0], vec!["1"]);
        assert_eq!(unz.elements[1], vec!["REF001"]);
    }

    #[test]
    fn test_roundtrip_interchangedaten_rebuild() {
        let original = OwnedSegment {
            id: "UNB".to_string(),
            elements: vec![
                vec!["UNOC".to_string(), "3".to_string()],
                vec!["9900123456789".to_string(), "500".to_string()],
                vec!["9900987654321".to_string(), "500".to_string()],
                vec!["210101".to_string(), "1200".to_string()],
                vec!["REF001".to_string()],
            ],
            segment_number: 0,
        };

        let data = extract_interchangedaten(&[original]);
        let rebuilt = rebuild_unb_from_interchangedaten(&data);
        assert_eq!(rebuilt.elements[0], vec!["UNOC", "3"]);
        assert_eq!(rebuilt.elements[1][0], "9900123456789");
        assert_eq!(rebuilt.elements[2][0], "9900987654321");
        assert_eq!(rebuilt.elements[3], vec!["210101", "1200"]);
        assert_eq!(rebuilt.elements[4], vec!["REF001"]);
    }

    #[test]
    fn test_roundtrip_nachrichtendaten_rebuild() {
        let original = OwnedSegment {
            id: "UNB".to_string(),
            elements: vec![
                vec!["UNOC".to_string(), "3".to_string()],
                vec!["9900123456789".to_string(), "500".to_string()],
                vec!["9900987654321".to_string(), "500".to_string()],
                vec!["210101".to_string(), "1200".to_string()],
                vec!["REF001".to_string()],
            ],
            segment_number: 0,
        };

        let nd = extract_nachrichtendaten(&[original]);
        let rebuilt = rebuild_unb(&nd);
        assert_eq!(rebuilt.elements[0], vec!["UNOC", "3"]);
        assert_eq!(rebuilt.elements[1][0], "9900123456789");
        assert_eq!(rebuilt.elements[2][0], "9900987654321");
        assert_eq!(rebuilt.elements[3], vec!["210101", "1200"]);
        assert_eq!(rebuilt.elements[4], vec!["REF001"]);
    }

    #[test]
    fn test_rebuild_unb_normalizes_ccyymmdd_to_yymmdd() {
        // UNB S004 datum must be YYMMDD (6 digits), not CCYYMMDD (8 digits)
        let data = Interchangedaten {
            syntax_kennung: Some("UNOC".to_string()),
            absender_code: Some("9900000000003".to_string()),
            empfaenger_code: Some("9900000000001".to_string()),
            datum: Some("20260409".to_string()), // 8-digit CCYYMMDD input
            zeit: Some("0725".to_string()),
            interchange_ref: Some("00004".to_string()),
        };

        let unb = rebuild_unb_from_interchangedaten(&data);
        assert_eq!(unb.elements[3], vec!["260409", "0725"]); // normalized to 6-digit YYMMDD

        // Same via JSON path
        let nd = serde_json::json!({
            "syntaxKennung": "UNOC",
            "absenderCode": "9900000000003",
            "empfaengerCode": "9900000000001",
            "datum": "20260409",
            "zeit": "0725",
            "interchangeRef": "00004"
        });
        let unb_json = rebuild_unb(&nd);
        assert_eq!(unb_json.elements[3], vec!["260409", "0725"]);
    }

    #[test]
    fn test_rebuild_unb_preserves_yymmdd() {
        // Already 6-digit YYMMDD — should pass through unchanged
        let data = Interchangedaten {
            datum: Some("260409".to_string()),
            zeit: Some("0725".to_string()),
            ..Default::default()
        };
        let unb = rebuild_unb_from_interchangedaten(&data);
        assert_eq!(unb.elements[3], vec!["260409", "0725"]);
    }

    #[test]
    fn test_into_dynamic_nachricht() {
        let mapped = MappedMessage {
            nachricht_meta: serde_json::Value::Null,
            stammdaten: serde_json::json!({"marktteilnehmer": []}),
            transaktionen: vec![MappedTransaktion {
                transaktionsdaten: serde_json::json!({"vorgangId": "1"}),
                stammdaten: serde_json::json!({}),
                nesting_info: Default::default(),
            }],
            nesting_info: Default::default(),
            inter_group_segments: Default::default(),
        };

        let nd = Nachrichtendaten {
            unh_referenz: "00001".to_string(),
            nachrichten_typ: "UTILMD".to_string(),
            nachricht: Default::default(),
            ..Default::default()
        };

        let nachricht = mapped.into_dynamic_nachricht(nd);
        assert_eq!(nachricht.nachrichtendaten.unh_referenz, "00001");
        assert_eq!(nachricht.transaktionen.len(), 1);
        // The transaction's metadata now sits in its own slot, not among the BOs.
        assert_eq!(
            nachricht.transaktionen[0].transaktionsdaten["vorgangId"],
            "1"
        );
    }
}