automapper_validation/validator/

validate.rs

//! Main EdifactValidator implementation.

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

use crate::expr::{ConditionExpr, ConditionParser, StatusKind};

use crate::eval::answer_lists::{answer_path, is_answer_list_id};
use crate::eval::{
    AnswerCodeLists, ConditionEvaluator, ConditionExprEvaluator, ConditionResult,
    EvaluationContext, ExternalConditionProvider, GroupScope, StatusResolution,
};
use mig_assembly::assembler::AssembledTree;
use mig_assembly::navigator::AssembledTreeNavigator;
use mig_assembly::transaction_view::{TransactionSegmentsView, TransactionViews};
use mig_types::navigator::GroupNavigator;
use mig_types::segment::OwnedSegment;

use super::tree::{AhbGroupNode, AhbNode, ValidatedTree};

use super::issue::{Severity, ValidationIssue};
use super::level::ValidationLevel;
use super::report::ValidationReport;
use crate::{IssueKind, UnresolvedConditions};

// The AHB rulebook data types (`AhbFieldRule`, `AhbCodeRule`, `AhbWorkflow`) now
// live in the `ahb-types` crate so both this validation crate and `mig-bo4e`
// (which embeds `AhbWorkflow` in the distribution bundle) can share them as
// serializable data — without a mapping↔validation dependency edge. Re-exported
// here so existing `crate::validator::validate::Ahb*` paths keep resolving.
pub use ahb_types::{AhbCodeRule, AhbFieldRule, AhbWorkflow};

/// Validates EDIFACT messages against AHB business rules.
///
/// The validator is a pure validation engine: it receives pre-parsed
/// segments, an AHB workflow, and an external condition provider.
/// Parsing and message-type detection are the caller's responsibility.
///
/// The validator is generic over the `ConditionEvaluator` implementation,
/// which is typically generated from AHB XML schemas.
///
/// # Example
///
/// ```ignore
/// use automapper_validation::validator::EdifactValidator;
/// use automapper_validation::eval::NoOpExternalProvider;
///
/// let evaluator = UtilmdConditionEvaluatorFV2510::new();
/// let validator = EdifactValidator::new(evaluator);
/// let external = NoOpExternalProvider;
///
/// let report = validator.validate(
///     &segments,
///     &ahb_workflow,
///     &external,
///     ValidationLevel::Full,
/// );
///
/// if !report.is_valid() {
///     for error in report.errors() {
///         eprintln!("{error}");
///     }
/// }
/// ```
pub struct EdifactValidator<E: ConditionEvaluator> {
    evaluator: E,
    report_segments: bool,
}

impl<E: ConditionEvaluator> EdifactValidator<E> {
    /// Create a new validator with the given condition evaluator.
    pub fn new(evaluator: E) -> Self {
        Self {
            evaluator,
            report_segments: false,
        }
    }

    /// Also report segments sent although their own condition does not hold
    /// ([`IssueKind::SegmentNotAllowed`]). Off by default: the fixture
    /// generator uses it to repair its samples (#258); for messages in
    /// general it still reports what some approximate condition evaluators
    /// get wrong (`[401]` ignores its Zeitraum-ID).
    pub fn reporting_segments(mut self) -> Self {
        self.report_segments = true;
        self
    }

    /// Validate pre-parsed EDIFACT segments against an AHB workflow.
    ///
    /// # Arguments
    ///
    /// * `segments` - Pre-parsed EDIFACT segments
    /// * `workflow` - AHB workflow definition for the PID
    /// * `external` - Provider for external conditions
    /// * `level` - Validation strictness level
    ///
    /// # Returns
    ///
    /// A `ValidationReport` with all issues found.
    pub fn validate(
        &self,
        segments: &[OwnedSegment],
        workflow: &AhbWorkflow,
        external: &dyn ExternalConditionProvider,
        level: ValidationLevel,
    ) -> ValidationReport {
        let mut report = ValidationReport::new(self.evaluator.message_type(), level)
            .with_format_version(self.evaluator.format_version())
            .with_pruefidentifikator(&workflow.pruefidentifikator);

        let ctx = EvaluationContext::new(&workflow.pruefidentifikator, external, segments);

        if matches!(level, ValidationLevel::Conditions | ValidationLevel::Full) {
            self.validate_conditions(workflow, &ctx, &mut report);
        }

        report
    }

    /// Validate with a group navigator for group-scoped condition queries.
    ///
    /// Same as [`validate`] but passes a `GroupNavigator` to the
    /// `EvaluationContext`, enabling conditions to query segments within
    /// specific group instances (e.g., "in derselben SG8").
    pub fn validate_with_navigator(
        &self,
        segments: &[OwnedSegment],
        workflow: &AhbWorkflow,
        external: &dyn ExternalConditionProvider,
        level: ValidationLevel,
        navigator: &dyn GroupNavigator,
    ) -> ValidationReport {
        let mut report = ValidationReport::new(self.evaluator.message_type(), level)
            .with_format_version(self.evaluator.format_version())
            .with_pruefidentifikator(&workflow.pruefidentifikator);

        let ctx = EvaluationContext::with_navigator(
            &workflow.pruefidentifikator,
            external,
            segments,
            navigator,
        );

        if matches!(level, ValidationLevel::Conditions | ValidationLevel::Full) {
            self.validate_conditions(workflow, &ctx, &mut report);
        }

        report
    }

    /// Validate using a pre-built ValidatedTree where each node carries
    /// its resolved EDIFACT value.
    ///
    /// This is the preferred validation path -- conditions see `ctx.resolved_value`
    /// set from the tree node, so format conditions like [931] "ZZZ=+00" check
    /// the correct segment instance (e.g., DTM+92, not DTM+137).
    pub fn validate_tree(
        &self,
        validated_tree: &ValidatedTree,
        segments: &[OwnedSegment],
        external: &dyn ExternalConditionProvider,
        level: ValidationLevel,
        navigator: Option<&dyn GroupNavigator>,
    ) -> ValidationReport {
        self.validate_tree_in(validated_tree, segments, external, level, navigator, None)
    }

    /// [`validate_tree`](Self::validate_tree) over the assembled `tree`
    /// `validated_tree` was built from. A transaction (UTILMD SG4, see
    /// [`transactions`](crate::eval::transactions)) is evaluated
    /// against the message as it sees it — without the other transactions of
    /// its kind ([`AssembledTree::transaction_view`]): the AHB states its
    /// conditions per transaction (#337).
    pub fn validate_assembled_tree(
        &self,
        validated_tree: &ValidatedTree,
        segments: &[OwnedSegment],
        external: &dyn ExternalConditionProvider,
        level: ValidationLevel,
        tree: &AssembledTree,
    ) -> ValidationReport {
        let navigator = AssembledTreeNavigator::new(tree);
        self.validate_tree_in(
            validated_tree,
            segments,
            external,
            level,
            Some(&navigator),
            Some(tree),
        )
    }

    fn validate_tree_in(
        &self,
        validated_tree: &ValidatedTree,
        segments: &[OwnedSegment],
        external: &dyn ExternalConditionProvider,
        level: ValidationLevel,
        navigator: Option<&dyn GroupNavigator>,
        tree: Option<&AssembledTree>,
    ) -> ValidationReport {
        let mut report = ValidationReport::new(self.evaluator.message_type(), level)
            .with_format_version(self.evaluator.format_version())
            .with_pruefidentifikator(validated_tree.pruefidentifikator);

        if !matches!(level, ValidationLevel::Conditions | ValidationLevel::Full) {
            return report;
        }

        let ctx = match navigator {
            Some(nav) => EvaluationContext::with_navigator(
                validated_tree.pruefidentifikator,
                external,
                segments,
                nav,
            ),
            None => EvaluationContext::new(validated_tree.pruefidentifikator, external, segments),
        };

        let expr_eval = ConditionExprEvaluator::new(&self.evaluator);

        // Collect all nodes depth-first from the tree (used for tag_migs
        // precomputation and for the synthetic workflow at the bottom).
        let mut all_nodes: Vec<&AhbNode> = Vec::new();
        all_nodes.extend(validated_tree.root_fields.iter());
        for group in &validated_tree.groups {
            collect_nodes_depth_first(group, &mut all_nodes);
        }

        // For each segment tag, collect all distinct mig_numbers the workflow
        // defines. Tags with a single mig variant (UNT/UNS/UNZ in MSCONS) let
        // us fall back to a flat-segment check when assembly didn't claim the
        // segment; tags with multiple variants (DTM with +92/+93 in UTILMD)
        // must not, because a different variant's segment may satisfy
        // `is_field_present` while the rule's specific variant is absent.
        let mut tag_migs: HashMap<String, HashSet<&str>> = HashMap::new();
        for node in &all_nodes {
            if let Some(ref m) = node.rule.mig_number {
                tag_migs
                    .entry(extract_segment_id(&node.rule.segment_path))
                    .or_default()
                    .insert(m.as_str());
            }
        }
        for rule in &validated_tree.unmatched_rules {
            if let Some(ref m) = rule.mig_number {
                tag_migs
                    .entry(extract_segment_id(&rule.segment_path))
                    .or_default()
                    .insert(m.as_str());
            }
        }

        // Evaluate root-level fields (not inside any group) with message-wide scope.
        for node in &validated_tree.root_fields {
            evaluate_node(
                node,
                &ctx,
                &expr_eval,
                &self.evaluator,
                validated_tree.ub_definitions,
                &tag_migs,
                None,
                true,
                &mut report,
            );
        }

        if self.report_segments {
            refuse_segments(
                &validated_tree.root_fields,
                None,
                &[],
                &ctx,
                &self.evaluator,
                validated_tree.ub_definitions,
                0,
                &mut report,
            );
        }

        // Walk top-level groups with per-instance scope. `validated_tree.groups`
        // is a flat Vec<AhbGroupNode> where each entry corresponds to one
        // group repetition; compute the instance index by counting preceding
        // entries with the same group_id.
        let message_type = self.evaluator.message_type();
        let absent = crate::eval::AbsentTarget(&self.evaluator);
        let absent_eval = ConditionExprEvaluator::new(&absent);
        // The MIG numbers of the transaction kinds judged one transaction at a
        // time, absent groups included; the message-wide check below leaves
        // them alone.
        let mut per_transaction: HashSet<&str> = HashSet::new();
        let mut instance_counter: HashMap<&str, usize> = HashMap::new();
        // Prepared once: built one by one, each view cost a pass over the
        // whole message.
        let views = tree.map(|t| {
            t.transaction_views(segments, |g| {
                crate::eval::is_transaction_group(message_type, g)
            })
        });
        for group in &validated_tree.groups {
            let instance_index = *instance_counter
                .entry(group.group_id)
                .and_modify(|c| *c += 1)
                .or_insert(0);

            // A transaction sees the message without the other transactions
            // of its kind; it is repetition 0 there.
            let view = views
                .as_ref()
                .and_then(|v| v.view(group.group_id, instance_index));
            if let Some(view) = view {
                let first_new = report.issues.len();
                let view_navigator = AssembledTreeNavigator::new(&view.tree);
                let view_ctx = ctx.with_view(&view.segments, &view_navigator);
                let path_storage = [(group.group_id, 0)];
                let scoped_ctx = view_ctx.with_scope(GroupScope {
                    path: &path_storage,
                });
                walk_group_instance(
                    group,
                    &path_storage,
                    &scoped_ctx,
                    &expr_eval,
                    &self.evaluator,
                    validated_tree.ub_definitions,
                    &tag_migs,
                    instance_index,
                    self.report_segments,
                    &mut report,
                );
                report_absent_children(
                    group,
                    &path_storage,
                    &scoped_ctx,
                    &absent_eval,
                    &self.evaluator,
                    validated_tree.ub_definitions,
                    instance_index,
                    &mut report,
                );
                for issue in &mut report.issues[first_new..] {
                    issue.transaction_index = Some(instance_index);
                }
                per_transaction.extend(
                    group
                        .variant_rules
                        .iter()
                        .filter_map(|r| r.mig_number.as_deref()),
                );
                continue;
            }

            let path_storage = [(group.group_id, instance_index)];
            // Build a scoped context without consuming `ctx` (used again for
            // the synthetic-workflow checks at the end of this method).
            let scoped_ctx = ctx.with_scope(GroupScope {
                path: &path_storage,
            });

            walk_group_instance(
                group,
                &path_storage,
                &scoped_ctx,
                &expr_eval,
                &self.evaluator,
                validated_tree.ub_definitions,
                &tag_migs,
                instance_index,
                self.report_segments,
                &mut report,
            );
        }

        // What the AHB allows once per transaction ([2061]), counted.
        if let Some((once, transaction)) =
            crate::eval::once_per_transaction(self.evaluator.message_type())
        {
            let mut index: HashMap<&str, usize> = HashMap::new();
            for group in &validated_tree.groups {
                let i = *index
                    .entry(group.group_id)
                    .and_modify(|c| *c += 1)
                    .or_insert(0);
                if group.group_id == transaction {
                    let first_new = report.issues.len();
                    report_repeated_in_transaction(group, i, once, &ctx, &mut report);
                    for issue in &mut report.issues[first_new..] {
                        issue.transaction_index = Some(i);
                    }
                }
            }
        }

        // What UTILMD Strom asks for once / at least once per Zeitraum-ID
        // ([2004] / [2005]), counted (#483).
        if self.evaluator.message_type() == "UTILMD_Strom" {
            let mut index: HashMap<&str, usize> = HashMap::new();
            for group in &validated_tree.groups {
                let i = *index
                    .entry(group.group_id)
                    .and_modify(|c| *c += 1)
                    .or_insert(0);
                if group.group_id == "SG4" {
                    let first_new = report.issues.len();
                    report_off_count_per_zeitraum(
                        group,
                        i,
                        &ctx,
                        &self.evaluator,
                        validated_tree.ub_definitions,
                        &mut report,
                    );
                    for issue in &mut report.issues[first_new..] {
                        issue.transaction_index = Some(i);
                    }
                }
            }
        }

        // Evaluate rules whose mig_number wasn't matched to any tree node.
        // These represent entirely-absent group variants (e.g., NAD+MS when
        // only NAD+MR is present). Use the flat is_field_present/is_group_variant_absent
        // logic which correctly distinguishes mandatory-but-missing variants from
        // optional-and-absent ones.
        //
        // What they annotate is absent, so a condition asking whether it is
        // there ("Wenn vorhanden", UTILMD `[166]`) is false: an absent SG10
        // `Muss ([2004]) ∧ ([166])` variant is not demanded (`AbsentTarget`).
        for field in &validated_tree.unmatched_rules {
            if field
                .mig_number
                .as_deref()
                .is_some_and(|n| per_transaction.contains(n))
            {
                continue;
            }
            if should_skip_for_parent_group(
                field,
                &absent_eval,
                &ctx,
                validated_tree.ub_definitions,
            ) {
                continue;
            }

            let status =
                absent_eval.resolve_status(&field.ahb_status, &ctx, validated_tree.ub_definitions);

            if status.result == ConditionResult::True
                && status.kind == Some(StatusKind::Muss)
                && !is_field_present(&ctx, field)
                && !is_group_variant_absent(
                    &ctx,
                    field,
                    is_parent_group_required(
                        field,
                        &absent_eval,
                        &ctx,
                        validated_tree.ub_definitions,
                    ),
                )
            {
                let mut issue = ValidationIssue::new(
                    Severity::Error,
                    IssueKind::MissingRequiredField {
                        field_name: field.name.clone(),
                    },
                )
                .with_field_path(&field.segment_path)
                .with_rule(&field.ahb_status);
                if let Some(first_code) = field.codes.first() {
                    issue.expected_value = Some(first_code.value.clone());
                }
                issue = attach_field_position(issue, field);
                report.add_issue(issue);
            }
        }

        // Run cross-field code validation and package cardinality checks.
        // These operate on flat field rules (no resolved_value needed),
        // so we reconstruct a lightweight workflow from the tree's rules.
        if matches!(level, ValidationLevel::Full) {
            // Each rule once, in the order first seen: the tree holds a rule
            // once per node it matched (an MSCONS Lastgang's SG10 rules once
            // per value), and these checks read rules as sets.
            let mut seen: HashSet<*const AhbFieldRule> = HashSet::new();
            let all_fields: Vec<AhbFieldRule> = all_nodes
                .iter()
                .map(|node| node.rule)
                .chain(validated_tree.unmatched_rules.iter().copied())
                .filter(|rule| seen.insert(*rule as *const AhbFieldRule))
                .cloned()
                .collect();
            let synthetic_workflow = AhbWorkflow {
                pruefidentifikator: validated_tree.pruefidentifikator.to_string(),
                description: String::new(),
                communication_direction: None,
                fields: all_fields,
                ub_definitions: validated_tree.ub_definitions.clone(),
                package_conditions: validated_tree.package_conditions.clone(),
            };
            self.validate_codes_cross_field(&synthetic_workflow, &ctx, &mut report);
            self.validate_answer_lists(&synthetic_workflow, &ctx, &mut report);
            self.validate_package_cardinality(
                &synthetic_workflow,
                &ctx,
                views.as_ref(),
                &mut report,
            );
        }

        report
    }

    /// Validate AHB conditions for each field in the workflow.
    fn validate_conditions(
        &self,
        workflow: &AhbWorkflow,
        ctx: &EvaluationContext,
        report: &mut ValidationReport,
    ) {
        let expr_eval = ConditionExprEvaluator::new(&self.evaluator);

        for field in &workflow.fields {
            // Skip if parent group condition is not met (False or Unknown).
            if should_skip_for_parent_group(field, &expr_eval, ctx, &workflow.ub_definitions) {
                continue;
            }

            // Evaluate the AHB status condition expression, collecting
            // which specific condition IDs are unknown when the result is Unknown.
            let StatusResolution {
                result: condition_result,
                kind,
                unknown_ids,
            } = expr_eval.resolve_status(&field.ahb_status, ctx, &workflow.ub_definitions);
            let mandatory = kind == Some(StatusKind::Muss);

            match condition_result {
                ConditionResult::True => {
                    // Condition is met - field is required/applicable
                    if mandatory
                        && !is_field_present(ctx, field)
                        && !is_group_variant_absent(
                            ctx,
                            field,
                            is_parent_group_required(
                                field,
                                &expr_eval,
                                ctx,
                                &workflow.ub_definitions,
                            ),
                        )
                    {
                        let mut issue = ValidationIssue::new(
                            Severity::Error,
                            IssueKind::MissingRequiredField {
                                field_name: field.name.clone(),
                            },
                        )
                        .with_field_path(&field.segment_path)
                        .with_rule(&field.ahb_status)
                        .with_mig_number(field.mig_number.as_deref());
                        // Store the first expected code for BO4E path disambiguation.
                        // E.g., DTM+93's code "93" helps resolve SG4/DTM/C507/2005
                        // to Prozessdaten.gueltigBis vs gueltigAb.
                        if let Some(first_code) = field.codes.first() {
                            issue.expected_value = Some(first_code.value.clone());
                        }
                        report.add_issue(issue);
                    }
                }
                ConditionResult::False => {
                    // Condition not met.
                    // If the field has a mandatory prefix (X, Muss) AND the field is
                    // present, the condition is a format/value constraint that the
                    // value violates. E.g., "X [UB1]" where UB1 checks timezone
                    // format — the field is required, but its value is wrong.
                    if mandatory && is_field_present(ctx, field) {
                        let failed = expr_eval.false_ids_with_ub(
                            &field.ahb_status,
                            ctx,
                            &workflow.ub_definitions,
                        );
                        report.add_issue(
                            ValidationIssue::new(
                                Severity::Error,
                                IssueKind::FieldConditionNotSatisfied {
                                    field_name: field.name.clone(),
                                    failed,
                                },
                            )
                            .with_field_path(&field.segment_path)
                            .with_rule(&field.ahb_status)
                            .with_mig_number(field.mig_number.as_deref()),
                        );
                    }
                }
                ConditionResult::Unknown => {
                    // Partition unknown IDs into three categories:
                    // 1. External: require an external provider (business context)
                    // 2. Undetermined: implemented but returned Unknown (data not present)
                    // 3. Missing: not implemented in evaluator at all
                    let mut external_ids = Vec::new();
                    let mut undetermined_ids = Vec::new();
                    let mut missing_ids = Vec::new();
                    for id in unknown_ids {
                        if self.evaluator.is_external(id) {
                            external_ids.push(id);
                        } else if self.evaluator.is_known(id) {
                            undetermined_ids.push(id);
                        } else {
                            missing_ids.push(id);
                        }
                    }

                    report.add_issue(
                        ValidationIssue::new(
                            Severity::Info,
                            IssueKind::ConditionUnknown {
                                field_name: field.name.clone(),
                                unresolved: UnresolvedConditions {
                                    external: external_ids,
                                    undetermined: undetermined_ids,
                                    missing: missing_ids,
                                },
                            },
                        )
                        .with_field_path(&field.segment_path)
                        .with_rule(&field.ahb_status),
                    );
                }
            }
        }

        // Cross-field code validation: aggregate allowed codes across all field
        // rules sharing the same segment path, then check each segment instance
        // against the combined set. This avoids false positives from per-field
        // validation (e.g., NAD/3035 with [MS] for sender and [MR] for receiver).
        self.validate_codes_cross_field(workflow, ctx, report);
        self.validate_answer_lists(workflow, ctx, report);

        // Package cardinality post-processing: check that the count of codes
        // present from each package group falls within [min..max] bounds.
        self.validate_package_cardinality(workflow, ctx, None, report);
    }

    /// Validate package cardinality constraints across all field rules.
    ///
    /// Scans each code's `ahb_status` for `[NP_min..max]` package references,
    /// groups codes by `(segment_path, package_id)`, counts how many of the
    /// package's codes are actually present in the segment, and emits AHB006
    /// if the count falls outside `[min..max]`.
    ///
    /// With `views`, a package's condition is judged for an instance inside a
    /// transaction in that transaction's view, as the condition walk judges
    /// it there (#337).
    fn validate_package_cardinality(
        &self,
        workflow: &AhbWorkflow,
        ctx: &EvaluationContext,
        views: Option<&TransactionViews<'_>>,
        report: &mut ValidationReport,
    ) {
        // Collect package groups: (segment_path, package_id) -> (min, max, Vec<code_value>)
        // Also store (element_index, component_index) for looking up the value in the segment.
        struct PackageGroup {
            min: u32,
            max: u32,
            /// The sum of the codes' own maxima, and the distinct bounds the
            /// codes give (several: the sum is the package's maximum).
            max_sum: u32,
            bounds: BTreeSet<(u32, u32)>,
            code_values: Vec<String>,
            element_index: usize,
            component_index: usize,
        }

        // Key: (segment_path, mig_number, package_id).
        //
        // `mig_number` scopes the package to a specific MIG segment variant.
        // Example: in MSCONS SG10, STS+Z32 and STS+Z40 are separate variants
        // that both declare `[4P0..1]` on component 9013, but they refer to
        // disjoint packages (Z32's Statusanlaß codes vs Z40's). Without the
        // mig_number key, both variants' codes merge into one "super-package"
        // and any real message using both STS types fails cardinality.
        let mut groups: HashMap<(String, Option<String>, u32, u32, u32), PackageGroup> =
            HashMap::new();
        // Packages a code's status offers as alternatives (`X [19P1..1] ⊻
        // [20P1..1] ⊻ [22P1..1]`, UTILMD SG10 CAV Verwendungszweck): the
        // instance holds to one of them, not to each.
        let mut alternatives: HashMap<(String, Option<String>, u32), BTreeSet<u32>> =
            HashMap::new();

        let expr_eval = ConditionExprEvaluator::new(&self.evaluator);

        // The synthetic workflow of a validated tree holds one rule per
        // matched node, so an MSCONS Lastgang brings each SG10 rule once per
        // SG10, all with the same parent group status — and judging that
        // status scans the message (#437). The verdict depends on the status
        // alone here, so it is taken once per status, and only for fields
        // that name a package at all.
        let mut parent_group_skipped: HashMap<&str, bool> = HashMap::new();

        for field in &workflow.fields {
            let el_idx = field.element_index.unwrap_or(0);
            let comp_idx = field.component_index.unwrap_or(0);

            // The packages each code's ahb_status names.
            let code_packages: Vec<(&str, Vec<(u32, u32, u32)>)> = field
                .codes
                .iter()
                .filter_map(|code| {
                    let expr = ConditionParser::parse(&code.ahb_status).ok()??;
                    let mut packages = Vec::new();
                    collect_packages(&expr, &mut packages);
                    (!packages.is_empty()).then_some((code.value.as_str(), packages))
                })
                .collect();
            if code_packages.is_empty() {
                continue;
            }

            // Skip package codes whose parent group condition is False or Unknown.
            let skipped = match field.parent_group_ahb_status.as_deref() {
                Some(status) => *parent_group_skipped.entry(status).or_insert_with(|| {
                    should_skip_for_parent_group(field, &expr_eval, ctx, &workflow.ub_definitions)
                }),
                None => false,
            };
            if skipped {
                continue;
            }

            for (code_value, packages) in code_packages {
                if packages.len() > 1 {
                    let ids: BTreeSet<u32> = packages.iter().map(|(id, _, _)| *id).collect();
                    for id in &ids {
                        alternatives
                            .entry((field.segment_path.clone(), field.mig_number.clone(), *id))
                            .or_default()
                            .extend(ids.iter().copied().filter(|other| other != id));
                    }
                }

                for (pkg_id, pkg_min, pkg_max) in packages {
                    let key = (
                        field.segment_path.clone(),
                        field.mig_number.clone(),
                        pkg_id,
                        0,
                        0,
                    );
                    let group = groups.entry(key).or_insert_with(|| PackageGroup {
                        min: pkg_min,
                        max: pkg_max,
                        max_sum: 0,
                        bounds: BTreeSet::new(),
                        code_values: Vec::new(),
                        element_index: el_idx,
                        component_index: comp_idx,
                    });
                    // Codes of one package with different bounds (UTILMD
                    // CCI 4051 `Z01 [1P0..4]`, `Z02 [1P1..1]`; CAV
                    // `Z85 [1P0..1]`, `ZB5 [1P1..1]`) leave the package's
                    // own bounds open. The widest reading is taken — the
                    // lowest minimum, and as many codes as each may occur
                    // — so a message is not refused on a guess.
                    group.bounds.insert((pkg_min, pkg_max));
                    group.min = group.min.min(pkg_min);
                    if !group.code_values.iter().any(|v| v == code_value) {
                        group.max_sum = group.max_sum.saturating_add(pkg_max);
                        group.code_values.push(code_value.to_string());
                    }
                    group.max = group.max.max(pkg_max);
                }
            }
        }

        // For each package group, count present codes and check bounds.
        //
        // Package cardinality like `[4P0..1]` limits the number of codes that
        // may appear *within a single group instance*, not message-wide. When
        // a navigator is available and the field has a group path, iterate
        // per-instance and check each independently; otherwise fall back to
        // the message-wide count (used by flat-segment test fixtures).
        // Where a field's codes offer packages as alternatives at all, every
        // package of the field is one: `ZE1 [38P1..1]` ("kein
        // Verwendungszweck") is the other choice to `Z47 [19P1..1] ⊻ …`.
        let mut field_packages: HashMap<(String, Option<String>), BTreeSet<u32>> = HashMap::new();
        for (seg_path, mig_number, pkg_id, _, _) in groups.keys() {
            field_packages
                .entry((seg_path.clone(), mig_number.clone()))
                .or_default()
                .insert(*pkg_id);
        }
        let with_alternatives: Vec<(String, Option<String>)> = alternatives
            .keys()
            .map(|(p, m, _)| (p.clone(), m.clone()))
            .collect();
        for field in with_alternatives {
            let Some(ids) = field_packages.get(&field) else {
                continue;
            };
            for id in ids {
                alternatives
                    .entry((field.0.clone(), field.1.clone(), *id))
                    .or_default()
                    .extend(ids.iter().copied().filter(|other| other != id));
            }
        }

        // Per package: its counts per instance, its bounds and its codes.
        type Counted = (Vec<usize>, Vec<bool>, usize, usize, Vec<String>);
        let mut counted: HashMap<(String, Option<String>, u32, u32, u32), Counted> = HashMap::new();
        // The views of the transactions a package condition is judged in,
        // built when first needed.
        let mut transaction_views: HashMap<(String, usize), TransactionSegmentsView> =
            HashMap::new();
        for ((seg_path, mig_number, pkg_id, _, _), group) in &groups {
            let segment_id = extract_segment_id(seg_path);

            // Deduplicate code values: the synthetic workflow built from a
            // validated tree duplicates rules once per matched node, which
            // otherwise inflates the error message's code list.
            let mut unique_codes: Vec<&str> =
                group.code_values.iter().map(|s| s.as_str()).collect();
            unique_codes.sort_unstable();
            unique_codes.dedup();
            let code_set: HashSet<&str> = unique_codes.iter().copied().collect();

            let group_path_str = extract_group_path_key(seg_path);
            let group_path: Vec<&str> = if group_path_str.is_empty() {
                Vec::new()
            } else {
                group_path_str.split('/').collect()
            };

            let min = group.min as usize;
            let max = if group.bounds.len() > 1 {
                group.max_sum as usize
            } else {
                group.max as usize
            };

            // Per instance: the count, and the instance's path to judge the
            // package's condition in.
            type Instance<'p> = (usize, Option<Vec<(&'p str, usize)>>);
            let per_instance_counts: Option<Vec<Instance>> =
                match (ctx.navigator, group_path.is_empty()) {
                    // A group under a repeating parent (PARTIN `SG4/SG7`):
                    // every instance at every level. The innermost index
                    // reaches children of the first parent only, so with an
                    // SG4 that has no SG7 first, the count fell back to the
                    // whole message — 12 COMs against `[1P1..1]`.
                    // A navigator that addresses only the innermost level finds
                    // no instance this way and takes the arm below.
                    (Some(nav), false)
                        if group_path.len() > 1
                            && !full_instance_paths(nav, &group_path).is_empty() =>
                    {
                        let paths = full_instance_paths(nav, &group_path);
                        // A merged group's instance carries every variant's
                        // MIG numbers; its own variant is the one whose entry
                        // code its entry segment holds (PARTIN SG12: the
                        // `CCI+Z40` variant's DTM package does not apply to a
                        // `CCI+Z19` instance).
                        // At every level: an SG10 package of the SG8
                        // `SEQ+Z01` variant does not apply under a `SEQ+Z03`.
                        let variant_entries: Vec<(usize, VariantEntry)> = match mig_number
                            .as_deref()
                        {
                            Some(m) => (0..group_path.len())
                                .filter_map(|level| {
                                    let prefix = group_path[..=level].join("/");
                                    merged_variant_entry(workflow, &prefix, m).map(|e| (level, e))
                                })
                                .collect(),
                            None => Vec::new(),
                        };
                        if paths.is_empty() {
                            None
                        } else {
                            Some(
                                paths
                                    .into_iter()
                                    .filter(|path| match mig_number.as_deref() {
                                        Some(m) => nav.instance_at_has_mig_number(path, m),
                                        None => true,
                                    })
                                    .filter(|path| {
                                        variant_entries.iter().all(|(level, entry)| {
                                            nav.find_segments_in_instance(
                                                &entry.tag,
                                                &path[..=*level],
                                            )
                                            .first()
                                            .and_then(|seg| {
                                                seg.elements
                                                    .get(entry.element)
                                                    .and_then(|e| e.get(entry.component))
                                                    .cloned()
                                            })
                                            .map_or(true, |v| entry.codes.contains(v.as_str()))
                                        })
                                    })
                                    .map(|path| {
                                        let count = nav
                                            .find_segments_in_instance(&segment_id, &path)
                                            .iter()
                                            .filter_map(|seg| {
                                                seg.elements
                                                    .get(group.element_index)
                                                    .and_then(|e| e.get(group.component_index))
                                                    .filter(|v| !v.is_empty())
                                                    .cloned()
                                            })
                                            .filter(|v| code_set.contains(v.as_str()))
                                            .count();
                                        (count, Some(path))
                                    })
                                    .collect(),
                            )
                        }
                    }
                    (Some(nav), false) => {
                        let instance_count = nav.group_instance_count(&group_path);
                        if instance_count == 0 {
                            None
                        } else {
                            // Restrict the check to instances whose variant
                            // declares the rule's mig_number. Without this, a
                            // rule from one SG variant (e.g. PID 55218 SEQ
                            // mig=00171 for sg8_z45_z84) is counted against
                            // sibling variants (sg8_z01 with SEQ mig=00115)
                            // and fires "0 codes present" on those. Rules
                            // with no mig_number stay unscoped.
                            Some(
                                (0..instance_count)
                                    .filter(|i| match mig_number.as_deref() {
                                        Some(m) => nav.instance_has_mig_number(&group_path, *i, m),
                                        None => true,
                                    })
                                    .map(|i| {
                                        let count = nav
                                            .find_segments_in_group(&segment_id, &group_path, i)
                                            .iter()
                                            .filter_map(|seg| {
                                                seg.elements
                                                    .get(group.element_index)
                                                    .and_then(|e| e.get(group.component_index))
                                                    .filter(|v| !v.is_empty())
                                                    .cloned()
                                            })
                                            .filter(|v| code_set.contains(v.as_str()))
                                            .count();
                                        // Addressable only as a top-level group.
                                        let path = (group_path.len() == 1)
                                            .then(|| vec![(group_path[0], i)]);
                                        (count, path)
                                    })
                                    .collect(),
                            )
                        }
                    }
                    _ => None,
                };

            let instances = per_instance_counts.unwrap_or_else(|| {
                let segments = ctx.find_segments(&segment_id);
                let count = segments
                    .iter()
                    .filter_map(|seg| {
                        seg.elements
                            .get(group.element_index)
                            .and_then(|e| e.get(group.component_index))
                            .filter(|v| !v.is_empty())
                            .map(|s| s.as_str())
                    })
                    .filter(|v| code_set.contains(v))
                    .count();
                vec![(count, None)]
            });
            // A package with a condition (`[11P]` = `[68]`) binds only where
            // it holds, judged in the instance — and inside a transaction in
            // the transaction's view, where it is repetition 0: `[66]` "SEQ+ZH0
            // mehr als einmal" counts the transaction's SEQ+ZH0, not the
            // message's.
            let applies: Vec<bool> = instances
                .iter()
                .map(|(_, path)| match workflow.package_conditions.get(pkg_id) {
                    None => true,
                    Some(condition) => {
                        let result = match path {
                            Some(path) => match path.first().and_then(|&(group_id, index)| {
                                let key = (group_id.to_string(), index);
                                if !transaction_views.contains_key(&key) {
                                    let view = views?.view(group_id, index)?;
                                    transaction_views.insert(key.clone(), view);
                                }
                                transaction_views.get(&key)
                            }) {
                                Some(view) => {
                                    let navigator = AssembledTreeNavigator::new(&view.tree);
                                    let mut in_view = path.clone();
                                    in_view[0].1 = 0;
                                    expr_eval.evaluate(
                                        condition,
                                        &ctx.with_view(&view.segments, &navigator)
                                            .with_scope(crate::eval::GroupScope { path: &in_view }),
                                    )
                                }
                                None => expr_eval.evaluate(
                                    condition,
                                    &ctx.with_scope(crate::eval::GroupScope { path }),
                                ),
                            },
                            None => expr_eval.evaluate(condition, ctx),
                        };
                        result == ConditionResult::True
                    }
                })
                .collect();
            let counts: Vec<usize> = instances.iter().map(|(c, _)| *c).collect();

            counted.insert(
                (
                    seg_path.clone(),
                    mig_number.clone(),
                    *pkg_id,
                    group.min,
                    group.max,
                ),
                (
                    counts,
                    applies,
                    min,
                    max,
                    unique_codes.iter().map(|s| s.to_string()).collect(),
                ),
            );
        }

        // Emit one issue per out-of-bounds instance — unless an alternative
        // package holds there. Dedup by count so a single message-wide
        // overflow doesn't produce N copies of the same error for repeated
        // groups.
        let mut keys: Vec<&(String, Option<String>, u32, u32, u32)> = counted.keys().collect();
        keys.sort();
        for key in keys {
            let (counts, applies, min, max, codes) = &counted[key];
            let (seg_path, mig_number, pkg_id, _, _) = key;
            let holds = |c: &[usize], a: &[bool], lo: usize, hi: usize, i: usize| {
                c.len() == counts.len() && a[i] && (lo..=hi).contains(&c[i]) && c[i] > 0
            };
            let alternative_holds = |i: usize| {
                alternatives
                    .get(&(seg_path.clone(), mig_number.clone(), *pkg_id))
                    .is_some_and(|alts| {
                        counted.iter().any(|((p, m, id, _, _), (c, a, lo, hi, _))| {
                            p == seg_path
                                && m == mig_number
                                && alts.contains(id)
                                && holds(c, a, *lo, *hi, i)
                        })
                    })
            };
            // Packages of one field that apply in an instance and each demand
            // a code are alternatives there: the CAV of each SG8 SEQ+ZH0 sends
            // one priority, so with three Produktpakete `[10P1..1]` (Z75, Z76)
            // and `[11P1..1]` (Z77) both apply, and each SG10 holds to one.
            let applicable_alternative_holds = |i: usize| {
                *min > 0
                    && counted.iter().any(|((p, m, id, _, _), (c, a, lo, hi, _))| {
                        p == seg_path
                            && m == mig_number
                            && id != pkg_id
                            && *lo > 0
                            && holds(c, a, *lo, *hi, i)
                    })
            };
            let mut reported_counts: HashSet<usize> = HashSet::new();
            for (i, &present_count) in counts.iter().enumerate() {
                if applies[i]
                    && (present_count < *min || present_count > *max)
                    && !alternative_holds(i)
                    && !(present_count < *min && applicable_alternative_holds(i))
                    && reported_counts.insert(present_count)
                {
                    report.add_issue(
                        ValidationIssue::new(
                            Severity::Error,
                            IssueKind::PackageCardinality {
                                package_id: pkg_id.to_string(),
                                present: present_count,
                                min: *min,
                                max: *max,
                                codes: codes.clone(),
                            },
                        )
                        .with_field_path(seg_path)
                        .with_expected(format!("{min}..{max}"))
                        .with_actual(present_count.to_string()),
                    );
                }
            }
        }
    }

    /// Validate qualifier codes by aggregating allowed values across field rules.
    ///
    /// When a group navigator is available, codes are grouped by segment path
    /// (e.g., `SG2/NAD/3035` → `{MS, MR}`) and segments are looked up within
    /// the specific group, giving precise per-group validation.
    ///
    /// Without a navigator, falls back to grouping by segment tag and unioning
    /// all codes across groups to avoid cross-group false positives.
    ///
    /// Only validates simple qualifier paths (`[SG/]*/SEG/ELEMENT`) where the
    /// code is in `element[0][0]`. Composite paths are skipped.
    fn validate_codes_cross_field(
        &self,
        workflow: &AhbWorkflow,
        ctx: &EvaluationContext,
        report: &mut ValidationReport,
    ) {
        if ctx.navigator.is_some() {
            self.validate_codes_group_scoped(workflow, ctx, report);
        } else {
            self.validate_codes_tag_scoped(workflow, ctx, report);
        }
    }

    /// Group-scoped code validation: group codes by path, use navigator to
    /// find segments within each group, check against that group's codes only.
    fn validate_codes_group_scoped(
        &self,
        workflow: &AhbWorkflow,
        ctx: &EvaluationContext,
        report: &mut ValidationReport,
    ) {
        let by_loc = partition_codes_by_mig(workflow);
        let known_qualifiers = global_qualifiers_by_tag(&by_loc);
        let data_slots = data_slot_entries(workflow);
        let nav = ctx.navigator.unwrap();

        for ((group_key, tag), migs) in &by_loc {
            let field_path = if group_key.is_empty() {
                format!("{tag}/qualifier")
            } else {
                format!("{group_key}/{tag}/qualifier")
            };

            let group_path: Vec<&str> = if group_key.is_empty() {
                Vec::new()
            } else {
                group_key.split('/').collect()
            };

            let tag_qualifiers = known_qualifiers.get(tag);

            if group_path.is_empty() {
                Self::validate_segments_per_mig(
                    &ctx.find_segments(tag),
                    migs,
                    tag_qualifiers,
                    false,
                    tag,
                    &field_path,
                    report,
                );
            } else {
                let instance_count = nav.group_instance_count(&group_path);
                let slots = data_slots.get(&(group_key.clone(), tag.clone()));
                for i in 0..instance_count {
                    let owned = nav.find_segments_in_group(tag, &group_path, i);
                    let refs: Vec<&OwnedSegment> = owned.iter().collect();
                    // This instance is the variant holding a data slot of
                    // this tag: a value no bucket matches may be that data.
                    let holds_data_slot = slots.is_some_and(|entries| {
                        entries.iter().any(|(entry_tag, entry_mig)| {
                            let Some(bucket) = by_loc
                                .get(&(group_key.clone(), entry_tag.clone()))
                                .and_then(|m| m.get(entry_mig))
                            else {
                                return false;
                            };
                            nav.find_segments_in_group(entry_tag, &group_path, i)
                                .iter()
                                .any(|s| matches_qualifier(s, bucket))
                        })
                    });
                    Self::validate_segments_per_mig(
                        &refs,
                        migs,
                        tag_qualifiers,
                        holds_data_slot,
                        tag,
                        &field_path,
                        report,
                    );
                }
            }
        }
    }

    /// Fallback: no navigator — validate segments flat by tag. Still partitions
    /// codes by mig_number so segments are checked only against codes from their
    /// matching mig.
    fn validate_codes_tag_scoped(
        &self,
        workflow: &AhbWorkflow,
        ctx: &EvaluationContext,
        report: &mut ValidationReport,
    ) {
        let by_loc = partition_codes_by_mig(workflow);
        let known_qualifiers = global_qualifiers_by_tag(&by_loc);
        // Merge entries that share a tag (tag-scoped ignores group_key).
        let mut by_tag: BTreeMap<String, BTreeMap<Option<String>, MigCodeBucket>> = BTreeMap::new();
        for ((_group_key, tag), migs) in by_loc {
            let merged = by_tag.entry(tag).or_default();
            for (mig_key, bucket) in migs {
                let entry = merged.entry(mig_key).or_default();
                if entry.qualifier_position.is_none() {
                    entry.qualifier_position = bucket.qualifier_position;
                }
                if entry.qualifier_position == bucket.qualifier_position {
                    entry.qualifier_values.extend(&bucket.qualifier_values);
                }
                for (pos, codes) in bucket.codes {
                    entry.codes.entry(pos).or_default().extend(codes);
                }
            }
        }

        for (tag, migs) in &by_tag {
            let field_path = format!("{tag}/qualifier");
            Self::validate_segments_per_mig(
                &ctx.find_segments(tag),
                migs,
                known_qualifiers.get(tag),
                false,
                tag,
                &field_path,
                report,
            );
        }
    }

    /// For each segment, match it to a mig_number via its primary qualifier and
    /// validate only that mig's code constraints.
    ///
    /// `tag_qualifiers` is the set of all qualifier values this tag uses anywhere
    /// in the workflow, keyed by position. When no mig at the current location
    /// matches a segment, but the segment's qualifier IS valid somewhere else for
    /// this tag, we skip it (the segment belongs to another location that's
    /// handled separately). Only truly unknown qualifier values are flagged.
    ///
    /// `holds_data_slot`: the segments' group instance has a slot of this tag
    /// whose leading element the AHB gives as data (55673's Zeitreihentyp
    /// CAV under `CCI+15++Z21`), so a value no bucket matches is that data.
    fn validate_segments_per_mig(
        segments: &[&OwnedSegment],
        migs: &BTreeMap<Option<String>, MigCodeBucket>,
        tag_qualifiers: Option<&BTreeMap<(usize, usize), HashSet<String>>>,
        holds_data_slot: bool,
        tag: &str,
        field_path: &str,
        report: &mut ValidationReport,
    ) {
        for seg in segments {
            match match_segment_to_mig(seg, migs) {
                Some(bucket) => {
                    for ((el, c), allowed) in &bucket.codes {
                        if allowed.is_empty() {
                            continue;
                        }
                        Self::check_segments_against_codes(
                            vec![*seg],
                            allowed,
                            tag,
                            *el,
                            *c,
                            field_path,
                            report,
                        );
                    }
                }
                None => {
                    let Some(qualifiers) = tag_qualifiers.filter(|_| !holds_data_slot) else {
                        continue;
                    };
                    // Find a qualifier position where this segment has a value.
                    // If the value matches any known qualifier for this tag (at any
                    // location), the segment belongs elsewhere — skip. Otherwise
                    // report an invalid qualifier against the union at this position.
                    for ((el, c), allowed) in qualifiers {
                        let Some(actual) = seg
                            .elements
                            .get(*el)
                            .and_then(|e| e.get(*c))
                            .filter(|v| !v.is_empty())
                            .map(|s| s.as_str())
                        else {
                            continue;
                        };
                        if allowed.iter().any(|v| v == actual) {
                            // Qualifier is valid at some location — skip here.
                            break;
                        }
                        // Truly unknown qualifier value — report against this
                        // location's bucket union if it has one.
                        let bucket_values: HashSet<&str> = migs
                            .values()
                            .filter(|b| b.qualifier_position == Some((*el, *c)))
                            .flat_map(|b| b.qualifier_values.iter().copied())
                            .collect();
                        if !bucket_values.is_empty() {
                            Self::check_segments_against_codes(
                                vec![*seg],
                                &bucket_values,
                                tag,
                                *el,
                                *c,
                                field_path,
                                report,
                            );
                            break;
                        }
                    }
                }
            }
        }
    }

    /// A response's answer must be one of the codes of the EBD or Codeliste it
    /// names: AJT 4465 of the list in AJT 1082, STS C556/9013 of the list in
    /// C556/1131 ([`IssueKind::AnswerNotInList`]). A warning — the AHB, which
    /// the other checks enforce, does not say what a list holds.
    ///
    /// Silent when the list is not in the data, the answer is empty or one of
    /// the AHB's own codes for the element, or the list element holds
    /// something other than a list the rule allows.
    fn validate_answer_lists(
        &self,
        workflow: &AhbWorkflow,
        ctx: &EvaluationContext,
        report: &mut ValidationReport,
    ) {
        let lists = AnswerCodeLists::embedded();
        let fv = self.evaluator.format_version();
        let mut seen: HashSet<(*const OwnedSegment, usize, usize)> = HashSet::new();
        for list_rule in &workflow.fields {
            let Some(answer_path) = answer_path(&list_rule.segment_path) else {
                continue;
            };
            if list_rule.codes.is_empty()
                || !list_rule.codes.iter().all(|c| is_answer_list_id(&c.value))
            {
                continue;
            }
            let Some(answer_rule) = workflow
                .fields
                .iter()
                .find(|f| f.segment_path == answer_path && f.mig_number == list_rule.mig_number)
            else {
                continue;
            };
            let at = |rule: &AhbFieldRule| {
                (
                    rule.element_index.unwrap_or(0),
                    rule.component_index.unwrap_or(0),
                )
            };
            let (list_el, list_c) = at(list_rule);
            let (answer_el, answer_c) = at(answer_rule);
            let value = |seg: &OwnedSegment, el: usize, c: usize| {
                seg.elements
                    .get(el)
                    .and_then(|e| e.get(c))
                    .filter(|v| !v.is_empty())
                    .cloned()
            };
            for seg in ctx.find_segments(&extract_segment_id(&list_rule.segment_path)) {
                if !seen.insert((seg as *const OwnedSegment, list_el, list_c)) {
                    continue;
                }
                let (Some(list), Some(answer)) =
                    (value(seg, list_el, list_c), value(seg, answer_el, answer_c))
                else {
                    continue;
                };
                if !list_rule.codes.iter().any(|c| c.value == list) {
                    continue;
                }
                // An answer the AHB itself lists for the element is judged by
                // the AHB (IFTSTA 21025: 9013 `Z74` "kein Zugang" beside
                // `E_0286`, which holds only A-codes).
                if answer_rule.codes.iter().any(|c| c.value == answer) {
                    continue;
                }
                let Some(codes) = lists.codes(fv, &list) else {
                    continue;
                };
                if codes.contains(&answer) {
                    continue;
                }
                let mut allowed: Vec<String> = codes.iter().cloned().collect();
                allowed.sort_unstable();
                report.add_issue(
                    ValidationIssue::new(
                        Severity::Warning,
                        IssueKind::AnswerNotInList {
                            answer: answer.clone(),
                            list: list.clone(),
                            allowed: allowed.clone(),
                        },
                    )
                    .with_field_path(&answer_rule.segment_path)
                    .with_actual(&answer)
                    .with_expected(allowed.join(", ")),
                );
            }
        }
    }

    /// Check a list of segments' qualifier at the given element/component index against allowed codes.
    fn check_segments_against_codes(
        segments: Vec<&OwnedSegment>,
        allowed_codes: &HashSet<&str>,
        _tag: &str,
        el_idx: usize,
        comp_idx: usize,
        field_path: &str,
        report: &mut ValidationReport,
    ) {
        for segment in segments {
            if let Some(code_value) = segment
                .elements
                .get(el_idx)
                .and_then(|e| e.get(comp_idx))
                .filter(|v| !v.is_empty())
            {
                if !allowed_codes.contains(code_value.as_str()) {
                    let mut sorted_codes: Vec<&str> = allowed_codes.iter().copied().collect();
                    sorted_codes.sort_unstable();
                    let kind = IssueKind::CodeNotAllowedForPid {
                        value: code_value.to_string(),
                        allowed: sorted_codes.iter().map(|s| (*s).to_string()).collect(),
                    };
                    let mut issue = ValidationIssue::new(Severity::Error, kind)
                        .with_field_path(field_path)
                        .with_actual(code_value)
                        .with_expected(sorted_codes.join(", "))
                        .with_field_position(el_idx as u32 + 2, Some(comp_idx as u32 + 1));
                    if segment.segment_number > 0 {
                        issue =
                            issue.with_position(crate::SegmentPosition::at(segment.segment_number));
                    }
                    report.add_issue(issue);
                }
            }
        }
    }
}

/// Every instance of the group at `group_path`, addressed at every level:
/// `[("SG4", 3), ("SG7", 0)]`, in message order.
fn full_instance_paths<'p>(
    nav: &dyn GroupNavigator,
    group_path: &[&'p str],
) -> Vec<Vec<(&'p str, usize)>> {
    let mut paths: Vec<Vec<(&'p str, usize)>> = vec![Vec::new()];
    for g in group_path {
        paths = paths
            .into_iter()
            .flat_map(|parent| {
                (0..nav.child_instance_count(&parent, g)).map(move |i| {
                    let mut path = parent.clone();
                    path.push((*g, i));
                    path
                })
            })
            .collect();
    }
    paths
}

/// The entry rule of the variant a rule belongs to, in a group the PID filter
/// merged from several variants.
struct VariantEntry<'a> {
    tag: String,
    element: usize,
    component: usize,
    codes: HashSet<&'a str>,
}

/// For the rule numbered `mig` in the group at `group_path` (`SG4/SG12`): the
/// entry rule of its variant, when the group is a merge of variants told
/// apart by their entry segment's codes. Variants occupy contiguous MIG
/// number ranges, so the variant is the one whose entry rule has the greatest
/// number not above `mig`. `None` for a group of one variant.
fn merged_variant_entry<'a>(
    workflow: &'a AhbWorkflow,
    group_path: &str,
    mig: &str,
) -> Option<VariantEntry<'a>> {
    let mig: u32 = mig.parse().ok()?;
    let prefix = format!("{group_path}/");
    // Direct rules of the group: `SG4/SG12/TAG/...`, no deeper group.
    let direct: Vec<(&AhbFieldRule, u32, &str)> = workflow
        .fields
        .iter()
        .filter_map(|r| {
            let rest = r.segment_path.strip_prefix(&prefix)?;
            let tag = rest.split('/').next()?;
            if tag.starts_with("SG") {
                return None;
            }
            Some((r, r.mig_number.as_deref()?.parse::<u32>().ok()?, tag))
        })
        .collect();
    // The entry tag is that of the group's first segment.
    let (_, _, entry_tag) = *direct.iter().min_by_key(|(_, n, _)| *n)?;
    let entries: Vec<&(&AhbFieldRule, u32, &str)> = direct
        .iter()
        .filter(|(r, _, tag)| *tag == entry_tag && !r.codes.is_empty())
        .collect();
    let numbers: HashSet<u32> = entries.iter().map(|(_, n, _)| *n).collect();
    if numbers.len() < 2 {
        return None;
    }
    let own = entries
        .iter()
        .filter(|(_, n, _)| *n <= mig)
        .map(|(_, n, _)| *n)
        .max()?;
    // The entry rule of that variant coding the first coded position.
    let (rule, _, tag) = entries
        .iter()
        .filter(|(_, n, _)| *n == own)
        .min_by_key(|(r, _, _)| (r.element_index.unwrap_or(0), r.component_index.unwrap_or(0)))?;
    Some(VariantEntry {
        tag: tag.to_string(),
        element: rule.element_index.unwrap_or(0),
        component: rule.component_index.unwrap_or(0),
        codes: rule.codes.iter().map(|c| c.value.as_str()).collect(),
    })
}

/// The length of `value` as its format counts it: in a numeric (`n..15`)
/// the decimal mark and a sign are not part of the length; everything else
/// counts, letters included, so a non-numeric value cannot slip under it.
fn value_length(format: &str, value: &str) -> usize {
    let format = format.trim();
    if format.starts_with('n') {
        value
            .chars()
            .filter(|c| !matches!(c, '.' | ',' | '-'))
            .count()
    } else {
        value.chars().count()
    }
}

/// The maximum length a MIG data format allows: `an..512` → 512, `n13` → 13,
/// `an3` → 3. `None` for anything else.
fn max_length(format: &str) -> Option<usize> {
    let digits = format
        .trim()
        .strip_prefix("an")
        .or_else(|| format.trim().strip_prefix('a'))
        .or_else(|| format.trim().strip_prefix('n'))?;
    digits.strip_prefix("..").unwrap_or(digits).parse().ok()
}

/// The status that governs `field` when it carries `value`.
///
/// The PID schema gives a code element the status of its *first* code when the
/// AHB annotates only the codes (`D_9013` Transaktionsgrund: `E01` is
/// `X [192]`, `E03` is `X`; the element reads `X [192]`). Judged by that, a
/// message sending `E03` violates [192], which says nothing about `E03`. So a
/// present value that is one of the codes is judged by that code's own status —
/// but only where the element's status is evidently the first code's, so an
/// element with a condition of its own keeps it, unless its codes are
/// [alternatives](codes_are_alternatives) to it.
fn governing_status<'a>(field: &'a AhbFieldRule, value: Option<&str>) -> &'a str {
    let derived_from_codes = field
        .codes
        .first()
        .is_some_and(|c| c.ahb_status == field.ahb_status);
    if !derived_from_codes && !codes_are_alternatives(field) {
        return &field.ahb_status;
    }
    value
        .and_then(|v| field.codes.iter().find(|c| c.value == v))
        .map_or(&field.ahb_status, |c| &c.ahb_status)
}

/// Whether the element's own status and its codes' conditions are
/// alternatives, not one rule: the element status admits a value the AHB does
/// not list, each code row its code (#319). IFTSTA 21025/21027 STS
/// `D_9013` is `X [153] ∧ [538]` — with DE1131 = E_0286 "der Code aus dem
/// EBD" (A01 …) — while its codes Z74/Z75 are `X [103] ∧ [537]`, without
/// DE1131.
///
/// Recognised by an element status of its own beside codes that carry
/// conditions of their own; every other element with both (CONTRL `0085`,
/// PRICAT `7009`) has unconditional code rows, which only restrict it.
fn codes_are_alternatives(field: &AhbFieldRule) -> bool {
    !field.codes.is_empty()
        && field.ahb_status.contains('[')
        && field
            .codes
            .iter()
            .all(|c| c.ahb_status.contains('[') && c.ahb_status != field.ahb_status)
}

/// Check if the parent group's conditional status evaluates to False or Unknown.
///
/// Returns `true` if the field should be skipped (parent group condition not met).
/// Only evaluates when `parent_group_ahb_status` contains condition brackets `[`.
/// Simple statuses like "Kann" or "Muss" pass through (return `false`).
///
/// The group applies when any of its status lines holds: ORDERS 17101's
/// SG2 `NAD+DP` is `Muss [69]` / `Kann`, so with NAD+Z23 present it is
/// optional, not excluded, and its LOC+172 is still held to `[950]` (#373).
fn should_skip_for_parent_group<E: ConditionEvaluator>(
    field: &AhbFieldRule,
    expr_eval: &ConditionExprEvaluator<E>,
    ctx: &EvaluationContext,
    ub_definitions: &BTreeMap<String, ConditionExpr>,
) -> bool {
    let Some(group_status) = field.parent_group_ahb_status.as_deref() else {
        return false;
    };
    if !group_status.contains('[') {
        return false;
    }
    match ConditionParser::parse_status_branches(group_status, ub_definitions) {
        Ok(branches) => !branches.iter().any(|branch| {
            branch.condition.as_ref().map_or(true, |c| {
                expr_eval.evaluate(c, ctx) == ConditionResult::True
            })
        }),
        Err(_) => true,
    }
}

/// Whether no status line of the field's parent group can hold: each is
/// conditional and its condition is False. Unlike
/// [`should_skip_for_parent_group`], an Unknown line keeps the group.
fn parent_group_refused<E: ConditionEvaluator>(
    field: &AhbFieldRule,
    expr_eval: &ConditionExprEvaluator<E>,
    ctx: &EvaluationContext,
    ub_definitions: &BTreeMap<String, ConditionExpr>,
) -> bool {
    let Some(group_status) = field.parent_group_ahb_status.as_deref() else {
        return false;
    };
    if !group_status.contains('[') {
        return false;
    }
    match ConditionParser::parse_status_branches(group_status, ub_definitions) {
        Ok(branches) => branches.iter().all(|branch| {
            branch
                .condition
                .as_ref()
                .is_some_and(|c| expr_eval.evaluate(c, ctx) == ConditionResult::False)
        }),
        Err(_) => true,
    }
}

/// Whether the field's parent group is required here: the status that applies
/// to it (the strictest of its lines that holds) is `Muss`/`X`.
///
/// `should_skip_for_parent_group` has already dropped fields whose group does
/// not apply at all; this tells a required group from a recommended one, which
/// for `Soll [47] ∧ … / Muss [46] ∧ …` depends on which line holds.
fn is_parent_group_required<E: ConditionEvaluator>(
    field: &AhbFieldRule,
    expr_eval: &ConditionExprEvaluator<E>,
    ctx: &EvaluationContext,
    ub_definitions: &BTreeMap<String, ConditionExpr>,
) -> bool {
    field
        .parent_group_ahb_status
        .as_deref()
        .is_some_and(|status| {
            let status = expr_eval.resolve_status(status, ctx, ub_definitions);
            status.result == ConditionResult::True && status.kind == Some(StatusKind::Muss)
        })
}

/// Check if a field's required segment instance is present.
///
/// For fields with qualifier codes (e.g., `SG2/NAD/3035` with `[MR]`),
/// checks that a segment with one of those qualifier values exists.
/// Otherwise just checks that any segment with the tag is present.
///
/// This prevents false negatives where `NAD+MS` is present but the
/// validator incorrectly says NAD "exists" when `NAD+MR` is missing.
fn is_field_present(ctx: &EvaluationContext, field: &AhbFieldRule) -> bool {
    let segment_id = extract_segment_id(&field.segment_path);

    // When a field has known codes, check for a segment containing one of those
    // specific values at the right element/component position. This applies to both
    // simple qualifier paths (NAD/3035) and composite paths (CCI/C240/7037) —
    // without this, a CCI segment from a different group variant (e.g., CCI+Z61)
    // would falsely satisfy the check for CCI with C240/7037 codes Z15/Z18.
    if !field.codes.is_empty() {
        if let (Some(el_idx), Some(comp_idx)) = (field.element_index, field.component_index) {
            let required_codes: Vec<&str> = field.codes.iter().map(|c| c.value.as_str()).collect();
            let matching = ctx.find_segments(&segment_id);
            return matching.iter().any(|seg| {
                seg.elements
                    .get(el_idx)
                    .and_then(|e| e.get(comp_idx))
                    .is_some_and(|v| required_codes.contains(&v.as_str()))
            });
        }
        // Fallback for fields with codes but no element/component indices:
        // use simple qualifier check if it's a qualifier-style path.
        if is_qualifier_field(&field.segment_path) {
            let required_codes: Vec<&str> = field.codes.iter().map(|c| c.value.as_str()).collect();
            let el_idx = field.element_index.unwrap_or(0);
            let comp_idx = field.component_index.unwrap_or(0);
            let matching = ctx.find_segments(&segment_id);
            return matching.iter().any(|seg| {
                seg.elements
                    .get(el_idx)
                    .and_then(|e| e.get(comp_idx))
                    .is_some_and(|v| required_codes.contains(&v.as_str()))
            });
        }
    }

    ctx.has_segment(&segment_id)
}

/// Check if the group variant for a field is absent from the message.
///
/// Uses tree-based logic:
/// 1. **Group entirely absent**: If the group path has 0 instances, the
///    whole group is absent and its children aren't required.
/// 2. **Optional group variant absent**: If the parent group is optional
///    ("Kann") and the specific qualifier variant isn't present, the variant
///    is absent. E.g., SG5 "Kann" with LOC+Z17 — if no SG5 instance has
///    LOC+Z17, all fields under that variant are skipped.
///
/// Returns `false` (not absent) when:
/// - The field has no group prefix (e.g., `NAD/3035`)
/// - No navigator is available (can't determine group presence)
/// - The parent group is mandatory and has instances
fn is_group_variant_absent(
    ctx: &EvaluationContext,
    field: &AhbFieldRule,
    is_group_mandatory: bool,
) -> bool {
    let group_path: Vec<&str> = field
        .segment_path
        .split('/')
        .take_while(|p| p.starts_with("SG"))
        .collect();

    if group_path.is_empty() {
        return false;
    }

    let nav = match ctx.navigator {
        Some(nav) => nav,
        None => return false,
    };

    let instance_count = nav.group_instance_count(&group_path);

    // Case 1: group entirely absent — only skip if the group is NOT mandatory.
    // When a mandatory group (parent_group_ahb_status contains "Muss" or "X")
    // has 0 instances, the group's absence is itself the error, so we should
    // NOT skip field validation — let the field-level check report the missing field.
    if instance_count == 0 {
        if !is_group_mandatory {
            return true;
        }
        // Mandatory group with 0 instances → don't suppress field errors
        return false;
    }

    // Case 2: group has instances, but the specific qualifier variant may be absent.
    // Only applies when the parent group is not required here ("Kann", "Soll",
    // or "Kann [345]" whose condition holds — allowed, never demanded):
    // required groups ("Muss", "X") require all their qualifier variants.
    if field.parent_group_ahb_status.is_some() && !is_group_mandatory {
        // Check if the field's qualifier variant is present in any instance.
        if !field.codes.is_empty() && is_qualifier_field(&field.segment_path) {
            let segment_id = extract_segment_id(&field.segment_path);
            let required_codes: Vec<&str> = field.codes.iter().map(|c| c.value.as_str()).collect();

            let any_instance_has_qualifier = (0..instance_count).any(|i| {
                nav.find_segments_in_group(&segment_id, &group_path, i)
                    .iter()
                    .any(|seg| {
                        seg.elements
                            .first()
                            .and_then(|e| e.first())
                            .is_some_and(|v| required_codes.contains(&v.as_str()))
                    })
            });

            if !any_instance_has_qualifier {
                return true; // optional group variant absent
            }
        }
    }

    // Case 3: non-entry segment absent from all group instances.
    // E.g., SG10 has QTY (entry) + optional STS segments. If no STS appears
    // in any SG10 instance but the entry segment (QTY) is present, fields
    // under STS are not required.
    //
    // We check `has_any_segment_in_group` to confirm the group instance is
    // genuinely populated (proving our target segment is a non-entry optional
    // one) vs a navigator that simply can't resolve segments.
    let segment_id = extract_segment_id(&field.segment_path);
    let segment_absent_from_all = (0..instance_count).all(|i| {
        nav.find_segments_in_group(&segment_id, &group_path, i)
            .is_empty()
    });
    if segment_absent_from_all {
        let group_has_other_segments =
            (0..instance_count).any(|i| nav.has_any_segment_in_group(&group_path, i));
        if group_has_other_segments {
            return true;
        }
    }

    false
}

/// Recursively collect all AhbNodes from a group node in depth-first order.
fn collect_nodes_depth_first<'a, 'b>(group: &'b AhbGroupNode<'a>, out: &mut Vec<&'b AhbNode<'a>>) {
    out.extend(group.fields.iter());
    for child in &group.children {
        collect_nodes_depth_first(child, out);
    }
}

/// Evaluate a single `AhbNode` with the given (possibly scoped) context,
/// emitting AHB001/AHB003/AHB005 issues as appropriate. When `instance_index`
/// is `Some`, errors are tagged with it via `with_instance_index`.
#[allow(clippy::too_many_arguments)]
fn evaluate_node<E: ConditionEvaluator>(
    node: &AhbNode,
    ctx: &EvaluationContext,
    expr_eval: &ConditionExprEvaluator<E>,
    evaluator: &E,
    ub_definitions: &BTreeMap<String, ConditionExpr>,
    tag_migs: &HashMap<String, HashSet<&str>>,
    instance_index: Option<usize>,
    slot_holds: bool,
    report: &mut ValidationReport,
) {
    let field = node.rule;

    // Create a field-scoped context with resolved value from the tree node.
    let node_ctx = ctx.with_resolved(node.value, node.segment_elements);

    // A present value no longer than its MIG format allows (`an..512`: FTX
    // C108/4440). Checked whatever the condition says — the format binds
    // wherever the field is sent,
    // so before the group condition decides whether the rest applies.
    if let (Some(value), Some(max)) = (node.value, field.format.as_deref().and_then(max_length)) {
        let length = value_length(field.format.as_deref().unwrap_or_default(), value);
        if length > max {
            let mut issue = ValidationIssue::new(
                Severity::Error,
                IssueKind::ValueTooLong {
                    field_name: field.name.clone(),
                    length,
                    max,
                },
            )
            .with_field_path(&field.segment_path)
            .with_actual(value)
            .with_expected(field.format.clone().unwrap_or_default());
            if let Some(idx) = instance_index {
                issue = issue.with_instance_index(idx);
            }
            if let Some(num) = node.matched_segment_number {
                issue = issue.with_position(crate::SegmentPosition::at(num));
            }
            report.add_issue(attach_field_position(issue, field));
        }
    }

    // A value of a numeric format that is no number (`n..10`: RFF+Z60
    // `O5D2DXBG1A`). A code element is judged by its code list.
    if let (Some(value), Some(format)) = (node.value, field.format.as_deref()) {
        if slot_holds
            && format.trim().starts_with('n')
            && field.codes.is_empty()
            && !value.is_empty()
            && !crate::eval::format_validators::is_edifact_number(value)
        {
            let mut issue = ValidationIssue::new(
                Severity::Error,
                IssueKind::ValueNotNumeric {
                    field_name: field.name.clone(),
                },
            )
            .with_field_path(&field.segment_path)
            .with_actual(value)
            .with_expected(format);
            if let Some(idx) = instance_index {
                issue = issue.with_instance_index(idx);
            }
            if let Some(num) = node.matched_segment_number {
                issue = issue.with_position(crate::SegmentPosition::at(num));
            }
            report.add_issue(attach_field_position(issue, field));
        }
    }

    // Skip if the parent group's condition refuses it. A present group whose
    // condition is Unknown (external, ORDERS 17002 SG3 `Muss [492]`) still
    // holds its fields to their own conditions (#379).
    if parent_group_refused(field, expr_eval, ctx, ub_definitions) {
        return;
    }

    // Evaluate the field's AHB status condition using the node context
    // (WITH resolved_value set). A present code is judged by its own status.
    let status = governing_status(field, node.value);
    let StatusResolution {
        result: condition_result,
        kind,
        unknown_ids,
    } = expr_eval.resolve_status(status, &node_ctx, ub_definitions);
    let mandatory = kind == Some(StatusKind::Muss);

    match condition_result {
        ConditionResult::True => {
            // Condition is met -- field is required/applicable.
            //
            // Normally rely on the tree's resolved value. The exception:
            // if assembly didn't claim the segment at all (value AND
            // segment_elements both absent) AND the tag has exactly one
            // mig variant in this PID, a flat-segment hit means the
            // segment IS present and assembly just failed to pick it up.
            // Don't double-report — structure diagnostics already warn.
            if mandatory && node.value.is_none() {
                let tag = extract_segment_id(&field.segment_path);
                let single_variant_present = node.segment_elements.is_none()
                    && tag_migs.get(&tag).is_some_and(|ms| ms.len() == 1)
                    && is_field_present(ctx, field);
                // Suppress missing-field errors when the containing segment
                // is optional (Kann/Soll) and absent from the instance.
                // "X" on a Kann segment's sub-element means "required IF
                // segment present"; the segment's absence is legal.
                let segment_optional_and_absent = node.segment_elements.is_none()
                    && field
                        .segment_ahb_status
                        .as_deref()
                        .is_some_and(is_optional_segment_status);
                // Likewise when the absent segment is required only under a
                // condition that does not hold here: a position without an
                // Eichgültigkeit (QUOTES 15001 `DTM+Z04`, `Muss [5] ⊻ [3] ⊻
                // [22]`), a position that is not the SMGW (ORDERS 17001
                // `FTX+Z30`, `Muss [185] ∧ [593]`), or whose holding line is
                // `Kann` (UTILMD 55604 `FTX+ACB`, `Muss [55]` / `Kann`).
                let segment_not_required_and_absent = node.segment_elements.is_none()
                    && field.segment_ahb_status.as_deref().is_some_and(|st| {
                        let status = expr_eval.resolve_status(st, &node_ctx, ub_definitions);
                        status.result != ConditionResult::True
                            || status.kind != Some(StatusKind::Muss)
                    });
                if !single_variant_present
                    && !segment_optional_and_absent
                    && !segment_not_required_and_absent
                {
                    let mut issue = ValidationIssue::new(
                        Severity::Error,
                        IssueKind::MissingRequiredField {
                            field_name: field.name.clone(),
                        },
                    )
                    .with_field_path(&field.segment_path)
                    .with_rule(&field.ahb_status);
                    if let Some(first_code) = field.codes.first() {
                        issue.expected_value = Some(first_code.value.clone());
                    }
                    if let Some(idx) = instance_index {
                        issue = issue.with_instance_index(idx);
                    }
                    if let Some(num) = node.matched_segment_number {
                        issue = issue.with_position(crate::SegmentPosition::at(num));
                    }
                    issue = attach_field_position(issue, field);
                    report.add_issue(issue);
                }
            }
        }
        ConditionResult::False => {
            // Condition not met. If mandatory AND value is present,
            // the value violates the condition constraint.
            if mandatory && node.value.is_some() {
                let failed = expr_eval.false_ids_with_ub(status, &node_ctx, ub_definitions);
                let mut issue = ValidationIssue::new(
                    Severity::Error,
                    IssueKind::FieldConditionNotSatisfied {
                        field_name: field.name.clone(),
                        failed,
                    },
                )
                .with_field_path(&field.segment_path)
                .with_rule(&field.ahb_status);
                if let Some(idx) = instance_index {
                    issue = issue.with_instance_index(idx);
                }
                if let Some(num) = node.matched_segment_number {
                    issue = issue.with_position(crate::SegmentPosition::at(num));
                }
                issue = attach_field_position(issue, field);
                report.add_issue(issue);
            }
        }
        ConditionResult::Unknown => {
            // Partition unknown IDs into external / undetermined / missing.
            let mut external_ids = Vec::new();
            let mut undetermined_ids = Vec::new();
            let mut missing_ids = Vec::new();
            for id in unknown_ids {
                if evaluator.is_external(id) {
                    external_ids.push(id);
                } else if evaluator.is_known(id) {
                    undetermined_ids.push(id);
                } else {
                    missing_ids.push(id);
                }
            }

            let mut issue = ValidationIssue::new(
                Severity::Info,
                IssueKind::ConditionUnknown {
                    field_name: field.name.clone(),
                    unresolved: UnresolvedConditions {
                        external: external_ids,
                        undetermined: undetermined_ids,
                        missing: missing_ids,
                    },
                },
            )
            .with_field_path(&field.segment_path)
            .with_rule(&field.ahb_status);
            if let Some(idx) = instance_index {
                issue = issue.with_instance_index(idx);
            }
            if let Some(num) = node.matched_segment_number {
                issue = issue.with_position(crate::SegmentPosition::at(num));
            }
            issue = attach_field_position(issue, field);
            report.add_issue(issue);
        }
    }
}

/// Attach UCD `S011` position info derived from the AHB field rule's
/// `element_index` / `component_index`. Both are 0-based array indices
/// in the parsed segment; CONTRL DE0098 / DE0104 are 1-based and
/// DE0098 counts the segment identifier as position 1.
fn attach_field_position(issue: ValidationIssue, field: &AhbFieldRule) -> ValidationIssue {
    let issue = issue.with_mig_number(field.mig_number.as_deref());
    match field.element_index {
        Some(el) => {
            let element_pos = (el as u32) + 2;
            let component_pos = field.component_index.map(|c| (c as u32) + 1);
            issue.with_field_position(element_pos, component_pos)
        }
        None => issue,
    }
}

/// The groups and segments of one transaction that its AHB allows once per
/// transaction (`[2061]`, see [`crate::eval::binds_once`]) but that it sends
/// more often: two SG8 SEQ+Z98 "Informative Daten der Marktlokation", two
/// STS+E01. Group variants are told apart by their entry segment's MIG number,
/// segments by the qualifier their slot's rule names; a segment whose status is
/// its group's is counted with the group.
fn report_repeated_in_transaction(
    transaction: &AhbGroupNode,
    transaction_index: usize,
    once: u32,
    ctx: &EvaluationContext,
    report: &mut ValidationReport,
) {
    // (path, variant) -> (count, status)
    let mut counts: BTreeMap<(String, String), (usize, String)> = BTreeMap::new();
    fn visit<'a>(
        node: &'a AhbGroupNode<'a>,
        path: &mut Vec<(&'a str, usize)>,
        once: u32,
        ctx: &EvaluationContext,
        counts: &mut BTreeMap<(String, String), (usize, String)>,
    ) {
        let ids: Vec<&str> = path.iter().map(|(g, _)| *g).collect();
        let mut seen: HashSet<Option<&str>> = HashSet::new();
        for n in &node.fields {
            let rule = n.rule;
            let Some(status) = rule.segment_ahb_status.as_deref() else {
                continue;
            };
            if Some(status) == node.ahb_status
                || rule.element_index.unwrap_or(0) != 0
                || rule.component_index.unwrap_or(0) != 0
                || rule.codes.is_empty()
                || !crate::eval::binds_once(status, once)
                || !seen.insert(rule.mig_number.as_deref())
            {
                continue;
            }
            let tag = extract_segment_id(&rule.segment_path);
            let sent = ctx.navigator().map_or(0, |nav| {
                nav.find_segments_in_instance(&tag, path)
                    .iter()
                    .filter(|s| rule.codes.iter().any(|c| c.value == s.get_component(0, 0)))
                    .count()
            });
            let entry = counts
                .entry((
                    format!("{}/{tag}", ids.join("/")),
                    rule.mig_number.clone().unwrap_or_default(),
                ))
                .or_insert((0, status.to_string()));
            entry.0 += sent;
        }
        for child in &node.children {
            if let Some(status) = child
                .ahb_status
                .filter(|s| crate::eval::binds_once(s, once))
            {
                let variant = child
                    .fields
                    .first()
                    .and_then(|n| n.rule.mig_number.clone())
                    .unwrap_or_default();
                let entry = counts
                    .entry((format!("{}/{}", ids.join("/"), child.group_id), variant))
                    .or_insert((0, status.to_string()));
                entry.0 += 1;
            }
            path.push((child.group_id, child.instance_index));
            visit(child, path, once, ctx, counts);
            path.pop();
        }
    }
    let mut path = vec![(transaction.group_id, transaction_index)];
    visit(transaction, &mut path, once, ctx, &mut counts);
    for ((path, _), (count, status)) in counts {
        if count > 1 {
            report.add_issue(
                ValidationIssue::new(
                    Severity::Error,
                    IssueKind::RepeatedInTransaction {
                        path: path.clone(),
                        count,
                    },
                )
                .with_field_path(path)
                .with_rule(status)
                .with_instance_index(transaction_index),
            );
        }
    }
}

/// The segments of `group` sent although their own condition does not hold
/// (#258): `CAV+Z56` (Wärmenutzung, `Muss [239]`) without CAV+Z65 in its SG10.
/// A segment counts when the qualifier rule of its slot finds its code there
/// — that identifies the slot among same-tag segments — and is reported once. A
/// segment whose status is the group's own is the group check's business.
/// The message's root segments come with no group (`group_status` `None`).
#[allow(clippy::too_many_arguments)]
fn refuse_segments<E: ConditionEvaluator>(
    fields: &[AhbNode],
    group_status: Option<&str>,
    path: &[(&str, usize)],
    scoped_ctx: &EvaluationContext,
    evaluator: &E,
    ub_definitions: &BTreeMap<String, ConditionExpr>,
    instance_index: usize,
    report: &mut ValidationReport,
) {
    let mut seen: Vec<u32> = Vec::new();
    for node in fields {
        let rule = node.rule;
        let (Some(status), Some(value), Some(number)) = (
            rule.segment_ahb_status.as_deref(),
            node.value,
            node.matched_segment_number,
        ) else {
            continue;
        };
        // Only the qualifier (element 0, component 0) names the slot: a
        // format code such as DTM's `303` is shared by DTM+92 and DTM+93.
        let qualifier =
            rule.element_index.unwrap_or(0) == 0 && rule.component_index.unwrap_or(0) == 0;
        if !qualifier
            || seen.contains(&number)
            || Some(status) == group_status
            || !rule.codes.iter().any(|c| c.value == value)
        {
            continue;
        }
        seen.push(number);
        if !crate::eval::refuses_presence(status, evaluator, scoped_ctx, ub_definitions) {
            continue;
        }
        let mut segment: Vec<&str> = path.iter().map(|(g, _)| *g).collect();
        segment.extend(rule.segment_path.split('/').find(|p| !p.starts_with("SG")));
        report.add_issue(
            ValidationIssue::new(
                Severity::Warning,
                IssueKind::SegmentNotAllowed {
                    segment: segment.join("/"),
                },
            )
            .with_field_path(segment.join("/"))
            .with_rule(status)
            .with_instance_index(instance_index)
            .with_position(crate::SegmentPosition::at(number)),
        );
    }
}

/// The segments of `group` it holds another number of times than a
/// repetition condition that applies here allows
/// ([`crate::eval::breaks_repetition_limit`]): UTILMD 55643's Wandler with
/// CAV+MIW and one CAV+Z30, where `[2317]` asks for at least two. A slot is
/// told by the codes its qualifier rule lists and reported once; one not
/// sent at all is the required-field check's business.
fn report_segment_counts<E: ConditionEvaluator>(
    group: &AhbGroupNode,
    path: &[(&str, usize)],
    scoped_ctx: &EvaluationContext,
    evaluator: &E,
    instance_index: usize,
    report: &mut ValidationReport,
) {
    if crate::eval::repetition_limits(evaluator.message_type()).is_empty() {
        return;
    }
    let mut seen: HashSet<Option<&str>> = HashSet::new();
    for node in &group.fields {
        let rule = node.rule;
        let Some(status) = rule.segment_ahb_status.as_deref() else {
            continue;
        };
        if rule.element_index.unwrap_or(0) != 0
            || rule.component_index.unwrap_or(0) != 0
            || rule.codes.is_empty()
            || !seen.insert(rule.mig_number.as_deref())
        {
            continue;
        }
        let tag = extract_segment_id(&rule.segment_path);
        let sent: Vec<_> = scoped_ctx
            .find_segments_at(path, &tag)
            .into_iter()
            .filter(|s| rule.codes.iter().any(|c| c.value == s.get_component(0, 0)))
            .collect();
        if sent.is_empty()
            || !crate::eval::breaks_repetition_limit(status, evaluator, scoped_ctx, sent.len())
        {
            continue;
        }
        let mut segment: Vec<&str> = path.iter().map(|(g, _)| *g).collect();
        segment.push(&tag);
        let mut issue = ValidationIssue::new(
            Severity::Error,
            IssueKind::RepetitionCount {
                path: segment.join("/"),
                count: sent.len(),
            },
        )
        .with_field_path(segment.join("/"))
        .with_rule(status)
        .with_instance_index(instance_index);
        if let Some(num) = node.matched_segment_number {
            issue = issue.with_position(crate::SegmentPosition::at(num));
        }
        report.add_issue(issue);
    }
}

/// The SG8 kinds of transaction `tx` that `[2004]` / `[2005]` ask for once /
/// at least once per Zeitraum-ID of its SG6 RFF+Z49, held another number of
/// times for one (#483): 55126's SEQ+Z01 missing for a second Zeitraum, or
/// sent twice for one. Judged for the kinds the transaction sends; one it
/// does not send at all is the required-group check's business. The issue
/// names the Zeitraum-ID as its expected value.
fn report_off_count_per_zeitraum<E: ConditionEvaluator>(
    transaction: &AhbGroupNode,
    tx: usize,
    ctx: &EvaluationContext,
    evaluator: &E,
    ub_definitions: &BTreeMap<String, ConditionExpr>,
    report: &mut ValidationReport,
) {
    let mut judged: Vec<(&str, Vec<&str>)> = Vec::new();
    for child in &transaction.children {
        let Some(status) = child.ahb_status else {
            continue;
        };
        if child.group_id != "SG8"
            || !(status.contains("[2004]") || status.contains("[2005]"))
            || crate::eval::refuses_presence(status, evaluator, ctx, ub_definitions)
        {
            continue;
        }
        let Some(codes) = child.fields.iter().find_map(|node| {
            let rule = node.rule;
            (extract_segment_id(&rule.segment_path) == "SEQ"
                && rule.element_index.unwrap_or(0) == 0
                && rule.component_index.unwrap_or(0) == 0
                && !rule.codes.is_empty())
            .then(|| {
                rule.codes
                    .iter()
                    .map(|c| c.value.as_str())
                    .collect::<Vec<_>>()
            })
        }) else {
            continue;
        };
        if judged.iter().any(|(s, c)| *s == status && *c == codes) {
            continue;
        }
        let position = child.fields.iter().find_map(|n| n.matched_segment_number);
        for (id, count) in
            crate::eval::periods::sg8_off_count_per_zeitraum(ctx, "SG4", tx, &codes, status)
        {
            let mut issue = ValidationIssue::new(
                Severity::Error,
                IssueKind::RepetitionCount {
                    path: "SG4/SG8".to_string(),
                    count,
                },
            )
            .with_field_path("SG4/SG8")
            .with_rule(status)
            .with_instance_index(tx);
            issue.expected_value = Some(format!("Zeitraum-ID {id}"));
            if let Some(num) = position {
                issue = issue.with_position(crate::SegmentPosition::at(num));
            }
            report.add_issue(issue);
        }
        judged.push((status, codes));
    }
}

/// The child groups of `group` it holds more often than a repetition
/// condition allows ([`crate::eval::refuses_count`]): ORDERS 17009's second
/// SG34 RFF+Z09 in the SG29 of a Zähleinrichtung (`[2005]`, "Pro SG29 LIN …
/// genau einmal"). Reported once per group and parent, with how often the
/// parent holds it, at the first instance that is one too many.
#[allow(clippy::too_many_arguments)]
fn report_repeated_in_group<E: ConditionEvaluator>(
    group: &AhbGroupNode,
    path: &[(&str, usize)],
    scoped_ctx: &EvaluationContext,
    evaluator: &E,
    ub_definitions: &BTreeMap<String, ConditionExpr>,
    instance_index: usize,
    report: &mut ValidationReport,
) {
    if crate::eval::counted_repetitions(evaluator.message_type()).is_empty() {
        return;
    }
    let mut reported: HashSet<&str> = HashSet::new();
    for child in &group.children {
        let Some(status) = child.ahb_status else {
            continue;
        };
        let count = group
            .children
            .iter()
            .filter(|c| c.group_id == child.group_id)
            .count();
        // Held once, it is not repeated; a "genau einmal" that fails then
        // fails on its content (`RFF+XXX` where RFF+Z09 is due).
        if count < 2 || reported.contains(child.group_id) {
            continue;
        }
        let mut child_path = path.to_vec();
        child_path.push((child.group_id, child.instance_index));
        let child_ctx = scoped_ctx.with_scope(GroupScope { path: &child_path });
        if !crate::eval::refuses_count(status, evaluator, &child_ctx, ub_definitions) {
            continue;
        }
        reported.insert(child.group_id);
        let group_path: Vec<&str> = child_path.iter().map(|(g, _)| *g).collect();
        let mut issue = ValidationIssue::new(
            Severity::Error,
            IssueKind::RepetitionCount {
                path: group_path.join("/"),
                count,
            },
        )
        .with_field_path(group_path.join("/"))
        .with_rule(status)
        .with_instance_index(instance_index);
        if let Some(num) = child.fields.iter().find_map(|n| n.matched_segment_number) {
            issue = issue.with_position(crate::SegmentPosition::at(num));
        }
        report.add_issue(issue);
    }
}

/// Recursively walk a group instance (and its children) evaluating every
/// `AhbNode` in the scope of the instance it belongs to.
///
/// `path` addresses `group` by its repetition at every level from the root
/// (`[("SG4", 1), ("SG8", 2)]`); each child instance is walked with the path
/// one level deeper, so "in dieser SG8" means this SG8, not every SG8 of the
/// first SG4. `instance_index` stays the top-level repetition, which is what
/// issues report.
#[allow(clippy::too_many_arguments)]
fn walk_group_instance<E: ConditionEvaluator>(
    group: &AhbGroupNode,
    path: &[(&str, usize)],
    scoped_ctx: &EvaluationContext,
    expr_eval: &ConditionExprEvaluator<E>,
    evaluator: &E,
    ub_definitions: &BTreeMap<String, ConditionExpr>,
    tag_migs: &HashMap<String, HashSet<&str>>,
    instance_index: usize,
    report_segments: bool,
    report: &mut ValidationReport,
) {
    // A group sent although its condition does not hold (a warning while the
    // check proves itself). Its fields are then skipped as before.
    let mut group_refused = false;
    if let Some(status) = group.ahb_status {
        if crate::eval::refuses_presence(status, evaluator, scoped_ctx, ub_definitions) {
            group_refused = true;
            let group_path: Vec<&str> = path.iter().map(|(g, _)| *g).collect();
            let mut issue = ValidationIssue::new(
                Severity::Warning,
                IssueKind::GroupNotAllowed {
                    group: group_path.join("/"),
                },
            )
            .with_field_path(group_path.join("/"))
            .with_rule(status)
            .with_instance_index(instance_index);
            if let Some(num) = group.fields.iter().find_map(|n| n.matched_segment_number) {
                issue = issue.with_position(crate::SegmentPosition::at(num));
            }
            report.add_issue(issue);
        }
    }
    if report_segments && !group_refused {
        refuse_segments(
            &group.fields,
            group.ahb_status,
            path,
            scoped_ctx,
            evaluator,
            ub_definitions,
            instance_index,
            report,
        );
    }
    // Nodes bound to a segment their slot's qualifier rule does not name: a
    // repeated CAV+Z30 taken for the CAV+MIW after it (55043). What that slot
    // says about its values does not apply to them.
    let slot_codes: HashMap<Option<&str>, &[AhbCodeRule]> = group
        .fields
        .iter()
        .filter(|n| {
            n.rule.element_index.unwrap_or(0) == 0
                && n.rule.component_index.unwrap_or(0) == 0
                && !n.rule.codes.is_empty()
        })
        .map(|n| (n.rule.mig_number.as_deref(), n.rule.codes.as_slice()))
        .collect();
    let holds = |node: &AhbNode| {
        let (Some(codes), Some(elements)) = (
            slot_codes.get(&node.rule.mig_number.as_deref()),
            node.segment_elements,
        ) else {
            return true;
        };
        let qualifier = elements
            .first()
            .and_then(|e| e.first())
            .map(String::as_str)
            .unwrap_or_default();
        codes.iter().any(|c| c.value == qualifier)
    };
    for node in &group.fields {
        evaluate_node(
            node,
            scoped_ctx,
            expr_eval,
            evaluator,
            ub_definitions,
            tag_migs,
            Some(instance_index),
            holds(node),
            report,
        );
    }
    report_repeated_in_group(
        group,
        path,
        scoped_ctx,
        evaluator,
        ub_definitions,
        instance_index,
        report,
    );
    report_segment_counts(group, path, scoped_ctx, evaluator, instance_index, report);
    for child in &group.children {
        let mut child_path = path.to_vec();
        child_path.push((child.group_id, child.instance_index));
        let child_ctx = scoped_ctx.with_scope(GroupScope { path: &child_path });
        walk_group_instance(
            child,
            &child_path,
            &child_ctx,
            expr_eval,
            evaluator,
            ub_definitions,
            tag_migs,
            instance_index,
            report_segments,
            report,
        );
    }
}

/// Recursively collect all Package nodes from a condition expression tree.
/// Report the child groups `group` lacks although they are required in it:
/// the variants its kind lists ([`AhbGroupNode::absent_children`]) whose
/// group status and own status hold here, judged in this instance's scope.
/// The message-wide check for absent variants asks whether *any* such segment
/// is in the message, so another transaction's stood in for this one's (a
/// UTILMD list's `SEQ+Z22` for a Vorgang's, #343). Descends into the present
/// child groups; a group sent although its condition does not hold demands
/// nothing.
#[allow(clippy::too_many_arguments)]
fn report_absent_children<E: ConditionEvaluator>(
    group: &AhbGroupNode,
    path: &[(&str, usize)],
    scoped_ctx: &EvaluationContext,
    absent_eval: &ConditionExprEvaluator<crate::eval::AbsentTarget<'_, E>>,
    evaluator: &E,
    ub_definitions: &BTreeMap<String, ConditionExpr>,
    instance_index: usize,
    report: &mut ValidationReport,
) {
    if group.ahb_status.is_some_and(|status| {
        crate::eval::refuses_presence(status, evaluator, scoped_ctx, ub_definitions)
    }) {
        return;
    }
    for rule in &group.absent_children {
        if should_skip_for_parent_group(rule, absent_eval, scoped_ctx, ub_definitions)
            || !is_parent_group_required(rule, absent_eval, scoped_ctx, ub_definitions)
        {
            continue;
        }
        let required = |status: &str| {
            let resolved = absent_eval.resolve_status(status, scoped_ctx, ub_definitions);
            resolved.result == ConditionResult::True && resolved.kind == Some(StatusKind::Muss)
        };
        if !required(&rule.ahb_status)
            || rule
                .segment_ahb_status
                .as_deref()
                .is_some_and(|status| !required(status))
        {
            continue;
        }
        let mut issue = ValidationIssue::new(
            Severity::Error,
            IssueKind::MissingRequiredField {
                field_name: rule.name.clone(),
            },
        )
        .with_field_path(&rule.segment_path)
        .with_rule(&rule.ahb_status)
        .with_instance_index(instance_index);
        if let Some(first_code) = rule.codes.first() {
            issue.expected_value = Some(first_code.value.clone());
        }
        report.add_issue(attach_field_position(issue, rule));
    }
    for child in &group.children {
        let mut child_path = path.to_vec();
        child_path.push((child.group_id, child.instance_index));
        let child_ctx = scoped_ctx.with_scope(GroupScope { path: &child_path });
        report_absent_children(
            child,
            &child_path,
            &child_ctx,
            absent_eval,
            evaluator,
            ub_definitions,
            instance_index,
            report,
        );
    }
}

fn collect_packages(expr: &ConditionExpr, out: &mut Vec<(u32, u32, u32)>) {
    match expr {
        ConditionExpr::Package { id, min, max } => {
            out.push((*id, *min, *max));
        }
        ConditionExpr::And(exprs) | ConditionExpr::Or(exprs) => {
            for e in exprs {
                collect_packages(e, out);
            }
        }
        ConditionExpr::Xor(left, right) => {
            collect_packages(left, out);
            collect_packages(right, out);
        }
        ConditionExpr::Not(inner) => {
            collect_packages(inner, out);
        }
        ConditionExpr::Ref(_) => {}
    }
}

/// Check if a segment-level AHB status indicates an optional segment.
///
/// "Kann" / "Kann [x]" — always optional: absence is legal.
/// "Soll" / "Soll [x]" — should-be: absence is tolerated (not an error).
/// "Muss" (with or without conditions) — required; absence must be reported.
///
/// Used to suppress AHB001 missing-field errors on sub-elements of a segment
/// that is both optional at segment-level and absent from the assembled
/// instance: "X" on such a sub-element means "required IF segment present".
fn is_optional_segment_status(status: &str) -> bool {
    let trimmed = status.trim();
    trimmed.starts_with("Kann") || trimmed.starts_with("Soll")
}

/// Check if a field path points to a simple qualifier element (element[0] of the segment).
///
/// Returns `true` for paths like `[SG/]*/SEG/ELEMENT` where the data element is
/// directly under the segment (no composite wrapper). These fields have their code
/// in `element[0][0]` and can be validated.
///
/// Also accepts composite paths like `SEG/COMPOSITE/ELEMENT` (e.g., `STS/C556/9013`).
/// The `element_index` and `component_index` on the field rule carry the exact
/// position, so composites can be checked just like simple elements.
fn is_qualifier_field(path: &str) -> bool {
    let parts: Vec<&str> = path.split('/').filter(|p| !p.starts_with("SG")).collect();
    // [SEG, ELEMENT] for simple data elements; [SEG, COMPOSITE, ELEMENT] for composites.
    matches!(parts.len(), 2 | 3)
}

/// Per-mig code constraints at one (group_key, tag) location.
///
/// A bucket represents one mig_number (or the `None` bucket when rules lack
/// mig numbers). Each bucket tracks its qualifier position and the set of
/// valid qualifier values there, so multiple single-code rules under the same
/// mig key (e.g. two distinct NAD qualifiers both under mig=None in a test
/// fixture) all contribute as valid qualifier matches.
#[derive(Default)]
struct MigCodeBucket<'a> {
    /// The position (element_index, component_index) treated as the discriminator
    /// for this bucket — the first single-code required field seen in the workflow.
    qualifier_position: Option<(usize, usize)>,
    /// Valid qualifier values at `qualifier_position`. Empty if no single-code
    /// required field exists for this bucket.
    qualifier_values: HashSet<&'a str>,
    /// Allowed codes for this bucket, keyed by `(element_index, component_index)`.
    /// Includes the qualifier position itself.
    codes: BTreeMap<(usize, usize), HashSet<&'a str>>,
}

/// Partition workflow code rules by `(group_key, tag, mig_number)`. Without this
/// split, codes from multiple migs sharing a tag (e.g. STS+7 mig 00035 and
/// STS+E01 mig 00036 in PID 55018) get unioned and every segment is checked
/// against codes that only apply to one mig.
fn partition_codes_by_mig(
    workflow: &AhbWorkflow,
) -> BTreeMap<(String, String), BTreeMap<Option<String>, MigCodeBucket<'_>>> {
    let mut out: BTreeMap<(String, String), BTreeMap<Option<String>, MigCodeBucket>> =
        BTreeMap::new();
    for field in &workflow.fields {
        if field.codes.is_empty() || !is_qualifier_field(&field.segment_path) {
            continue;
        }
        // The codes do not restrict an element they are alternatives to: a
        // value they do not list is judged by the element's own status.
        if codes_are_alternatives(field) {
            continue;
        }
        let tag = extract_segment_id(&field.segment_path);
        let group_key = extract_group_path_key(&field.segment_path);
        let mig = field.mig_number.clone();
        let el = field.element_index.unwrap_or(0);
        let c = field.component_index.unwrap_or(0);

        let bucket = out
            .entry((group_key, tag))
            .or_default()
            .entry(mig)
            .or_default();

        // A code is "allowed for this PID" whenever its AHB status declares it
        // usable — whether unconditionally (`X`, `Muss`) or under a condition
        // (`X [35]`, `X [35] ∨ ([32] ∧ [77])`). Matching only the exact string
        // `"X"` drops every conditionally-allowed code, causing COD002 false
        // positives on fields like MSCONS QTY 6063 (220 unconditional, 67/Z18
        // conditional).
        let required: Vec<&str> = field
            .codes
            .iter()
            .filter(|code| code.ahb_status.starts_with('X') || code.ahb_status.starts_with("Muss"))
            .map(|code| code.value.as_str())
            .collect();

        // The first code-bearing field locks in the qualifier position; any
        // further required codes at that position contribute additional valid
        // qualifier values. A bucket whose entry qualifier permits multiple
        // codes (e.g. PID 55035 SG8/RFF mig=00075 allows {Z31, Z39}) must be
        // matchable by any of them — without this, segments with Z39 fall
        // through to the union-of-other-migs path and produce a false COD002.
        if !required.is_empty() {
            if bucket.qualifier_position.is_none() {
                bucket.qualifier_position = Some((el, c));
            }
            if bucket.qualifier_position == Some((el, c)) {
                bucket.qualifier_values.extend(required.iter().copied());
            }
        }

        for v in required {
            bucket.codes.entry((el, c)).or_default().insert(v);
        }
    }
    out
}

/// For each tag, collect every qualifier value used anywhere in the workflow,
/// keyed by qualifier position. This lets code validation distinguish "segment
/// has an unknown qualifier value" (truly invalid — report) from "segment has
/// a valid qualifier used at a different location than the current bucket"
/// (belongs elsewhere — skip at this location).
fn global_qualifiers_by_tag(
    by_loc: &BTreeMap<(String, String), BTreeMap<Option<String>, MigCodeBucket<'_>>>,
) -> BTreeMap<String, BTreeMap<(usize, usize), HashSet<String>>> {
    let mut out: BTreeMap<String, BTreeMap<(usize, usize), HashSet<String>>> = BTreeMap::new();
    for ((_group, tag), migs) in by_loc {
        let tag_entry = out.entry(tag.clone()).or_default();
        for bucket in migs.values() {
            if let Some(pos) = bucket.qualifier_position {
                tag_entry
                    .entry(pos)
                    .or_default()
                    .extend(bucket.qualifier_values.iter().map(|s| s.to_string()));
            }
        }
    }
    out
}

/// Whether `seg` carries one of `bucket`'s qualifier values.
fn matches_qualifier(seg: &OwnedSegment, bucket: &MigCodeBucket<'_>) -> bool {
    bucket.qualifier_position.is_some_and(|(el, c)| {
        seg.elements
            .get(el)
            .and_then(|e| e.get(c))
            .is_some_and(|v| bucket.qualifier_values.contains(v.as_str()))
    })
}

/// The slots whose leading element the AHB gives as data — a code-less rule
/// at element 0, component 0, such as 55673's Zeitreihentyp (CAV 7111, from
/// an external code list) — keyed by `(group_key, tag)`, each with the entry
/// of the group variant holding it: the closest segment of another tag before
/// it in MIG order at the same group key (`CCI+15++Z21` before that CAV).
fn data_slot_entries(
    workflow: &AhbWorkflow,
) -> HashMap<(String, String), Vec<(String, Option<String>)>> {
    let mut out: HashMap<(String, String), Vec<(String, Option<String>)>> = HashMap::new();
    // Per group key, the tags of the fields of each MIG number, in field
    // order: looked up once per data slot instead of scanning every field
    // for each (#437 follow-up: one data slot per LIN of a message with many
    // Lokationen made this quadratic).
    let mut tags_by_mig: HashMap<String, BTreeMap<&str, Vec<String>>> = HashMap::new();
    for f in &workflow.fields {
        if let Some(n) = f.mig_number.as_deref() {
            let tags = tags_by_mig
                .entry(extract_group_path_key(&f.segment_path))
                .or_default()
                .entry(n)
                .or_default();
            let tag = extract_segment_id(&f.segment_path);
            if tags.last() != Some(&tag) {
                tags.push(tag);
            }
        }
    }
    let mut judged: HashSet<(&str, &str)> = HashSet::new();
    for field in &workflow.fields {
        let leading =
            field.element_index.unwrap_or(0) == 0 && field.component_index.unwrap_or(0) == 0;
        let Some(mig) = field.mig_number.as_deref() else {
            continue;
        };
        if !field.codes.is_empty() || !leading || !is_qualifier_field(&field.segment_path) {
            continue;
        }
        if !judged.insert((field.segment_path.as_str(), mig)) {
            continue;
        }
        let tag = extract_segment_id(&field.segment_path);
        let group_key = extract_group_path_key(&field.segment_path);
        if group_key.is_empty() {
            continue;
        }
        // The closest MIG number before this one with a field of another tag
        // (the last such field of it, as `max_by_key` picked).
        let entry = tags_by_mig.get(&group_key).and_then(|migs| {
            migs.range(..mig).rev().find_map(|(n, tags)| {
                tags.iter()
                    .rev()
                    .find(|t| **t != tag)
                    .map(|t| (*n, t.clone()))
            })
        });
        if let Some((n, entry_tag)) = entry {
            let slot = (entry_tag, Some(n.to_string()));
            let entries = out.entry((group_key, tag)).or_default();
            if !entries.contains(&slot) {
                entries.push(slot);
            }
        }
    }
    out
}

/// Find the bucket that best matches this segment.
///
/// A bucket is a candidate if its `qualifier_values` contain the segment's
/// value at `qualifier_position`. Among candidates, the one with the most
/// additional code positions matching the segment wins. This disambiguates
/// migs that share the same primary qualifier but differ on a secondary
/// code position (e.g. PID 55035 SG8/PIA variants all use 4347='5' but
/// differ on C212/7143={Z12} vs {SRW}).
///
/// Returns `None` if no bucket's qualifier matches the segment.
fn match_segment_to_mig<'a, 'b>(
    seg: &OwnedSegment,
    migs: &'a BTreeMap<Option<String>, MigCodeBucket<'b>>,
) -> Option<&'a MigCodeBucket<'b>> {
    let actual_at = |el: usize, c: usize| -> &str {
        seg.elements
            .get(el)
            .and_then(|e| e.get(c))
            .map(|s| s.as_str())
            .unwrap_or("")
    };

    let mut best: Option<&MigCodeBucket> = None;
    let mut best_matches = 0usize;

    for bucket in migs.values() {
        let Some((el, c)) = bucket.qualifier_position else {
            continue;
        };
        if !bucket.qualifier_values.contains(actual_at(el, c)) {
            continue;
        }
        let extra_matches = bucket
            .codes
            .iter()
            .filter(|(pos, _)| **pos != (el, c))
            .filter(|((e, k), allowed)| {
                let v = actual_at(*e, *k);
                !v.is_empty() && allowed.contains(v)
            })
            .count();
        if best.is_none() || extra_matches > best_matches {
            best = Some(bucket);
            best_matches = extra_matches;
        }
    }
    best
}

/// Extract the group path prefix from a field path.
///
/// `"SG2/NAD/3035"` → `"SG2"`, `"SG4/SG12/NAD/3035"` → `"SG4/SG12"`,
/// `"NAD/3035"` → `""` (no group prefix).
fn extract_group_path_key(path: &str) -> String {
    let sg_parts: Vec<&str> = path
        .split('/')
        .take_while(|p| p.starts_with("SG"))
        .collect();
    sg_parts.join("/")
}

/// Extract the segment ID from a field path like "SG2/NAD/C082/3039" -> "NAD".
fn extract_segment_id(path: &str) -> String {
    for part in path.split('/') {
        // Skip segment group identifiers and composite/element identifiers
        if part.starts_with("SG") || part.starts_with("C_") || part.starts_with("D_") {
            continue;
        }
        // Return first 3-letter uppercase segment identifier
        if part.len() >= 3
            && part
                .chars()
                .all(|c| c.is_ascii_uppercase() || c.is_ascii_digit())
        {
            return part.to_string();
        }
    }
    // Fallback: return the last part
    path.split('/').next_back().unwrap_or(path).to_string()
}

/// Validate that the UNT segment count matches the actual number of segments.
///
/// The UNT segment's first data element (D0074) declares the number of segments
/// in the message, counting from UNH to UNT inclusive. This function compares
/// that declared value against the actual segment count.
///
/// Pass per-message segments (from [`MessageChunk::message_segments()`] or
/// [`MessageChunk::all_segments()`]), not the full interchange. For multi-message
/// interchanges, call once per message.
///
/// Returns `Some(ValidationIssue)` if there's a mismatch, `None` if correct.
pub fn validate_unt_segment_count(segments: &[OwnedSegment]) -> Option<ValidationIssue> {
    // Reject multi-message input — counting would be incorrect.
    let unh_count = segments.iter().filter(|s| s.id == "UNH").count();
    if unh_count > 1 {
        return Some(ValidationIssue::new(
            Severity::Error,
            IssueKind::UntCountNotVerifiable { unh_count },
        ));
    }

    // Find the UNT segment
    let unt = segments.iter().rfind(|s| s.id == "UNT")?;
    let declared: usize = unt.get_element(0).parse().ok()?;

    // Count segments from UNH to UNT inclusive
    let actual = segments
        .iter()
        .filter(|s| s.id != "UNA" && s.id != "UNB" && s.id != "UNZ")
        .count();

    if declared != actual {
        Some(
            ValidationIssue::new(
                Severity::Error,
                IssueKind::UntSegmentCountMismatch { declared, actual },
            )
            .with_field_path("UNT/0074")
            .with_expected(actual.to_string())
            .with_actual(declared.to_string()),
        )
    } else {
        None
    }
}

#[cfg(test)]
mod tests {

    #[test]
    fn a_numeric_length_counts_digits_only() {
        assert_eq!(value_length("n..15", "-12.50"), 4);
        assert_eq!(value_length("n..6", "JMMHAYJXGIJT"), 12);
        assert_eq!(value_length("n5", "55001"), 5);
        assert_eq!(value_length("an..3", "Z.1"), 3);
        assert_eq!(value_length("an..35", "Müller"), 6);
    }
    use super::super::codes::ErrorCodes;
    use super::super::issue::ValidationCategory;
    use super::*;
    use crate::display::{EdifactView, IssueNarrator, IssueView, TechnicalNarrator};
    use crate::eval::{ConditionResult as CR, NoOpExternalProvider};
    use std::collections::HashMap;

    /// Narrate an issue the way the EDIFACT view would, for assertions that
    /// used to read `.message` before Task 5 removed it.
    fn narrate(issue: &ValidationIssue) -> String {
        TechnicalNarrator.describe(issue, EdifactView.location(issue).as_deref())
    }

    /// Mock evaluator for testing the validator.
    struct MockEvaluator {
        results: HashMap<u32, CR>,
    }

    impl MockEvaluator {
        fn new(results: Vec<(u32, CR)>) -> Self {
            Self {
                results: results.into_iter().collect(),
            }
        }

        fn all_true(ids: &[u32]) -> Self {
            Self::new(ids.iter().map(|&id| (id, CR::True)).collect())
        }
    }

    impl ConditionEvaluator for MockEvaluator {
        fn evaluate(&self, condition: u32, _ctx: &EvaluationContext) -> CR {
            self.results.get(&condition).copied().unwrap_or(CR::Unknown)
        }
        fn is_external(&self, _condition: u32) -> bool {
            false
        }
        fn message_type(&self) -> &str {
            "UTILMD"
        }
        fn format_version(&self) -> &str {
            "FV2510"
        }
    }

    // === Helper function tests ===

    #[test]
    fn a_present_code_is_judged_by_its_own_status() {
        // 55010 STS Transaktionsgrund: the schema gives the element E01's status.
        let code = |value: &str, status: &str| AhbCodeRule {
            value: value.to_string(),
            description: String::new(),
            ahb_status: status.to_string(),
        };
        let field = AhbFieldRule {
            segment_path: "SG4/STS/C556/9013".to_string(),
            ahb_status: "X [192]".to_string(),
            codes: vec![code("E01", "X [192]"), code("E03", "X")],
            ..Default::default()
        };
        assert_eq!(governing_status(&field, Some("E03")), "X");
        assert_eq!(governing_status(&field, Some("E01")), "X [192]");
        assert_eq!(governing_status(&field, None), "X [192]");
        assert_eq!(governing_status(&field, Some("ZZZ")), "X [192]");

        // An element with a condition of its own keeps it.
        let own = AhbFieldRule {
            ahb_status: "X [931]".to_string(),
            codes: vec![code("303", "X")],
            ..Default::default()
        };
        assert_eq!(governing_status(&own, Some("303")), "X [931]");
        assert!(!codes_are_alternatives(&own));

        // IFTSTA 21025 STS 9013 (#319): the element status admits E_0286's
        // answers, the code rows their codes without DE1131.
        let alternatives = AhbFieldRule {
            ahb_status: "X [153] ∧ [538]".to_string(),
            codes: vec![
                code("Z74", "X [103] ∧ [537]"),
                code("Z75", "X [103] ∧ [537]"),
            ],
            ..Default::default()
        };
        assert!(codes_are_alternatives(&alternatives));
        assert_eq!(
            governing_status(&alternatives, Some("Z74")),
            "X [103] ∧ [537]"
        );
        assert_eq!(
            governing_status(&alternatives, Some("A01")),
            "X [153] ∧ [538]"
        );
        assert_eq!(governing_status(&alternatives, None), "X [153] ∧ [538]");

        // CONTRL 0013: unconditional code rows only restrict the element.
        let restricting = AhbFieldRule {
            ahb_status: "X [2] ∨ [3]".to_string(),
            codes: vec![code("UNH", "X"), code("UNT", "X")],
            ..Default::default()
        };
        assert!(!codes_are_alternatives(&restricting));
        assert_eq!(governing_status(&restricting, Some("UNH")), "X [2] ∨ [3]");
    }

    #[test]
    fn test_extract_segment_id_simple() {
        assert_eq!(extract_segment_id("NAD"), "NAD");
    }

    #[test]
    fn test_extract_segment_id_with_sg_prefix() {
        assert_eq!(extract_segment_id("SG2/NAD/C082/3039"), "NAD");
    }

    #[test]
    fn test_extract_segment_id_nested_sg() {
        assert_eq!(extract_segment_id("SG4/SG8/SEQ/C286/6350"), "SEQ");
    }

    // === Validator tests with mock data ===

    #[test]
    fn test_validate_missing_mandatory_field() {
        let evaluator = MockEvaluator::all_true(&[182, 152]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let workflow = AhbWorkflow {
            pruefidentifikator: "11001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![AhbFieldRule {
                segment_path: "SG2/NAD/C082/3039".to_string(),
                name: "MP-ID des MSB".to_string(),
                ahb_status: "Muss [182] ∧ [152]".to_string(),
                codes: vec![],
                parent_group_ahb_status: None,
                segment_ahb_status: None,
                ..Default::default()
            }],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        // Validate with no segments
        let report = validator.validate(&[], &workflow, &external, ValidationLevel::Conditions);

        // Should have an error for missing mandatory field
        assert!(!report.is_valid());
        let errors: Vec<_> = report.errors().collect();
        assert_eq!(errors.len(), 1);
        assert_eq!(errors[0].code(), ErrorCodes::MISSING_REQUIRED_FIELD);
        assert!(narrate(errors[0]).contains("MP-ID des MSB"));
    }

    #[test]
    fn test_validate_condition_false_no_error() {
        // When condition evaluates to False, field is not required
        let evaluator = MockEvaluator::new(vec![(182, CR::True), (152, CR::False)]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let workflow = AhbWorkflow {
            pruefidentifikator: "11001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![AhbFieldRule {
                segment_path: "NAD".to_string(),
                name: "Partnerrolle".to_string(),
                ahb_status: "Muss [182] ∧ [152]".to_string(),
                codes: vec![],
                parent_group_ahb_status: None,
                segment_ahb_status: None,
                ..Default::default()
            }],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate(&[], &workflow, &external, ValidationLevel::Conditions);

        // Condition is false, so field is not required - no error
        assert!(report.is_valid());
    }

    /// Validate an absent field with `status`, conditions set as given.
    fn validate_absent_field(status: &str, conditions: Vec<(u32, CR)>) -> ValidationReport {
        let validator = EdifactValidator::new(MockEvaluator::new(conditions));
        let workflow = AhbWorkflow {
            pruefidentifikator: "11001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![AhbFieldRule {
                segment_path: "SG2/NAD/C082/3039".to_string(),
                name: "MP-ID".to_string(),
                ahb_status: status.to_string(),
                ..Default::default()
            }],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };
        validator.validate(
            &[],
            &workflow,
            &NoOpExternalProvider,
            ValidationLevel::Conditions,
        )
    }

    #[test]
    fn a_later_soll_line_alone_does_not_require_the_field() {
        // Muss [2119] / Soll [130], only [130] holds: recommended, not required.
        let report = validate_absent_field(
            "Muss [2119] \r\nSoll [130]",
            vec![(2119, CR::False), (130, CR::True)],
        );
        assert!(
            report.is_valid(),
            "{:?}",
            report.errors().collect::<Vec<_>>()
        );
    }

    #[test]
    fn a_later_muss_line_requires_the_field() {
        // Soll [47] / Muss [46], only [46] holds: required.
        let report = validate_absent_field(
            "Soll [47]\r\nMuss [46]",
            vec![(47, CR::False), (46, CR::True)],
        );
        let errors: Vec<_> = report.errors().collect();
        assert_eq!(errors.len(), 1);
        assert_eq!(errors[0].code(), ErrorCodes::MISSING_REQUIRED_FIELD);
    }

    #[test]
    fn a_weaker_unknown_line_does_not_stop_a_muss() {
        // [130] cannot make it any stricter than the Muss that holds.
        let report = validate_absent_field("Muss [2119]\nSoll [130]", vec![(2119, CR::True)]);
        let errors: Vec<_> = report.errors().collect();
        assert_eq!(errors.len(), 1);
        assert_eq!(errors[0].code(), ErrorCodes::MISSING_REQUIRED_FIELD);
    }

    #[test]
    fn a_stricter_unknown_line_leaves_the_status_undecided() {
        let report = validate_absent_field("Muss [2119]\nSoll [130]", vec![(130, CR::True)]);
        assert!(report.is_valid());
        let infos: Vec<_> = report.infos().collect();
        assert_eq!(infos.len(), 1, "{infos:?}");
        match &infos[0].kind {
            IssueKind::ConditionUnknown { unresolved, .. } => {
                assert_eq!(unresolved.missing, vec![2119]);
            }
            other => panic!("expected ConditionUnknown, got {other:?}"),
        }
    }

    #[test]
    fn test_validate_condition_unknown_adds_info() {
        // When condition is Unknown, add an info-level note
        let evaluator = MockEvaluator::new(vec![(182, CR::True)]);
        // 152 is not registered -> Unknown
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let workflow = AhbWorkflow {
            pruefidentifikator: "11001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![AhbFieldRule {
                segment_path: "NAD".to_string(),
                name: "Partnerrolle".to_string(),
                ahb_status: "Muss [182] ∧ [152]".to_string(),
                codes: vec![],
                parent_group_ahb_status: None,
                segment_ahb_status: None,
                ..Default::default()
            }],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate(&[], &workflow, &external, ValidationLevel::Conditions);

        // Should be valid (Unknown is not an error) but have an info issue
        assert!(report.is_valid());
        let infos: Vec<_> = report.infos().collect();
        assert_eq!(infos.len(), 1);
        assert_eq!(infos[0].code(), ErrorCodes::CONDITION_UNKNOWN);
    }

    #[test]
    fn test_validate_structure_level_skips_conditions() {
        let evaluator = MockEvaluator::all_true(&[182, 152]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let workflow = AhbWorkflow {
            pruefidentifikator: "11001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![AhbFieldRule {
                segment_path: "NAD".to_string(),
                name: "Partnerrolle".to_string(),
                ahb_status: "Muss [182] ∧ [152]".to_string(),
                codes: vec![],
                parent_group_ahb_status: None,
                segment_ahb_status: None,
                ..Default::default()
            }],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        // With Structure level, conditions are not checked
        let report = validator.validate(&[], &workflow, &external, ValidationLevel::Structure);

        // No AHB errors because conditions were not evaluated
        assert!(report.is_valid());
        assert_eq!(report.by_category(ValidationCategory::Ahb).count(), 0);
    }

    #[test]
    fn test_validate_empty_workflow_no_condition_errors() {
        let evaluator = MockEvaluator::all_true(&[]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let empty_workflow = AhbWorkflow {
            pruefidentifikator: String::new(),
            description: String::new(),
            communication_direction: None,
            fields: vec![],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate(&[], &empty_workflow, &external, ValidationLevel::Full);

        assert!(report.is_valid());
    }

    #[test]
    fn test_validate_bare_muss_always_required() {
        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: Some("NB an LF".to_string()),
            fields: vec![AhbFieldRule {
                segment_path: "SG2/NAD/3035".to_string(),
                name: "Partnerrolle".to_string(),
                ahb_status: "Muss".to_string(), // No conditions
                codes: vec![],
                parent_group_ahb_status: None,
                segment_ahb_status: None,
                ..Default::default()
            }],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate(&[], &workflow, &external, ValidationLevel::Conditions);

        // Bare "Muss" with no conditions -> unconditionally required -> missing = error
        assert!(!report.is_valid());
        assert_eq!(report.error_count(), 1);
    }

    #[test]
    fn test_validate_x_status_is_mandatory() {
        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![AhbFieldRule {
                segment_path: "DTM".to_string(),
                name: "Datum".to_string(),
                ahb_status: "X".to_string(),
                codes: vec![],
                parent_group_ahb_status: None,
                segment_ahb_status: None,
                ..Default::default()
            }],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate(&[], &workflow, &external, ValidationLevel::Conditions);

        assert!(!report.is_valid());
        let errors: Vec<_> = report.errors().collect();
        assert_eq!(errors[0].code(), ErrorCodes::MISSING_REQUIRED_FIELD);
    }

    #[test]
    fn test_validate_soll_not_mandatory() {
        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![AhbFieldRule {
                segment_path: "DTM".to_string(),
                name: "Datum".to_string(),
                ahb_status: "Soll".to_string(),
                codes: vec![],
                parent_group_ahb_status: None,
                segment_ahb_status: None,
                ..Default::default()
            }],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate(&[], &workflow, &external, ValidationLevel::Conditions);

        // Soll is not mandatory, so missing is not an error
        assert!(report.is_valid());
    }

    #[test]
    fn test_report_includes_metadata() {
        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: String::new(),
            communication_direction: None,
            fields: vec![],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate(&[], &workflow, &external, ValidationLevel::Full);

        assert_eq!(report.format_version.as_deref(), Some("FV2510"));
        assert_eq!(report.level, ValidationLevel::Full);
        assert_eq!(report.message_type, "UTILMD");
        assert_eq!(report.pruefidentifikator.as_deref(), Some("55001"));
    }

    #[test]
    fn test_validate_with_navigator_returns_report() {
        let evaluator = MockEvaluator::all_true(&[]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;
        let nav = crate::eval::NoOpGroupNavigator;

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate_with_navigator(
            &[],
            &workflow,
            &external,
            ValidationLevel::Full,
            &nav,
        );
        assert!(report.is_valid());
    }

    #[test]
    fn test_code_validation_composite_paths_valid_codes() {
        // UNH/S009/0065 and UNH/S009/0052 carry codes inside composite S009 at
        // element_index=1, component sub_index 0 and 1. Validation should match
        // the actual composite positions and find no errors for matching values.
        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let unh_segment = OwnedSegment {
            id: "UNH".to_string(),
            elements: vec![
                vec!["ALEXANDE951842".to_string()],
                vec![
                    "UTILMD".to_string(),
                    "D".to_string(),
                    "11A".to_string(),
                    "UN".to_string(),
                    "S2.1".to_string(),
                ],
            ],
            segment_number: 1,
        };

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![
                AhbFieldRule {
                    segment_path: "UNH/S009/0065".to_string(),
                    name: "Nachrichtentyp".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "UTILMD".to_string(),
                        description: "Stammdaten".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    element_index: Some(1),
                    component_index: Some(0),
                    ..Default::default()
                },
                AhbFieldRule {
                    segment_path: "UNH/S009/0052".to_string(),
                    name: "Version".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "D".to_string(),
                        description: "Draft".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    element_index: Some(1),
                    component_index: Some(1),
                    ..Default::default()
                },
            ],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate(
            &[unh_segment],
            &workflow,
            &external,
            ValidationLevel::Conditions,
        );

        let code_errors: Vec<_> = report
            .by_category(ValidationCategory::Code)
            .filter(|i| i.severity == Severity::Error)
            .collect();
        assert!(
            code_errors.is_empty(),
            "Expected no code errors when composite values match allowed codes, got: {:?}",
            code_errors
        );
    }

    #[test]
    fn test_code_validation_partitions_by_mig_number() {
        // PID 55018 has two STS migs: 00035 (Statuskategorie=7) constrains
        // element 2 to {E03}; 00036 (Statuskategorie=E01) has no constraint there.
        // Unioning codes across migs would flag A99 in STS+E01 — it must not.
        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let sts_7 = OwnedSegment {
            id: "STS".to_string(),
            elements: vec![
                vec!["7".to_string()],
                vec![String::new()],
                vec!["GH02".to_string()],
                vec!["ZW4".to_string()],
            ],
            segment_number: 1,
        };
        let sts_e01 = OwnedSegment {
            id: "STS".to_string(),
            elements: vec![
                vec!["E01".to_string()],
                vec![String::new()],
                vec!["A99".to_string(), "E_0614".to_string()],
            ],
            segment_number: 2,
        };

        let workflow = AhbWorkflow {
            pruefidentifikator: "55018".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![
                // Mig 00035: qualifier 7 at element 0, E03 required at element 2.
                AhbFieldRule {
                    segment_path: "SG4/STS/C601/9015".to_string(),
                    name: "Statuskategorie".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "7".to_string(),
                        description: "Transaktionsgrund".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    element_index: Some(0),
                    component_index: Some(0),
                    mig_number: Some("00035".to_string()),
                    format: None,
                },
                AhbFieldRule {
                    segment_path: "SG4/STS/C556/9013".to_string(),
                    name: "Statusanlaß".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "E03".to_string(),
                        description: "Transaktionsgrund".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    element_index: Some(2),
                    component_index: Some(0),
                    mig_number: Some("00035".to_string()),
                    format: None,
                },
                // Mig 00036: qualifier E01 at element 0, no codes at element 2.
                AhbFieldRule {
                    segment_path: "SG4/STS/C601/9015".to_string(),
                    name: "Statuskategorie".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "E01".to_string(),
                        description: "Antwort".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    element_index: Some(0),
                    component_index: Some(0),
                    mig_number: Some("00036".to_string()),
                    format: None,
                },
            ],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate(
            &[sts_7, sts_e01],
            &workflow,
            &external,
            ValidationLevel::Conditions,
        );

        let code_errors: Vec<_> = report
            .by_category(ValidationCategory::Code)
            .filter(|i| {
                i.severity == Severity::Error && i.code() == ErrorCodes::CODE_NOT_ALLOWED_FOR_PID
            })
            .collect();
        assert_eq!(
            code_errors.len(),
            1,
            "Expected one COD002 (for GH02 only), got: {:?}",
            code_errors
        );
        assert_eq!(code_errors[0].actual_value.as_deref(), Some("GH02"));
    }

    #[test]
    fn test_code_validation_composite_paths_detects_invalid_code() {
        // Mirror of the STS+7 case that motivated composite validation: a bad code
        // at element_index=2, component_index=0 must produce COD002.
        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let sts_segment = OwnedSegment {
            id: "STS".to_string(),
            elements: vec![
                vec!["7".to_string()],
                vec![String::new()],
                vec!["GH02".to_string()],
                vec!["ZW4".to_string()],
            ],
            segment_number: 1,
        };

        let workflow = AhbWorkflow {
            pruefidentifikator: "55018".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![AhbFieldRule {
                segment_path: "SG4/STS/C556/9013".to_string(),
                name: "Statusanlaß".to_string(),
                ahb_status: "X".to_string(),
                codes: vec![AhbCodeRule {
                    value: "E03".to_string(),
                    description: "Transaktionsgrund".to_string(),
                    ahb_status: "X".to_string(),
                }],
                parent_group_ahb_status: None,
                segment_ahb_status: None,
                element_index: Some(2),
                component_index: Some(0),
                ..Default::default()
            }],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate(
            &[sts_segment],
            &workflow,
            &external,
            ValidationLevel::Conditions,
        );

        let code_errors: Vec<_> = report
            .by_category(ValidationCategory::Code)
            .filter(|i| {
                i.severity == Severity::Error && i.code() == ErrorCodes::CODE_NOT_ALLOWED_FOR_PID
            })
            .collect();
        assert_eq!(
            code_errors.len(),
            1,
            "Expected COD002 for GH02, got: {:?}",
            code_errors
        );
        assert_eq!(code_errors[0].actual_value.as_deref(), Some("GH02"));
    }

    #[test]
    fn test_cross_field_code_validation_valid_qualifiers() {
        // NAD/3035 has separate field rules: [MS] for sender, [MR] for receiver.
        // Cross-field validation unions them → {MS, MR}. Both segments are valid.
        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let nad_ms = OwnedSegment {
            id: "NAD".to_string(),
            elements: vec![vec!["MS".to_string()]],
            segment_number: 4,
        };
        let nad_mr = OwnedSegment {
            id: "NAD".to_string(),
            elements: vec![vec!["MR".to_string()]],
            segment_number: 5,
        };

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![
                AhbFieldRule {
                    segment_path: "SG2/NAD/3035".to_string(),
                    name: "Absender".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "MS".to_string(),
                        description: "Absender".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
                AhbFieldRule {
                    segment_path: "SG2/NAD/3035".to_string(),
                    name: "Empfaenger".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "MR".to_string(),
                        description: "Empfaenger".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
            ],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate(
            &[nad_ms, nad_mr],
            &workflow,
            &external,
            ValidationLevel::Conditions,
        );

        let code_errors: Vec<_> = report
            .by_category(ValidationCategory::Code)
            .filter(|i| i.severity == Severity::Error)
            .collect();
        assert!(
            code_errors.is_empty(),
            "Expected no code errors for valid qualifiers, got: {:?}",
            code_errors
        );
    }

    #[test]
    fn test_cross_field_code_validation_catches_invalid_qualifier() {
        // NAD+MT is not in the allowed set {MS, MR} → should produce COD002.
        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let nad_ms = OwnedSegment {
            id: "NAD".to_string(),
            elements: vec![vec!["MS".to_string()]],
            segment_number: 4,
        };
        let nad_mt = OwnedSegment {
            id: "NAD".to_string(),
            elements: vec![vec!["MT".to_string()]], // invalid
            segment_number: 5,
        };

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![
                AhbFieldRule {
                    segment_path: "SG2/NAD/3035".to_string(),
                    name: "Absender".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "MS".to_string(),
                        description: "Absender".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
                AhbFieldRule {
                    segment_path: "SG2/NAD/3035".to_string(),
                    name: "Empfaenger".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "MR".to_string(),
                        description: "Empfaenger".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
            ],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate(
            &[nad_ms, nad_mt],
            &workflow,
            &external,
            ValidationLevel::Conditions,
        );

        let code_errors: Vec<_> = report
            .by_category(ValidationCategory::Code)
            .filter(|i| i.severity == Severity::Error)
            .collect();
        assert_eq!(code_errors.len(), 1, "Expected one COD002 error for MT");
        assert!(narrate(code_errors[0]).contains("MT"));
        assert!(narrate(code_errors[0]).contains("MR"));
        assert!(narrate(code_errors[0]).contains("MS"));
    }

    #[test]
    fn test_cross_field_code_validation_unions_across_groups() {
        // SG2/NAD/3035 allows {MS, MR}, SG4/SG12/NAD/3035 allows {Z04, Z09}.
        // Since find_segments("NAD") returns all NADs, codes must be unioned
        // by tag: {MS, MR, Z04, Z09}. NAD+MT should be caught, all others pass.
        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let segments = vec![
            OwnedSegment {
                id: "NAD".to_string(),
                elements: vec![vec!["MS".to_string()]],
                segment_number: 3,
            },
            OwnedSegment {
                id: "NAD".to_string(),
                elements: vec![vec!["MR".to_string()]],
                segment_number: 4,
            },
            OwnedSegment {
                id: "NAD".to_string(),
                elements: vec![vec!["Z04".to_string()]],
                segment_number: 20,
            },
            OwnedSegment {
                id: "NAD".to_string(),
                elements: vec![vec!["Z09".to_string()]],
                segment_number: 21,
            },
            OwnedSegment {
                id: "NAD".to_string(),
                elements: vec![vec!["MT".to_string()]], // invalid
                segment_number: 22,
            },
        ];

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![
                AhbFieldRule {
                    segment_path: "SG2/NAD/3035".to_string(),
                    name: "Absender".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "MS".to_string(),
                        description: "Absender".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
                AhbFieldRule {
                    segment_path: "SG2/NAD/3035".to_string(),
                    name: "Empfaenger".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "MR".to_string(),
                        description: "Empfaenger".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
                AhbFieldRule {
                    segment_path: "SG4/SG12/NAD/3035".to_string(),
                    name: "Anschlussnutzer".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "Z04".to_string(),
                        description: "Anschlussnutzer".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
                AhbFieldRule {
                    segment_path: "SG4/SG12/NAD/3035".to_string(),
                    name: "Korrespondenzanschrift".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "Z09".to_string(),
                        description: "Korrespondenzanschrift".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
            ],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report =
            validator.validate(&segments, &workflow, &external, ValidationLevel::Conditions);

        let code_errors: Vec<_> = report
            .by_category(ValidationCategory::Code)
            .filter(|i| i.severity == Severity::Error)
            .collect();
        assert_eq!(
            code_errors.len(),
            1,
            "Expected exactly one COD002 error for MT, got: {:?}",
            code_errors
        );
        assert!(narrate(code_errors[0]).contains("MT"));
    }

    #[test]
    fn test_cross_field_code_validation_accepts_conditionally_allowed_codes() {
        // QTY 6063 in MSCONS PID 13025 has three AHB-allowed codes:
        //   220  ahb_status "X"                        (unconditional)
        //   67   ahb_status "X [35] ∨ ([32] ∧ [77])"   (conditional)
        //   Z18  ahb_status "X [35]"                    (conditional)
        // All three are "allowed codes for this PID" — they differ only in when
        // they may be used. The COD002 "code not allowed for this PID" check
        // must accept the conditional ones too, otherwise real-world load-profile
        // messages using QTY+67 (Ersatzwert) are incorrectly rejected.
        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let qty_67 = OwnedSegment {
            id: "QTY".to_string(),
            elements: vec![vec!["67".to_string(), "0.185".to_string()]],
            segment_number: 10,
        };

        let workflow = AhbWorkflow {
            pruefidentifikator: "13025".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![AhbFieldRule {
                segment_path: "SG5/SG6/SG9/SG10/QTY/qualifier".to_string(),
                name: "Menge, Qualifier".to_string(),
                ahb_status: "X".to_string(),
                codes: vec![
                    AhbCodeRule {
                        value: "220".to_string(),
                        description: "Wahrer Wert".to_string(),
                        ahb_status: "X".to_string(),
                    },
                    AhbCodeRule {
                        value: "67".to_string(),
                        description: "Ersatzwert".to_string(),
                        ahb_status: "X [35] ∨ ([32] ∧ [77])".to_string(),
                    },
                    AhbCodeRule {
                        value: "Z18".to_string(),
                        description: "Vorläufiger Wert".to_string(),
                        ahb_status: "X [35]".to_string(),
                    },
                ],
                parent_group_ahb_status: None,
                segment_ahb_status: None,
                element_index: Some(0),
                component_index: Some(0),
                ..Default::default()
            }],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report =
            validator.validate(&[qty_67], &workflow, &external, ValidationLevel::Conditions);

        let code_errors: Vec<_> = report
            .by_category(ValidationCategory::Code)
            .filter(|i| i.severity == Severity::Error)
            .collect();
        assert!(
            code_errors.is_empty(),
            "QTY+67 should be accepted because code '67' is conditionally allowed for this PID (X [35] ∨ ([32] ∧ [77])). Got errors: {:?}",
            code_errors
        );
    }

    #[test]
    fn test_is_qualifier_field_simple_paths() {
        assert!(is_qualifier_field("NAD/3035"));
        assert!(is_qualifier_field("SG2/NAD/3035"));
        assert!(is_qualifier_field("SG4/SG8/SEQ/6350"));
        assert!(is_qualifier_field("LOC/3227"));
    }

    #[test]
    fn test_is_qualifier_field_composite_paths() {
        // Composite paths (3 parts after SG stripping) are accepted so composite-level
        // codes like STS/C556/9013 get validated. The field rule's element_index and
        // component_index carry the exact position.
        assert!(is_qualifier_field("UNH/S009/0065"));
        assert!(is_qualifier_field("NAD/C082/3039"));
        assert!(is_qualifier_field("SG2/NAD/C082/3039"));
        assert!(is_qualifier_field("SG4/STS/C556/9013"));
    }

    #[test]
    fn test_is_qualifier_field_bare_segment() {
        assert!(!is_qualifier_field("NAD"));
        assert!(!is_qualifier_field("SG2/NAD"));
    }

    #[test]
    fn test_is_qualifier_field_rejects_deep_paths() {
        // 4+ parts after SG stripping are malformed — reject.
        assert!(!is_qualifier_field("SEG/A/B/C/D"));
    }

    #[test]
    fn test_missing_qualifier_instance_is_detected() {
        // NAD+MS is present but NAD+MR is missing.
        // The Empfaenger field requires [MR] → should produce AHB001.
        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let nad_ms = OwnedSegment {
            id: "NAD".to_string(),
            elements: vec![vec!["MS".to_string()]],
            segment_number: 3,
        };

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![
                AhbFieldRule {
                    segment_path: "SG2/NAD/3035".to_string(),
                    name: "Absender".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "MS".to_string(),
                        description: "Absender".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
                AhbFieldRule {
                    segment_path: "SG2/NAD/3035".to_string(),
                    name: "Empfaenger".to_string(),
                    ahb_status: "Muss".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "MR".to_string(),
                        description: "Empfaenger".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
            ],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report =
            validator.validate(&[nad_ms], &workflow, &external, ValidationLevel::Conditions);

        let ahb_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.severity == Severity::Error)
            .collect();
        assert_eq!(
            ahb_errors.len(),
            1,
            "Expected AHB001 for missing NAD+MR, got: {:?}",
            ahb_errors
        );
        assert!(narrate(ahb_errors[0]).contains("Empfaenger"));
    }

    #[test]
    fn test_present_qualifier_instance_no_error() {
        // Both NAD+MS and NAD+MR present → no AHB001 for either.
        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let segments = vec![
            OwnedSegment {
                id: "NAD".to_string(),
                elements: vec![vec!["MS".to_string()]],
                segment_number: 3,
            },
            OwnedSegment {
                id: "NAD".to_string(),
                elements: vec![vec!["MR".to_string()]],
                segment_number: 4,
            },
        ];

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![
                AhbFieldRule {
                    segment_path: "SG2/NAD/3035".to_string(),
                    name: "Absender".to_string(),
                    ahb_status: "Muss".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "MS".to_string(),
                        description: "Absender".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
                AhbFieldRule {
                    segment_path: "SG2/NAD/3035".to_string(),
                    name: "Empfaenger".to_string(),
                    ahb_status: "Muss".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "MR".to_string(),
                        description: "Empfaenger".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
            ],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report =
            validator.validate(&segments, &workflow, &external, ValidationLevel::Conditions);

        let ahb_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.severity == Severity::Error)
            .collect();
        assert!(
            ahb_errors.is_empty(),
            "Expected no AHB001 errors, got: {:?}",
            ahb_errors
        );
    }

    #[test]
    fn test_extract_group_path_key() {
        assert_eq!(extract_group_path_key("SG2/NAD/3035"), "SG2");
        assert_eq!(extract_group_path_key("SG4/SG12/NAD/3035"), "SG4/SG12");
        assert_eq!(extract_group_path_key("NAD/3035"), "");
        assert_eq!(extract_group_path_key("SG4/SG8/SEQ/6350"), "SG4/SG8");
    }

    /// Validate a field of an absent SG9 whose group status is `group_status`.
    fn validate_field_of_absent_group(
        group_status: &str,
        conditions: Vec<(u32, CR)>,
    ) -> ValidationReport {
        use mig_types::navigator::GroupNavigator;

        struct NoSg9;
        impl GroupNavigator for NoSg9 {
            fn find_segments_in_group(&self, _: &str, _: &[&str], _: usize) -> Vec<OwnedSegment> {
                vec![]
            }
            fn find_segments_with_qualifier_in_group(
                &self,
                _: &str,
                _: usize,
                _: &str,
                _: &[&str],
                _: usize,
            ) -> Vec<OwnedSegment> {
                vec![]
            }
            fn group_instance_count(&self, _: &[&str]) -> usize {
                0
            }
        }

        let validator = EdifactValidator::new(MockEvaluator::new(conditions));
        let workflow = AhbWorkflow {
            pruefidentifikator: "44001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![AhbFieldRule {
                segment_path: "SG9/QTY/C186/6060".to_string(),
                name: "Menge".to_string(),
                ahb_status: "X".to_string(),
                parent_group_ahb_status: Some(group_status.to_string()),
                ..Default::default()
            }],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };
        validator.validate_with_navigator(
            &[],
            &workflow,
            &NoOpExternalProvider,
            ValidationLevel::Conditions,
            &NoSg9,
        )
    }

    #[test]
    fn an_absent_group_whose_holding_line_is_soll_is_not_missing() {
        // UTILMD Gas SG9 "TUM Kundenwert": Soll [47] ∧ … / Muss [46] ∧ …
        let report = validate_field_of_absent_group(
            "Soll [47]\r\nMuss [46]",
            vec![(47, CR::True), (46, CR::False)],
        );
        assert!(
            report.is_valid(),
            "{:?}",
            report.errors().collect::<Vec<_>>()
        );
    }

    #[test]
    fn an_absent_group_whose_holding_line_is_muss_is_missing() {
        let report = validate_field_of_absent_group(
            "Soll [47]\r\nMuss [46]",
            vec![(47, CR::False), (46, CR::True)],
        );
        let errors: Vec<_> = report.errors().collect();
        assert_eq!(errors.len(), 1, "{errors:?}");
        assert_eq!(errors[0].code(), ErrorCodes::MISSING_REQUIRED_FIELD);
    }

    #[test]
    fn test_absent_optional_group_no_missing_field_error() {
        // SG3 is optional ("Kann"). If SG3 is absent, its children CTA/3139
        // and CTA/C056/3412 should NOT produce AHB001 errors.
        use mig_types::navigator::GroupNavigator;

        struct NavWithoutSG3;
        impl GroupNavigator for NavWithoutSG3 {
            fn find_segments_in_group(&self, _: &str, _: &[&str], _: usize) -> Vec<OwnedSegment> {
                vec![]
            }
            fn find_segments_with_qualifier_in_group(
                &self,
                _: &str,
                _: usize,
                _: &str,
                _: &[&str],
                _: usize,
            ) -> Vec<OwnedSegment> {
                vec![]
            }
            fn group_instance_count(&self, group_path: &[&str]) -> usize {
                match group_path {
                    ["SG2"] => 2,        // two NAD groups present
                    ["SG2", "SG3"] => 0, // SG3 is absent
                    _ => 0,
                }
            }
        }

        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;
        let nav = NavWithoutSG3;

        // Only NAD segments present, no CTA
        let segments = vec![
            OwnedSegment {
                id: "NAD".into(),
                elements: vec![vec!["MS".into()]],
                segment_number: 3,
            },
            OwnedSegment {
                id: "NAD".into(),
                elements: vec![vec!["MR".into()]],
                segment_number: 4,
            },
        ];

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![
                AhbFieldRule {
                    segment_path: "SG2/SG3/CTA/3139".to_string(),
                    name: "Funktion des Ansprechpartners, Code".to_string(),
                    ahb_status: "Muss".to_string(),
                    codes: vec![],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
                AhbFieldRule {
                    segment_path: "SG2/SG3/CTA/C056/3412".to_string(),
                    name: "Name vom Ansprechpartner".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
            ],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate_with_navigator(
            &segments,
            &workflow,
            &external,
            ValidationLevel::Conditions,
            &nav,
        );

        let ahb_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.severity == Severity::Error)
            .collect();
        assert!(
            ahb_errors.is_empty(),
            "Expected no AHB001 errors when SG3 is absent, got: {:?}",
            ahb_errors
        );
    }

    #[test]
    fn test_present_group_still_checks_mandatory_fields() {
        // If SG3 IS present but CTA is missing within it → AHB001 error.
        use mig_types::navigator::GroupNavigator;

        struct NavWithSG3;
        impl GroupNavigator for NavWithSG3 {
            fn find_segments_in_group(&self, _: &str, _: &[&str], _: usize) -> Vec<OwnedSegment> {
                vec![]
            }
            fn find_segments_with_qualifier_in_group(
                &self,
                _: &str,
                _: usize,
                _: &str,
                _: &[&str],
                _: usize,
            ) -> Vec<OwnedSegment> {
                vec![]
            }
            fn group_instance_count(&self, group_path: &[&str]) -> usize {
                match group_path {
                    ["SG2"] => 1,
                    ["SG2", "SG3"] => 1, // SG3 is present
                    _ => 0,
                }
            }
        }

        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;
        let nav = NavWithSG3;

        // SG3 is present (nav says 1 instance) but CTA is not in flat segments
        let segments = vec![OwnedSegment {
            id: "NAD".into(),
            elements: vec![vec!["MS".into()]],
            segment_number: 3,
        }];

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![AhbFieldRule {
                segment_path: "SG2/SG3/CTA/3139".to_string(),
                name: "Funktion des Ansprechpartners, Code".to_string(),
                ahb_status: "Muss".to_string(),
                codes: vec![],
                parent_group_ahb_status: None,
                segment_ahb_status: None,
                ..Default::default()
            }],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate_with_navigator(
            &segments,
            &workflow,
            &external,
            ValidationLevel::Conditions,
            &nav,
        );

        let ahb_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.severity == Severity::Error)
            .collect();
        assert_eq!(
            ahb_errors.len(),
            1,
            "Expected AHB001 error when SG3 is present but CTA missing"
        );
        assert!(narrate(ahb_errors[0]).contains("CTA"));
    }

    #[test]
    fn test_missing_qualifier_with_navigator_is_detected() {
        // NAD+MS is in SG2 but NAD+MR is missing. With a navigator that
        // reports SG2 has 1 instance, the missing MR must still be flagged.
        use mig_types::navigator::GroupNavigator;

        struct NavWithSG2;
        impl GroupNavigator for NavWithSG2 {
            fn find_segments_in_group(
                &self,
                segment_id: &str,
                group_path: &[&str],
                instance_index: usize,
            ) -> Vec<OwnedSegment> {
                if segment_id == "NAD" && group_path == ["SG2"] && instance_index == 0 {
                    vec![OwnedSegment {
                        id: "NAD".into(),
                        elements: vec![vec!["MS".into()]],
                        segment_number: 3,
                    }]
                } else {
                    vec![]
                }
            }
            fn find_segments_with_qualifier_in_group(
                &self,
                _: &str,
                _: usize,
                _: &str,
                _: &[&str],
                _: usize,
            ) -> Vec<OwnedSegment> {
                vec![]
            }
            fn group_instance_count(&self, group_path: &[&str]) -> usize {
                match group_path {
                    ["SG2"] => 1,
                    _ => 0,
                }
            }
        }

        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;
        let nav = NavWithSG2;

        let segments = vec![OwnedSegment {
            id: "NAD".into(),
            elements: vec![vec!["MS".into()]],
            segment_number: 3,
        }];

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![
                AhbFieldRule {
                    segment_path: "SG2/NAD/3035".to_string(),
                    name: "Absender".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "MS".to_string(),
                        description: "Absender".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
                AhbFieldRule {
                    segment_path: "SG2/NAD/3035".to_string(),
                    name: "Empfaenger".to_string(),
                    ahb_status: "Muss".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "MR".to_string(),
                        description: "Empfaenger".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
            ],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate_with_navigator(
            &segments,
            &workflow,
            &external,
            ValidationLevel::Conditions,
            &nav,
        );

        let ahb_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.severity == Severity::Error)
            .collect();
        assert_eq!(
            ahb_errors.len(),
            1,
            "Expected AHB001 for missing NAD+MR even with navigator, got: {:?}",
            ahb_errors
        );
        assert!(narrate(ahb_errors[0]).contains("Empfaenger"));
    }

    #[test]
    fn test_optional_group_variant_absent_no_error() {
        // SG5 is "Kann" (optional) with LOC+Z16 present but LOC+Z17 absent.
        // Field rules for LOC/3227 with Z17 and its children should NOT error
        // because the parent group is optional and the variant is absent.
        // Meanwhile, SG2 is "Muss" — missing NAD+MR MUST still error.
        use mig_types::navigator::GroupNavigator;

        struct TestNav;
        impl GroupNavigator for TestNav {
            fn find_segments_in_group(
                &self,
                segment_id: &str,
                group_path: &[&str],
                instance_index: usize,
            ) -> Vec<OwnedSegment> {
                match (segment_id, group_path, instance_index) {
                    ("LOC", ["SG4", "SG5"], 0) => vec![OwnedSegment {
                        id: "LOC".into(),
                        elements: vec![vec!["Z16".into()], vec!["DE00012345".into()]],
                        segment_number: 10,
                    }],
                    ("NAD", ["SG2"], 0) => vec![OwnedSegment {
                        id: "NAD".into(),
                        elements: vec![vec!["MS".into()]],
                        segment_number: 3,
                    }],
                    _ => vec![],
                }
            }
            fn find_segments_with_qualifier_in_group(
                &self,
                _: &str,
                _: usize,
                _: &str,
                _: &[&str],
                _: usize,
            ) -> Vec<OwnedSegment> {
                vec![]
            }
            fn group_instance_count(&self, group_path: &[&str]) -> usize {
                match group_path {
                    ["SG2"] => 1,
                    ["SG4"] => 1,
                    ["SG4", "SG5"] => 1, // only Z16 instance
                    _ => 0,
                }
            }
        }

        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;
        let nav = TestNav;

        let segments = vec![
            OwnedSegment {
                id: "NAD".into(),
                elements: vec![vec!["MS".into()]],
                segment_number: 3,
            },
            OwnedSegment {
                id: "LOC".into(),
                elements: vec![vec!["Z16".into()], vec!["DE00012345".into()]],
                segment_number: 10,
            },
        ];

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![
                // SG2 "Muss" — NAD+MS present, NAD+MR missing → should error
                AhbFieldRule {
                    segment_path: "SG2/NAD/3035".to_string(),
                    name: "Absender".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "MS".to_string(),
                        description: "Absender".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: Some("Muss".to_string()),
                    segment_ahb_status: None,
                    ..Default::default()
                },
                AhbFieldRule {
                    segment_path: "SG2/NAD/3035".to_string(),
                    name: "Empfaenger".to_string(),
                    ahb_status: "Muss".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "MR".to_string(),
                        description: "Empfaenger".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: Some("Muss".to_string()),
                    segment_ahb_status: None,
                    ..Default::default()
                },
                // SG5 "Kann" — LOC+Z16 present, LOC+Z17 absent → should NOT error
                AhbFieldRule {
                    segment_path: "SG4/SG5/LOC/3227".to_string(),
                    name: "Ortsangabe, Qualifier (Z16)".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "Z16".to_string(),
                        description: "Marktlokation".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: Some("Kann".to_string()),
                    segment_ahb_status: None,
                    ..Default::default()
                },
                AhbFieldRule {
                    segment_path: "SG4/SG5/LOC/3227".to_string(),
                    name: "Ortsangabe, Qualifier (Z17)".to_string(),
                    ahb_status: "Muss".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "Z17".to_string(),
                        description: "Messlokation".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: Some("Kann".to_string()),
                    segment_ahb_status: None,
                    ..Default::default()
                },
            ],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate_with_navigator(
            &segments,
            &workflow,
            &external,
            ValidationLevel::Conditions,
            &nav,
        );

        let ahb_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.severity == Severity::Error)
            .collect();

        // Exactly 1 error: NAD+MR missing (mandatory group)
        // LOC+Z17 should NOT error (optional group variant absent)
        assert_eq!(
            ahb_errors.len(),
            1,
            "Expected only AHB001 for missing NAD+MR, got: {:?}",
            ahb_errors
        );
        assert!(
            narrate(ahb_errors[0]).contains("Empfaenger"),
            "Error should be for missing NAD+MR (Empfaenger)"
        );
    }

    /// UTILMD Gas 44143: SG8 "Messdatenregistriergerätedaten" (SEQ+Z50) is
    /// `Kann [345]`. With [345] true the variant is allowed, not required, so its
    /// absence — beside a present SEQ+Z03 SG8 — must not report its `SEQ 1229`.
    #[test]
    fn test_optional_group_variant_with_true_condition_absent_no_error() {
        use mig_types::navigator::GroupNavigator;

        struct TestNav;
        impl GroupNavigator for TestNav {
            fn find_segments_in_group(
                &self,
                segment_id: &str,
                group_path: &[&str],
                instance_index: usize,
            ) -> Vec<OwnedSegment> {
                if segment_id == "SEQ" && group_path == ["SG4", "SG8"] && instance_index == 0 {
                    vec![OwnedSegment {
                        id: "SEQ".into(),
                        elements: vec![vec!["Z03".into()]],
                        segment_number: 10,
                    }]
                } else {
                    vec![]
                }
            }
            fn find_segments_with_qualifier_in_group(
                &self,
                _: &str,
                _: usize,
                _: &str,
                _: &[&str],
                _: usize,
            ) -> Vec<OwnedSegment> {
                vec![]
            }
            fn group_instance_count(&self, group_path: &[&str]) -> usize {
                match group_path {
                    ["SG4"] => 1,
                    ["SG4", "SG8"] => 1,
                    _ => 0,
                }
            }
        }

        let evaluator = MockEvaluator::new(vec![(345, CR::True)]);
        let validator = EdifactValidator::new(evaluator);
        let segments = vec![OwnedSegment {
            id: "SEQ".into(),
            elements: vec![vec!["Z03".into()]],
            segment_number: 10,
        }];
        let seq = |code: &str, group: &str| AhbFieldRule {
            segment_path: "SG4/SG8/SEQ/1229".to_string(),
            name: format!("Handlung, Code ({code})"),
            ahb_status: "X".to_string(),
            codes: vec![AhbCodeRule {
                value: code.to_string(),
                description: String::new(),
                ahb_status: "X".to_string(),
            }],
            parent_group_ahb_status: Some(group.to_string()),
            segment_ahb_status: None,
            ..Default::default()
        };
        let workflow = AhbWorkflow {
            pruefidentifikator: "44143".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![seq("Z03", "Kann"), seq("Z50", "Kann [345]")],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate_with_navigator(
            &segments,
            &workflow,
            &NoOpExternalProvider,
            ValidationLevel::Conditions,
            &TestNav,
        );
        let missing: Vec<_> = report
            .issues
            .iter()
            .filter(|i| matches!(i.kind, IssueKind::MissingRequiredField { .. }))
            .collect();
        assert!(missing.is_empty(), "{missing:#?}");
    }

    #[test]
    fn test_conditional_group_variant_absent_no_error() {
        // Real-world scenario: SG5 "Messlokation" has AHB_Status="Soll [165]".
        // Condition [165] evaluates to False → LOC+Z17 should NOT error.
        // SG5 "Marktlokation" has AHB_Status="Muss [2061]".
        // Condition [2061] evaluates to True → LOC+Z16 is present → no error.
        use mig_types::navigator::GroupNavigator;

        struct TestNav;
        impl GroupNavigator for TestNav {
            fn find_segments_in_group(
                &self,
                segment_id: &str,
                group_path: &[&str],
                instance_index: usize,
            ) -> Vec<OwnedSegment> {
                if segment_id == "LOC" && group_path == ["SG4", "SG5"] && instance_index == 0 {
                    vec![OwnedSegment {
                        id: "LOC".into(),
                        elements: vec![vec!["Z16".into()], vec!["DE00012345".into()]],
                        segment_number: 10,
                    }]
                } else {
                    vec![]
                }
            }
            fn find_segments_with_qualifier_in_group(
                &self,
                _: &str,
                _: usize,
                _: &str,
                _: &[&str],
                _: usize,
            ) -> Vec<OwnedSegment> {
                vec![]
            }
            fn group_instance_count(&self, group_path: &[&str]) -> usize {
                match group_path {
                    ["SG4"] => 1,
                    ["SG4", "SG5"] => 1, // only Z16 instance
                    _ => 0,
                }
            }
        }

        // Condition 165 → False (Messlokation not required)
        // Condition 2061 → True (Marktlokation required)
        let evaluator = MockEvaluator::new(vec![(165, CR::False), (2061, CR::True)]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;
        let nav = TestNav;

        let segments = vec![OwnedSegment {
            id: "LOC".into(),
            elements: vec![vec!["Z16".into()], vec!["DE00012345".into()]],
            segment_number: 10,
        }];

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![
                // SG5 "Muss [2061]" with [2061]=True → LOC+Z16 required, present → OK
                AhbFieldRule {
                    segment_path: "SG4/SG5/LOC/3227".to_string(),
                    name: "Ortsangabe, Qualifier (Z16)".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "Z16".to_string(),
                        description: "Marktlokation".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: Some("Muss [2061]".to_string()),
                    segment_ahb_status: None,
                    ..Default::default()
                },
                // SG5 "Soll [165]" with [165]=False → LOC+Z17 NOT required → skip
                AhbFieldRule {
                    segment_path: "SG4/SG5/LOC/3227".to_string(),
                    name: "Ortsangabe, Qualifier (Z17)".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "Z17".to_string(),
                        description: "Messlokation".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: Some("Soll [165]".to_string()),
                    segment_ahb_status: None,
                    ..Default::default()
                },
            ],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate_with_navigator(
            &segments,
            &workflow,
            &external,
            ValidationLevel::Conditions,
            &nav,
        );

        let ahb_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.severity == Severity::Error)
            .collect();

        // Zero errors: Z16 is present, and Z17's group condition is False
        assert!(
            ahb_errors.is_empty(),
            "Expected no errors when conditional group variant [165]=False, got: {:?}",
            ahb_errors
        );
    }

    #[test]
    fn test_conditional_group_variant_unknown_no_error() {
        // When a parent group condition evaluates to Unknown (unimplemented
        // condition), child fields should NOT produce mandatory-missing errors.
        // The group-level entry itself will produce an Info "condition unknown".

        // Condition 165 is NOT in the evaluator → returns Unknown
        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![AhbFieldRule {
                segment_path: "SG4/SG5/LOC/3227".to_string(),
                name: "Ortsangabe, Qualifier (Z17)".to_string(),
                ahb_status: "X".to_string(),
                codes: vec![AhbCodeRule {
                    value: "Z17".to_string(),
                    description: "Messlokation".to_string(),
                    ahb_status: "X".to_string(),
                }],
                parent_group_ahb_status: Some("Soll [165]".to_string()),
                segment_ahb_status: None,
                ..Default::default()
            }],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate(&[], &workflow, &external, ValidationLevel::Conditions);

        let ahb_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.severity == Severity::Error)
            .collect();

        // No errors: parent group condition [165] is Unknown → skip child fields
        assert!(
            ahb_errors.is_empty(),
            "Expected no errors when parent group condition is Unknown, got: {:?}",
            ahb_errors
        );
    }

    #[test]
    fn test_segment_absent_within_present_group_no_error() {
        // MSCONS scenario: SG10 has QTY (entry) + optional STS segments.
        // SG10 is present (QTY+220 exists) but STS is absent.
        // Fields under STS should NOT produce AHB001 errors.
        use mig_types::navigator::GroupNavigator;

        struct TestNav;
        impl GroupNavigator for TestNav {
            fn find_segments_in_group(
                &self,
                segment_id: &str,
                group_path: &[&str],
                instance_index: usize,
            ) -> Vec<OwnedSegment> {
                // SG10 has QTY but no STS
                if segment_id == "QTY"
                    && group_path == ["SG5", "SG6", "SG9", "SG10"]
                    && instance_index == 0
                {
                    vec![OwnedSegment {
                        id: "QTY".into(),
                        elements: vec![vec!["220".into(), "0".into()]],
                        segment_number: 14,
                    }]
                } else {
                    vec![]
                }
            }
            fn find_segments_with_qualifier_in_group(
                &self,
                _: &str,
                _: usize,
                _: &str,
                _: &[&str],
                _: usize,
            ) -> Vec<OwnedSegment> {
                vec![]
            }
            fn group_instance_count(&self, group_path: &[&str]) -> usize {
                match group_path {
                    ["SG5"] => 1,
                    ["SG5", "SG6"] => 1,
                    ["SG5", "SG6", "SG9"] => 1,
                    ["SG5", "SG6", "SG9", "SG10"] => 1,
                    _ => 0,
                }
            }
            fn has_any_segment_in_group(&self, group_path: &[&str], instance_index: usize) -> bool {
                // SG10 instance 0 has QTY (the entry segment)
                group_path == ["SG5", "SG6", "SG9", "SG10"] && instance_index == 0
            }
        }

        let evaluator = MockEvaluator::all_true(&[]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;
        let nav = TestNav;

        let segments = vec![OwnedSegment {
            id: "QTY".into(),
            elements: vec![vec!["220".into(), "0".into()]],
            segment_number: 14,
        }];

        let workflow = AhbWorkflow {
            pruefidentifikator: "13017".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![
                // STS/C601/9015 — mandatory field under STS, but STS is absent from SG10
                AhbFieldRule {
                    segment_path: "SG5/SG6/SG9/SG10/STS/C601/9015".to_string(),
                    name: "Statuskategorie, Code".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![],
                    parent_group_ahb_status: Some("Muss".to_string()),
                    segment_ahb_status: None,
                    ..Default::default()
                },
                // STS/C556/9013 — another field under STS
                AhbFieldRule {
                    segment_path: "SG5/SG6/SG9/SG10/STS/C556/9013".to_string(),
                    name: "Statusanlaß, Code".to_string(),
                    ahb_status: "X [5]".to_string(),
                    codes: vec![],
                    parent_group_ahb_status: Some("Muss".to_string()),
                    segment_ahb_status: None,
                    ..Default::default()
                },
            ],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate_with_navigator(
            &segments,
            &workflow,
            &external,
            ValidationLevel::Conditions,
            &nav,
        );

        let ahb_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.severity == Severity::Error)
            .collect();

        assert!(
            ahb_errors.is_empty(),
            "Expected no AHB001 errors when STS segment is absent from SG10, got: {:?}",
            ahb_errors
        );
    }

    #[test]
    fn test_group_scoped_code_validation_with_navigator() {
        // With a navigator, SG2/NAD is checked against {MS, MR} only,
        // and SG4/SG12/NAD is checked against {Z04, Z09} only.
        // NAD+MT in SG2 → error with allowed [MR, MS] (not the full union).
        use mig_types::navigator::GroupNavigator;

        struct TestNav;
        impl GroupNavigator for TestNav {
            fn find_segments_in_group(
                &self,
                segment_id: &str,
                group_path: &[&str],
                _instance_index: usize,
            ) -> Vec<OwnedSegment> {
                if segment_id != "NAD" {
                    return vec![];
                }
                match group_path {
                    ["SG2"] => vec![
                        OwnedSegment {
                            id: "NAD".into(),
                            elements: vec![vec!["MS".into()]],
                            segment_number: 3,
                        },
                        OwnedSegment {
                            id: "NAD".into(),
                            elements: vec![vec!["MT".into()]], // invalid in SG2
                            segment_number: 4,
                        },
                    ],
                    ["SG4", "SG12"] => vec![
                        OwnedSegment {
                            id: "NAD".into(),
                            elements: vec![vec!["Z04".into()]],
                            segment_number: 20,
                        },
                        OwnedSegment {
                            id: "NAD".into(),
                            elements: vec![vec!["Z09".into()]],
                            segment_number: 21,
                        },
                    ],
                    _ => vec![],
                }
            }
            fn find_segments_with_qualifier_in_group(
                &self,
                _: &str,
                _: usize,
                _: &str,
                _: &[&str],
                _: usize,
            ) -> Vec<OwnedSegment> {
                vec![]
            }
            fn group_instance_count(&self, group_path: &[&str]) -> usize {
                match group_path {
                    ["SG2"] | ["SG4", "SG12"] => 1,
                    _ => 0,
                }
            }
        }

        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;
        let nav = TestNav;

        let workflow = AhbWorkflow {
            pruefidentifikator: "55001".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![
                AhbFieldRule {
                    segment_path: "SG2/NAD/3035".to_string(),
                    name: "Absender".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "MS".to_string(),
                        description: "Absender".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
                AhbFieldRule {
                    segment_path: "SG2/NAD/3035".to_string(),
                    name: "Empfaenger".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "MR".to_string(),
                        description: "Empfaenger".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
                AhbFieldRule {
                    segment_path: "SG4/SG12/NAD/3035".to_string(),
                    name: "Anschlussnutzer".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "Z04".to_string(),
                        description: "Anschlussnutzer".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
                AhbFieldRule {
                    segment_path: "SG4/SG12/NAD/3035".to_string(),
                    name: "Korrespondenzanschrift".to_string(),
                    ahb_status: "X".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "Z09".to_string(),
                        description: "Korrespondenzanschrift".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    ..Default::default()
                },
            ],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        // All segments flat (for condition evaluation), navigator provides group scope.
        let all_segments = vec![
            OwnedSegment {
                id: "NAD".into(),
                elements: vec![vec!["MS".into()]],
                segment_number: 3,
            },
            OwnedSegment {
                id: "NAD".into(),
                elements: vec![vec!["MT".into()]],
                segment_number: 4,
            },
            OwnedSegment {
                id: "NAD".into(),
                elements: vec![vec!["Z04".into()]],
                segment_number: 20,
            },
            OwnedSegment {
                id: "NAD".into(),
                elements: vec![vec!["Z09".into()]],
                segment_number: 21,
            },
        ];

        let report = validator.validate_with_navigator(
            &all_segments,
            &workflow,
            &external,
            ValidationLevel::Conditions,
            &nav,
        );

        let code_errors: Vec<_> = report
            .by_category(ValidationCategory::Code)
            .filter(|i| i.severity == Severity::Error)
            .collect();

        // Only one error: MT in SG2 (not allowed in {MS, MR}).
        // Z04 and Z09 are NOT checked against {MS, MR} — group-scoped.
        assert_eq!(
            code_errors.len(),
            1,
            "Expected exactly one COD002 error for MT in SG2, got: {:?}",
            code_errors
        );
        assert!(narrate(code_errors[0]).contains("MT"));
        // Error should show only SG2's allowed codes, not the full union
        assert!(narrate(code_errors[0]).contains("MR"));
        assert!(narrate(code_errors[0]).contains("MS"));
        assert!(
            !narrate(code_errors[0]).contains("Z04"),
            "SG4/SG12 codes should not leak into SG2 error"
        );
        // Field path should include the group
        assert!(
            code_errors[0]
                .field_path
                .as_deref()
                .unwrap_or("")
                .contains("SG2"),
            "Error field_path should reference SG2, got: {:?}",
            code_errors[0].field_path
        );
    }

    // === Package cardinality tests ===

    #[test]
    fn test_package_cardinality_within_bounds() {
        // 1 code present from package [4P0..1], max=1 -> OK
        let evaluator = MockEvaluator::all_true(&[]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let segments = vec![OwnedSegment {
            id: "STS".into(),
            elements: vec![
                vec!["Z33".into()], // element[0]
                vec![],             // element[1]
                vec!["E01".into()], // element[2], component[0]
            ],
            segment_number: 5,
        }];

        let workflow = AhbWorkflow {
            pruefidentifikator: "13017".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
            fields: vec![AhbFieldRule {
                segment_path: "SG5/SG6/SG9/SG10/STS/C556/9013".to_string(),
                name: "Statusanlaß, Code".to_string(),
                ahb_status: "X".to_string(),
                element_index: Some(2),
                component_index: Some(0),
                codes: vec![
                    AhbCodeRule {
                        value: "E01".into(),
                        description: "Code 1".into(),
                        ahb_status: "X [4P0..1]".into(),
                    },
                    AhbCodeRule {
                        value: "E02".into(),
                        description: "Code 2".into(),
                        ahb_status: "X [4P0..1]".into(),
                    },
                ],
                parent_group_ahb_status: Some("Muss".to_string()),
                segment_ahb_status: None,
                mig_number: None,
                format: None,
            }],
        };

        let report = validator.validate(&segments, &workflow, &external, ValidationLevel::Full);
        let pkg_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.code() == ErrorCodes::PACKAGE_CARDINALITY_VIOLATION)
            .collect();
        assert!(
            pkg_errors.is_empty(),
            "1 code within [4P0..1] bounds — no error expected, got: {:?}",
            pkg_errors
        );
    }

    #[test]
    fn test_package_cardinality_zero_present_min_zero() {
        // No codes from the package present, min=0 -> OK
        let evaluator = MockEvaluator::all_true(&[]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let segments = vec![OwnedSegment {
            id: "STS".into(),
            elements: vec![
                vec!["Z33".into()],
                vec![],
                vec!["X99".into()], // X99 not in package
            ],
            segment_number: 5,
        }];

        let workflow = AhbWorkflow {
            pruefidentifikator: "13017".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
            fields: vec![AhbFieldRule {
                segment_path: "SG5/SG6/SG9/SG10/STS/C556/9013".to_string(),
                name: "Statusanlaß, Code".to_string(),
                ahb_status: "X".to_string(),
                element_index: Some(2),
                component_index: Some(0),
                codes: vec![
                    AhbCodeRule {
                        value: "E01".into(),
                        description: "Code 1".into(),
                        ahb_status: "X [4P0..1]".into(),
                    },
                    AhbCodeRule {
                        value: "E02".into(),
                        description: "Code 2".into(),
                        ahb_status: "X [4P0..1]".into(),
                    },
                ],
                parent_group_ahb_status: Some("Muss".to_string()),
                segment_ahb_status: None,
                mig_number: None,
                format: None,
            }],
        };

        let report = validator.validate(&segments, &workflow, &external, ValidationLevel::Full);
        let pkg_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.code() == ErrorCodes::PACKAGE_CARDINALITY_VIOLATION)
            .collect();
        assert!(
            pkg_errors.is_empty(),
            "0 codes, min=0 — no error expected, got: {:?}",
            pkg_errors
        );
    }

    #[test]
    fn test_package_cardinality_too_many() {
        // 2 codes present from package [4P0..1], max=1 -> ERROR
        let evaluator = MockEvaluator::all_true(&[]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        // Two STS segments, each with a different package code
        let segments = vec![
            OwnedSegment {
                id: "STS".into(),
                elements: vec![vec!["Z33".into()], vec![], vec!["E01".into()]],
                segment_number: 5,
            },
            OwnedSegment {
                id: "STS".into(),
                elements: vec![vec!["Z33".into()], vec![], vec!["E02".into()]],
                segment_number: 6,
            },
        ];

        let workflow = AhbWorkflow {
            pruefidentifikator: "13017".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
            fields: vec![AhbFieldRule {
                segment_path: "SG5/SG6/SG9/SG10/STS/C556/9013".to_string(),
                name: "Statusanlaß, Code".to_string(),
                ahb_status: "X".to_string(),
                element_index: Some(2),
                component_index: Some(0),
                codes: vec![
                    AhbCodeRule {
                        value: "E01".into(),
                        description: "Code 1".into(),
                        ahb_status: "X [4P0..1]".into(),
                    },
                    AhbCodeRule {
                        value: "E02".into(),
                        description: "Code 2".into(),
                        ahb_status: "X [4P0..1]".into(),
                    },
                ],
                parent_group_ahb_status: Some("Muss".to_string()),
                segment_ahb_status: None,
                mig_number: None,
                format: None,
            }],
        };

        let report = validator.validate(&segments, &workflow, &external, ValidationLevel::Full);
        let pkg_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.code() == ErrorCodes::PACKAGE_CARDINALITY_VIOLATION)
            .collect();
        assert_eq!(
            pkg_errors.len(),
            1,
            "2 codes present, max=1 — expected 1 error, got: {:?}",
            pkg_errors
        );
        assert!(narrate(pkg_errors[0]).contains("[4P0..1]"));
        assert_eq!(pkg_errors[0].actual_value.as_deref(), Some("2"));
        assert_eq!(pkg_errors[0].expected_value.as_deref(), Some("0..1"));
    }

    #[test]
    fn test_package_cardinality_too_few() {
        // 0 codes present from package [5P1..3], min=1 -> ERROR
        let evaluator = MockEvaluator::all_true(&[]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let segments = vec![OwnedSegment {
            id: "STS".into(),
            elements: vec![
                vec!["Z33".into()],
                vec![],
                vec!["X99".into()], // not in package
            ],
            segment_number: 5,
        }];

        let workflow = AhbWorkflow {
            pruefidentifikator: "13017".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
            fields: vec![AhbFieldRule {
                segment_path: "SG5/SG6/SG9/SG10/STS/C556/9013".to_string(),
                name: "Statusanlaß, Code".to_string(),
                ahb_status: "X".to_string(),
                element_index: Some(2),
                component_index: Some(0),
                codes: vec![
                    AhbCodeRule {
                        value: "E01".into(),
                        description: "Code 1".into(),
                        ahb_status: "X [5P1..3]".into(),
                    },
                    AhbCodeRule {
                        value: "E02".into(),
                        description: "Code 2".into(),
                        ahb_status: "X [5P1..3]".into(),
                    },
                    AhbCodeRule {
                        value: "E03".into(),
                        description: "Code 3".into(),
                        ahb_status: "X [5P1..3]".into(),
                    },
                ],
                parent_group_ahb_status: Some("Muss".to_string()),
                segment_ahb_status: None,
                mig_number: None,
                format: None,
            }],
        };

        let report = validator.validate(&segments, &workflow, &external, ValidationLevel::Full);
        let pkg_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.code() == ErrorCodes::PACKAGE_CARDINALITY_VIOLATION)
            .collect();
        assert_eq!(
            pkg_errors.len(),
            1,
            "0 codes present, min=1 — expected 1 error, got: {:?}",
            pkg_errors
        );
        assert!(narrate(pkg_errors[0]).contains("[5P1..3]"));
        assert_eq!(pkg_errors[0].actual_value.as_deref(), Some("0"));
        assert_eq!(pkg_errors[0].expected_value.as_deref(), Some("1..3"));
    }

    #[test]
    fn test_package_cardinality_no_packages_in_workflow() {
        // Codes without package annotations -> no package errors
        let evaluator = MockEvaluator::all_true(&[]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let segments = vec![OwnedSegment {
            id: "STS".into(),
            elements: vec![vec!["E01".into()]],
            segment_number: 5,
        }];

        let workflow = AhbWorkflow {
            pruefidentifikator: "13017".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
            fields: vec![AhbFieldRule {
                segment_path: "STS/9015".to_string(),
                name: "Status Code".to_string(),
                ahb_status: "X".to_string(),
                codes: vec![AhbCodeRule {
                    value: "E01".into(),
                    description: "Code 1".into(),
                    ahb_status: "X".into(),
                }],
                parent_group_ahb_status: Some("Muss".to_string()),
                segment_ahb_status: None,
                ..Default::default()
            }],
        };

        let report = validator.validate(&segments, &workflow, &external, ValidationLevel::Full);
        let pkg_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.code() == ErrorCodes::PACKAGE_CARDINALITY_VIOLATION)
            .collect();
        assert!(
            pkg_errors.is_empty(),
            "No packages in workflow — no errors expected"
        );
    }

    #[test]
    fn test_package_cardinality_with_condition_and_package() {
        // Code status "X [901] [4P0..1]" has both condition and package
        let evaluator = MockEvaluator::all_true(&[901]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let segments = vec![OwnedSegment {
            id: "STS".into(),
            elements: vec![vec![], vec![], vec!["E01".into()]],
            segment_number: 5,
        }];

        let workflow = AhbWorkflow {
            pruefidentifikator: "13017".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
            fields: vec![AhbFieldRule {
                segment_path: "SG10/STS/C556/9013".to_string(),
                name: "Code".to_string(),
                ahb_status: "X".to_string(),
                element_index: Some(2),
                component_index: Some(0),
                codes: vec![
                    AhbCodeRule {
                        value: "E01".into(),
                        description: "Code 1".into(),
                        ahb_status: "X [901] [4P0..1]".into(),
                    },
                    AhbCodeRule {
                        value: "E02".into(),
                        description: "Code 2".into(),
                        ahb_status: "X [901] [4P0..1]".into(),
                    },
                ],
                parent_group_ahb_status: Some("Muss".to_string()),
                segment_ahb_status: None,
                mig_number: None,
                format: None,
            }],
        };

        let report = validator.validate(&segments, &workflow, &external, ValidationLevel::Full);
        let pkg_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.code() == ErrorCodes::PACKAGE_CARDINALITY_VIOLATION)
            .collect();
        assert!(
            pkg_errors.is_empty(),
            "1 code within [4P0..1] bounds — no error, got: {:?}",
            pkg_errors
        );
    }

    #[test]
    fn test_package_binds_only_where_its_condition_holds() {
        // `[5P1..1]` with the package condition `[902]` (the AHB's
        // `<Paket Nummer="[5P]">[902]</Paket>`): no code of the package is
        // sent, which is a violation only where [902] holds.
        let report_for = |package_condition: CR| {
            let validator =
                EdifactValidator::new(MockEvaluator::new(vec![(902, package_condition)]));
            let segments = vec![OwnedSegment {
                id: "STS".into(),
                elements: vec![vec![], vec![], vec!["E09".into()]],
                segment_number: 5,
            }];
            let workflow = AhbWorkflow {
                pruefidentifikator: "13017".to_string(),
                description: "Test".to_string(),
                communication_direction: None,
                ub_definitions: BTreeMap::new(),
                package_conditions: BTreeMap::from([(5, ConditionExpr::Ref(902))]),
                fields: vec![AhbFieldRule {
                    segment_path: "SG10/STS/C556/9013".to_string(),
                    name: "Code".to_string(),
                    ahb_status: "X".to_string(),
                    element_index: Some(2),
                    component_index: Some(0),
                    codes: vec![
                        AhbCodeRule {
                            value: "E01".into(),
                            description: "Code 1".into(),
                            ahb_status: "X [5P1..1]".into(),
                        },
                        AhbCodeRule {
                            value: "E09".into(),
                            description: "Code 9".into(),
                            ahb_status: "X".into(),
                        },
                    ],
                    parent_group_ahb_status: Some("Muss".to_string()),
                    segment_ahb_status: None,
                    mig_number: None,
                    format: None,
                }],
            };
            validator
                .validate(
                    &segments,
                    &workflow,
                    &NoOpExternalProvider,
                    ValidationLevel::Full,
                )
                .by_category(ValidationCategory::Ahb)
                .filter(|i| i.code() == ErrorCodes::PACKAGE_CARDINALITY_VIOLATION)
                .count()
        };
        assert_eq!(report_for(CR::False), 0, "[902] false: [5P] does not bind");
        assert_eq!(report_for(CR::True), 1, "[902] true: [5P1..1] binds");
    }

    #[test]
    fn test_package_cardinality_scoped_per_group_instance() {
        // Package [4P0..1] caps the number of codes per SG10 group instance at 0..1.
        // MSCONS PID 13025 messages contain many SG10 reps (one per interval); each
        // rep has its own STS+Z32++<reason> segment using one code from the package.
        // The old global count summed codes across reps and flagged every
        // multi-interval message (e.g. 96 intervals → 96 codes "allowed 0..1").
        // With a navigator present, package cardinality must be evaluated per
        // group instance, not message-wide.
        use mig_types::navigator::GroupNavigator;

        struct TwoSg10s {
            sts_a: OwnedSegment,
            sts_b: OwnedSegment,
        }
        impl GroupNavigator for TwoSg10s {
            fn find_segments_in_group(
                &self,
                segment_id: &str,
                group_path: &[&str],
                instance_index: usize,
            ) -> Vec<OwnedSegment> {
                if group_path == ["SG5", "SG6", "SG9", "SG10"] && segment_id == "STS" {
                    match instance_index {
                        0 => vec![self.sts_a.clone()],
                        1 => vec![self.sts_b.clone()],
                        _ => vec![],
                    }
                } else {
                    vec![]
                }
            }
            fn find_segments_with_qualifier_in_group(
                &self,
                _: &str,
                _: usize,
                _: &str,
                _: &[&str],
                _: usize,
            ) -> Vec<OwnedSegment> {
                vec![]
            }
            fn group_instance_count(&self, group_path: &[&str]) -> usize {
                match group_path {
                    ["SG5"] | ["SG5", "SG6"] | ["SG5", "SG6", "SG9"] => 1,
                    ["SG5", "SG6", "SG9", "SG10"] => 2,
                    _ => 0,
                }
            }
        }

        let sts_a = OwnedSegment {
            id: "STS".into(),
            elements: vec![vec!["Z32".into()], vec![], vec!["E01".into()]],
            segment_number: 10,
        };
        let sts_b = OwnedSegment {
            id: "STS".into(),
            elements: vec![vec!["Z32".into()], vec![], vec!["E01".into()]],
            segment_number: 15,
        };
        let nav = TwoSg10s {
            sts_a: sts_a.clone(),
            sts_b: sts_b.clone(),
        };

        let evaluator = MockEvaluator::all_true(&[]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let workflow = AhbWorkflow {
            pruefidentifikator: "13025".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
            fields: vec![AhbFieldRule {
                segment_path: "SG5/SG6/SG9/SG10/STS/C556/9013".to_string(),
                name: "Statusanlaß, Code".to_string(),
                ahb_status: "X".to_string(),
                element_index: Some(2),
                component_index: Some(0),
                codes: vec![
                    AhbCodeRule {
                        value: "E01".into(),
                        description: "Code 1".into(),
                        ahb_status: "X [4P0..1]".into(),
                    },
                    AhbCodeRule {
                        value: "E02".into(),
                        description: "Code 2".into(),
                        ahb_status: "X [4P0..1]".into(),
                    },
                ],
                parent_group_ahb_status: Some("Muss".to_string()),
                segment_ahb_status: None,
                mig_number: None,
                format: None,
            }],
        };

        let report = validator.validate_with_navigator(
            &[sts_a, sts_b],
            &workflow,
            &external,
            ValidationLevel::Full,
            &nav,
        );
        let pkg_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.code() == ErrorCodes::PACKAGE_CARDINALITY_VIOLATION)
            .collect();
        assert!(
            pkg_errors.is_empty(),
            "Package cardinality is per-instance: 1 code per SG10 rep is within [4P0..1]. Got: {:?}",
            pkg_errors
        );
    }

    fn make_segment(id: &str, elements: Vec<Vec<&str>>) -> OwnedSegment {
        OwnedSegment {
            id: id.to_string(),
            elements: elements
                .into_iter()
                .map(|e| e.into_iter().map(|s| s.to_string()).collect())
                .collect(),
            segment_number: 0,
        }
    }

    /// Package cardinality must not fire against sibling group variants.
    ///
    /// PID 55218 has two SG8 variants: `sg8_z01` (SEQ mig=00115, no
    /// package) and `sg8_z45_z84` (SEQ mig=00171, with `[1P1..n]`
    /// package on Z45/Z84). The rule is scoped to mig=00171, but the
    /// old per-instance loop counted codes across every SG8 instance
    /// (including the Z01 sibling) and fired "0 codes present" on
    /// instances belonging to the other variant. With
    /// `instance_has_mig_number` the loop skips instances whose variant
    /// doesn't define the rule's mig_number.
    #[test]
    fn test_package_cardinality_scoped_to_rule_mig_variant() {
        use mig_types::navigator::GroupNavigator;

        struct TwoSg8Variants {
            seq_z01: OwnedSegment,
            seq_z45: OwnedSegment,
        }
        impl GroupNavigator for TwoSg8Variants {
            fn find_segments_in_group(
                &self,
                segment_id: &str,
                group_path: &[&str],
                instance_index: usize,
            ) -> Vec<OwnedSegment> {
                if group_path == ["SG4", "SG8"] && segment_id == "SEQ" {
                    match instance_index {
                        0 => vec![self.seq_z01.clone()],
                        1 => vec![self.seq_z45.clone()],
                        _ => vec![],
                    }
                } else {
                    vec![]
                }
            }
            fn find_segments_with_qualifier_in_group(
                &self,
                _: &str,
                _: usize,
                _: &str,
                _: &[&str],
                _: usize,
            ) -> Vec<OwnedSegment> {
                vec![]
            }
            fn group_instance_count(&self, group_path: &[&str]) -> usize {
                match group_path {
                    ["SG4"] => 1,
                    ["SG4", "SG8"] => 2,
                    _ => 0,
                }
            }
            fn instance_has_mig_number(
                &self,
                group_path: &[&str],
                instance_index: usize,
                mig_number: &str,
            ) -> bool {
                if group_path != ["SG4", "SG8"] {
                    return true;
                }
                match (instance_index, mig_number) {
                    (0, "00115") => true,
                    (0, _) => false,
                    (1, "00171") => true,
                    (1, _) => false,
                    _ => false,
                }
            }
        }

        let seq_z01 = OwnedSegment {
            id: "SEQ".into(),
            elements: vec![vec!["Z01".into()], vec!["1".into()]],
            segment_number: 10,
        };
        let seq_z45 = OwnedSegment {
            id: "SEQ".into(),
            elements: vec![vec!["Z45".into()], vec!["1".into()]],
            segment_number: 20,
        };
        let nav = TwoSg8Variants {
            seq_z01: seq_z01.clone(),
            seq_z45: seq_z45.clone(),
        };

        let evaluator = MockEvaluator::all_true(&[]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let workflow = AhbWorkflow {
            pruefidentifikator: "55218".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
            fields: vec![AhbFieldRule {
                segment_path: "SG4/SG8/SEQ/1229".to_string(),
                name: "Handlung, Code".to_string(),
                ahb_status: "X".to_string(),
                element_index: Some(0),
                component_index: Some(0),
                codes: vec![
                    AhbCodeRule {
                        value: "Z45".into(),
                        description: "NNA".into(),
                        ahb_status: "X [1P1..4294967295]".into(),
                    },
                    AhbCodeRule {
                        value: "Z84".into(),
                        description: "Differenz-NNA".into(),
                        ahb_status: "X [1P0..4294967295]".into(),
                    },
                ],
                parent_group_ahb_status: Some("Muss".to_string()),
                segment_ahb_status: None,
                mig_number: Some("00171".to_string()),
                format: None,
            }],
        };

        let report = validator.validate_with_navigator(
            &[seq_z01, seq_z45],
            &workflow,
            &external,
            ValidationLevel::Full,
            &nav,
        );
        let pkg_errors: Vec<_> = report
            .by_category(ValidationCategory::Ahb)
            .filter(|i| i.code() == ErrorCodes::PACKAGE_CARDINALITY_VIOLATION)
            .collect();
        assert!(
            pkg_errors.is_empty(),
            "Package rule with mig=00171 must only count the Z45 instance (which has 1 code), not the sibling Z01 variant. Got: {:?}",
            pkg_errors
        );
    }

    #[test]
    fn test_unt_count_correct() {
        // UNH + BGM + DTM + UNT = 4 segments, UNT declares 4
        let segments = vec![
            make_segment("UNH", vec![vec!["001"]]),
            make_segment("BGM", vec![vec!["E01"]]),
            make_segment("DTM", vec![vec!["137", "20250401"]]),
            make_segment("UNT", vec![vec!["4", "001"]]),
        ];
        assert!(
            validate_unt_segment_count(&segments).is_none(),
            "Correct count should produce no issue"
        );
    }

    #[test]
    fn test_unt_count_mismatch() {
        // UNH + BGM + UNT = 3 segments, but UNT declares 5
        let segments = vec![
            make_segment("UNH", vec![vec!["001"]]),
            make_segment("BGM", vec![vec!["E01"]]),
            make_segment("UNT", vec![vec!["5", "001"]]),
        ];
        let issue =
            validate_unt_segment_count(&segments).expect("Mismatch should produce an issue");
        assert_eq!(issue.code(), ErrorCodes::UNT_SEGMENT_COUNT_MISMATCH);
        assert_eq!(issue.severity, Severity::Error);
        assert!(narrate(&issue).contains("declared 5"));
        assert!(narrate(&issue).contains("actual 3"));
    }

    #[test]
    fn test_unt_count_excludes_envelope() {
        // Envelope segments (UNA, UNB, UNZ) should not be counted
        let segments = vec![
            make_segment("UNA", vec![]),
            make_segment("UNB", vec![vec!["UNOC", "3"]]),
            make_segment("UNH", vec![vec!["001"]]),
            make_segment("BGM", vec![vec!["E01"]]),
            make_segment("UNT", vec![vec!["3", "001"]]),
            make_segment("UNZ", vec![vec!["1"]]),
        ];
        assert!(
            validate_unt_segment_count(&segments).is_none(),
            "Envelope segments excluded — count should be 3 (UNH+BGM+UNT)"
        );
    }

    #[test]
    fn test_unt_count_no_unt_returns_none() {
        let segments = vec![
            make_segment("UNH", vec![vec!["001"]]),
            make_segment("BGM", vec![vec!["E01"]]),
        ];
        assert!(
            validate_unt_segment_count(&segments).is_none(),
            "No UNT segment should return None (not our problem)"
        );
    }

    #[test]
    fn test_unt_count_rejects_multi_message_input() {
        // Two messages spliced together — should return an error
        let segments = vec![
            make_segment("UNH", vec![vec!["001"]]),
            make_segment("BGM", vec![vec!["E01"]]),
            make_segment("UNT", vec![vec!["3", "001"]]),
            make_segment("UNH", vec![vec!["002"]]),
            make_segment("BGM", vec![vec!["E02"]]),
            make_segment("UNT", vec![vec!["3", "002"]]),
        ];
        let issue = validate_unt_segment_count(&segments)
            .expect("Multi-message input should produce an error");
        assert_eq!(issue.code(), ErrorCodes::UNT_SEGMENT_COUNT_MISMATCH);
        assert!(
            narrate(&issue).contains("2 UNH"),
            "Should mention UNH count: {}",
            narrate(&issue)
        );
    }

    #[test]
    fn test_code_validation_accepts_multi_code_variant_qualifier() {
        // PID 55035 SG4/SG8 has many RFF variants — one per mig_number. The
        // variant with mig=00075 has TWO required codes (Z31, Z39): both are
        // valid qualifier values for that variant. Prior behavior only treated
        // buckets with exactly one required code as qualifier buckets, so
        // segments with Z31/Z39 fell through and were compared against the
        // union of *other* variants' codes — producing a false COD002.
        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        let rff_z39 = OwnedSegment {
            id: "RFF".to_string(),
            elements: vec![
                vec!["RFF".to_string()],
                vec!["Z39".to_string(), "REF1".to_string()],
            ],
            segment_number: 1,
        };

        let workflow = AhbWorkflow {
            pruefidentifikator: "55035".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields: vec![
                // Mig 00075 variant: qualifier is Z31 or Z39 (multi-code bucket)
                AhbFieldRule {
                    segment_path: "SG4/SG8/RFF/C506/1153".to_string(),
                    name: "Referenznummer Qualifier".to_string(),
                    ahb_status: "Muss".to_string(),
                    codes: vec![
                        AhbCodeRule {
                            value: "Z31".to_string(),
                            description: "".to_string(),
                            ahb_status: "X".to_string(),
                        },
                        AhbCodeRule {
                            value: "Z39".to_string(),
                            description: "".to_string(),
                            ahb_status: "X".to_string(),
                        },
                    ],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    element_index: Some(1),
                    component_index: Some(0),
                    mig_number: Some("00075".to_string()),
                    format: None,
                },
                // Mig 00078 variant: single-code qualifier Z33
                AhbFieldRule {
                    segment_path: "SG4/SG8/RFF/C506/1153".to_string(),
                    name: "Referenznummer Qualifier".to_string(),
                    ahb_status: "Muss".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "Z33".to_string(),
                        description: "".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    element_index: Some(1),
                    component_index: Some(0),
                    mig_number: Some("00078".to_string()),
                    format: None,
                },
            ],
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate(
            &[rff_z39],
            &workflow,
            &external,
            ValidationLevel::Conditions,
        );

        let code_errors: Vec<_> = report
            .by_category(ValidationCategory::Code)
            .filter(|i| {
                i.severity == Severity::Error && i.code() == ErrorCodes::CODE_NOT_ALLOWED_FOR_PID
            })
            .collect();
        assert!(
            code_errors.is_empty(),
            "RFF+Z39 must be accepted (Z39 is valid for mig=00075). Got: {:?}",
            code_errors
        );
    }

    #[test]
    fn test_code_validation_disambiguates_migs_by_full_code_profile() {
        // PID 55035 SG4/SG8 PIA variants all share element 0 code '5' as
        // qualifier. They differ only at composite C212/7143 (one variant
        // allows Z12, another allows SRW). Matching on the first single-code
        // field alone picks an arbitrary bucket and then rejects the other
        // variant's composite value — a false COD002.
        let evaluator = MockEvaluator::new(vec![]);
        let validator = EdifactValidator::new(evaluator);
        let external = NoOpExternalProvider;

        // Include BOTH variants so the current bug is triggered deterministically:
        // match_segment_to_mig picks one bucket by HashMap iteration order, so
        // exactly one of {Z12, SRW} is rejected under the current logic.
        let pia_5_z12 = OwnedSegment {
            id: "PIA".to_string(),
            elements: vec![vec!["5".to_string()], vec!["Z12".to_string()]],
            segment_number: 1,
        };
        let pia_5_srw = OwnedSegment {
            id: "PIA".to_string(),
            elements: vec![vec!["5".to_string()], vec!["SRW".to_string()]],
            segment_number: 2,
        };

        let make_rules = |mig: &str, composite_code: &str| {
            vec![
                AhbFieldRule {
                    segment_path: "SG4/SG8/PIA/4347".to_string(),
                    name: "Produkt-ID-Funktion".to_string(),
                    ahb_status: "Muss".to_string(),
                    codes: vec![AhbCodeRule {
                        value: "5".to_string(),
                        description: "".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    element_index: Some(0),
                    component_index: Some(0),
                    mig_number: Some(mig.to_string()),
                    format: None,
                },
                AhbFieldRule {
                    segment_path: "SG4/SG8/PIA/C212/7143".to_string(),
                    name: "Artikel/Dienstleistung-Identifikator".to_string(),
                    ahb_status: "Muss".to_string(),
                    codes: vec![AhbCodeRule {
                        value: composite_code.to_string(),
                        description: "".to_string(),
                        ahb_status: "X".to_string(),
                    }],
                    parent_group_ahb_status: None,
                    segment_ahb_status: None,
                    element_index: Some(1),
                    component_index: Some(0),
                    mig_number: Some(mig.to_string()),
                    format: None,
                },
            ]
        };

        let mut fields = make_rules("00108", "Z12");
        fields.extend(make_rules("00197", "SRW"));

        let workflow = AhbWorkflow {
            pruefidentifikator: "55035".to_string(),
            description: "Test".to_string(),
            communication_direction: None,
            fields,
            ub_definitions: BTreeMap::new(),
            package_conditions: Default::default(),
        };

        let report = validator.validate(
            &[pia_5_z12, pia_5_srw],
            &workflow,
            &external,
            ValidationLevel::Conditions,
        );

        let code_errors: Vec<_> = report
            .by_category(ValidationCategory::Code)
            .filter(|i| {
                i.severity == Severity::Error && i.code() == ErrorCodes::CODE_NOT_ALLOWED_FOR_PID
            })
            .collect();
        assert!(
            code_errors.is_empty(),
            "Both PIA+5+Z12 (mig=00108) and PIA+5+SRW (mig=00197) must be accepted. Got: {:?}",
            code_errors
        );
    }
}