mig-assembly 0.8.0

//! Tree disassembler — converts AssembledTree back to ordered segments.
//!
//! Walks the MIG schema tree in order. For each MIG node that has
//! corresponding data in the assembled tree, emits segments in MIG order.

use crate::assembler::{AssembledGroup, AssembledGroupInstance, AssembledSegment, AssembledTree};
use crate::error::AssemblyError;
use mig_types::schema::mig::{MigSchema, MigSegmentGroup};

/// Output segment from disassembly (owned data, ready for rendering).
#[derive(Debug, Clone)]
pub struct DisassembledSegment {
    pub tag: String,
    pub elements: Vec<Vec<String>>,
}

/// A group instance that carries content but not the segment that opens the
/// group in the MIG (e.g. an SG10 with a `CAV` but no `CCI`).
///
/// Rendering such an instance yields EDIFACT no receiver can assemble: the
/// orphaned segments are rejected or skipped, and their data is lost. See
/// [`Disassembler::disassemble_checked`].
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MissingEntrySegment {
    /// MIG group path from the message root, e.g. `"SG4.SG8.SG10"`.
    pub group_path: String,
    /// The same path in the TOML `source_path` convention, with the variant
    /// qualifier where the MIG defines one, e.g. `"sg4.sg8_z03.sg10"`.
    pub source_path: String,
    /// Tag of the MIG entry segment the instance lacks, e.g. `"CCI"`.
    pub entry_segment: String,
    /// Tags of the segments the instance does carry, in instance order.
    pub present_segments: Vec<String>,
}

/// MIG-guided disassembler — walks the MIG tree to emit segments in correct order.
pub struct Disassembler<'a> {
    mig: &'a MigSchema,
}

/// Mutable state threaded through one disassembly walk.
struct Emit {
    output: Vec<DisassembledSegment>,
    /// `(group_path, source_path)` of each enclosing group instance.
    path: Vec<(String, String)>,
    missing: Vec<MissingEntrySegment>,
}

impl Emit {
    fn push(&mut self, seg: &AssembledSegment) {
        self.output.push(assembled_to_disassembled(seg));
    }
}

impl<'a> Disassembler<'a> {
    pub fn new(mig: &'a MigSchema) -> Self {
        Self { mig }
    }

    /// Disassemble a tree into ordered segments following MIG sequence.
    ///
    /// Emits segments in correct EDIFACT order:
    /// 1. Pre-group top-level segments (e.g., UNB, UNH, BGM, DTM)
    /// 2. Groups (recursively, in MIG order)
    /// 3. Post-group top-level segments (e.g., UNT, UNZ)
    ///
    /// Uses MIG-guided ordering: walks the MIG schema tree and looks up
    /// matching data in the assembled tree. This handles both assembler output
    /// (already in MIG order) and reverse-mapped trees (may be in arbitrary order).
    ///
    /// This is lenient: a group instance lacking its entry segment is emitted
    /// as-is. Use [`disassemble_checked`](Self::disassemble_checked) for output
    /// built from BO4E that is meant to be sent.
    pub fn disassemble(&self, tree: &AssembledTree) -> Vec<DisassembledSegment> {
        self.walk(tree).output
    }

    /// Like [`disassemble`](Self::disassemble), but refuses a group instance
    /// that has content without its MIG entry segment.
    ///
    /// The entry segment opens a group repetition (CCI for SG10, SEQ for SG8,
    /// NAD for SG12, …). Without it a receiver cannot assemble the group's
    /// other segments — our own assembler skips them, so their data is lost on
    /// parse. The error names the first offending group; all of them are
    /// available through [`missing_entry_segments`](Self::missing_entry_segments).
    pub fn disassemble_checked(
        &self,
        tree: &AssembledTree,
    ) -> Result<Vec<DisassembledSegment>, AssemblyError> {
        let emit = self.walk(tree);
        match emit.missing.into_iter().next() {
            None => Ok(emit.output),
            Some(m) => Err(AssemblyError::MissingGroupEntrySegment {
                group_path: m.group_path,
                source_path: m.source_path,
                entry_segment: m.entry_segment,
                present_segments: m.present_segments,
            }),
        }
    }

    /// Every group instance in `tree` that carries content but lacks its MIG
    /// entry segment, in emission order.
    pub fn missing_entry_segments(&self, tree: &AssembledTree) -> Vec<MissingEntrySegment> {
        self.walk(tree).missing
    }

    fn walk(&self, tree: &AssembledTree) -> Emit {
        let mut emit = Emit {
            output: Vec::new(),
            path: Vec::new(),
            missing: Vec::new(),
        };

        // 1. Emit pre-group segments in MIG order
        let pre_group = &tree.segments[..tree.post_group_start];
        let mut consumed = vec![false; pre_group.len()];
        for mig_seg in &self.mig.segments {
            if let Some(idx) = pre_group
                .iter()
                .enumerate()
                .position(|(i, s)| !consumed[i] && s.tag == mig_seg.id)
            {
                emit.push(&pre_group[idx]);
                consumed[idx] = true;
            }
        }

        // 2. Emit groups in MIG order (lookup by group ID with consumption tracking).
        //    Between groups, emit any inter-group root segments (e.g., UNS in MSCONS).
        //    For variant groups (consecutive same-ID with variant_code), collect all
        //    variant definitions and match each rep to its correct variant.
        let mut consumed_groups = vec![false; tree.groups.len()];
        let mut mig_group_idx = 0;
        while mig_group_idx < self.mig.segment_groups.len() {
            let mig_group = &self.mig.segment_groups[mig_group_idx];

            // Check if this starts a variant set
            if mig_group.variant_code.is_some() {
                let variant_count = self.mig.segment_groups[mig_group_idx..]
                    .iter()
                    .take_while(|g| g.id == mig_group.id && g.variant_code.is_some())
                    .count();
                let variant_defs =
                    &self.mig.segment_groups[mig_group_idx..mig_group_idx + variant_count];

                if let Some(idx) = tree
                    .groups
                    .iter()
                    .enumerate()
                    .position(|(i, g)| !consumed_groups[i] && g.group_id == mig_group.id)
                {
                    if let Some(inter_segs) = tree.inter_group_segments.get(&idx) {
                        for seg in inter_segs {
                            emit.push(seg);
                        }
                    }
                    self.emit_variant_group(&tree.groups[idx], variant_defs, &mut emit);
                    consumed_groups[idx] = true;
                }
                mig_group_idx += variant_count;
            } else {
                if let Some(idx) = tree
                    .groups
                    .iter()
                    .enumerate()
                    .position(|(i, g)| !consumed_groups[i] && g.group_id == mig_group.id)
                {
                    // Emit any inter-group segments that precede this group
                    if let Some(inter_segs) = tree.inter_group_segments.get(&idx) {
                        for seg in inter_segs {
                            emit.push(seg);
                        }
                    }
                    self.emit_group(&tree.groups[idx], mig_group, &mut emit);
                    consumed_groups[idx] = true;
                }
                mig_group_idx += 1;
            }
        }

        // 2b. Emit trailing inter-group segments (after the last group).
        //     For ORDERS, UNS+S comes after SG29 (detail/summary boundary).
        let trailing_idx = tree.groups.len();
        if let Some(inter_segs) = tree.inter_group_segments.get(&trailing_idx) {
            for seg in inter_segs {
                emit.push(seg);
            }
        }

        // 3. Emit post-group segments (e.g., UNT, UNZ)
        for seg in &tree.segments[tree.post_group_start..] {
            emit.push(seg);
        }

        emit
    }

    fn emit_group(&self, group: &AssembledGroup, mig_group: &MigSegmentGroup, emit: &mut Emit) {
        for instance in &group.repetitions {
            self.emit_group_instance(instance, mig_group, emit);
        }
    }

    /// Emit a group whose reps come from multiple variant definitions.
    ///
    /// For each rep, determine which variant it belongs to by applying the same
    /// test the assembler uses: the qualifier at the variant's
    /// `variant_qualifier_position` must be one of the codes that variant allows
    /// (`variant_codes`, falling back to the single `variant_code`).
    /// Then emit the rep using that variant's segment/nested-group ordering.
    ///
    /// Matching the variant's *first* code only routes a rep to the wrong
    /// variant definition whenever a variant allows several codes (the UTILMD
    /// SG8 variant allowing `Z01, Z80, Z81, Z98`) or reads its qualifier at
    /// another position (CCI variants). The rep's nested groups are then looked
    /// up in a definition that does not declare them and are silently dropped —
    /// the SG9 `QTY` under `SEQ+Z98` in UTILMD 55013.
    fn emit_variant_group(
        &self,
        group: &AssembledGroup,
        variant_defs: &[MigSegmentGroup],
        emit: &mut Emit,
    ) {
        for instance in &group.repetitions {
            let matches_variant = |v: &MigSegmentGroup| {
                let (ei, ci) = v.variant_qualifier_position.unwrap_or((0, 0));
                // Find the entry segment by tag: a reverse-built repetition
                // holds its segments in definition order, which need not start
                // with the entry segment.
                let entry_tag = v.segments.first().map(|s| s.id.as_str());
                let qual = instance
                    .segments
                    .iter()
                    .find(|s| Some(s.tag.as_str()) == entry_tag)
                    .or_else(|| instance.segments.first())
                    .and_then(|s| s.elements.get(ei))
                    .and_then(|e| e.get(ci))
                    .map(|v| v.as_str())
                    .unwrap_or("");
                if !v.variant_codes.is_empty() {
                    v.variant_codes.iter().any(|c| c.eq_ignore_ascii_case(qual))
                } else {
                    v.variant_code
                        .as_deref()
                        .is_some_and(|vc| vc.eq_ignore_ascii_case(qual))
                }
            };

            let variant_def = variant_defs
                .iter()
                .find(|v| matches_variant(v))
                .unwrap_or(&variant_defs[0]); // fallback to first variant

            self.emit_group_instance(instance, variant_def, emit);
        }
    }

    /// Record `instance` if it has content but not `mig_group`'s entry segment,
    /// and return its `(group_path, source_path)`.
    fn check_entry_segment(
        instance: &AssembledGroupInstance,
        mig_group: &MigSegmentGroup,
        emit: &mut Emit,
    ) -> (String, String) {
        let join = |parent: Option<&String>, child: String| match parent {
            Some(p) => format!("{p}.{child}"),
            None => child,
        };
        let parent = emit.path.last();
        let group_path = join(parent.map(|p| &p.0), mig_group.id.clone());
        let missing_entry = mig_group.segments.first().filter(|entry| {
            let has_content = !instance.segments.is_empty()
                || instance
                    .child_groups
                    .iter()
                    .any(|g| !g.repetitions.is_empty());
            has_content && !instance.segments.iter().any(|s| s.tag == entry.id)
        });
        // The variant is identified by the entry segment's qualifier, so without
        // an entry segment `mig_group` is only a fallback guess — leave the
        // variant out of the path rather than report a wrong one.
        let own_source = match &mig_group.variant_code {
            Some(vc) if missing_entry.is_none() => {
                format!("{}_{}", mig_group.id, vc).to_lowercase()
            }
            _ => mig_group.id.to_lowercase(),
        };
        let source_path = join(parent.map(|p| &p.1), own_source);

        if let Some(entry) = missing_entry {
            emit.missing.push(MissingEntrySegment {
                group_path: group_path.clone(),
                source_path: source_path.clone(),
                entry_segment: entry.id.clone(),
                present_segments: instance.segments.iter().map(|s| s.tag.clone()).collect(),
            });
        }
        (group_path, source_path)
    }

    fn emit_group_instance(
        &self,
        instance: &AssembledGroupInstance,
        mig_group: &MigSegmentGroup,
        emit: &mut Emit,
    ) {
        let paths = Self::check_entry_segment(instance, mig_group, emit);
        emit.path.push(paths);

        // Emit segments in MIG order using tag-based lookup with consumption tracking.
        // This handles both assembler output (in MIG order) and reverse-mapped trees
        // (may be in arbitrary order).
        //
        // After MIG-guided emission, any remaining unconsumed segments are appended.
        // This handles cases where the assembler captured more segments than the MIG
        // defines (e.g., 6 RFFs when the merged MIG only has 4 slots).
        let mut consumed = vec![false; instance.segments.len()];
        for mig_seg in &mig_group.segments {
            if let Some(idx) = instance
                .segments
                .iter()
                .enumerate()
                .position(|(i, s)| !consumed[i] && s.tag == mig_seg.id)
            {
                emit.push(&instance.segments[idx]);
                consumed[idx] = true;
            }
        }
        // Emit any remaining segments not matched by MIG slots
        for (i, seg) in instance.segments.iter().enumerate() {
            if !consumed[i] {
                emit.push(seg);
            }
        }

        // Re-emit skipped segments (unknown segments preserved for roundtrip fidelity)
        for skipped in &instance.skipped_segments {
            emit.push(skipped);
        }

        // Child groups — lookup by group ID with consumption tracking.
        // Applies variant-aware logic recursively for nested variant groups.
        let mut consumed_child = vec![false; instance.child_groups.len()];
        let mut nested_idx = 0;
        while nested_idx < mig_group.nested_groups.len() {
            let nested_mig = &mig_group.nested_groups[nested_idx];

            if nested_mig.variant_code.is_some() {
                let variant_count = mig_group.nested_groups[nested_idx..]
                    .iter()
                    .take_while(|g| g.id == nested_mig.id && g.variant_code.is_some())
                    .count();
                let variant_defs = &mig_group.nested_groups[nested_idx..nested_idx + variant_count];

                if let Some(idx) = instance
                    .child_groups
                    .iter()
                    .enumerate()
                    .position(|(i, g)| !consumed_child[i] && g.group_id == nested_mig.id)
                {
                    self.emit_variant_group(&instance.child_groups[idx], variant_defs, emit);
                    consumed_child[idx] = true;
                }
                nested_idx += variant_count;
            } else {
                if let Some(idx) = instance
                    .child_groups
                    .iter()
                    .enumerate()
                    .position(|(i, g)| !consumed_child[i] && g.group_id == nested_mig.id)
                {
                    self.emit_group(&instance.child_groups[idx], nested_mig, emit);
                    consumed_child[idx] = true;
                }
                nested_idx += 1;
            }
        }

        emit.path.pop();
    }
}

fn assembled_to_disassembled(seg: &AssembledSegment) -> DisassembledSegment {
    DisassembledSegment {
        tag: seg.tag.clone(),
        elements: seg.elements.clone(),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::assembler::{
        AssembledGroup, AssembledGroupInstance, AssembledSegment, AssembledTree,
    };
    use crate::test_support::{make_mig_group, make_mig_segment};
    use mig_types::schema::mig::MigSchema;

    #[test]
    fn test_disassemble_top_level_only() {
        let mig = MigSchema {
            message_type: "UTILMD".to_string(),
            variant: Some("Strom".to_string()),
            version: "S2.1".to_string(),
            publication_date: "2025-03-20".to_string(),
            author: "BDEW".to_string(),
            format_version: "FV2504".to_string(),
            source_file: "test".to_string(),
            segments: vec![make_mig_segment("UNH"), make_mig_segment("BGM")],
            segment_groups: vec![],
        };

        let tree = AssembledTree {
            segments: vec![
                AssembledSegment {
                    tag: "UNH".to_string(),
                    elements: vec![
                        vec!["1".to_string()],
                        vec![
                            "UTILMD".to_string(),
                            "D".to_string(),
                            "11A".to_string(),
                            "UN".to_string(),
                            "S2.1".to_string(),
                        ],
                    ],
                    mig_number: None,
                    segment_number: None,
                },
                AssembledSegment {
                    tag: "BGM".to_string(),
                    elements: vec![
                        vec!["E01".to_string()],
                        vec!["MSG001".to_string()],
                        vec!["9".to_string()],
                    ],
                    mig_number: None,
                    segment_number: None,
                },
            ],
            groups: vec![],
            post_group_start: 2,
            inter_group_segments: std::collections::BTreeMap::new(),
        };

        let disassembler = Disassembler::new(&mig);
        let segments = disassembler.disassemble(&tree);

        assert_eq!(segments.len(), 2);
        assert_eq!(segments[0].tag, "UNH");
        assert_eq!(segments[1].tag, "BGM");
        assert_eq!(segments[0].elements[0], vec!["1"]);
    }

    #[test]
    fn test_disassemble_with_groups() {
        let mig = MigSchema {
            message_type: "UTILMD".to_string(),
            variant: None,
            version: "S2.1".to_string(),
            publication_date: "".to_string(),
            author: "".to_string(),
            format_version: "FV2504".to_string(),
            source_file: "test".to_string(),
            segments: vec![make_mig_segment("UNH"), make_mig_segment("BGM")],
            segment_groups: vec![make_mig_group("SG2", vec!["NAD", "LOC"], vec![])],
        };

        let tree = AssembledTree {
            segments: vec![
                AssembledSegment {
                    tag: "UNH".to_string(),
                    elements: vec![vec!["1".to_string()]],
                    mig_number: None,
                    segment_number: None,
                },
                AssembledSegment {
                    tag: "BGM".to_string(),
                    elements: vec![vec!["E01".to_string()]],
                    mig_number: None,
                    segment_number: None,
                },
            ],
            post_group_start: 2,
            groups: vec![AssembledGroup {
                group_id: "SG2".to_string(),
                repetitions: vec![
                    AssembledGroupInstance {
                        segments: vec![AssembledSegment {
                            tag: "NAD".to_string(),
                            elements: vec![vec!["MS".to_string()]],
                            mig_number: None,
                            segment_number: None,
                        }],
                        child_groups: vec![],
                        entry_mig_number: None,
                        variant_mig_numbers: vec![],
                        skipped_segments: vec![],
                        skipped_positions: Vec::new(),
                    },
                    AssembledGroupInstance {
                        segments: vec![AssembledSegment {
                            tag: "NAD".to_string(),
                            elements: vec![vec!["MR".to_string()]],
                            mig_number: None,
                            segment_number: None,
                        }],
                        child_groups: vec![],
                        entry_mig_number: None,
                        variant_mig_numbers: vec![],
                        skipped_segments: vec![],
                        skipped_positions: Vec::new(),
                    },
                ],
            }],
            inter_group_segments: std::collections::BTreeMap::new(),
        };

        let disassembler = Disassembler::new(&mig);
        let segments = disassembler.disassemble(&tree);

        assert_eq!(segments.len(), 4); // UNH, BGM, NAD(MS), NAD(MR)
        assert_eq!(segments[0].tag, "UNH");
        assert_eq!(segments[1].tag, "BGM");
        assert_eq!(segments[2].tag, "NAD");
        assert_eq!(segments[2].elements[0][0], "MS");
        assert_eq!(segments[3].tag, "NAD");
        assert_eq!(segments[3].elements[0][0], "MR");
    }

    #[test]
    fn test_disassemble_nested_groups() {
        let sg3 = make_mig_group("SG3", vec!["CTA", "COM"], vec![]);
        let mig = MigSchema {
            message_type: "UTILMD".to_string(),
            variant: None,
            version: "S2.1".to_string(),
            publication_date: "".to_string(),
            author: "".to_string(),
            format_version: "FV2504".to_string(),
            source_file: "test".to_string(),
            segments: vec![make_mig_segment("UNH")],
            segment_groups: vec![make_mig_group("SG2", vec!["NAD"], vec![sg3])],
        };

        let tree = AssembledTree {
            segments: vec![AssembledSegment {
                tag: "UNH".to_string(),
                elements: vec![vec!["1".to_string()]],
                mig_number: None,
                segment_number: None,
            }],
            post_group_start: 1,
            groups: vec![AssembledGroup {
                group_id: "SG2".to_string(),
                repetitions: vec![AssembledGroupInstance {
                    segments: vec![AssembledSegment {
                        tag: "NAD".to_string(),
                        elements: vec![vec!["MS".to_string()]],
                        mig_number: None,
                        segment_number: None,
                    }],
                    child_groups: vec![AssembledGroup {
                        group_id: "SG3".to_string(),
                        repetitions: vec![AssembledGroupInstance {
                            segments: vec![
                                AssembledSegment {
                                    tag: "CTA".to_string(),
                                    elements: vec![vec!["IC".to_string()]],
                                    mig_number: None,
                                    segment_number: None,
                                },
                                AssembledSegment {
                                    tag: "COM".to_string(),
                                    elements: vec![vec![
                                        "040@ex.com".to_string(),
                                        "EM".to_string(),
                                    ]],
                                    mig_number: None,
                                    segment_number: None,
                                },
                            ],
                            child_groups: vec![],
                            entry_mig_number: None,
                            variant_mig_numbers: vec![],
                            skipped_segments: vec![],
                            skipped_positions: Vec::new(),
                        }],
                    }],
                    entry_mig_number: None,
                    variant_mig_numbers: vec![],
                    skipped_segments: vec![],
                    skipped_positions: Vec::new(),
                }],
            }],
            inter_group_segments: std::collections::BTreeMap::new(),
        };

        let disassembler = Disassembler::new(&mig);
        let segments = disassembler.disassemble(&tree);

        assert_eq!(segments.len(), 4); // UNH, NAD, CTA, COM
        assert_eq!(segments[0].tag, "UNH");
        assert_eq!(segments[1].tag, "NAD");
        assert_eq!(segments[2].tag, "CTA");
        assert_eq!(segments[3].tag, "COM");
    }

    #[test]
    fn test_disassemble_variant_groups_uses_per_variant_ordering() {
        use crate::test_support::make_mig_group_with_variant;

        // Two SG8 variant definitions with different segment ordering:
        // - ZD7 variant: SEQ, RFF, DTM
        // - Z98 variant: SEQ, CCI, CAV
        let sg8_zd7 = make_mig_group_with_variant("SG8", vec!["SEQ", "RFF", "DTM"], vec![], "ZD7");
        let sg8_z98 = make_mig_group_with_variant("SG8", vec!["SEQ", "CCI", "CAV"], vec![], "Z98");

        let mig = MigSchema {
            message_type: "UTILMD".to_string(),
            variant: None,
            version: "S2.1".to_string(),
            publication_date: "".to_string(),
            author: "".to_string(),
            format_version: "FV2504".to_string(),
            source_file: "test".to_string(),
            segments: vec![make_mig_segment("UNH")],
            segment_groups: vec![sg8_zd7, sg8_z98],
        };

        // Assembled tree has 3 reps: ZD7, Z98, ZD7 (interleaved)
        let tree = AssembledTree {
            segments: vec![AssembledSegment {
                tag: "UNH".to_string(),
                elements: vec![vec!["1".to_string()]],
                mig_number: None,
                segment_number: None,
            }],
            post_group_start: 1,
            groups: vec![AssembledGroup {
                group_id: "SG8".to_string(),
                repetitions: vec![
                    // Rep 0: ZD7 variant — has SEQ, DTM, RFF (out of MIG order)
                    AssembledGroupInstance {
                        segments: vec![
                            AssembledSegment {
                                tag: "SEQ".to_string(),
                                elements: vec![vec!["ZD7".to_string()]],
                                mig_number: None,
                                segment_number: None,
                            },
                            AssembledSegment {
                                tag: "DTM".to_string(),
                                elements: vec![vec!["303".to_string()]],
                                mig_number: None,
                                segment_number: None,
                            },
                            AssembledSegment {
                                tag: "RFF".to_string(),
                                elements: vec![vec!["Z13".to_string()]],
                                mig_number: None,
                                segment_number: None,
                            },
                        ],
                        child_groups: vec![],
                        entry_mig_number: None,
                        variant_mig_numbers: vec![],
                        skipped_segments: vec![],
                        skipped_positions: Vec::new(),
                    },
                    // Rep 1: Z98 variant — has SEQ, CAV, CCI (out of MIG order)
                    AssembledGroupInstance {
                        segments: vec![
                            AssembledSegment {
                                tag: "SEQ".to_string(),
                                elements: vec![vec!["Z98".to_string()]],
                                mig_number: None,
                                segment_number: None,
                            },
                            AssembledSegment {
                                tag: "CAV".to_string(),
                                elements: vec![vec!["Z91".to_string()]],
                                mig_number: None,
                                segment_number: None,
                            },
                            AssembledSegment {
                                tag: "CCI".to_string(),
                                elements: vec![vec!["".to_string()]],
                                mig_number: None,
                                segment_number: None,
                            },
                        ],
                        child_groups: vec![],
                        entry_mig_number: None,
                        variant_mig_numbers: vec![],
                        skipped_segments: vec![],
                        skipped_positions: Vec::new(),
                    },
                    // Rep 2: another ZD7 variant
                    AssembledGroupInstance {
                        segments: vec![
                            AssembledSegment {
                                tag: "SEQ".to_string(),
                                elements: vec![vec!["ZD7".to_string()]],
                                mig_number: None,
                                segment_number: None,
                            },
                            AssembledSegment {
                                tag: "RFF".to_string(),
                                elements: vec![vec!["Z34".to_string()]],
                                mig_number: None,
                                segment_number: None,
                            },
                        ],
                        child_groups: vec![],
                        entry_mig_number: None,
                        variant_mig_numbers: vec![],
                        skipped_segments: vec![],
                        skipped_positions: Vec::new(),
                    },
                ],
            }],
            inter_group_segments: std::collections::BTreeMap::new(),
        };

        let disassembler = Disassembler::new(&mig);
        let segments = disassembler.disassemble(&tree);

        // UNH + 3 reps
        assert_eq!(segments[0].tag, "UNH");

        // Rep 0 (ZD7): MIG order is SEQ, RFF, DTM
        assert_eq!(segments[1].tag, "SEQ");
        assert_eq!(segments[1].elements[0][0], "ZD7");
        assert_eq!(segments[2].tag, "RFF"); // reordered from position 3 to 2
        assert_eq!(segments[3].tag, "DTM"); // reordered from position 2 to 3

        // Rep 1 (Z98): MIG order is SEQ, CCI, CAV
        assert_eq!(segments[4].tag, "SEQ");
        assert_eq!(segments[4].elements[0][0], "Z98");
        assert_eq!(segments[5].tag, "CCI"); // reordered from position 3 to 2
        assert_eq!(segments[6].tag, "CAV"); // reordered from position 2 to 3

        // Rep 2 (ZD7): SEQ, RFF (no DTM)
        assert_eq!(segments[7].tag, "SEQ");
        assert_eq!(segments[7].elements[0][0], "ZD7");
        assert_eq!(segments[8].tag, "RFF");

        assert_eq!(segments.len(), 9);
    }

    /// A repetition belongs to the variant whose *allowed* qualifier codes
    /// (`variant_codes`, read at `variant_qualifier_position`) contain its entry
    /// qualifier — not only to the variant whose first code (`variant_code`) it
    /// happens to carry. Otherwise the rep is emitted with the wrong variant
    /// definition and its nested groups, which only the correct variant
    /// declares, are silently dropped (UTILMD 55013: SG9 `QTY` under `SEQ+Z98`,
    /// whose SG8 variant allows `Z01, Z80, Z81, Z98`).
    #[test]
    fn test_disassemble_variant_group_matches_any_allowed_code() {
        use crate::test_support::make_mig_group_with_variant;

        let seg = |tag: &str, qual: &str| AssembledSegment {
            tag: tag.to_string(),
            elements: vec![vec![qual.to_string()]],
            mig_number: None,
            segment_number: None,
        };
        let instance = |segments: Vec<AssembledSegment>, child_groups: Vec<AssembledGroup>| {
            AssembledGroupInstance {
                segments,
                child_groups,
                entry_mig_number: None,
                variant_mig_numbers: vec![],
                skipped_segments: vec![],
                skipped_positions: Vec::new(),
            }
        };
        let group = |id: &str, reps: Vec<AssembledGroupInstance>| AssembledGroup {
            group_id: id.to_string(),
            repetitions: reps,
        };

        // Variant 1: SEQ+ZD7, no SG9. Variant 2: SEQ+{Z01,Z98} with SG9.
        let sg8_zd7 = make_mig_group_with_variant("SG8", vec!["SEQ", "RFF"], vec![], "ZD7");
        let mut sg8_z01 = make_mig_group_with_variant(
            "SG8",
            vec!["SEQ"],
            vec![make_mig_group("SG9", vec!["QTY"], vec![])],
            "Z01",
        );
        sg8_z01.variant_codes = vec!["Z01".to_string(), "Z98".to_string()];

        let mig = MigSchema {
            message_type: "UTILMD".to_string(),
            variant: None,
            version: "S2.1".to_string(),
            publication_date: String::new(),
            author: String::new(),
            format_version: "FV2504".to_string(),
            source_file: "test".to_string(),
            segments: vec![],
            segment_groups: vec![sg8_zd7, sg8_z01],
        };

        let tree = AssembledTree {
            segments: vec![],
            post_group_start: 0,
            groups: vec![group(
                "SG8",
                vec![instance(
                    vec![seg("SEQ", "Z98")],
                    vec![group("SG9", vec![instance(vec![seg("QTY", "31")], vec![])])],
                )],
            )],
            inter_group_segments: std::collections::BTreeMap::new(),
        };

        let tags: Vec<String> = Disassembler::new(&mig)
            .disassemble(&tree)
            .iter()
            .map(|s| s.tag.clone())
            .collect();
        assert_eq!(tags, ["SEQ", "QTY"], "SG9 under SEQ+Z98 must survive");
    }

    #[test]
    fn test_disassemble_empty_tree() {
        let mig = MigSchema {
            message_type: "UTILMD".to_string(),
            variant: None,
            version: "S2.1".to_string(),
            publication_date: "".to_string(),
            author: "".to_string(),
            format_version: "FV2504".to_string(),
            source_file: "test".to_string(),
            segments: vec![make_mig_segment("UNH")],
            segment_groups: vec![],
        };

        let tree = AssembledTree {
            segments: vec![],
            groups: vec![],
            post_group_start: 0,
            inter_group_segments: std::collections::BTreeMap::new(),
        };

        let disassembler = Disassembler::new(&mig);
        let segments = disassembler.disassemble(&tree);
        assert!(segments.is_empty());
    }

    fn seg(tag: &str, first: &str) -> AssembledSegment {
        AssembledSegment {
            tag: tag.to_string(),
            elements: vec![vec![first.to_string()]],
            mig_number: None,
            segment_number: None,
        }
    }

    fn instance(
        segments: Vec<AssembledSegment>,
        child_groups: Vec<AssembledGroup>,
    ) -> AssembledGroupInstance {
        AssembledGroupInstance {
            segments,
            child_groups,
            entry_mig_number: None,
            variant_mig_numbers: vec![],
            skipped_segments: vec![],
            skipped_positions: vec![],
        }
    }

    /// UNH, SG4[IDE] > SG8_Z03[SEQ] > SG10[CCI, CAV] — the #103 shape.
    fn sg10_mig_and_tree(sg10: AssembledGroupInstance) -> (MigSchema, AssembledTree) {
        let sg10_mig = make_mig_group("SG10", vec!["CCI", "CAV"], vec![]);
        let sg8_mig = crate::test_support::make_mig_group_with_variant(
            "SG8",
            vec!["SEQ"],
            vec![sg10_mig],
            "Z03",
        );
        let sg4_mig = make_mig_group("SG4", vec!["IDE"], vec![sg8_mig]);
        let mig = MigSchema {
            message_type: "UTILMD".to_string(),
            variant: None,
            version: "S2.1".to_string(),
            publication_date: "".to_string(),
            author: "".to_string(),
            format_version: "FV2604".to_string(),
            source_file: "test".to_string(),
            segments: vec![make_mig_segment("UNH")],
            segment_groups: vec![sg4_mig],
        };
        let sg8 = instance(
            vec![seg("SEQ", "Z03")],
            vec![AssembledGroup {
                group_id: "SG10".to_string(),
                repetitions: vec![sg10],
            }],
        );
        let sg4 = instance(
            vec![seg("IDE", "24")],
            vec![AssembledGroup {
                group_id: "SG8".to_string(),
                repetitions: vec![sg8],
            }],
        );
        let tree = AssembledTree {
            segments: vec![seg("UNH", "1")],
            groups: vec![AssembledGroup {
                group_id: "SG4".to_string(),
                repetitions: vec![sg4],
            }],
            post_group_start: 1,
            inter_group_segments: std::collections::BTreeMap::new(),
        };
        (mig, tree)
    }

    #[test]
    fn checked_disassembly_refuses_group_without_entry_segment() {
        let (mig, tree) = sg10_mig_and_tree(instance(vec![seg("CAV", "Z30")], vec![]));
        let disassembler = Disassembler::new(&mig);

        // Lenient disassembly still emits it (tooling, roundtrip of raw trees).
        let tags: Vec<_> = disassembler
            .disassemble(&tree)
            .into_iter()
            .map(|s| s.tag)
            .collect();
        assert_eq!(tags, ["UNH", "IDE", "SEQ", "CAV"]);

        let expected = MissingEntrySegment {
            group_path: "SG4.SG8.SG10".to_string(),
            source_path: "sg4.sg8_z03.sg10".to_string(),
            entry_segment: "CCI".to_string(),
            present_segments: vec!["CAV".to_string()],
        };
        assert_eq!(
            disassembler.missing_entry_segments(&tree),
            vec![expected.clone()]
        );
        match disassembler.disassemble_checked(&tree) {
            Err(AssemblyError::MissingGroupEntrySegment {
                group_path,
                source_path,
                entry_segment,
                present_segments,
            }) => {
                assert_eq!(group_path, expected.group_path);
                assert_eq!(source_path, expected.source_path);
                assert_eq!(entry_segment, expected.entry_segment);
                assert_eq!(present_segments, expected.present_segments);
            }
            other => panic!("expected MissingGroupEntrySegment, got {other:?}"),
        }
    }

    #[test]
    fn checked_disassembly_accepts_complete_groups() {
        let (mig, tree) =
            sg10_mig_and_tree(instance(vec![seg("CCI", ""), seg("CAV", "Z30")], vec![]));
        let disassembler = Disassembler::new(&mig);
        assert!(disassembler.missing_entry_segments(&tree).is_empty());
        let tags: Vec<_> = disassembler
            .disassemble_checked(&tree)
            .expect("complete tree")
            .into_iter()
            .map(|s| s.tag)
            .collect();
        assert_eq!(tags, ["UNH", "IDE", "SEQ", "CCI", "CAV"]);
    }

    #[test]
    fn empty_group_instance_is_not_a_missing_entry_segment() {
        let (mig, tree) = sg10_mig_and_tree(instance(vec![], vec![]));
        assert!(Disassembler::new(&mig)
            .missing_entry_segments(&tree)
            .is_empty());
    }
}