automapper_validation/validator/

tree.rs

//! Merged AHB + EDIFACT tree for validation.
//!
//! [`build_validated_tree`] joins an [`AhbWorkflow`] (what should be there)
//! with an [`AssembledTree`] (what is there) into a single [`ValidatedTree`]
//! where each node carries both the AHB rule and the resolved EDIFACT value.

use std::collections::{BTreeMap, HashMap, HashSet};

use crate::expr::ConditionExpr;

use super::validate::{AhbFieldRule, AhbWorkflow};
use mig_assembly::assembler::{
    AssembledGroup, AssembledGroupInstance, AssembledSegment, AssembledTree,
};

/// A single AHB field matched against EDIFACT data.
#[derive(Debug)]
pub struct AhbNode<'a> {
    /// The AHB field rule (segment path, ahb_status, codes, etc.)
    pub rule: &'a AhbFieldRule,
    /// The actual value found in the EDIFACT at this position. `None` if absent.
    pub value: Option<&'a str>,
    /// The full segment elements for cross-element access. `None` if segment absent.
    pub segment_elements: Option<&'a [Vec<String>]>,
    /// Source segment counter of the matched [`AssembledSegment`], when known.
    /// Used by issue construction to populate `segment_position`.
    pub matched_segment_number: Option<u32>,
}

/// A segment group instance matched against EDIFACT data.
#[derive(Debug)]
pub struct AhbGroupNode<'a> {
    /// Group ID (e.g., "SG4", "SG8").
    pub group_id: &'a str,
    /// Which repetition of `group_id` this is, among its siblings.
    pub instance_index: usize,
    /// AHB status of this group.
    pub ahb_status: Option<&'a str>,
    /// Fields in this group instance, resolved against EDIFACT segments.
    pub fields: Vec<AhbNode<'a>>,
    /// Child group instances.
    pub children: Vec<AhbGroupNode<'a>>,
    /// Every rule of this instance's variant, its child groups' included.
    pub variant_rules: Vec<&'a AhbFieldRule>,
    /// The rules of child group variants this instance lists but lacks: each
    /// such variant's own segments, not those of groups nested in it. Only
    /// variants told apart by their entry qualifier are counted.
    pub absent_children: Vec<&'a AhbFieldRule>,
}

/// AHB workflow merged with assembled EDIFACT data.
#[derive(Debug)]
pub struct ValidatedTree<'a> {
    /// The Pruefidentifikator.
    pub pruefidentifikator: &'a str,
    /// UB definitions for condition expansion.
    pub ub_definitions: &'a BTreeMap<String, ConditionExpr>,
    /// The packages' conditions, for package cardinality.
    pub package_conditions: &'a BTreeMap<u32, ConditionExpr>,
    /// Root-level fields (outside segment groups).
    pub root_fields: Vec<AhbNode<'a>>,
    /// Top-level group instances.
    pub groups: Vec<AhbGroupNode<'a>>,
    /// Rules whose `mig_number` did not match any assembled group instance.
    ///
    /// These represent entirely-absent group variants (e.g., NAD+MS when only
    /// NAD+MR is present). `validate_tree` evaluates these using the flat
    /// `is_field_present`/`is_group_variant_absent` logic to correctly
    /// distinguish mandatory-but-missing variants from optional-and-absent ones.
    pub unmatched_rules: Vec<&'a AhbFieldRule>,
}

/// Build a [`ValidatedTree`] by merging an AHB workflow with an assembled EDIFACT tree.
///
/// The join key is `mig_number`: both [`AhbFieldRule::mig_number`] and
/// [`AssembledSegment::mig_number`] carry the MIG `Number` attribute that
/// uniquely identifies a segment variant.
pub fn build_validated_tree<'a>(
    workflow: &'a AhbWorkflow,
    tree: &'a AssembledTree,
) -> ValidatedTree<'a> {
    // Partition AHB rules into root-level and per-group buckets.
    let mut root_rules: Vec<&'a AhbFieldRule> = Vec::new();
    // Map from top-level group prefix (e.g., "SG2", "SG4") to rules.
    let mut group_rules: HashMap<String, Vec<&'a AhbFieldRule>> = HashMap::new();

    for rule in &workflow.fields {
        match extract_top_group(&rule.segment_path) {
            Some(group_id) => {
                group_rules
                    .entry(group_id.to_owned())
                    .or_default()
                    .push(rule);
            }
            None => {
                root_rules.push(rule);
            }
        }
    }

    // Resolve root-level fields against root segments.
    let root_fields = resolve_fields(&root_rules, &tree.segments, None);

    // Resolve groups recursively (depth 0 = top-level groups).
    let groups = resolve_groups(&tree.groups, &group_rules, 0, false);

    // Find rules whose mig_number wasn't matched to any tree node.
    // Collect all mig_numbers that appear in the assembled tree.
    let mut matched_mig_numbers: std::collections::HashSet<&str> = std::collections::HashSet::new();
    collect_matched_mig_numbers_from_groups(&groups, &mut matched_mig_numbers);
    // Also include root segment mig_numbers.
    for seg in &tree.segments {
        if let Some(ref num) = seg.mig_number {
            matched_mig_numbers.insert(num.as_str());
        }
    }

    let unmatched_rules: Vec<&AhbFieldRule> = workflow
        .fields
        .iter()
        .filter(|rule| {
            rule.mig_number
                .as_ref()
                .is_some_and(|num| !matched_mig_numbers.contains(num.as_str()))
        })
        .collect();

    ValidatedTree {
        pruefidentifikator: &workflow.pruefidentifikator,
        ub_definitions: &workflow.ub_definitions,
        package_conditions: &workflow.package_conditions,
        root_fields,
        groups,
        unmatched_rules,
    }
}

/// Collect all mig_numbers from rules that were accepted into the tree.
///
/// Any rule in the tree — even with `value: None` — was accepted by the
/// variant filter and is therefore "claimed". Rules NOT in this set are
/// genuinely unmatched (their variant is entirely absent).
fn collect_matched_mig_numbers_from_groups<'a>(
    groups: &[AhbGroupNode<'a>],
    out: &mut std::collections::HashSet<&'a str>,
) {
    for group in groups {
        for node in &group.fields {
            if let Some(ref num) = node.rule.mig_number {
                out.insert(num.as_str());
            }
        }
        collect_matched_mig_numbers_from_groups(&group.children, out);
    }
}

/// The variant of a merged group `instance` belongs to: its entry rule's MIG
/// number and the MIG numbers of the variant (up to the next variant's
/// entry). The variants are told apart at the entry segment's position where
/// several rules list disjoint codes; `None` when there is no such position
/// or the instance's value names none of them.
fn merged_variant<'a>(
    rules: &[&'a AhbFieldRule],
    instance: &AssembledGroupInstance,
) -> Option<(&'a str, std::ops::Range<u32>)> {
    let entry = instance.segments.first()?;
    // Only when the first segment is the group's entry: the assembler records
    // the (first variant's) entry MIG number, and a rule of that number is on
    // this tag.
    // Under a merged parent the number recorded is that of the parent's
    // first variant's group (ORDERS 17121: the SG30 of SG29 LIN+Z16, not of
    // LIN+Z54); then the first rule of these, in MIG order, is on this tag.
    let recorded = instance.entry_mig_number.as_deref()?;
    let first_tag = rules
        .iter()
        .filter_map(|r| Some((r.mig_number.as_deref()?.parse::<u32>().ok()?, *r)))
        .min_by_key(|(n, _)| *n)
        .and_then(|(_, r)| extract_segment_tag(&r.segment_path));
    if !rules.iter().any(|r| {
        r.mig_number.as_deref() == Some(recorded)
            && extract_segment_tag(&r.segment_path) == Some(entry.tag.as_str())
    }) && first_tag != Some(entry.tag.as_str())
    {
        return None;
    }
    // A merged variant's entry segment occurs once per instance — the next
    // one starts the next instance. Several same-tag segments are slots of one
    // variant (MSCONS SG10 STS+Z32, STS+Z40), told apart segment by segment.
    if instance
        .segments
        .iter()
        .filter(|s| s.tag == entry.tag)
        .count()
        != 1
    {
        return None;
    }
    let number = |r: &AhbFieldRule| r.mig_number.as_deref()?.parse::<u32>().ok();
    let mut positions: Vec<(usize, usize)> = Vec::new();
    for r in rules {
        let pos = (r.element_index.unwrap_or(0), r.component_index.unwrap_or(0));
        if extract_segment_tag(&r.segment_path) == Some(entry.tag.as_str())
            && !r.codes.is_empty()
            && !positions.contains(&pos)
        {
            positions.push(pos);
        }
    }
    // The MIG numbers of every entry-tag rule: where a variant starts.
    let all_entry_numbers: std::collections::BTreeSet<u32> = rules
        .iter()
        .filter(|r| extract_segment_tag(&r.segment_path) == Some(entry.tag.as_str()))
        .filter_map(|r| number(r))
        .collect();
    // First a position every variant codes; failing that, one where the
    // instance carries the code of exactly one variant, its range ending at
    // the next variant's entry whether or not that variant codes the
    // position (ORDERS 17121's SG30: the Zählzeit codes DE7059, CCI+++ZA8/
    // ZA7/ZA9 code DE7037).
    for every_variant in [true, false] {
        // A group of one variant is no merged group (55003's SG4).
        if !every_variant && all_entry_numbers.len() < 2 {
            break;
        }
        if let Some(found) =
            variant_at_positions(rules, entry, &positions, &all_entry_numbers, every_variant)
        {
            return Some(found);
        }
    }
    None
}

/// [`merged_variant`] at the first of `positions` that tells the instance's
/// entry segment apart: the variant whose disjoint codes there hold its
/// value. With `every_variant`, only a position every entry-tag rule codes.
fn variant_at_positions<'a>(
    rules: &[&'a AhbFieldRule],
    entry: &mig_assembly::assembler::AssembledSegment,
    positions: &[(usize, usize)],
    all_entry_numbers: &std::collections::BTreeSet<u32>,
    every_variant: bool,
) -> Option<(&'a str, std::ops::Range<u32>)> {
    let number = |r: &AhbFieldRule| r.mig_number.as_deref()?.parse::<u32>().ok();
    for &(element, component) in positions {
        // (MIG number, rule) of every entry-tag rule coding this position.
        let mut entries: Vec<(u32, &'a AhbFieldRule)> = rules
            .iter()
            .filter(|r| {
                extract_segment_tag(&r.segment_path) == Some(entry.tag.as_str())
                    && r.element_index.unwrap_or(0) == element
                    && r.component_index.unwrap_or(0) == component
                    && !r.codes.is_empty()
            })
            .filter_map(|r| Some((number(r)?, *r)))
            .collect();
        entries.sort_by_key(|(n, _)| *n);
        entries.dedup_by_key(|(n, _)| *n);
        // Every entry-tag segment of the group told apart here; else a
        // variant without a code at this position must not fall into its
        // neighbour's range (UTILMD SG10: `CCI+Z17` has no DE7037), so the
        // range ends at the next variant of all.
        if every_variant && entries.len() != all_entry_numbers.len() {
            continue;
        }
        let disjoint = (entries.len() >= 2 || !every_variant && !entries.is_empty())
            && entries.iter().enumerate().all(|(i, (_, a))| {
                entries[i + 1..].iter().all(|(_, b)| {
                    !a.codes
                        .iter()
                        .any(|c| b.codes.iter().any(|d| d.value == c.value))
                })
            });
        if !disjoint {
            continue;
        }
        let Some(value) = entry.elements.get(element).and_then(|e| e.get(component)) else {
            if every_variant {
                return None;
            }
            continue;
        };
        let Some(at) = entries
            .iter()
            .position(|(_, r)| r.codes.iter().any(|c| &c.value == value))
        else {
            if every_variant {
                return None;
            }
            continue;
        };
        let start = entries[at].0;
        let end = all_entry_numbers
            .range(start + 1..)
            .next()
            .copied()
            .unwrap_or(u32::MAX);
        return Some((entries[at].1.mig_number.as_deref()?, start..end));
    }
    None
}

/// Extract the top-level segment group from a segment path.
///
/// `"SG4/DTM/C507/2380"` -> `Some("SG4")`
/// `"SG4/SG5/LOC/3225"` -> `Some("SG4")`
/// `"BGM/1004"` -> `None`
fn extract_top_group(segment_path: &str) -> Option<&str> {
    let first = segment_path.split('/').next()?;
    if first.starts_with("SG") {
        Some(first)
    } else {
        None
    }
}

/// Extract the child group prefix from a path that already had parent groups stripped.
///
/// `"SG5/LOC/3225"` -> `Some("SG5")`
/// `"DTM/C507/2380"` -> `None`
fn extract_child_group(stripped_path: &str) -> Option<&str> {
    let first = stripped_path.split('/').next()?;
    if first.starts_with("SG") {
        Some(first)
    } else {
        None
    }
}

/// Resolve AHB fields against a list of assembled segments.
///
/// For each rule, tries to find a matching segment by `mig_number` first,
/// then falls back to segment tag matching. Rules that don't match any
/// segment get `value: None` — condition evaluation decides if that's an error.
fn resolve_fields<'a>(
    rules: &[&'a AhbFieldRule],
    segments: &'a [AssembledSegment],
    numbers: Option<&[Option<String>]>,
) -> Vec<AhbNode<'a>> {
    // The qualifiers of each MIG segment slot, from its rules that list
    // codes at the qualifier position (element 0, component 0): `00004` →
    // {137}. A rule of the same slot without codes (DE2380) finds its
    // segment by them, not by the MIG number the assembler gave positionally.
    let mut qualifiers: HashMap<(&str, &str), HashSet<&str>> = HashMap::new();
    for rule in rules {
        if rule.element_index.unwrap_or(0) != 0 || rule.component_index.unwrap_or(0) != 0 {
            continue;
        }
        let (Some(tag), Some(number)) = (
            extract_segment_tag(&rule.segment_path),
            rule.mig_number.as_deref(),
        ) else {
            continue;
        };
        if !rule.codes.is_empty() {
            qualifiers
                .entry((tag, number))
                .or_default()
                .extend(rule.codes.iter().map(|c| c.value.as_str()));
        }
    }
    rules
        .iter()
        .map(|rule| {
            let slot_qualifiers = match (
                rule.codes.is_empty(),
                extract_segment_tag(&rule.segment_path),
                rule.mig_number.as_deref(),
            ) {
                (true, Some(tag), Some(number)) => qualifiers.get(&(tag, number)),
                _ => None,
            };
            let matched_segment = match slot_qualifiers {
                Some(q) => find_segment_by_qualifier(rule, segments, q)
                    .unwrap_or_else(|| find_segment(rule, segments, numbers)),
                None => find_segment(rule, segments, numbers),
            };
            let (value, elements, segment_number) = match matched_segment {
                Some(seg) => {
                    let val = extract_value(seg, rule);
                    (val, Some(seg.elements.as_slice()), seg.segment_number)
                }
                None => {
                    // Best-effort segment counter fallback: when find_segment
                    // returns None because the expected qualifier is absent
                    // (e.g., a Muss-313 format code missing from a DTM
                    // segment that IS present), still surface the counter of
                    // the same-tag segment in this scope so a CONTRL can
                    // point to the right line. We don't borrow value/elements
                    // because the variant truly is absent — only the counter
                    // is meaningful.
                    let fallback_num = extract_segment_tag(&rule.segment_path)
                        .and_then(|tag| segments.iter().find(|s| s.tag == tag))
                        .and_then(|s| s.segment_number);
                    (None, None, fallback_num)
                }
            };
            AhbNode {
                rule,
                value,
                segment_elements: elements,
                matched_segment_number: segment_number,
            }
        })
        .collect()
}

/// Find the assembled segment matching an AHB field rule.
///
/// Matching strategy when the rule has a `mig_number`:
/// 1. **Strict match**: find a segment with the exact `mig_number`.
/// 2. **Tag fallback**: if no segment has that `mig_number`, fall back to tag
///    matching — but ONLY against segments that don't have a *different*
///    `mig_number` assigned. This prevents cross-matching between same-tag
///    segments with known identities (e.g., DTM+92 rules must not match a
///    DTM+93 segment that has `mig_number` "00024").
/// 3. Segments with `mig_number: None` (unattributed) are eligible for the
///    tag fallback, preserving backward compatibility with greedy assembly.
fn find_segment<'a>(
    rule: &AhbFieldRule,
    segments: &'a [AssembledSegment],
    numbers: Option<&[Option<String>]>,
) -> Option<&'a AssembledSegment> {
    // A segment's MIG number: its own, or the one `numbers` assigns it.
    let number_of = |i: usize, s: &'a AssembledSegment| -> Option<&str> {
        match numbers {
            Some(n) => n.get(i).and_then(|n| n.as_deref()),
            None => s.mig_number.as_deref(),
        }
    };
    let tag = extract_segment_tag(&rule.segment_path)?;

    // Qualifier-aware match: when the rule's codes identify a segment
    // variant (e.g. `STS/C601/9015` with codes=[Z32]), pick the segment
    // whose value at the rule's position matches one of those codes.
    // This overrides any mig_number that the assembler may have
    // mis-assigned positionally to same-tag variants sharing a single
    // group instance (e.g. MSCONS SG10 carries STS+Z32 *and* STS+Z40,
    // and the assembler tags them by MIG slot order, not by qualifier).
    //
    // When *no* segment in the instance carries a matching qualifier,
    // the outcome depends on how many same-tag segments are in view:
    //   * 2+ same-tag segments → real contention between variants; the
    //     rule's variant is genuinely absent from this instance, so
    //     return None and let condition evaluation decide if that's an
    //     error.
    //   * 0–1 same-tag segment → no contention. Fall through to the
    //     mig_number / tag match below to preserve behavior for merged
    //     entry slots where multiple variants share one mig_number
    //     (MSCONS SG2 collapses NAD+MS and NAD+MR onto mig=00013).
    if !rule.codes.is_empty() {
        let el_idx = rule.element_index.unwrap_or(0);
        let comp_idx = rule.component_index.unwrap_or(0);
        let expected: std::collections::HashSet<&str> =
            rule.codes.iter().map(|c| c.value.as_str()).collect();
        if let Some(seg) = segments.iter().find(|s| {
            s.tag == tag
                && s.elements
                    .get(el_idx)
                    .and_then(|e| e.get(comp_idx))
                    .is_some_and(|v| expected.contains(v.as_str()))
        }) {
            return Some(seg);
        }
        let same_tag_count = segments.iter().filter(|s| s.tag == tag).count();
        if same_tag_count > 1 {
            return None;
        }
        // One same-tag segment that is not the group's entry and carries a
        // different qualifier is another slot's (QUOTES 15001 SG27: a
        // position with only `DTM+Z03` Baujahr has no `DTM+Z04`
        // Eichgültigkeit). Only an entry segment may stand for a merged
        // variant whose qualifier it does not carry.
        let other_slot = segments.iter().enumerate().any(|(i, s)| {
            i > 0
                && s.tag == tag
                && s.elements
                    .get(el_idx)
                    .and_then(|e| e.get(comp_idx))
                    .is_some_and(|v| !v.is_empty() && !expected.contains(v.as_str()))
        });
        if other_slot {
            return None;
        }
    }

    if let Some(mig_num) = rule.mig_number.as_ref() {
        // 1. Strict mig_number match.
        if let Some((_, seg)) = segments
            .iter()
            .enumerate()
            .find(|(i, s)| number_of(*i, s) == Some(mig_num.as_str()))
        {
            return Some(seg);
        }

        // 2. Tag fallback, excluding segments with a conflicting mig_number.
        return segments
            .iter()
            .enumerate()
            .find(|(i, s)| s.tag == tag && number_of(*i, s).map_or(true, |m| m == mig_num))
            .map(|(_, s)| s);
    }

    // No mig_number on rule — pure tag match.
    segments.iter().find(|s| s.tag == tag)
}

/// The segment of `rule`'s slot among several of its tag, by the slot's
/// `qualifiers`: PRICAT 27001 sends DTM+137 before DTM+492, against MIG
/// order, and the assembler numbers them by position, so DTM+492 took
/// DTM+137's rule (`X [931] [494]`). `None` (decide as before) with fewer
/// than two segments of the tag; `Some(None)` when none carries a qualifier
/// of the slot, which is then absent.
fn find_segment_by_qualifier<'a>(
    rule: &AhbFieldRule,
    segments: &'a [AssembledSegment],
    qualifiers: &HashSet<&str>,
) -> Option<Option<&'a AssembledSegment>> {
    let tag = extract_segment_tag(&rule.segment_path)?;
    let same_tag = || segments.iter().filter(|s| s.tag == tag);
    if same_tag().count() < 2 {
        return None;
    }
    Some(same_tag().find(|s| {
        s.elements
            .first()
            .and_then(|e| e.first())
            .is_some_and(|v| qualifiers.contains(v.as_str()))
    }))
}

/// Extract the segment tag from a segment path.
///
/// `"SG4/DTM/C507/2380"` -> `"DTM"` (first non-SG component)
/// `"BGM/1004"` -> `"BGM"`
fn extract_segment_tag(segment_path: &str) -> Option<&str> {
    segment_path.split('/').find(|part| !part.starts_with("SG"))
}

/// Extract a field value from an assembled segment using element/component indices.
fn extract_value<'a>(segment: &'a AssembledSegment, rule: &AhbFieldRule) -> Option<&'a str> {
    let elem_idx = rule.element_index.unwrap_or(0);
    let comp_idx = rule.component_index.unwrap_or(0);

    let element = segment.elements.get(elem_idx)?;
    let component = element.get(comp_idx)?;

    if component.is_empty() {
        None
    } else {
        Some(component.as_str())
    }
}

/// Resolve assembled groups against grouped AHB rules, recursively.
///
/// `depth` is the number of group prefixes to strip from each rule's
/// `segment_path` before classifying it as direct or child.
fn resolve_groups<'a>(
    assembled_groups: &'a [AssembledGroup],
    group_rules: &HashMap<String, Vec<&'a AhbFieldRule>>,
    depth: usize,
    narrowed: bool,
) -> Vec<AhbGroupNode<'a>> {
    let mut result = Vec::new();

    for assembled_group in assembled_groups {
        let rules = group_rules.get(&assembled_group.group_id);

        for (instance_index, instance) in assembled_group.repetitions.iter().enumerate() {
            let mut node =
                resolve_group_instance(&assembled_group.group_id, instance, rules, depth, narrowed);
            node.instance_index = instance_index;
            result.push(node);
        }
    }

    result
}

/// Strip `n` leading group prefixes from a segment path.
///
/// `strip_n_groups("SG4/SG5/LOC/3225", 2)` -> `"LOC/3225"`
fn strip_n_groups(path: &str, n: usize) -> &str {
    let mut rest = path;
    for _ in 0..n {
        match rest.find('/') {
            Some(idx) => rest = &rest[idx + 1..],
            None => return rest,
        }
    }
    rest
}

/// Resolve a single group instance.
///
/// `depth` is how many group prefixes have been consumed so far (0 for top-level groups).
///
/// Rules are filtered to this instance by `mig_number`: a rule only applies if
/// its `mig_number` matches a segment in this instance (or a segment in a child
/// group instance). This prevents rules for SG8/SEQ+Z79 from generating false
/// missing-field errors against an SG8/SEQ+Z01 rep.
fn resolve_group_instance<'a>(
    group_id: &'a str,
    instance: &'a AssembledGroupInstance,
    rules: Option<&Vec<&'a AhbFieldRule>>,
    depth: usize,
    narrowed: bool,
) -> AhbGroupNode<'a> {
    // We need to strip (depth + 1) group prefixes to get below this group level.
    let strip_count = depth + 1;

    // Use the variant's full set of mig_numbers (from MIG definition) to
    // determine which rules belong to this instance. This includes numbers
    // for segments that may be absent — so missing-field detection still works.
    // Falls back to collecting from present segments if variant_mig_numbers is empty.
    let variant_numbers: std::collections::HashSet<&str> =
        if !instance.variant_mig_numbers.is_empty() {
            instance
                .variant_mig_numbers
                .iter()
                .map(|s| s.as_str())
                .collect()
        } else {
            collect_instance_mig_numbers(instance)
        };

    let mut direct_rules: Vec<&'a AhbFieldRule> = Vec::new();
    let mut child_group_rules: HashMap<String, Vec<&'a AhbFieldRule>> = HashMap::new();
    let mut ahb_status: Option<&'a str> = None;

    // A group merged from several variants (QUOTES SG28: CCI+++E13 00029,
    // CCI+++Z75 00042, …) carries one variant's MIG numbers and entry for
    // every instance. The instance's own variant is the one whose entry code
    // its entry segment carries; only that variant's rules apply.
    let merged = rules.and_then(|rules| {
        let own: Vec<&'a AhbFieldRule> = rules
            .iter()
            .copied()
            .filter(|r| extract_child_group(strip_n_groups(&r.segment_path, strip_count)).is_none())
            .collect();
        merged_variant(&own, instance)
    });

    // The span of this instance's MIG numbers. A child group's rules belong
    // to it when they lie inside: variants occupy contiguous MIG ranges, and
    // the instance's own numbers name only one variant of a merged child
    // (QUOTES SG28 keeps CCI+++Z75's), not all of them.
    let span = variant_numbers
        .iter()
        .filter_map(|n| n.parse::<u32>().ok())
        .fold(None, |acc: Option<(u32, u32)>, n| {
            Some(acc.map_or((n, n), |(lo, hi)| (lo.min(n), hi.max(n))))
        });

    // The rules a merged parent (`narrowed`) handed down are its own
    // variant's already (QUOTES 15005's SG31 under SG27 LIN+Z19,
    // 00084–00086). When none of them is among the numbers the assembler
    // recorded for this instance — another variant's (00096–00098, under
    // LIN+Z56) — they all apply; filtered by those numbers, the SG31 of every
    // position but the last kept no rule and was never checked.
    //
    // Only the group's own rules count here, not its child groups': the
    // recorded numbers include the children's (PRICAT 27003's SG36 records
    // its SG40 PRI 00019), so a child rule of this variant would look like a
    // match and drop the group's own rules (LIN 00016 under PGI+9) — the SG36
    // then kept no field, was never checked, and read as absent.
    let handed_down = narrowed
        && rules.is_some_and(|rules| {
            let own: Vec<&&'a AhbFieldRule> = rules
                .iter()
                .filter(|r| {
                    extract_child_group(strip_n_groups(&r.segment_path, strip_count)).is_none()
                })
                .collect();
            !own.is_empty()
                && !own.iter().any(|r| {
                    r.mig_number
                        .as_deref()
                        .is_some_and(|n| variant_numbers.contains(n))
                })
        });
    if let Some(rules) = rules {
        for rule in rules {
            // Strip all parent group prefixes plus this group to get the relative path.
            let stripped = strip_n_groups(&rule.segment_path, strip_count);
            let child = extract_child_group(stripped);

            // Skip rules whose mig_number doesn't belong to this variant.
            // Rules without mig_number pass through (tag-based fallback).
            if let Some(ref rule_mig) = rule.mig_number {
                let number = rule_mig.parse::<u32>().ok();
                let belongs = match (&merged, child) {
                    (Some((_, range)), _) => number.is_some_and(|m| range.contains(&m)),
                    (None, _) if handed_down => true,
                    (None, Some(_)) => match (number, span) {
                        (Some(m), Some((lo, hi))) => (lo..=hi).contains(&m),
                        _ => variant_numbers.contains(rule_mig.as_str()),
                    },
                    (None, None) => variant_numbers.contains(rule_mig.as_str()),
                };
                if !belongs {
                    continue;
                }
            }

            if let Some(child_group_id) = child {
                child_group_rules
                    .entry(child_group_id.to_owned())
                    .or_default()
                    .push(rule);
            } else {
                direct_rules.push(rule);
            }
        }
    }
    // The group's status is its variant's: read from the rule of the instance's
    // entry segment, else from any rule of this group proper with a MIG number
    // of the instance — never a child group's rule (it carries the child's
    // status) or a rule without a MIG number (it may be another variant's).
    let own_status = |rule: &&'a AhbFieldRule| rule.parent_group_ahb_status.as_deref();
    let entry = merged
        .as_ref()
        .map(|(entry, _)| *entry)
        .or(instance.entry_mig_number.as_deref());
    if let Some(status) = direct_rules
        .iter()
        .filter(|r| entry.is_some() && r.mig_number.as_deref() == entry)
        .find_map(own_status)
        .or_else(|| {
            direct_rules
                .iter()
                .filter(|r| r.mig_number.is_some())
                .find_map(own_status)
        })
    {
        ahb_status = Some(status);
    }

    // Resolve direct fields against instance segments.
    // The segments of a merged group's instance carry the first variant's MIG
    // numbers, not their own: per tag, the n-th segment takes the variant's
    // n-th slot (the assembler fills slots in MIG order too).
    let numbers: Option<Vec<Option<String>>> = merged.as_ref().map(|_| {
        let mut used: Vec<&str> = Vec::new();
        instance
            .segments
            .iter()
            .map(|seg| {
                let of_tag = |r: &&&'a AhbFieldRule| {
                    extract_segment_tag(&r.segment_path) == Some(seg.tag.as_str())
                };
                let mut slots: Vec<&str> = direct_rules
                    .iter()
                    .filter(of_tag)
                    .filter_map(|r| r.mig_number.as_deref())
                    .filter(|n| !used.contains(n))
                    .collect();
                slots.sort_by_key(|n| n.parse::<u32>().unwrap_or(u32::MAX));
                slots.dedup();
                // The slot whose codes the segment carries; else the first
                // slot that lists no codes; else the next one in MIG order.
                let coded = |slot: &str| {
                    direct_rules
                        .iter()
                        .filter(of_tag)
                        .filter(|r| r.mig_number.as_deref() == Some(slot) && !r.codes.is_empty())
                        .collect::<Vec<_>>()
                };
                let carries = |slot: &&str| {
                    coded(slot).iter().any(|r| {
                        seg.elements
                            .get(r.element_index.unwrap_or(0))
                            .and_then(|e| e.get(r.component_index.unwrap_or(0)))
                            .is_some_and(|v| r.codes.iter().any(|c| &c.value == v))
                    })
                };
                let slot = slots
                    .iter()
                    .find(|s| carries(s))
                    .or_else(|| slots.iter().find(|s| coded(s).is_empty()))
                    .or_else(|| slots.first())
                    .copied();
                if let Some(slot) = slot {
                    used.push(slot);
                }
                slot.map(str::to_string)
            })
            .collect()
    });
    // Handed-down rules carry this variant's MIG numbers and the segments
    // another variant's: match the segments by tag and qualifier only.
    let numbers = if handed_down && numbers.is_none() {
        Some(vec![None; instance.segments.len()])
    } else {
        numbers
    };
    let fields = resolve_fields(&direct_rules, &instance.segments, numbers.as_deref());

    // Recurse into child groups one level deeper.
    let children = resolve_groups(
        &instance.child_groups,
        &child_group_rules,
        strip_count,
        merged.is_some(),
    );

    let mut absent_children = Vec::new();
    for (child_id, rules) in &child_group_rules {
        absent_children.extend(absent_variant_rules(
            child_id,
            rules,
            &children,
            strip_count + 1,
        ));
    }
    absent_children.sort_by_key(|r| r.mig_number.as_deref().and_then(|n| n.parse::<u32>().ok()));
    let mut variant_rules = direct_rules;
    variant_rules.extend(child_group_rules.into_values().flatten());

    AhbGroupNode {
        group_id,
        instance_index: 0,
        ahb_status,
        fields,
        children,
        variant_rules,
        absent_children,
    }
}

/// The codes an entry segment lists, by (element, component).
type Profile<'a> = std::collections::BTreeMap<(usize, usize), Vec<&'a str>>;

/// The rules of `child_id`'s variants that no instance among `children`
/// claims: for each, the rules of its own segments. `rules` are every rule
/// below this instance under `child_id`; `strip` the group prefixes to strip
/// to reach the child's own segments.
///
/// Variants are told apart by the codes of their entry segment: the entry tag
/// is that of the child's first rule in MIG order, and each variant starts at
/// a segment of that tag. Every variant must code some position of it, and
/// every two must differ at one position — both code it, with disjoint codes
/// (`SG8 SEQ+Z01`, `SEQ+Z02`), or only one lists it at all (SG10 `CCI+Z39`
/// beside `CCI+++ZE4`, which leaves 7059 empty, #351). A child whose variants
/// cannot be told apart this way yields nothing.
fn absent_variant_rules<'a>(
    child_id: &str,
    rules: &[&'a AhbFieldRule],
    children: &[AhbGroupNode<'a>],
    strip: usize,
) -> Vec<&'a AhbFieldRule> {
    let number = |r: &AhbFieldRule| r.mig_number.as_deref()?.parse::<u32>().ok();
    let own: Vec<&'a AhbFieldRule> = rules
        .iter()
        .copied()
        .filter(|r| extract_child_group(strip_n_groups(&r.segment_path, strip)).is_none())
        .filter(|r| number(r).is_some())
        .collect();
    let Some(entry_tag) = own
        .iter()
        .min_by_key(|r| number(r))
        .and_then(|r| extract_segment_tag(&r.segment_path))
    else {
        return Vec::new();
    };
    let is_entry_tag = |r: &AhbFieldRule| extract_segment_tag(&r.segment_path) == Some(entry_tag);
    let starts: std::collections::BTreeSet<u32> = own
        .iter()
        .filter(|r| is_entry_tag(r))
        .filter_map(|r| number(r))
        .collect();
    // Per variant: its entry rule, and the codes its entry segment lists at
    // each (element, component) — none for a data position.
    let mut entries: Vec<(u32, &'a AhbFieldRule, Profile<'a>)> = Vec::new();
    for &start in &starts {
        let mut profile = Profile::new();
        let mut entry = None;
        for r in own
            .iter()
            .copied()
            .filter(|r| is_entry_tag(r) && number(r) == Some(start))
        {
            entry.get_or_insert(r);
            profile
                .entry((r.element_index.unwrap_or(0), r.component_index.unwrap_or(0)))
                .or_default()
                .extend(r.codes.iter().map(|c| c.value.as_str()));
        }
        if let Some(entry) = entry {
            entries.push((start, entry, profile));
        }
    }
    let coded = |p: &Profile| p.values().any(|codes| !codes.is_empty());
    // `a` codes a position `b` either leaves out or codes otherwise.
    let apart = |a: &Profile, b: &Profile| {
        a.iter().any(|(pos, codes)| {
            !codes.is_empty()
                && b.get(pos).map_or(true, |other| {
                    !other.is_empty() && !codes.iter().any(|c| other.contains(c))
                })
        })
    };
    let distinct = entries.iter().all(|(_, _, p)| coded(p))
        && entries.iter().enumerate().all(|(i, (_, _, a))| {
            entries[i + 1..]
                .iter()
                .all(|(_, _, b)| apart(a, b) || apart(b, a))
        });
    if !distinct {
        return Vec::new();
    }
    let claimed: std::collections::HashSet<&str> = children
        .iter()
        .filter(|c| c.group_id == child_id)
        .flat_map(|c| c.fields.iter().filter_map(|n| n.rule.mig_number.as_deref()))
        .collect();
    let mut out = Vec::new();
    for (i, (start, entry, _)) in entries.iter().enumerate() {
        if claimed.contains(entry.mig_number.as_deref().unwrap_or_default()) {
            continue;
        }
        let end = entries.get(i + 1).map_or(u32::MAX, |(n, _, _)| *n);
        out.extend(
            own.iter()
                .copied()
                .filter(|r| number(r).is_some_and(|n| (*start..end).contains(&n))),
        );
    }
    out
}

/// Collect all mig_numbers present in a group instance, including child groups recursively.
fn collect_instance_mig_numbers(
    instance: &AssembledGroupInstance,
) -> std::collections::HashSet<&str> {
    let mut numbers = std::collections::HashSet::new();
    for seg in &instance.segments {
        if let Some(ref num) = seg.mig_number {
            numbers.insert(num.as_str());
        }
    }
    for child_group in &instance.child_groups {
        for child_instance in &child_group.repetitions {
            numbers.extend(collect_instance_mig_numbers(child_instance));
        }
    }
    numbers
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::validator::validate::{AhbFieldRule, AhbWorkflow};
    use mig_assembly::assembler::{
        AssembledGroup, AssembledGroupInstance, AssembledSegment, AssembledTree,
    };
    use std::collections::BTreeMap;

    fn empty_workflow() -> AhbWorkflow {
        AhbWorkflow {
            pruefidentifikator: "11001".to_string(),
            description: String::new(),
            communication_direction: None,
            fields: vec![],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        }
    }

    fn empty_tree() -> AssembledTree {
        AssembledTree {
            segments: vec![],
            groups: vec![],
            post_group_start: 0,
            inter_group_segments: BTreeMap::new(),
        }
    }

    fn make_segment(
        tag: &str,
        elements: Vec<Vec<&str>>,
        mig_number: Option<&str>,
    ) -> AssembledSegment {
        AssembledSegment {
            tag: tag.to_string(),
            elements: elements
                .into_iter()
                .map(|e| e.into_iter().map(|s| s.to_string()).collect())
                .collect(),
            mig_number: mig_number.map(|s| s.to_string()),
            segment_number: None,
        }
    }

    fn make_rule(
        segment_path: &str,
        name: &str,
        ahb_status: &str,
        mig_number: Option<&str>,
        element_index: Option<usize>,
        component_index: Option<usize>,
    ) -> AhbFieldRule {
        AhbFieldRule {
            segment_path: segment_path.to_string(),
            name: name.to_string(),
            ahb_status: ahb_status.to_string(),
            codes: vec![],
            parent_group_ahb_status: None,
            segment_ahb_status: None,
            element_index,
            component_index,
            mig_number: mig_number.map(|s| s.to_string()),
            format: None,
        }
    }

    #[test]
    fn test_empty_workflow_empty_tree() {
        let workflow = empty_workflow();
        let tree = empty_tree();
        let result = build_validated_tree(&workflow, &tree);

        assert_eq!(result.pruefidentifikator, "11001");
        assert!(result.root_fields.is_empty());
        assert!(result.groups.is_empty());
    }

    #[test]
    fn test_root_field_matches_root_segment() {
        let mut workflow = empty_workflow();
        workflow.fields.push(make_rule(
            "BGM/C002/1001",
            "Nachrichtentyp",
            "X",
            Some("0001"),
            Some(0),
            Some(0),
        ));

        let tree = AssembledTree {
            segments: vec![make_segment("BGM", vec![vec!["E01"]], Some("0001"))],
            groups: vec![],
            post_group_start: 1,
            inter_group_segments: BTreeMap::new(),
        };

        let result = build_validated_tree(&workflow, &tree);

        assert_eq!(result.root_fields.len(), 1);
        let node = &result.root_fields[0];
        assert_eq!(node.value, Some("E01"));
        assert!(node.segment_elements.is_some());
        assert_eq!(node.rule.name, "Nachrichtentyp");
    }

    #[test]
    fn test_sg4_dtm_mig_number_matching() {
        // Two DTM segments with different mig_numbers.
        // AHB rule for DTM+92 (mig_number "0082") should match the correct one.
        let mut workflow = empty_workflow();

        // Rule for DTM+92: element 0 = qualifier "92", element 1 = the date value.
        workflow.fields.push(make_rule(
            "SG4/DTM/C507/2380",
            "Eingangsdatum",
            "X",
            Some("0082"),
            Some(1), // date value is element 1
            Some(0),
        ));

        // Rule for DTM+137.
        workflow.fields.push(make_rule(
            "SG4/DTM/C507/2380",
            "Dokumentendatum",
            "X",
            Some("0083"),
            Some(1),
            Some(0),
        ));

        let tree = AssembledTree {
            segments: vec![],
            groups: vec![AssembledGroup {
                group_id: "SG4".to_string(),
                repetitions: vec![AssembledGroupInstance {
                    segments: vec![
                        make_segment("DTM", vec![vec!["92"], vec!["20260101"]], Some("0082")),
                        make_segment("DTM", vec![vec!["137"], vec!["20260401"]], Some("0083")),
                    ],
                    child_groups: vec![],
                    entry_mig_number: None,
                    variant_mig_numbers: vec![],
                    skipped_segments: vec![],
                    skipped_positions: Vec::new(),
                }],
            }],
            post_group_start: 0,
            inter_group_segments: BTreeMap::new(),
        };

        let result = build_validated_tree(&workflow, &tree);

        assert_eq!(result.groups.len(), 1);
        let sg4 = &result.groups[0];
        assert_eq!(sg4.group_id, "SG4");
        assert_eq!(sg4.fields.len(), 2);

        // Eingangsdatum (mig_number 0082) should get DTM+92's date.
        let eingangsdatum = &sg4.fields[0];
        assert_eq!(eingangsdatum.rule.name, "Eingangsdatum");
        assert_eq!(eingangsdatum.value, Some("20260101"));

        // Dokumentendatum (mig_number 0083) should get DTM+137's date.
        let dokumentendatum = &sg4.fields[1];
        assert_eq!(dokumentendatum.rule.name, "Dokumentendatum");
        assert_eq!(dokumentendatum.value, Some("20260401"));
    }

    #[test]
    fn test_rule_filtered_to_correct_variant() {
        // A rule with mig_number "0099" is filtered out from an instance
        // that doesn't contain any segment with that mig_number.
        // This prevents false missing-field errors for wrong SG8 variants.
        let mut workflow = empty_workflow();
        workflow.fields.push(make_rule(
            "SG4/RFF/C506/1154",
            "Referenz",
            "X",
            Some("0099"),
            Some(0),
            Some(1),
        ));

        let tree = AssembledTree {
            segments: vec![],
            groups: vec![AssembledGroup {
                group_id: "SG4".to_string(),
                repetitions: vec![AssembledGroupInstance {
                    segments: vec![], // No segments — wrong variant
                    child_groups: vec![],
                    entry_mig_number: None,
                    variant_mig_numbers: vec![],
                    skipped_segments: vec![],
                    skipped_positions: Vec::new(),
                }],
            }],
            post_group_start: 0,
            inter_group_segments: BTreeMap::new(),
        };

        let result = build_validated_tree(&workflow, &tree);
        assert_eq!(result.groups.len(), 1);
        // Rule is filtered out — its mig_number doesn't match this instance
        assert_eq!(result.groups[0].fields.len(), 0);
    }

    #[test]
    fn test_missing_segment_within_correct_variant() {
        // A rule with mig_number "0099" IS included when the instance's
        // variant_mig_numbers lists it — even though the segment is absent.
        // This enables missing-field detection within the correct variant.
        let mut workflow = empty_workflow();
        // Entry segment rule (present)
        workflow.fields.push(make_rule(
            "SG4/SEQ/1229",
            "Qualifier",
            "X",
            Some("0098"),
            Some(0),
            Some(0),
        ));
        // Second segment rule (absent — should report missing)
        workflow.fields.push(make_rule(
            "SG4/RFF/C506/1154",
            "Referenz",
            "X",
            Some("0099"),
            Some(0),
            Some(1),
        ));

        let tree = AssembledTree {
            segments: vec![],
            groups: vec![AssembledGroup {
                group_id: "SG4".to_string(),
                repetitions: vec![AssembledGroupInstance {
                    segments: vec![
                        // Only the entry segment — RFF is missing
                        make_segment("SEQ", vec![vec!["Z01"]], Some("0098")),
                    ],
                    child_groups: vec![],
                    entry_mig_number: Some("0098".to_string()),
                    // variant_mig_numbers includes both "0098" (SEQ) and "0099" (RFF)
                    variant_mig_numbers: vec!["0098".to_string(), "0099".to_string()],
                    skipped_segments: vec![],
                    skipped_positions: Vec::new(),
                }],
            }],
            post_group_start: 0,
            inter_group_segments: BTreeMap::new(),
        };

        let result = build_validated_tree(&workflow, &tree);
        assert_eq!(result.groups.len(), 1);
        // Both rules match because variant_mig_numbers includes both
        assert_eq!(result.groups[0].fields.len(), 2);
        assert_eq!(result.groups[0].fields[0].rule.name, "Qualifier");
        assert_eq!(result.groups[0].fields[0].value, Some("Z01"));
        // RFF is missing — value is None (condition eval will report it)
        assert_eq!(result.groups[0].fields[1].rule.name, "Referenz");
        assert_eq!(result.groups[0].fields[1].value, None);
    }

    #[test]
    fn test_missing_group_variant_populates_unmatched_rules() {
        // AHB requires two SG2 variants: NAD+MS (mig "0010") and NAD+MR (mig "0011").
        // EDIFACT only has NAD+MR. Rules for NAD+MS must appear in unmatched_rules
        // so validate_tree can report them as missing using flat logic.
        let mut workflow = empty_workflow();

        // NAD+MS qualifier rule
        workflow.fields.push(make_rule(
            "SG2/NAD/3035",
            "MP-ID Absender Qualifier",
            "X",
            Some("0010"),
            Some(0),
            Some(0),
        ));
        // NAD+MS ID rule
        workflow.fields.push(make_rule(
            "SG2/NAD/C082/3039",
            "MP-ID Absender",
            "X",
            Some("0010"),
            Some(1),
            Some(0),
        ));
        // NAD+MR qualifier rule
        workflow.fields.push(make_rule(
            "SG2/NAD/3035",
            "MP-ID Empfänger Qualifier",
            "X",
            Some("0011"),
            Some(0),
            Some(0),
        ));
        // NAD+MR ID rule
        workflow.fields.push(make_rule(
            "SG2/NAD/C082/3039",
            "MP-ID Empfänger",
            "X",
            Some("0011"),
            Some(1),
            Some(0),
        ));

        // Only NAD+MR present in assembled tree.
        let tree = AssembledTree {
            segments: vec![],
            groups: vec![AssembledGroup {
                group_id: "SG2".to_string(),
                repetitions: vec![AssembledGroupInstance {
                    segments: vec![make_segment(
                        "NAD",
                        vec![vec!["MR"], vec!["9900269000000", "", "293"]],
                        Some("0011"),
                    )],
                    child_groups: vec![],
                    entry_mig_number: Some("0011".to_string()),
                    variant_mig_numbers: vec!["0011".to_string()],
                    skipped_segments: vec![],
                    skipped_positions: Vec::new(),
                }],
            }],
            post_group_start: 0,
            inter_group_segments: BTreeMap::new(),
        };

        let result = build_validated_tree(&workflow, &tree);

        // Tree should have 1 SG2 group node (NAD+MR).
        assert_eq!(result.groups.len(), 1);
        assert_eq!(result.groups[0].fields.len(), 2);
        assert_eq!(result.groups[0].fields[0].value, Some("MR"));

        // NAD+MS rules should be in unmatched_rules.
        assert_eq!(
            result.unmatched_rules.len(),
            2,
            "Expected 2 unmatched rules (NAD+MS), got {}",
            result.unmatched_rules.len()
        );
        assert_eq!(result.unmatched_rules[0].name, "MP-ID Absender Qualifier");
        assert_eq!(result.unmatched_rules[1].name, "MP-ID Absender");
    }

    #[test]
    fn test_entirely_absent_group_populates_unmatched_rules() {
        // AHB requires SG2 with NAD+MS (mig "0010"), but no SG2 exists at all.
        let mut workflow = empty_workflow();
        workflow.fields.push(make_rule(
            "SG2/NAD/3035",
            "MP-ID Absender Qualifier",
            "X",
            Some("0010"),
            Some(0),
            Some(0),
        ));

        let tree = empty_tree(); // No groups at all.

        let result = build_validated_tree(&workflow, &tree);

        // No tree nodes.
        assert!(result.groups.is_empty());

        // The rule should be in unmatched_rules.
        assert_eq!(
            result.unmatched_rules.len(),
            1,
            "Expected 1 unmatched rule, got {}",
            result.unmatched_rules.len()
        );
        assert_eq!(result.unmatched_rules[0].name, "MP-ID Absender Qualifier");
    }

    #[test]
    fn test_fallback_to_tag_when_no_mig_number() {
        let mut workflow = empty_workflow();
        workflow.fields.push(make_rule(
            "BGM/C002/1001",
            "Nachrichtentyp",
            "X",
            None, // No mig_number — should fall back to tag.
            Some(0),
            Some(0),
        ));

        let tree = AssembledTree {
            segments: vec![make_segment("BGM", vec![vec!["E01"]], None)],
            groups: vec![],
            post_group_start: 1,
            inter_group_segments: BTreeMap::new(),
        };

        let result = build_validated_tree(&workflow, &tree);
        assert_eq!(result.root_fields.len(), 1);
        assert_eq!(result.root_fields[0].value, Some("E01"));
    }

    #[test]
    fn test_nested_child_groups() {
        let mut workflow = empty_workflow();
        // A rule in SG4/SG5.
        workflow.fields.push(make_rule(
            "SG4/SG5/LOC/C517/3225",
            "Marktlokations-ID",
            "X",
            Some("0050"),
            Some(0),
            Some(0),
        ));

        let tree = AssembledTree {
            segments: vec![],
            groups: vec![AssembledGroup {
                group_id: "SG4".to_string(),
                repetitions: vec![AssembledGroupInstance {
                    segments: vec![],
                    entry_mig_number: None,
                    child_groups: vec![AssembledGroup {
                        group_id: "SG5".to_string(),
                        repetitions: vec![AssembledGroupInstance {
                            segments: vec![make_segment(
                                "LOC",
                                vec![vec!["DE00012345678"]],
                                Some("0050"),
                            )],
                            child_groups: vec![],
                            entry_mig_number: None,
                            variant_mig_numbers: vec![],
                            skipped_segments: vec![],
                            skipped_positions: Vec::new(),
                        }],
                    }],
                    variant_mig_numbers: vec![],
                    skipped_segments: vec![],
                    skipped_positions: Vec::new(),
                }],
            }],
            post_group_start: 0,
            inter_group_segments: BTreeMap::new(),
        };

        let result = build_validated_tree(&workflow, &tree);
        assert_eq!(result.groups.len(), 1);
        let sg4 = &result.groups[0];
        assert_eq!(sg4.children.len(), 1);

        let sg5 = &sg4.children[0];
        assert_eq!(sg5.group_id, "SG5");
        assert_eq!(sg5.fields.len(), 1);
        assert_eq!(sg5.fields[0].value, Some("DE00012345678"));
        assert_eq!(sg5.fields[0].rule.name, "Marktlokations-ID");
    }

    #[test]
    fn test_qualifier_aware_segment_matching_same_tag_variants() {
        // MSCONS SG10 has four STS variants (9015=Z33, Z32, Z34, Z40) with
        // mig_numbers 00035..00038. The assembler matches same-tag MIG slots
        // positionally, so when input contains STS+Z32++Z92 and STS+Z40++Z75,
        // the segments end up tagged with mig=00035 and mig=00036 (the first
        // two MIG slots) instead of mig=00036 and mig=00038.
        //
        // `find_segment` must therefore prefer a segment whose qualifier value
        // matches the rule's single-code constraint over the assembler's
        // positional mig_number. Otherwise:
        //   * rule for Z33 (mig 00035) attaches to the Z32 segment and looks
        //     "present" with the wrong value, suppressing the genuine absence;
        //   * rule for Z40 (mig 00038) finds no segment and reports the Z40
        //     STS as "missing" even though it is present in the input.
        let mut workflow = empty_workflow();

        // Z33 variant — not present in input, must resolve to None.
        let mut z33 = make_rule(
            "SG10/STS/C601/9015",
            "Statuskategorie Z33",
            "X",
            Some("00035"),
            Some(0),
            Some(0),
        );
        z33.codes = vec![super::super::validate::AhbCodeRule {
            value: "Z33".into(),
            description: String::new(),
            ahb_status: "X".into(),
        }];
        workflow.fields.push(z33);

        // Z32 variant — present in input.
        let mut z32 = make_rule(
            "SG10/STS/C601/9015",
            "Statuskategorie Z32",
            "X",
            Some("00036"),
            Some(0),
            Some(0),
        );
        z32.codes = vec![super::super::validate::AhbCodeRule {
            value: "Z32".into(),
            description: String::new(),
            ahb_status: "X".into(),
        }];
        workflow.fields.push(z32);

        // Z40 variant — present in input.
        let mut z40 = make_rule(
            "SG10/STS/C601/9015",
            "Statuskategorie Z40",
            "X",
            Some("00038"),
            Some(0),
            Some(0),
        );
        z40.codes = vec![super::super::validate::AhbCodeRule {
            value: "Z40".into(),
            description: String::new(),
            ahb_status: "X".into(),
        }];
        workflow.fields.push(z40);

        // Assembler assigned mig=00035 to the Z32 segment and mig=00036 to the Z40
        // segment (positional), mimicking the real MSCONS 13025 pipeline output.
        let tree = AssembledTree {
            segments: vec![],
            groups: vec![AssembledGroup {
                group_id: "SG10".to_string(),
                repetitions: vec![AssembledGroupInstance {
                    segments: vec![
                        make_segment("STS", vec![vec!["Z32"], vec![], vec!["Z92"]], Some("00035")),
                        make_segment("STS", vec![vec!["Z40"], vec![], vec!["Z75"]], Some("00036")),
                    ],
                    child_groups: vec![],
                    entry_mig_number: None,
                    variant_mig_numbers: vec![
                        "00035".into(),
                        "00036".into(),
                        "00037".into(),
                        "00038".into(),
                    ],
                    skipped_segments: vec![],
                    skipped_positions: Vec::new(),
                }],
            }],
            post_group_start: 0,
            inter_group_segments: BTreeMap::new(),
        };

        let result = build_validated_tree(&workflow, &tree);
        assert_eq!(result.groups.len(), 1);
        let sg10 = &result.groups[0];
        assert_eq!(
            sg10.fields.len(),
            3,
            "all three rules should pass the variant filter"
        );

        let by_name = |name: &str| sg10.fields.iter().find(|f| f.rule.name == name).unwrap();

        // Z33 is genuinely absent — no STS in the input has 9015=Z33.
        assert_eq!(
            by_name("Statuskategorie Z33").value,
            None,
            "Z33 has no matching STS in the input; must not silently pick up Z32's segment"
        );

        // Z32 must resolve to the STS segment whose 9015 is Z32,
        // regardless of the assembler's mis-assigned mig_number.
        assert_eq!(
            by_name("Statuskategorie Z32").value,
            Some("Z32"),
            "rule for Z32 must attach to the STS segment with qualifier Z32"
        );

        // Z40 must resolve to the STS segment whose 9015 is Z40.
        assert_eq!(
            by_name("Statuskategorie Z40").value,
            Some("Z40"),
            "rule for Z40 must attach to the STS segment with qualifier Z40"
        );
    }
}