automapper_validation/validator/

validate.rs

//! Main EdifactValidator implementation.

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

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

use crate::eval::{
    ConditionEvaluator, ConditionExprEvaluator, ConditionResult, EvaluationContext,
    ExternalConditionProvider,
};
use mig_types::navigator::GroupNavigator;
use mig_types::segment::OwnedSegment;

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

use super::codes::ErrorCodes;
use super::issue::{Severity, ValidationCategory, ValidationIssue};
use super::level::ValidationLevel;
use super::report::ValidationReport;

/// AHB field definition for validation.
///
/// Represents a single field in an AHB rule table with its status
/// and allowed codes for a specific Pruefidentifikator.
#[derive(Debug, Clone, Default)]
pub struct AhbFieldRule {
    /// Segment path (e.g., "SG2/NAD/C082/3039").
    pub segment_path: String,

    /// Human-readable field name (e.g., "MP-ID des MSB").
    pub name: String,

    /// AHB status (e.g., "Muss [182] ∧ [152]", "X", "Kann").
    pub ahb_status: String,

    /// Allowed code values with their AHB status.
    pub codes: Vec<AhbCodeRule>,

    /// AHB status of the innermost parent group (e.g., "Kann", "Muss", "Soll [46]").
    ///
    /// When the parent group is optional ("Kann") and its qualifier variant is
    /// absent from the message, mandatory checks for child fields are skipped.
    pub parent_group_ahb_status: Option<String>,

    /// Element index within the segment (0-based). Used to locate the correct
    /// element when checking presence and code values. `None` defaults to 0.
    pub element_index: Option<usize>,

    /// Component sub-index within a composite element (0-based). Used to locate
    /// the correct component. `None` defaults to 0.
    pub component_index: Option<usize>,

    /// MIG `Number` attribute of the parent segment. Links this AHB field to
    /// the corresponding `AssembledSegment::mig_number` for tree-based joining.
    pub mig_number: Option<String>,
}

/// An allowed code value within an AHB field rule.
#[derive(Debug, Clone, Default)]
pub struct AhbCodeRule {
    /// The code value (e.g., "E01", "Z33").
    pub value: String,

    /// Description of the code (e.g., "Anmeldung").
    pub description: String,

    /// AHB status for this code (e.g., "X", "Muss").
    pub ahb_status: String,
}

/// AHB workflow definition for a specific Pruefidentifikator.
#[derive(Debug, Clone)]
pub struct AhbWorkflow {
    /// The Pruefidentifikator (e.g., "11001", "55001").
    pub pruefidentifikator: String,

    /// Description of the workflow.
    pub description: String,

    /// Communication direction (e.g., "NB an LF").
    pub communication_direction: Option<String>,

    /// All field rules for this workflow.
    pub fields: Vec<AhbFieldRule>,

    /// UB (Unterbedingung) definitions parsed from the AHB XML.
    ///
    /// Maps UB IDs (e.g., "UB1") to their parsed condition expressions.
    /// These are expanded inline when evaluating condition expressions
    /// that reference UB conditions.
    pub ub_definitions: HashMap<String, ConditionExpr>,
}

/// 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,
}

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

    /// 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 {
        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.
        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);
        }

        // Evaluate each node.
        for node in &all_nodes {
            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);

            // If the parent group has a conditional status, evaluate it first
            // using the base ctx (group conditions are not field-scoped).
            if let Some(ref group_status) = field.parent_group_ahb_status {
                if group_status.contains('[') {
                    let group_result = expr_eval.evaluate_status_with_ub(
                        group_status,
                        &ctx,
                        validated_tree.ub_definitions,
                    );
                    if matches!(
                        group_result,
                        ConditionResult::False | ConditionResult::Unknown
                    ) {
                        continue;
                    }
                }
            }

            // Evaluate the field's AHB status condition using the node context
            // (WITH resolved_value set).
            let (condition_result, unknown_ids) = expr_eval.evaluate_status_detailed_with_ub(
                &field.ahb_status,
                &node_ctx,
                validated_tree.ub_definitions,
            );

            match condition_result {
                ConditionResult::True => {
                    // Condition is met -- field is required/applicable.
                    // Use node.value.is_some() instead of is_field_present()
                    // because the tree already resolved the value.
                    if is_mandatory_status(&field.ahb_status) && node.value.is_none() {
                        let mut issue = ValidationIssue::new(
                            Severity::Error,
                            ValidationCategory::Ahb,
                            ErrorCodes::MISSING_REQUIRED_FIELD,
                            format!(
                                "Required field '{}' at {} is missing",
                                field.name, field.segment_path
                            ),
                        )
                        .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());
                        }
                        report.add_issue(issue);
                    }
                }
                ConditionResult::False => {
                    // Condition not met. If mandatory AND value is present,
                    // the value violates the condition constraint.
                    if is_mandatory_status(&field.ahb_status) && node.value.is_some() {
                        report.add_issue(
                            ValidationIssue::new(
                                Severity::Error,
                                ValidationCategory::Ahb,
                                ErrorCodes::CONDITIONAL_RULE_VIOLATION,
                                format!(
                                    "Field '{}' at {} is present but does not satisfy condition: {}",
                                    field.name, field.segment_path, field.ahb_status
                                ),
                            )
                            .with_field_path(&field.segment_path)
                            .with_rule(&field.ahb_status),
                        );
                    }
                }
                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 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);
                        }
                    }

                    let mut parts = Vec::new();
                    if !external_ids.is_empty() {
                        let ids: Vec<String> =
                            external_ids.iter().map(|id| format!("[{id}]")).collect();
                        parts.push(format!(
                            "external conditions require provider: {}",
                            ids.join(", ")
                        ));
                    }
                    if !undetermined_ids.is_empty() {
                        let ids: Vec<String> = undetermined_ids
                            .iter()
                            .map(|id| format!("[{id}]"))
                            .collect();
                        parts.push(format!(
                            "conditions could not be determined from message data: {}",
                            ids.join(", ")
                        ));
                    }
                    if !missing_ids.is_empty() {
                        let ids: Vec<String> =
                            missing_ids.iter().map(|id| format!("[{id}]")).collect();
                        parts.push(format!("missing conditions: {}", ids.join(", ")));
                    }
                    let detail = if parts.is_empty() {
                        String::new()
                    } else {
                        format!(" ({})", parts.join("; "))
                    };
                    report.add_issue(
                        ValidationIssue::new(
                            Severity::Info,
                            ValidationCategory::Ahb,
                            ErrorCodes::CONDITION_UNKNOWN,
                            format!(
                                "Condition for field '{}' could not be fully evaluated{}",
                                field.name, detail
                            ),
                        )
                        .with_field_path(&field.segment_path)
                        .with_rule(&field.ahb_status),
                    );
                }
            }
        }

        // 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.
        for field in &validated_tree.unmatched_rules {
            // Evaluate parent group condition (same as tree-based path).
            if let Some(ref group_status) = field.parent_group_ahb_status {
                if group_status.contains('[') {
                    let group_result = expr_eval.evaluate_status_with_ub(
                        group_status,
                        &ctx,
                        validated_tree.ub_definitions,
                    );
                    if matches!(
                        group_result,
                        ConditionResult::False | ConditionResult::Unknown
                    ) {
                        continue;
                    }
                }
            }

            let (condition_result, _) = expr_eval.evaluate_status_detailed_with_ub(
                &field.ahb_status,
                &ctx,
                validated_tree.ub_definitions,
            );

            if matches!(condition_result, ConditionResult::True)
                && is_mandatory_status(&field.ahb_status)
                && !is_field_present(&ctx, field)
                && !is_group_variant_absent(&ctx, field)
            {
                let mut issue = ValidationIssue::new(
                    Severity::Error,
                    ValidationCategory::Ahb,
                    ErrorCodes::MISSING_REQUIRED_FIELD,
                    format!(
                        "Required field '{}' at {} is missing",
                        field.name, field.segment_path
                    ),
                )
                .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());
                }
                report.add_issue(issue);
            }
        }

        // TODO: validate_codes_cross_field() and validate_package_cardinality()
        // are skipped in the tree path for now. They operate on flat workflow
        // fields and don't need resolved_value. A future iteration should
        // reconstruct an AhbWorkflow from the ValidatedTree or adapt these
        // methods to work with tree nodes directly.

        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 {
            // If the parent group has a conditional status, evaluate it first.
            // When the parent group condition evaluates to False or Unknown,
            // the group variant is either not required or indeterminate —
            // skip child field validation. The group-level AhbFieldRule entry
            // itself already produces an Info "condition unknown" warning when
            // Unknown, so the user is informed without false mandatory errors.
            if let Some(ref group_status) = field.parent_group_ahb_status {
                if group_status.contains('[') {
                    let group_result = expr_eval.evaluate_status_with_ub(
                        group_status,
                        ctx,
                        &workflow.ub_definitions,
                    );
                    if matches!(
                        group_result,
                        ConditionResult::False | ConditionResult::Unknown
                    ) {
                        continue;
                    }
                }
            }

            // Evaluate the AHB status condition expression, collecting
            // which specific condition IDs are unknown when the result is Unknown.
            let (condition_result, unknown_ids) = expr_eval.evaluate_status_detailed_with_ub(
                &field.ahb_status,
                ctx,
                &workflow.ub_definitions,
            );

            match condition_result {
                ConditionResult::True => {
                    // Condition is met - field is required/applicable
                    if is_mandatory_status(&field.ahb_status)
                        && !is_field_present(ctx, field)
                        && !is_group_variant_absent(ctx, field)
                    {
                        let mut issue = ValidationIssue::new(
                            Severity::Error,
                            ValidationCategory::Ahb,
                            ErrorCodes::MISSING_REQUIRED_FIELD,
                            format!(
                                "Required field '{}' at {} is missing",
                                field.name, field.segment_path
                            ),
                        )
                        .with_field_path(&field.segment_path)
                        .with_rule(&field.ahb_status);
                        // 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 is_mandatory_status(&field.ahb_status)
                        && is_field_present(ctx, field)
                    {
                        report.add_issue(
                            ValidationIssue::new(
                                Severity::Error,
                                ValidationCategory::Ahb,
                                ErrorCodes::CONDITIONAL_RULE_VIOLATION,
                                format!(
                                    "Field '{}' at {} is present but does not satisfy condition: {}",
                                    field.name, field.segment_path, field.ahb_status
                                ),
                            )
                            .with_field_path(&field.segment_path)
                            .with_rule(&field.ahb_status),
                        );
                    }
                }
                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);
                        }
                    }

                    let mut parts = Vec::new();
                    if !external_ids.is_empty() {
                        let ids: Vec<String> =
                            external_ids.iter().map(|id| format!("[{id}]")).collect();
                        parts.push(format!(
                            "external conditions require provider: {}",
                            ids.join(", ")
                        ));
                    }
                    if !undetermined_ids.is_empty() {
                        let ids: Vec<String> = undetermined_ids
                            .iter()
                            .map(|id| format!("[{id}]"))
                            .collect();
                        parts.push(format!(
                            "conditions could not be determined from message data: {}",
                            ids.join(", ")
                        ));
                    }
                    if !missing_ids.is_empty() {
                        let ids: Vec<String> =
                            missing_ids.iter().map(|id| format!("[{id}]")).collect();
                        parts.push(format!("missing conditions: {}", ids.join(", ")));
                    }
                    let detail = if parts.is_empty() {
                        String::new()
                    } else {
                        format!(" ({})", parts.join("; "))
                    };
                    report.add_issue(
                        ValidationIssue::new(
                            Severity::Info,
                            ValidationCategory::Ahb,
                            ErrorCodes::CONDITION_UNKNOWN,
                            format!(
                                "Condition for field '{}' could not be fully evaluated{}",
                                field.name, detail
                            ),
                        )
                        .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);

        // 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, 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]`.
    fn validate_package_cardinality(
        &self,
        workflow: &AhbWorkflow,
        ctx: &EvaluationContext,
        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,
            code_values: Vec<String>,
            element_index: usize,
            component_index: usize,
        }

        // Key: (segment_path, package_id)
        let mut groups: HashMap<(String, u32), PackageGroup> = HashMap::new();

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

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

            // Skip package codes whose parent group condition is False or Unknown.
            // E.g., SG10 under SG8_ZH0 with parent_group_ahb_status="Muss [42]" —
            // if [42] can't be determined, don't enforce package constraints.
            if let Some(ref group_status) = field.parent_group_ahb_status {
                if group_status.contains('[') {
                    let group_result = expr_eval.evaluate_status_with_ub(
                        group_status,
                        ctx,
                        &workflow.ub_definitions,
                    );
                    if matches!(
                        group_result,
                        ConditionResult::False | ConditionResult::Unknown
                    ) {
                        continue;
                    }
                }
            }

            for code in &field.codes {
                // Parse the code's ahb_status for Package nodes
                if let Ok(Some(expr)) = ConditionParser::parse(&code.ahb_status) {
                    // Walk the AST to find Package nodes
                    let mut packages = Vec::new();
                    collect_packages(&expr, &mut packages);

                    for (pkg_id, pkg_min, pkg_max) in packages {
                        let key = (field.segment_path.clone(), pkg_id);
                        let group = groups.entry(key).or_insert_with(|| PackageGroup {
                            min: pkg_min,
                            max: pkg_max,
                            code_values: Vec::new(),
                            element_index: el_idx,
                            component_index: comp_idx,
                        });
                        // Update min/max in case different codes specify different bounds
                        // (should be the same, but take the intersection to be safe)
                        group.min = group.min.max(pkg_min);
                        group.max = group.max.min(pkg_max);
                        group.code_values.push(code.value.clone());
                    }
                }
            }
        }

        // For each package group, count present codes and check bounds
        for ((seg_path, pkg_id), group) in &groups {
            let segment_id = extract_segment_id(seg_path);
            let segments = ctx.find_segments(&segment_id);

            // Count how many of the package's codes appear across all segment instances
            let mut present_count: usize = 0;
            for seg in &segments {
                if let Some(value) = seg
                    .elements
                    .get(group.element_index)
                    .and_then(|e| e.get(group.component_index))
                    .filter(|v| !v.is_empty())
                {
                    if group.code_values.contains(value) {
                        present_count += 1;
                    }
                }
            }

            let min = group.min as usize;
            let max = group.max as usize;

            if present_count < min || present_count > max {
                let code_list = group.code_values.join(", ");
                report.add_issue(
                    ValidationIssue::new(
                        Severity::Error,
                        ValidationCategory::Ahb,
                        ErrorCodes::PACKAGE_CARDINALITY_VIOLATION,
                        format!(
                            "Package [{}P{}..{}] at {}: {} code(s) present (allowed {}..{}). Codes in package: [{}]",
                            pkg_id, group.min, group.max, seg_path, present_count, group.min, group.max, code_list
                        ),
                    )
                    .with_field_path(seg_path)
                    .with_expected(format!("{}..{}", group.min, group.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,
    ) {
        // Group allowed codes by (group_path_key, segment_tag, element_index, component_index).
        // E.g., "SG2/NAD/3035" → key ("SG2", "NAD", 0, 0)
        type CodeKey = (String, String, usize, usize);
        let mut codes_by_group: HashMap<CodeKey, HashSet<&str>> = HashMap::new();

        for field in &workflow.fields {
            if field.codes.is_empty() || !is_qualifier_field(&field.segment_path) {
                continue;
            }
            let tag = extract_segment_id(&field.segment_path);
            let group_key = extract_group_path_key(&field.segment_path);
            let el_idx = field.element_index.unwrap_or(0);
            let comp_idx = field.component_index.unwrap_or(0);
            let entry = codes_by_group
                .entry((group_key, tag, el_idx, comp_idx))
                .or_default();
            for code in &field.codes {
                if code.ahb_status == "X" || code.ahb_status.starts_with("Muss") {
                    entry.insert(&code.value);
                }
            }
        }

        let nav = ctx.navigator.unwrap();

        for ((group_key, tag, el_idx, comp_idx), allowed_codes) in &codes_by_group {
            if allowed_codes.is_empty() {
                continue;
            }

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

            // Iterate over all instances of this group and check segments.
            if group_path.is_empty() {
                // No group prefix (e.g., bare "NAD/3035") — check flat segments.
                Self::check_segments_against_codes(
                    ctx.find_segments(tag),
                    allowed_codes,
                    tag,
                    *el_idx,
                    *comp_idx,
                    &format!("{tag}/qualifier"),
                    report,
                );
            } else {
                let instance_count = nav.group_instance_count(&group_path);
                for i in 0..instance_count {
                    let segments = nav.find_segments_in_group(tag, &group_path, i);
                    let refs: Vec<&OwnedSegment> = segments.iter().collect();
                    Self::check_segments_against_codes(
                        refs,
                        allowed_codes,
                        tag,
                        *el_idx,
                        *comp_idx,
                        &format!("{group_key}/{tag}/qualifier"),
                        report,
                    );
                }
            }
        }
    }

    /// Fallback: group codes by segment tag (unioning across all groups) and
    /// check all segments of that tag. Used when no navigator is available.
    fn validate_codes_tag_scoped(
        &self,
        workflow: &AhbWorkflow,
        ctx: &EvaluationContext,
        report: &mut ValidationReport,
    ) {
        // Key: (tag, element_index, component_index)
        let mut codes_by_tag: HashMap<(String, usize, usize), HashSet<&str>> = HashMap::new();

        for field in &workflow.fields {
            if field.codes.is_empty() || !is_qualifier_field(&field.segment_path) {
                continue;
            }
            let tag = extract_segment_id(&field.segment_path);
            let el_idx = field.element_index.unwrap_or(0);
            let comp_idx = field.component_index.unwrap_or(0);
            let entry = codes_by_tag.entry((tag, el_idx, comp_idx)).or_default();
            for code in &field.codes {
                if code.ahb_status == "X" || code.ahb_status.starts_with("Muss") {
                    entry.insert(&code.value);
                }
            }
        }

        for ((tag, el_idx, comp_idx), allowed_codes) in &codes_by_tag {
            if allowed_codes.is_empty() {
                continue;
            }
            Self::check_segments_against_codes(
                ctx.find_segments(tag),
                allowed_codes,
                tag,
                *el_idx,
                *comp_idx,
                &format!("{tag}/qualifier"),
                report,
            );
        }
    }

    /// 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();
                    report.add_issue(
                        ValidationIssue::new(
                            Severity::Error,
                            ValidationCategory::Code,
                            ErrorCodes::CODE_NOT_ALLOWED_FOR_PID,
                            format!(
                                "Code '{}' is not allowed for this PID. Allowed: [{}]",
                                code_value,
                                sorted_codes.join(", ")
                            ),
                        )
                        .with_field_path(field_path)
                        .with_actual(code_value)
                        .with_expected(sorted_codes.join(", ")),
                    );
                }
            }
        }
    }
}

/// 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) -> 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 {
        let is_group_mandatory = field
            .parent_group_ahb_status
            .as_deref()
            .is_some_and(is_mandatory_status);
        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 optional ("Kann") — mandatory groups
    // ("Muss", "X") require all their qualifier variants to be present.
    if let Some(ref group_status) = field.parent_group_ahb_status {
        if !is_mandatory_status(group_status) && !group_status.contains('[') {
            // Parent group is unconditionally optional (e.g., "Kann").
            // 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);
    }
}

/// Recursively collect all Package nodes from a condition expression tree.
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 an AHB status is mandatory (Muss or X prefix).
fn is_mandatory_status(status: &str) -> bool {
    let trimmed = status.trim();
    trimmed.starts_with("Muss") || trimmed.starts_with('X')
}

/// 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.
///
/// Returns `false` for composite paths like `SEG/COMPOSITE/ELEMENT` (e.g.,
/// `UNH/S009/0065`) where the element is inside a composite at an unknown index.
fn is_qualifier_field(path: &str) -> bool {
    let parts: Vec<&str> = path.split('/').filter(|p| !p.starts_with("SG")).collect();
    // Expected: [SEGMENT_TAG, ELEMENT_ID] — exactly 2 parts after SG stripping.
    // If 3+ parts, there's a composite layer (e.g., [SEG, COMPOSITE, ELEMENT]).
    parts.len() == 2
}

/// 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.
///
/// Returns `Some(ValidationIssue)` if there's a mismatch, `None` if correct.
pub fn validate_unt_segment_count(segments: &[OwnedSegment]) -> Option<ValidationIssue> {
    // 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,
                ValidationCategory::Structure,
                ErrorCodes::UNT_SEGMENT_COUNT_MISMATCH,
                format!(
                    "UNT segment count mismatch: declared {declared}, actual {actual}"
                ),
            )
            .with_field_path("UNT/0074")
            .with_expected(actual.to_string())
            .with_actual(declared.to_string()),
        )
    } else {
        None
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::eval::{ConditionResult as CR, NoOpExternalProvider};
    use std::collections::HashMap;

    /// 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 test_is_mandatory_status() {
        assert!(is_mandatory_status("Muss"));
        assert!(is_mandatory_status("Muss [182] ∧ [152]"));
        assert!(is_mandatory_status("X"));
        assert!(is_mandatory_status("X [567]"));
        assert!(!is_mandatory_status("Soll [1]"));
        assert!(!is_mandatory_status("Kann [1]"));
        assert!(!is_mandatory_status(""));
    }

    #[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,
                ..Default::default()
            }],
            ub_definitions: HashMap::new(),
        };

        // 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!(errors[0].message.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,
                ..Default::default()
            }],
            ub_definitions: HashMap::new(),
        };

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

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

    #[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,
                ..Default::default()
            }],
            ub_definitions: HashMap::new(),
        };

        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,
                ..Default::default()
            }],
            ub_definitions: HashMap::new(),
        };

        // 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: HashMap::new(),
        };

        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,
                ..Default::default()
            }],
            ub_definitions: HashMap::new(),
        };

        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,
                ..Default::default()
            }],
            ub_definitions: HashMap::new(),
        };

        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,
                ..Default::default()
            }],
            ub_definitions: HashMap::new(),
        };

        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: HashMap::new(),
        };

        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: HashMap::new(),
        };

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

    #[test]
    fn test_code_validation_skips_composite_paths() {
        // UNH/S009/0065 has codes like ["UTILMD"], but the code is in element[1]
        // (composite S009), not element[0] (message reference).
        // The validator should skip code validation for composite paths.
        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()], // element 0: message ref
                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,
                    ..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,
                    ..Default::default()
                },
            ],
            ub_definitions: HashMap::new(),
        };

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

        // Should NOT produce COD002 false positives for composite element paths
        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 composite paths, got: {:?}",
            code_errors
        );
    }

    #[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,
                    ..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,
                    ..Default::default()
                },
            ],
            ub_definitions: HashMap::new(),
        };

        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,
                    ..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,
                    ..Default::default()
                },
            ],
            ub_definitions: HashMap::new(),
        };

        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!(code_errors[0].message.contains("MT"));
        assert!(code_errors[0].message.contains("MR"));
        assert!(code_errors[0].message.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,
                    ..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,
                    ..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,
                    ..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,
                    ..Default::default()
                },
            ],
            ub_definitions: HashMap::new(),
        };

        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!(code_errors[0].message.contains("MT"));
    }

    #[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() {
        assert!(!is_qualifier_field("UNH/S009/0065"));
        assert!(!is_qualifier_field("NAD/C082/3039"));
        assert!(!is_qualifier_field("SG2/NAD/C082/3039"));
    }

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

    #[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,
                    ..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,
                    ..Default::default()
                },
            ],
            ub_definitions: HashMap::new(),
        };

        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!(ahb_errors[0].message.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,
                    ..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,
                    ..Default::default()
                },
            ],
            ub_definitions: HashMap::new(),
        };

        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");
    }

    #[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,
                    ..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,
                    ..Default::default()
                },
            ],
            ub_definitions: HashMap::new(),
        };

        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,
                ..Default::default()
            }],
            ub_definitions: HashMap::new(),
        };

        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!(ahb_errors[0].message.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,
                    ..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,
                    ..Default::default()
                },
            ],
            ub_definitions: HashMap::new(),
        };

        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!(ahb_errors[0].message.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()),
                    ..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()),
                    ..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()),
                    ..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()),
                    ..Default::default()
                },
            ],
            ub_definitions: HashMap::new(),
        };

        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!(
            ahb_errors[0].message.contains("Empfaenger"),
            "Error should be for missing NAD+MR (Empfaenger)"
        );
    }

    #[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()),
                    ..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()),
                    ..Default::default()
                },
            ],
            ub_definitions: HashMap::new(),
        };

        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()),
                ..Default::default()
            }],
            ub_definitions: HashMap::new(),
        };

        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()),
                    ..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()),
                    ..Default::default()
                },
            ],
            ub_definitions: HashMap::new(),
        };

        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,
                    ..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,
                    ..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,
                    ..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,
                    ..Default::default()
                },
            ],
            ub_definitions: HashMap::new(),
        };

        // 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!(code_errors[0].message.contains("MT"));
        // Error should show only SG2's allowed codes, not the full union
        assert!(code_errors[0].message.contains("MR"));
        assert!(code_errors[0].message.contains("MS"));
        assert!(
            !code_errors[0].message.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: HashMap::new(),
            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()),
                mig_number: 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: HashMap::new(),
            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()),
                mig_number: 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: HashMap::new(),
            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()),
                mig_number: 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!(pkg_errors[0].message.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: HashMap::new(),
            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()),
                mig_number: 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!(pkg_errors[0].message.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: HashMap::new(),
            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()),
                ..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: HashMap::new(),
            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()),
                mig_number: 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
        );
    }

    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,
        }
    }

    #[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!(issue.message.contains("declared 5"));
        assert!(issue.message.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)"
        );
    }
}