automapper_validation/eval/

context.rs

//! Evaluation context for condition evaluation.

use super::codelist::ArtikelIdCodelist;
use super::ebd_cluster::EbdClusterLookup;
use super::evaluator::{ConditionResult, ExternalConditionProvider};
use mig_types::navigator::GroupNavigator;
use mig_types::segment::OwnedSegment;

/// Context passed to condition evaluators during evaluation.
///
/// Carries references to the transaction data and external condition
/// provider needed to evaluate AHB conditions.
pub struct EvaluationContext<'a> {
    /// The Pruefidentifikator (e.g., "11001", "55001") that identifies
    /// the specific AHB workflow being validated against.
    pub pruefidentifikator: &'a str,

    /// Provider for external conditions that depend on business context
    /// outside the EDIFACT message.
    pub external: &'a dyn ExternalConditionProvider,

    /// Parsed EDIFACT segments for direct segment inspection by condition
    /// evaluators. Conditions often need to check specific segment values.
    pub segments: &'a [OwnedSegment],

    /// Optional group navigator for group-scoped condition queries.
    /// When None, group-scoped methods return empty / false / 0.
    pub navigator: Option<&'a dyn GroupNavigator>,

    /// The resolved value of the data element currently being validated.
    ///
    /// Set per-field during tree-based validation from `AhbNode.value`.
    /// Format/value conditions (e.g., [931] "ZZZ=+00", [932] "HHMM=2200")
    /// check this first instead of searching message-wide.
    /// When None, conditions fall back to message-wide segment searches.
    pub resolved_value: Option<&'a str>,

    /// The full segment elements for the segment being validated.
    ///
    /// Allows cross-element access within the same segment (e.g., check
    /// qualifier in element 0 while validating value in element 1).
    /// When None, conditions fall back to message-wide segment searches.
    pub resolved_segment: Option<&'a [Vec<String>]>,

    /// BDEW Artikel-ID / Artikelnummer codelist, used by conditions like
    /// [73] and [284] that reference "Codeliste der Gruppenartikel- und
    /// Artikel-ID". Defaults to [`ArtikelIdCodelist::embedded`].
    pub codelist: &'a ArtikelIdCodelist,

    /// Per-EBD answer-code cluster lookup, used by conditions like
    /// `[359]` / `[360]` / `[366]` / `[368]` that restrict STS response
    /// codes to the Zustimmung or Ablehnung cluster of a specific EBD.
    /// Defaults to [`EbdClusterLookup::embedded`].
    pub ebd_clusters: &'a EbdClusterLookup,

    /// Optional group scope — when Some, scope-aware helpers like
    /// `scoped_find_segments` narrow lookups to that group instance.
    /// When None, scoped helpers fall back to message-wide semantics.
    pub scope: Option<GroupScope<'a>>,
}

/// A no-op group navigator that returns empty results for all queries.
pub struct NoOpGroupNavigator;

/// A scope identifying one group instance, by its repetition at every level
/// from the root: `[("SG4", 1), ("SG8", 2)]` is the third SG8 of the second SG4.
///
/// When attached to an [`EvaluationContext`] via [`EvaluationContext::with_scope`],
/// scope-aware helpers narrow segment lookups to that instance instead of searching
/// message-wide.
#[derive(Debug, Clone, Copy)]
pub struct GroupScope<'a> {
    pub path: &'a [(&'a str, usize)],
}

impl GroupNavigator for NoOpGroupNavigator {
    fn find_segments_in_group(&self, _: &str, _: &[&str], _: usize) -> Vec<OwnedSegment> {
        Vec::new()
    }
    fn find_segments_with_qualifier_in_group(
        &self,
        _: &str,
        _: usize,
        _: &str,
        _: &[&str],
        _: usize,
    ) -> Vec<OwnedSegment> {
        Vec::new()
    }
    fn group_instance_count(&self, _: &[&str]) -> usize {
        0
    }
}

impl<'a> EvaluationContext<'a> {
    /// Create a new evaluation context (without group navigator).
    pub fn new(
        pruefidentifikator: &'a str,
        external: &'a dyn ExternalConditionProvider,
        segments: &'a [OwnedSegment],
    ) -> Self {
        Self {
            pruefidentifikator,
            external,
            segments,
            navigator: None,
            resolved_value: None,
            resolved_segment: None,
            codelist: ArtikelIdCodelist::embedded(),
            ebd_clusters: EbdClusterLookup::embedded(),
            scope: None,
        }
    }

    /// Create a new evaluation context with a group navigator.
    pub fn with_navigator(
        pruefidentifikator: &'a str,
        external: &'a dyn ExternalConditionProvider,
        segments: &'a [OwnedSegment],
        navigator: &'a dyn GroupNavigator,
    ) -> Self {
        Self {
            pruefidentifikator,
            external,
            segments,
            navigator: Some(navigator),
            resolved_value: None,
            resolved_segment: None,
            codelist: ArtikelIdCodelist::embedded(),
            ebd_clusters: EbdClusterLookup::embedded(),
            scope: None,
        }
    }

    /// Override the codelist (tests only — defaults to embedded).
    pub fn with_codelist(mut self, codelist: &'a ArtikelIdCodelist) -> Self {
        self.codelist = codelist;
        self
    }

    /// Override the EBD cluster lookup (tests only — defaults to embedded).
    pub fn with_ebd_clusters(mut self, ebd_clusters: &'a EbdClusterLookup) -> Self {
        self.ebd_clusters = ebd_clusters;
        self
    }

    /// Attach a group scope; returns a fresh context without consuming self.
    /// Mirrors `with_resolved`'s `&self` shape so `validate_tree` can build
    /// a scoped context inside a loop without moving the outer one.
    pub fn with_scope(&self, scope: GroupScope<'a>) -> Self {
        Self {
            scope: Some(scope),
            ..*self
        }
    }

    /// Create a context with a resolved field value for tree-based validation.
    ///
    /// The resolved value comes from the `ValidatedTree` — the specific data
    /// element value at the current tree position. Conditions check this first.
    pub fn with_resolved(
        &self,
        value: Option<&'a str>,
        segment: Option<&'a [Vec<String>]>,
    ) -> Self {
        Self {
            resolved_value: value,
            resolved_segment: segment,
            ..*self
        }
    }

    /// Get the group navigator, if one is set.
    pub fn navigator(&self) -> Option<&'a dyn GroupNavigator> {
        self.navigator
    }

    /// Find the first segment with the given ID.
    pub fn find_segment(&self, segment_id: &str) -> Option<&'a OwnedSegment> {
        self.segments.iter().find(|s| s.id == segment_id)
    }

    /// Find all segments with the given ID.
    pub fn find_segments(&self, segment_id: &str) -> Vec<&'a OwnedSegment> {
        self.segments
            .iter()
            .filter(|s| s.id == segment_id)
            .collect()
    }

    /// Find segments with a specific qualifier value on a given element.
    pub fn find_segments_with_qualifier(
        &self,
        segment_id: &str,
        element_index: usize,
        qualifier: &str,
    ) -> Vec<&'a OwnedSegment> {
        self.segments
            .iter()
            .filter(|s| {
                s.id == segment_id
                    && s.elements
                        .get(element_index)
                        .and_then(|e| e.first())
                        .is_some_and(|v| v == qualifier)
            })
            .collect()
    }

    /// Find segments `tag` within the current scope — the scoped group instance
    /// and every group nested in it — or message-wide if no scope is set.
    /// Scope + navigator required for per-instance narrowing; falls back to
    /// `find_segments` when either is absent.
    ///
    /// Returns owned `OwnedSegment` values because the navigator may synthesise
    /// segments from an assembled tree rather than borrowing from
    /// `ctx.segments`. Callers that only need a `&OwnedSegment` should use
    /// `find_segments` directly when they know message-wide is correct.
    pub fn scoped_find_segments(&self, tag: &str) -> Vec<OwnedSegment> {
        match (self.scope, self.navigator) {
            (Some(scope), Some(nav)) => nav.find_segments_in_subtree(tag, scope.path),
            _ => self.find_segments(tag).into_iter().cloned().collect(),
        }
    }

    /// Find segments `tag` in the nearest enclosing instance of `group_id` —
    /// "in dieser SG8" asked by a field that sits in an SG10 of that SG8 —
    /// including every group nested in it.
    ///
    /// Message-wide when no scope or navigator is set, or when the scope has no
    /// enclosing `group_id` (a transaction-level field): the same answer an
    /// unscoped lookup gives.
    pub fn scoped_find_segments_in(&self, group_id: &str, tag: &str) -> Vec<OwnedSegment> {
        if let (Some(scope), Some(nav)) = (self.scope, self.navigator) {
            if let Some(level) = scope.path.iter().rposition(|(id, _)| *id == group_id) {
                return nav.find_segments_in_subtree(tag, &scope.path[..=level]);
            }
        }
        self.find_segments(tag).into_iter().cloned().collect()
    }

    /// The other instances of the enclosing `group_id` under the same parent —
    /// "in einem weiteren SG8" — as scope paths, in message order.
    ///
    /// `None` without a scope, a navigator, or an enclosing `group_id`.
    pub fn sibling_scopes(&self, group_id: &str) -> Option<Vec<Vec<(&'a str, usize)>>> {
        let (scope, nav) = (self.scope?, self.navigator?);
        let level = scope.path.iter().rposition(|(id, _)| *id == group_id)?;
        let (parent, own) = (&scope.path[..level], scope.path[level]);
        let count = nav.child_instance_count(parent, own.0);
        Some(
            (0..count)
                .filter(|&i| i != own.1)
                .map(|i| {
                    let mut path = parent.to_vec();
                    path.push((own.0, i));
                    path
                })
                .collect(),
        )
    }

    /// The segments `tag` of the group instance at `path` and the groups nested
    /// in it; empty without a navigator.
    pub fn find_segments_at(&self, path: &[(&str, usize)], tag: &str) -> Vec<OwnedSegment> {
        self.navigator
            .map(|nav| nav.find_segments_in_subtree(tag, path))
            .unwrap_or_default()
    }

    /// [`scoped_find_segments_in`](Self::scoped_find_segments_in), keeping the
    /// segments whose `element_index` starts with `qualifier`.
    pub fn scoped_find_segments_in_with_qualifier(
        &self,
        group_id: &str,
        tag: &str,
        element_index: usize,
        qualifier: &str,
    ) -> Vec<OwnedSegment> {
        self.scoped_find_segments_in(group_id, tag)
            .into_iter()
            .filter(|s| {
                s.elements
                    .get(element_index)
                    .and_then(|e| e.first())
                    .is_some_and(|v| v == qualifier)
            })
            .collect()
    }

    /// Find segments `tag` with a qualifier value on element `element_index`,
    /// narrowed to the current scope or message-wide.
    pub fn scoped_find_segments_with_qualifier(
        &self,
        tag: &str,
        element_index: usize,
        qualifier: &str,
    ) -> Vec<OwnedSegment> {
        self.scoped_find_segments(tag)
            .into_iter()
            .filter(|s| {
                s.elements
                    .get(element_index)
                    .and_then(|e| e.first())
                    .is_some_and(|v| v == qualifier)
            })
            .collect()
    }

    /// Validate a format condition on the current field value.
    ///
    /// Prefers `resolved_value` (exact field from tree-based validation).
    /// Falls back to searching segments by tag and extracting `elements[elem][comp]`,
    /// but only when exactly one segment of that tag exists — otherwise the
    /// fallback would pick an arbitrary occurrence and validate the wrong field.
    /// Returns `ConditionResult::Unknown` when no unambiguous value is available.
    ///
    /// Usage: `ctx.format_check("DTM", 0, 1, validate_timezone_utc)`
    pub fn format_check(
        &self,
        tag: &str,
        elem: usize,
        comp: usize,
        validate: impl FnOnce(&str) -> ConditionResult,
    ) -> ConditionResult {
        // Tree-based validation: the exact field value is authoritative.
        if let Some(val) = self.resolved_value {
            return validate(val);
        }
        // Non-tree fallback: use the segment only when unambiguous. Picking
        // `.first()` from multiple same-tag segments (e.g. several DTMs in the
        // message) would validate an arbitrary one, producing both false
        // positives and false negatives. Unknown is the honest answer.
        let segs = self.find_segments(tag);
        if segs.len() != 1 {
            return ConditionResult::Unknown;
        }
        match segs[0]
            .elements
            .get(elem)
            .and_then(|e| e.get(comp))
            .map(|s| s.as_str())
        {
            Some(val) => validate(val),
            None => ConditionResult::Unknown,
        }
    }

    /// Validate a format condition with qualifier-filtered segment fallback.
    ///
    /// Like `format_check`, but the fallback searches for segments matching
    /// `tag` where `elements[qual_elem][0] == qualifier`, then extracts
    /// `elements[val_elem][val_comp]`. Returns `Unknown` when the qualifier
    /// filter doesn't narrow down to exactly one segment.
    ///
    /// Usage: `ctx.format_check_qualified("DTM", 0, "163", 0, 1, |v| validate_hhmm_equals(v, "2200"))`
    pub fn format_check_qualified(
        &self,
        tag: &str,
        qual_elem: usize,
        qualifier: &str,
        val_elem: usize,
        val_comp: usize,
        validate: impl FnOnce(&str) -> ConditionResult,
    ) -> ConditionResult {
        if let Some(val) = self.resolved_value {
            return validate(val);
        }
        let segs = self.find_segments_with_qualifier(tag, qual_elem, qualifier);
        if segs.len() != 1 {
            return ConditionResult::Unknown;
        }
        match segs[0]
            .elements
            .get(val_elem)
            .and_then(|e| e.get(val_comp))
            .map(|s| s.as_str())
        {
            Some(val) => validate(val),
            None => ConditionResult::Unknown,
        }
    }

    /// Read a value at `elements[elem][comp]` of the segment currently being
    /// validated ("im selben Segment" conditions).
    ///
    /// Prefers `resolved_segment` (the exact segment the field lives in,
    /// bound per-field during tree-based validation). Falls back to the
    /// first message-wide segment matching `tag` when no tree context is
    /// available — matches the prior `find_segments(tag).first()` behavior.
    ///
    /// Conditions phrased "Wenn im selben Segment im DE2379 der Code 303
    /// vorhanden ist" should use this instead of iterating every `tag`
    /// segment in the message, which finds spurious matches elsewhere.
    pub fn self_segment_value(&self, tag: &str, elem: usize, comp: usize) -> Option<&str> {
        if let Some(elements) = self.resolved_segment {
            return elements
                .get(elem)
                .and_then(|e| e.get(comp))
                .map(|s| s.as_str());
        }
        self.segments
            .iter()
            .find(|s| s.id == tag)
            .and_then(|s| s.elements.get(elem))
            .and_then(|e| e.get(comp))
            .map(|s| s.as_str())
    }

    /// Convenience wrapper — returns `true` when `self_segment_value` equals
    /// `expected`. The common shape for "im selben Segment" code-equality
    /// conditions.
    pub fn self_segment_value_equals(
        &self,
        tag: &str,
        elem: usize,
        comp: usize,
        expected: &str,
    ) -> bool {
        self.self_segment_value(tag, elem, comp)
            .is_some_and(|v| v == expected)
    }

    /// Check if a segment with the given ID exists.
    pub fn has_segment(&self, segment_id: &str) -> bool {
        self.segments.iter().any(|s| s.id == segment_id)
    }

    /// Count SG8 instances whose PIA+5 OBIS code satisfies `obis_pred`,
    /// restricted to SG8 instances with:
    /// - SEQ qualifier (DE1229) == current SEQ's qualifier, AND
    /// - SEQ DE1050 (Zeitraum-ID in C286) == current SEQ's DE1050.
    ///
    /// "Current" is taken from `resolved_segment` (tree-based validation),
    /// which must point at a SEQ segment with a qualifier in
    /// `{Z02, ZA1, ZA2}` (OBIS-Daten der Marktlokation). Returns 0 when the
    /// context isn't anchored to such a SEQ.
    ///
    /// Used by UTILMD_Strom conditions [413]/[414]/[415]/[416] which ask
    /// "does another SG8 with matching Zeitraum-ID + qualifier have a
    /// Wirkarbeit kumuliert / 1/4 Stunde OBIS?"
    ///
    /// Implementation: linear scan of `self.segments`. Each encountered SEQ
    /// defines the "current group's" matching state; subsequent PIA+5
    /// segments (before the next SEQ) belong to that SG8 instance and are
    /// tested against `obis_pred` when the SEQ matches current's qualifier +
    /// Zeitraum-ID. This relies on the standard EDIFACT group layout where
    /// SEQ is SG8's entry segment and child segments (SG9 PIA …) appear
    /// consecutively after it.
    pub fn count_sg8_obis_matches<F>(&self, obis_pred: F) -> usize
    where
        F: Fn(&str) -> bool,
    {
        let resolved = match self.resolved_segment {
            Some(s) => s,
            None => return 0,
        };
        let cur_qual = match resolved.first().and_then(|e| e.first()) {
            Some(v) => v.as_str(),
            None => return 0,
        };
        if !matches!(cur_qual, "Z02" | "ZA1" | "ZA2") {
            return 0;
        }
        let cur_zid = match resolved.get(1).and_then(|e| e.first()) {
            Some(v) => v.as_str(),
            None => return 0,
        };

        let mut count = 0usize;
        let mut in_matching_seq = false;
        for seg in self.segments {
            if seg.id == "SEQ" {
                let qual = seg
                    .elements
                    .first()
                    .and_then(|e| e.first())
                    .map(String::as_str);
                let zid = seg
                    .elements
                    .get(1)
                    .and_then(|e| e.first())
                    .map(String::as_str);
                in_matching_seq = qual == Some(cur_qual) && zid == Some(cur_zid);
            } else if seg.id == "PIA" && in_matching_seq {
                let p_qual = seg
                    .elements
                    .first()
                    .and_then(|e| e.first())
                    .map(String::as_str);
                if p_qual == Some("5") {
                    if let Some(obis) = seg.elements.get(1).and_then(|e| e.first()) {
                        if obis_pred(obis) {
                            count += 1;
                        }
                    }
                }
            }
        }
        count
    }

    /// Find all segments with the given tag within a specific group instance.
    /// Returns empty if no navigator is set.
    pub fn find_segments_in_group(
        &self,
        segment_id: &str,
        group_path: &[&str],
        instance_index: usize,
    ) -> Vec<OwnedSegment> {
        match self.navigator {
            Some(nav) => nav.find_segments_in_group(segment_id, group_path, instance_index),
            None => Vec::new(),
        }
    }

    /// Find segments matching a tag + qualifier within a group instance.
    /// Returns empty if no navigator is set.
    pub fn find_segments_with_qualifier_in_group(
        &self,
        segment_id: &str,
        element_index: usize,
        qualifier: &str,
        group_path: &[&str],
        instance_index: usize,
    ) -> Vec<OwnedSegment> {
        match self.navigator {
            Some(nav) => nav.find_segments_with_qualifier_in_group(
                segment_id,
                element_index,
                qualifier,
                group_path,
                instance_index,
            ),
            None => Vec::new(),
        }
    }

    /// Check if a segment exists in a specific group instance.
    /// Returns false if no navigator is set.
    pub fn has_segment_in_group(
        &self,
        segment_id: &str,
        group_path: &[&str],
        instance_index: usize,
    ) -> bool {
        !self
            .find_segments_in_group(segment_id, group_path, instance_index)
            .is_empty()
    }

    /// Count repetitions of a group at the given path.
    /// Returns 0 if no navigator is set.
    pub fn group_instance_count(&self, group_path: &[&str]) -> usize {
        match self.navigator {
            Some(nav) => nav.group_instance_count(group_path),
            None => 0,
        }
    }

    /// Count child group repetitions within a specific parent group instance.
    /// Returns 0 if no navigator is set.
    pub fn child_group_instance_count(
        &self,
        parent_path: &[&str],
        parent_instance: usize,
        child_group_id: &str,
    ) -> usize {
        match self.navigator {
            Some(nav) => {
                nav.child_group_instance_count(parent_path, parent_instance, child_group_id)
            }
            None => 0,
        }
    }

    /// Find segments in a child group within a specific parent group instance.
    /// Returns empty if no navigator is set.
    pub fn find_segments_in_child_group(
        &self,
        segment_id: &str,
        parent_path: &[&str],
        parent_instance: usize,
        child_group_id: &str,
        child_instance: usize,
    ) -> Vec<OwnedSegment> {
        match self.navigator {
            Some(nav) => nav.find_segments_in_child_group(
                segment_id,
                parent_path,
                parent_instance,
                child_group_id,
                child_instance,
            ),
            None => Vec::new(),
        }
    }

    /// Extract a single value from the first matching segment in a group instance.
    /// Returns None if no navigator is set or value not found.
    pub fn extract_value_in_group(
        &self,
        segment_id: &str,
        element_index: usize,
        component_index: usize,
        group_path: &[&str],
        instance_index: usize,
    ) -> Option<String> {
        self.navigator?.extract_value_in_group(
            segment_id,
            element_index,
            component_index,
            group_path,
            instance_index,
        )
    }

    // --- High-level condition helpers ---
    // These reduce generated condition evaluator boilerplate by ~50%.

    /// Check if any segment with the given tag + qualifier exists (message-wide).
    /// Returns `True` if found, `False` if not.
    pub fn has_qualifier(
        &self,
        tag: &str,
        element_index: usize,
        qualifier: &str,
    ) -> ConditionResult {
        ConditionResult::from(
            !self
                .find_segments_with_qualifier(tag, element_index, qualifier)
                .is_empty(),
        )
    }

    /// Check if a segment with given tag + qualifier does NOT exist (message-wide).
    /// Returns `True` if absent, `False` if present.
    pub fn lacks_qualifier(
        &self,
        tag: &str,
        element_index: usize,
        qualifier: &str,
    ) -> ConditionResult {
        ConditionResult::from(
            self.find_segments_with_qualifier(tag, element_index, qualifier)
                .is_empty(),
        )
    }

    /// Check if any segment with the given tag + qualifier has a specific sub-element value.
    ///
    /// Finds segments matching `tag` with `elements[qual_elem][0] == qualifier`,
    /// then checks if `elements[value_elem][value_comp]` matches any of `values`.
    pub fn has_qualified_value(
        &self,
        tag: &str,
        qual_elem: usize,
        qualifier: &str,
        value_elem: usize,
        value_comp: usize,
        values: &[&str],
    ) -> ConditionResult {
        let segments = self.find_segments_with_qualifier(tag, qual_elem, qualifier);
        if segments.is_empty() {
            return ConditionResult::Unknown;
        }
        for seg in &segments {
            if let Some(v) = seg
                .elements
                .get(value_elem)
                .and_then(|e| e.get(value_comp))
                .map(|s| s.as_str())
            {
                if values.contains(&v) {
                    return ConditionResult::True;
                }
            }
        }
        ConditionResult::False
    }

    /// Group-scoped qualifier existence check with message-wide fallback.
    ///
    /// Checks if any group instance at `group_path` contains a segment matching
    /// `tag` with `elements[element_index][0] == qualifier`. Falls back to
    /// message-wide search if no group navigator is available.
    pub fn any_group_has_qualifier(
        &self,
        tag: &str,
        element_index: usize,
        qualifier: &str,
        group_path: &[&str],
    ) -> ConditionResult {
        let instance_count = self.group_instance_count(group_path);
        if instance_count > 0 {
            for i in 0..instance_count {
                if !self
                    .find_segments_with_qualifier_in_group(
                        tag,
                        element_index,
                        qualifier,
                        group_path,
                        i,
                    )
                    .is_empty()
                {
                    return ConditionResult::True;
                }
            }
            return ConditionResult::False;
        }
        // Fallback: message-wide search
        self.has_qualifier(tag, element_index, qualifier)
    }

    /// Group-scoped segment existence check (any tag match, no qualifier).
    ///
    /// Checks if any group instance at `group_path` contains a segment with
    /// `elements[element_index][0]` matching any of `qualifiers`. Falls back
    /// to message-wide search if no group navigator is available.
    pub fn any_group_has_any_qualifier(
        &self,
        tag: &str,
        element_index: usize,
        qualifiers: &[&str],
        group_path: &[&str],
    ) -> ConditionResult {
        let instance_count = self.group_instance_count(group_path);
        if instance_count > 0 {
            for i in 0..instance_count {
                let segs = self.find_segments_in_group(tag, group_path, i);
                if segs.iter().any(|seg| {
                    seg.elements
                        .get(element_index)
                        .and_then(|e| e.first())
                        .map(|s| s.as_str())
                        .is_some_and(|v| qualifiers.contains(&v))
                }) {
                    return ConditionResult::True;
                }
            }
            return ConditionResult::False;
        }
        // Fallback: message-wide search
        let found = self.find_segments(tag).iter().any(|seg| {
            seg.elements
                .get(element_index)
                .and_then(|e| e.first())
                .map(|s| s.as_str())
                .is_some_and(|v| qualifiers.contains(&v))
        });
        ConditionResult::from(found)
    }

    /// Group-scoped check for sub-element value within qualified segments.
    ///
    /// For each group instance at `group_path`, checks if a segment matching
    /// `tag` with `elements[qual_elem][0] == qualifier` has
    /// `elements[value_elem][value_comp]` in `values`. Falls back to message-wide.
    pub fn any_group_has_qualified_value(
        &self,
        tag: &str,
        qual_elem: usize,
        qualifier: &str,
        value_elem: usize,
        value_comp: usize,
        values: &[&str],
        group_path: &[&str],
    ) -> ConditionResult {
        let instance_count = self.group_instance_count(group_path);
        if instance_count > 0 {
            for i in 0..instance_count {
                let segs = self.find_segments_with_qualifier_in_group(
                    tag, qual_elem, qualifier, group_path, i,
                );
                for seg in &segs {
                    if seg
                        .elements
                        .get(value_elem)
                        .and_then(|e| e.get(value_comp))
                        .map(|s| s.as_str())
                        .is_some_and(|v| values.contains(&v))
                    {
                        return ConditionResult::True;
                    }
                }
            }
            return ConditionResult::False;
        }
        // Fallback: message-wide search
        self.has_qualified_value(tag, qual_elem, qualifier, value_elem, value_comp, values)
    }

    // --- Parent-child group navigation helpers ---

    /// Pattern A: Check if parent group instances matching a qualifier have a child
    /// group containing a specific qualifier.
    ///
    /// Example: "In the SG8 with SEQ+Z98, does its SG10 child have CCI+Z23?"
    ///
    /// Falls back to message-wide search if no navigator is available.
    #[allow(clippy::too_many_arguments)]
    pub fn filtered_parent_child_has_qualifier(
        &self,
        parent_path: &[&str],
        parent_tag: &str,
        parent_elem: usize,
        parent_qual: &str,
        child_group_id: &str,
        child_tag: &str,
        child_elem: usize,
        child_qual: &str,
    ) -> ConditionResult {
        let parent_count = self.group_instance_count(parent_path);
        if parent_count > 0 {
            for pi in 0..parent_count {
                // Check if this parent instance has the required qualifier
                let parent_segs = self.find_segments_with_qualifier_in_group(
                    parent_tag,
                    parent_elem,
                    parent_qual,
                    parent_path,
                    pi,
                );
                if parent_segs.is_empty() {
                    continue;
                }
                // Check child group instances for the child qualifier
                let child_count = self.child_group_instance_count(parent_path, pi, child_group_id);
                for ci in 0..child_count {
                    let child_segs = self.find_segments_in_child_group(
                        child_tag,
                        parent_path,
                        pi,
                        child_group_id,
                        ci,
                    );
                    if child_segs.iter().any(|s| {
                        s.elements
                            .get(child_elem)
                            .and_then(|e| e.first())
                            .is_some_and(|v| v == child_qual)
                    }) {
                        return ConditionResult::True;
                    }
                }
            }
            return ConditionResult::False;
        }
        // Fallback: message-wide — check both qualifiers exist independently
        let has_parent = !self
            .find_segments_with_qualifier(parent_tag, parent_elem, parent_qual)
            .is_empty();
        let has_child = !self
            .find_segments_with_qualifier(child_tag, child_elem, child_qual)
            .is_empty();
        ConditionResult::from(has_parent && has_child)
    }

    /// Pattern B: Check if any group instance has one qualifier present but another absent.
    ///
    /// Example: "In any SG8, SEQ+Z59 is present but CCI+11 is absent"
    ///
    /// Falls back to message-wide search if no navigator is available.
    #[allow(clippy::too_many_arguments)]
    pub fn any_group_has_qualifier_without(
        &self,
        present_tag: &str,
        present_elem: usize,
        present_qual: &str,
        absent_tag: &str,
        absent_elem: usize,
        absent_qual: &str,
        group_path: &[&str],
    ) -> ConditionResult {
        let instance_count = self.group_instance_count(group_path);
        if instance_count > 0 {
            for i in 0..instance_count {
                let has_present = !self
                    .find_segments_with_qualifier_in_group(
                        present_tag,
                        present_elem,
                        present_qual,
                        group_path,
                        i,
                    )
                    .is_empty();
                let has_absent = !self
                    .find_segments_with_qualifier_in_group(
                        absent_tag,
                        absent_elem,
                        absent_qual,
                        group_path,
                        i,
                    )
                    .is_empty();
                if has_present && !has_absent {
                    return ConditionResult::True;
                }
            }
            return ConditionResult::False;
        }
        // Fallback: message-wide
        let has_present = !self
            .find_segments_with_qualifier(present_tag, present_elem, present_qual)
            .is_empty();
        let has_absent = !self
            .find_segments_with_qualifier(absent_tag, absent_elem, absent_qual)
            .is_empty();
        ConditionResult::from(has_present && !has_absent)
    }

    /// The scope path down to the enclosing instance of `group_path`'s last
    /// group, when the scope reaches it.
    fn enclosing_path(&self, group_path: &[&str]) -> Option<&'a [(&'a str, usize)]> {
        let group = group_path.last()?;
        let scope = self.scope?;
        self.navigator?;
        let level = scope.path.iter().rposition(|(id, _)| id == group)?;
        Some(&scope.path[..=level])
    }

    /// The scope path down to the nearest enclosing instance of `group_id`
    /// ("dieser SG8" for a field in one of its SG10s), when the scope reaches
    /// it and a navigator can read it.
    pub fn enclosing_scope(&self, group_id: &str) -> Option<&'a [(&'a str, usize)]> {
        self.enclosing_path(&[group_id])
    }

    /// The `child_id` groups of the enclosing `group_id` instance, each with
    /// its `tags` segments (and those of groups nested in it): "SG10
    /// CCI+++E13 CAV+EHZ in dieser SG8" pairs a CCI and a CAV of one SG10.
    /// `None` when the scope does not reach a `group_id` instance.
    pub fn enclosing_child_segments(
        &self,
        group_id: &str,
        child_id: &str,
        tags: &[&str],
    ) -> Option<Vec<Vec<OwnedSegment>>> {
        let path = self.enclosing_scope(group_id)?;
        Some(self.child_segments_at(path, child_id, tags))
    }

    /// The `child_id` groups of the instance at `path`, each with its `tags`
    /// segments (and those of groups nested in it); empty without a navigator.
    pub fn child_segments_at(
        &self,
        path: &[(&str, usize)],
        child_id: &str,
        tags: &[&str],
    ) -> Vec<Vec<OwnedSegment>> {
        let Some(nav) = self.navigator else {
            return Vec::new();
        };
        (0..nav.child_instance_count(path, child_id))
            .map(|j| {
                let mut child = path.to_vec();
                child.push((child_id, j));
                tags.iter()
                    .flat_map(|tag| nav.find_segments_in_subtree(tag, &child))
                    .collect()
            })
            .collect()
    }

    /// Every `group_id` instance directly under the enclosing `parent_id`
    /// instance, the own one included, as scope paths in message order — "eine
    /// SG8 SEQ+Z01" asked from one SG8 or SG6 of an SG4. `None` when the scope
    /// does not reach a `parent_id` instance.
    pub fn scopes_under(
        &self,
        parent_id: &str,
        group_id: &'a str,
    ) -> Option<Vec<Vec<(&'a str, usize)>>> {
        let parent = self.enclosing_scope(parent_id)?;
        let nav = self.navigator?;
        Some(
            (0..nav.child_instance_count(parent, group_id))
                .map(|i| {
                    let mut path = parent.to_vec();
                    path.push((group_id, i));
                    path
                })
                .collect(),
        )
    }

    /// [`any_group_has_qualifier_without`](Self::any_group_has_qualifier_without)
    /// for "in derselben SGn … nicht vorhanden": the enclosing instance only,
    /// when the scope reaches it.
    #[allow(clippy::too_many_arguments)]
    pub fn this_group_has_qualifier_without(
        &self,
        present_tag: &str,
        present_elem: usize,
        present_qual: &str,
        absent_tag: &str,
        absent_elem: usize,
        absent_qual: &str,
        group_path: &[&str],
    ) -> ConditionResult {
        let Some(path) = self.enclosing_path(group_path) else {
            return self.any_group_has_qualifier_without(
                present_tag,
                present_elem,
                present_qual,
                absent_tag,
                absent_elem,
                absent_qual,
                group_path,
            );
        };
        let has = |tag: &str, elem: usize, qual: &str| {
            self.find_segments_at(path, tag)
                .iter()
                .any(|s| first_component(s, elem) == Some(qual))
        };
        ConditionResult::from(
            has(present_tag, present_elem, present_qual)
                && !has(absent_tag, absent_elem, absent_qual),
        )
    }

    /// [`filtered_parent_child_has_qualifier`](Self::filtered_parent_child_has_qualifier)
    /// for "in dieser SG8 SEQ+… SG10 CCI…": the enclosing parent instance and
    /// its child groups only, when the scope reaches it.
    #[allow(clippy::too_many_arguments)]
    pub fn this_group_parent_child_has_qualifier(
        &self,
        parent_path: &[&str],
        parent_tag: &str,
        parent_elem: usize,
        parent_qual: &str,
        child_group_id: &str,
        child_tag: &str,
        child_elem: usize,
        child_qual: &str,
    ) -> ConditionResult {
        let (Some(path), Some(nav)) = (self.enclosing_path(parent_path), self.navigator) else {
            return self.filtered_parent_child_has_qualifier(
                parent_path,
                parent_tag,
                parent_elem,
                parent_qual,
                child_group_id,
                child_tag,
                child_elem,
                child_qual,
            );
        };
        let parent_matches = nav
            .find_segments_in_instance(parent_tag, path)
            .iter()
            .any(|s| first_component(s, parent_elem) == Some(parent_qual));
        if !parent_matches {
            return ConditionResult::False;
        }
        let children = nav.child_instance_count(path, child_group_id);
        let found = (0..children).any(|j| {
            let mut child = path.to_vec();
            child.push((child_group_id, j));
            nav.find_segments_in_subtree(child_tag, &child)
                .iter()
                .any(|s| first_component(s, child_elem) == Some(child_qual))
        });
        ConditionResult::from(found)
    }

    /// [`any_group_has_qualifier`](Self::any_group_has_qualifier) for "in
    /// dieser SGn": only the enclosing instance of the group `group_path`
    /// names (and the groups nested in it), when the scope reaches it.
    pub fn this_group_has_qualifier(
        &self,
        tag: &str,
        element_index: usize,
        qualifier: &str,
        group_path: &[&str],
    ) -> ConditionResult {
        match self.enclosing_path(group_path) {
            Some(path) => ConditionResult::from(
                self.find_segments_at(path, tag)
                    .iter()
                    .any(|s| first_component(s, element_index) == Some(qualifier)),
            ),
            None => self.any_group_has_qualifier(tag, element_index, qualifier, group_path),
        }
    }

    /// [`any_group_has_any_qualifier`](Self::any_group_has_any_qualifier) for
    /// "in dieser SGn", as [`this_group_has_qualifier`](Self::this_group_has_qualifier).
    pub fn this_group_has_any_qualifier(
        &self,
        tag: &str,
        element_index: usize,
        qualifiers: &[&str],
        group_path: &[&str],
    ) -> ConditionResult {
        match self.enclosing_path(group_path) {
            Some(path) => ConditionResult::from(self.find_segments_at(path, tag).iter().any(|s| {
                first_component(s, element_index).is_some_and(|v| qualifiers.contains(&v))
            })),
            None => self.any_group_has_any_qualifier(tag, element_index, qualifiers, group_path),
        }
    }

    /// [`any_group_has_qualified_value`](Self::any_group_has_qualified_value)
    /// for "in dieser SGn", as [`this_group_has_qualifier`](Self::this_group_has_qualifier).
    #[allow(clippy::too_many_arguments)]
    pub fn this_group_has_qualified_value(
        &self,
        tag: &str,
        qual_elem: usize,
        qualifier: &str,
        value_elem: usize,
        value_comp: usize,
        values: &[&str],
        group_path: &[&str],
    ) -> ConditionResult {
        match self.enclosing_path(group_path) {
            Some(path) => ConditionResult::from(self.find_segments_at(path, tag).iter().any(|s| {
                first_component(s, qual_elem) == Some(qualifier)
                    && s.elements
                        .get(value_elem)
                        .and_then(|e| e.get(value_comp))
                        .is_some_and(|v| values.contains(&v.as_str()))
            })),
            None => self.any_group_has_qualified_value(
                tag, qual_elem, qualifier, value_elem, value_comp, values, group_path,
            ),
        }
    }

    /// [`collect_group_values`](Self::collect_group_values) for "in dieser
    /// SGn": the values of the enclosing instance (index 0), when the scope
    /// reaches it.
    pub fn this_group_values(
        &self,
        tag: &str,
        elem: usize,
        comp: usize,
        group_path: &[&str],
    ) -> Vec<(usize, String)> {
        match self.enclosing_path(group_path) {
            Some(path) => self
                .find_segments_at(path, tag)
                .iter()
                .filter_map(|s| s.elements.get(elem).and_then(|e| e.get(comp)).cloned())
                .filter(|v| !v.is_empty())
                .map(|v| (0, v))
                .collect(),
            None => self.collect_group_values(tag, elem, comp, group_path),
        }
    }

    /// Pattern C helper: Collect all values at a specific element+component across group instances.
    ///
    /// Returns `(instance_index, value)` pairs for non-empty values.
    pub fn collect_group_values(
        &self,
        tag: &str,
        elem: usize,
        comp: usize,
        group_path: &[&str],
    ) -> Vec<(usize, String)> {
        let instance_count = self.group_instance_count(group_path);
        let mut results = Vec::new();
        for i in 0..instance_count {
            if let Some(val) = self
                .navigator
                .and_then(|nav| nav.extract_value_in_group(tag, elem, comp, group_path, i))
            {
                if !val.is_empty() {
                    results.push((i, val));
                }
            }
        }
        results
    }

    /// Pattern C: Check if a value from one group path matches a value in another group path.
    ///
    /// Example: "Zeitraum-ID in SG6 RFF+Z49 matches reference in SG8 SEQ.c286"
    ///
    /// Finds qualified segments in source_path, extracts their value, then checks if
    /// any instance in target_path has the same value at the target position.
    ///
    /// Falls back to message-wide search if no navigator is available.
    #[allow(clippy::too_many_arguments)]
    pub fn groups_share_qualified_value(
        &self,
        source_tag: &str,
        source_qual_elem: usize,
        source_qual: &str,
        source_value_elem: usize,
        source_value_comp: usize,
        source_path: &[&str],
        target_tag: &str,
        target_elem: usize,
        target_comp: usize,
        target_path: &[&str],
    ) -> ConditionResult {
        let source_count = self.group_instance_count(source_path);
        let target_count = self.group_instance_count(target_path);
        if source_count > 0 && target_count > 0 {
            // Collect source values from qualified segments
            let mut source_values = Vec::new();
            for si in 0..source_count {
                let segs = self.find_segments_with_qualifier_in_group(
                    source_tag,
                    source_qual_elem,
                    source_qual,
                    source_path,
                    si,
                );
                for seg in &segs {
                    if let Some(val) = seg
                        .elements
                        .get(source_value_elem)
                        .and_then(|e| e.get(source_value_comp))
                    {
                        if !val.is_empty() {
                            source_values.push(val.clone());
                        }
                    }
                }
            }
            if source_values.is_empty() {
                return ConditionResult::Unknown;
            }
            // Check if any target instance has a matching value
            let target_values =
                self.collect_group_values(target_tag, target_elem, target_comp, target_path);
            for (_, tv) in &target_values {
                if source_values.iter().any(|sv| sv == tv) {
                    return ConditionResult::True;
                }
            }
            return ConditionResult::False;
        }
        // Fallback: message-wide search
        let source_segs =
            self.find_segments_with_qualifier(source_tag, source_qual_elem, source_qual);
        let source_vals: Vec<&str> = source_segs
            .iter()
            .filter_map(|s| {
                s.elements
                    .get(source_value_elem)
                    .and_then(|e| e.get(source_value_comp))
                    .map(|v| v.as_str())
            })
            .filter(|v| !v.is_empty())
            .collect();
        if source_vals.is_empty() {
            return ConditionResult::Unknown;
        }
        let target_segs = self.find_segments(target_tag);
        let has_match = target_segs.iter().any(|s| {
            s.elements
                .get(target_elem)
                .and_then(|e| e.get(target_comp))
                .map(|v| v.as_str())
                .is_some_and(|v| source_vals.contains(&v))
        });
        ConditionResult::from(has_match)
    }

    /// Group-scoped co-occurrence check: two segment conditions must both be true
    /// in the same group instance.
    ///
    /// For each group instance, checks that:
    /// 1. A segment with `tag_a` has `elements[elem_a][0]` in `quals_a`
    /// 2. A segment with `tag_b` has `elements[elem_b][comp_b]` in `vals_b`
    ///
    /// Falls back to message-wide search.
    #[allow(clippy::too_many_arguments)]
    pub fn any_group_has_co_occurrence(
        &self,
        tag_a: &str,
        elem_a: usize,
        quals_a: &[&str],
        tag_b: &str,
        elem_b: usize,
        comp_b: usize,
        vals_b: &[&str],
        group_path: &[&str],
    ) -> ConditionResult {
        let instance_count = self.group_instance_count(group_path);
        if instance_count > 0 {
            for i in 0..instance_count {
                let a_present = self
                    .find_segments_in_group(tag_a, group_path, i)
                    .iter()
                    .any(|seg| {
                        seg.elements
                            .get(elem_a)
                            .and_then(|e| e.first())
                            .map(|s| s.as_str())
                            .is_some_and(|v| quals_a.contains(&v))
                    });
                let b_present = self
                    .find_segments_in_group(tag_b, group_path, i)
                    .iter()
                    .any(|seg| {
                        seg.elements
                            .get(elem_b)
                            .and_then(|e| e.get(comp_b))
                            .map(|s| s.as_str())
                            .is_some_and(|v| vals_b.contains(&v))
                    });
                if a_present && b_present {
                    return ConditionResult::True;
                }
            }
            return ConditionResult::False;
        }
        // Fallback: message-wide
        let a_found = self.find_segments(tag_a).iter().any(|seg| {
            seg.elements
                .get(elem_a)
                .and_then(|e| e.first())
                .map(|s| s.as_str())
                .is_some_and(|v| quals_a.contains(&v))
        });
        if !a_found {
            return ConditionResult::False;
        }
        let b_found = self.find_segments(tag_b).iter().any(|seg| {
            seg.elements
                .get(elem_b)
                .and_then(|e| e.get(comp_b))
                .map(|s| s.as_str())
                .is_some_and(|v| vals_b.contains(&v))
        });
        ConditionResult::from(b_found)
    }

    // --- Multi-element matching helpers ---

    /// Check if any segment with the given tag has ALL specified element/component values.
    ///
    /// Each check is `(element_index, component_index, expected_value)`.
    /// Returns `True` if a matching segment exists, `False` if segments exist but none match,
    /// `Unknown` if no segments with the tag exist.
    ///
    /// Example: `ctx.has_segment_matching("STS", &[(0, 0, "Z20"), (1, 0, "Z32"), (2, 0, "A99")])`
    pub fn has_segment_matching(
        &self,
        tag: &str,
        checks: &[(usize, usize, &str)],
    ) -> ConditionResult {
        let segments = self.find_segments(tag);
        if segments.is_empty() {
            return ConditionResult::Unknown;
        }
        let found = segments.iter().any(|seg| {
            checks.iter().all(|(elem, comp, val)| {
                seg.elements
                    .get(*elem)
                    .and_then(|e| e.get(*comp))
                    .is_some_and(|v| v == val)
            })
        });
        ConditionResult::from(found)
    }

    /// Group-scoped multi-element match with message-wide fallback.
    ///
    /// Checks if any group instance at `group_path` contains a segment with `tag`
    /// where ALL element/component checks match.
    pub fn has_segment_matching_in_group(
        &self,
        tag: &str,
        checks: &[(usize, usize, &str)],
        group_path: &[&str],
    ) -> ConditionResult {
        let instance_count = self.group_instance_count(group_path);
        if instance_count > 0 {
            for i in 0..instance_count {
                let segs = self.find_segments_in_group(tag, group_path, i);
                if segs.iter().any(|seg| {
                    checks.iter().all(|(elem, comp, val)| {
                        seg.elements
                            .get(*elem)
                            .and_then(|e| e.get(*comp))
                            .is_some_and(|v| v == val)
                    })
                }) {
                    return ConditionResult::True;
                }
            }
            return ConditionResult::False;
        }
        // Fallback: message-wide
        self.has_segment_matching(tag, checks)
    }

    // --- DTM date comparison helpers ---

    /// Check if a DTM segment with the given qualifier has a value >= threshold.
    ///
    /// Both the DTM value and threshold should be in EDIFACT format 303 (CCYYMMDDHHMM).
    /// Returns `Unknown` if no DTM with the qualifier exists.
    pub fn dtm_ge(&self, qualifier: &str, threshold: &str) -> ConditionResult {
        let segs = self.find_segments_with_qualifier("DTM", 0, qualifier);
        match segs.first() {
            Some(dtm) => match dtm.elements.first().and_then(|e| e.get(1)) {
                Some(val) => ConditionResult::from(val.as_str() >= threshold),
                None => ConditionResult::Unknown,
            },
            None => ConditionResult::Unknown,
        }
    }

    /// Check if a DTM segment with the given qualifier has a value < threshold.
    pub fn dtm_lt(&self, qualifier: &str, threshold: &str) -> ConditionResult {
        let segs = self.find_segments_with_qualifier("DTM", 0, qualifier);
        match segs.first() {
            Some(dtm) => match dtm.elements.first().and_then(|e| e.get(1)) {
                Some(val) => ConditionResult::from((val.as_str()) < threshold),
                None => ConditionResult::Unknown,
            },
            None => ConditionResult::Unknown,
        }
    }

    /// Check if a DTM segment with the given qualifier has a value <= threshold.
    pub fn dtm_le(&self, qualifier: &str, threshold: &str) -> ConditionResult {
        let segs = self.find_segments_with_qualifier("DTM", 0, qualifier);
        match segs.first() {
            Some(dtm) => match dtm.elements.first().and_then(|e| e.get(1)) {
                Some(val) => ConditionResult::from(val.as_str() <= threshold),
                None => ConditionResult::Unknown,
            },
            None => ConditionResult::Unknown,
        }
    }

    // --- Group-scoped cardinality helpers ---

    /// Count segments matching tag + qualifier within a group path (across all instances).
    ///
    /// Returns the total count across all group instances.
    /// Falls back to message-wide count if no navigator.
    pub fn count_qualified_in_group(
        &self,
        tag: &str,
        element_index: usize,
        qualifier: &str,
        group_path: &[&str],
    ) -> usize {
        let instance_count = self.group_instance_count(group_path);
        if instance_count > 0 {
            let mut total = 0;
            for i in 0..instance_count {
                total += self
                    .find_segments_with_qualifier_in_group(
                        tag,
                        element_index,
                        qualifier,
                        group_path,
                        i,
                    )
                    .len();
            }
            return total;
        }
        // Fallback: message-wide
        self.find_segments_with_qualifier(tag, element_index, qualifier)
            .len()
    }

    /// Count segments matching tag (any qualifier) within a group path.
    pub fn count_in_group(&self, tag: &str, group_path: &[&str]) -> usize {
        let instance_count = self.group_instance_count(group_path);
        if instance_count > 0 {
            let mut total = 0;
            for i in 0..instance_count {
                total += self.find_segments_in_group(tag, group_path, i).len();
            }
            return total;
        }
        // Fallback: message-wide
        self.find_segments(tag).len()
    }
}

/// `elements[element][0]` of `segment`.
fn first_component(segment: &OwnedSegment, element: usize) -> Option<&str> {
    segment
        .elements
        .get(element)
        .and_then(|e| e.first())
        .map(String::as_str)
}

#[cfg(test)]
mod tests {
    use super::super::evaluator::NoOpExternalProvider;
    use super::*;
    use mig_types::navigator::GroupNavigator;

    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(|c| c.to_string()).collect())
                .collect(),
            segment_number: 0,
        }
    }

    // --- Mock navigator for testing ---
    struct MockGroupNavigator {
        groups: Vec<(Vec<String>, usize, Vec<OwnedSegment>)>,
        /// Children: (parent_path, parent_instance, child_group_id, child_instance, segments)
        children: Vec<(Vec<String>, usize, String, usize, Vec<OwnedSegment>)>,
    }

    impl MockGroupNavigator {
        fn new() -> Self {
            Self {
                groups: vec![],
                children: vec![],
            }
        }
        fn with_group(mut self, path: &[&str], instance: usize, segs: Vec<OwnedSegment>) -> Self {
            self.groups
                .push((path.iter().map(|s| s.to_string()).collect(), instance, segs));
            self
        }
        fn with_child_group(
            mut self,
            parent_path: &[&str],
            parent_instance: usize,
            child_id: &str,
            child_instance: usize,
            segs: Vec<OwnedSegment>,
        ) -> Self {
            self.children.push((
                parent_path.iter().map(|s| s.to_string()).collect(),
                parent_instance,
                child_id.to_string(),
                child_instance,
                segs,
            ));
            self
        }
        fn find_instance(&self, group_path: &[&str], idx: usize) -> Option<&[OwnedSegment]> {
            self.groups
                .iter()
                .find(|(p, i, _)| {
                    let ps: Vec<&str> = p.iter().map(|s| s.as_str()).collect();
                    ps.as_slice() == group_path && *i == idx
                })
                .map(|(_, _, segs)| segs.as_slice())
        }
    }

    impl GroupNavigator for MockGroupNavigator {
        fn find_segments_in_group(
            &self,
            segment_id: &str,
            group_path: &[&str],
            instance_index: usize,
        ) -> Vec<OwnedSegment> {
            self.find_instance(group_path, instance_index)
                .map(|segs| {
                    segs.iter()
                        .filter(|s| s.id == segment_id)
                        .cloned()
                        .collect()
                })
                .unwrap_or_default()
        }
        fn find_segments_with_qualifier_in_group(
            &self,
            segment_id: &str,
            element_index: usize,
            qualifier: &str,
            group_path: &[&str],
            instance_index: usize,
        ) -> Vec<OwnedSegment> {
            self.find_segments_in_group(segment_id, group_path, instance_index)
                .into_iter()
                .filter(|s| {
                    s.elements
                        .get(element_index)
                        .and_then(|e| e.first())
                        .is_some_and(|v| v == qualifier)
                })
                .collect()
        }
        fn group_instance_count(&self, group_path: &[&str]) -> usize {
            self.groups
                .iter()
                .filter(|(p, _, _)| {
                    let ps: Vec<&str> = p.iter().map(|s| s.as_str()).collect();
                    ps.as_slice() == group_path
                })
                .count()
        }
        fn child_group_instance_count(
            &self,
            parent_path: &[&str],
            parent_instance: usize,
            child_group_id: &str,
        ) -> usize {
            self.children
                .iter()
                .filter(|(pp, pi, cid, _, _)| {
                    let ps: Vec<&str> = pp.iter().map(|s| s.as_str()).collect();
                    ps.as_slice() == parent_path && *pi == parent_instance && cid == child_group_id
                })
                .count()
        }
        fn find_segments_in_child_group(
            &self,
            segment_id: &str,
            parent_path: &[&str],
            parent_instance: usize,
            child_group_id: &str,
            child_instance: usize,
        ) -> Vec<OwnedSegment> {
            self.children
                .iter()
                .find(|(pp, pi, cid, ci, _)| {
                    let ps: Vec<&str> = pp.iter().map(|s| s.as_str()).collect();
                    ps.as_slice() == parent_path
                        && *pi == parent_instance
                        && cid == child_group_id
                        && *ci == child_instance
                })
                .map(|(_, _, _, _, segs)| {
                    segs.iter()
                        .filter(|s| s.id == segment_id)
                        .cloned()
                        .collect()
                })
                .unwrap_or_default()
        }
        fn extract_value_in_group(
            &self,
            segment_id: &str,
            element_index: usize,
            component_index: usize,
            group_path: &[&str],
            instance_index: usize,
        ) -> Option<String> {
            let segs = self.find_instance(group_path, instance_index)?;
            let seg = segs.iter().find(|s| s.id == segment_id)?;
            seg.elements
                .get(element_index)?
                .get(component_index)
                .cloned()
        }
    }

    #[test]
    fn test_find_segment() {
        let segments = vec![
            make_segment("UNH", vec![vec!["test"]]),
            make_segment("NAD", vec![vec!["MS"], vec!["123456789", "", "293"]]),
        ];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("11001", &external, &segments);

        assert!(ctx.find_segment("NAD").is_some());
        assert!(ctx.find_segment("DTM").is_none());
    }

    #[test]
    fn test_find_segments_with_qualifier() {
        let segments = vec![
            make_segment("NAD", vec![vec!["MS"], vec!["111"]]),
            make_segment("NAD", vec![vec!["MR"], vec!["222"]]),
            make_segment("NAD", vec![vec!["MS"], vec!["333"]]),
        ];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("11001", &external, &segments);

        let ms_nads = ctx.find_segments_with_qualifier("NAD", 0, "MS");
        assert_eq!(ms_nads.len(), 2);
    }

    #[test]
    fn test_has_segment() {
        let segments = vec![make_segment("UNH", vec![vec!["test"]])];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("11001", &external, &segments);

        assert!(ctx.has_segment("UNH"));
        assert!(!ctx.has_segment("NAD"));
    }

    // --- Group navigator tests ---

    #[test]
    fn test_no_navigator_group_find_returns_empty() {
        let segments = vec![make_segment("SEQ", vec![vec!["Z98"]])];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);
        assert!(ctx
            .find_segments_in_group("SEQ", &["SG4", "SG8"], 0)
            .is_empty());
    }

    #[test]
    fn test_no_navigator_group_instance_count_zero() {
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &[]);
        assert_eq!(ctx.group_instance_count(&["SG4"]), 0);
    }

    #[test]
    fn test_with_navigator_finds_segments_in_group() {
        let external = NoOpExternalProvider;
        let nav = MockGroupNavigator::new().with_group(
            &["SG4", "SG8"],
            0,
            vec![
                make_segment("SEQ", vec![vec!["Z98"]]),
                make_segment("CCI", vec![vec!["Z30"], vec![], vec!["Z07"]]),
            ],
        );
        let ctx = EvaluationContext::with_navigator("55001", &external, &[], &nav);
        let result = ctx.find_segments_in_group("SEQ", &["SG4", "SG8"], 0);
        assert_eq!(result.len(), 1);
        assert_eq!(result[0].id, "SEQ");
    }

    #[test]
    fn test_with_navigator_qualifier_in_group() {
        let external = NoOpExternalProvider;
        let nav = MockGroupNavigator::new().with_group(
            &["SG4", "SG8"],
            0,
            vec![
                make_segment("SEQ", vec![vec!["Z98"]]),
                make_segment("SEQ", vec![vec!["Z01"]]),
            ],
        );
        let ctx = EvaluationContext::with_navigator("55001", &external, &[], &nav);
        let result = ctx.find_segments_with_qualifier_in_group("SEQ", 0, "Z98", &["SG4", "SG8"], 0);
        assert_eq!(result.len(), 1);
    }

    #[test]
    fn test_group_instance_count_with_navigator() {
        let external = NoOpExternalProvider;
        let nav = MockGroupNavigator::new()
            .with_group(
                &["SG4", "SG8"],
                0,
                vec![make_segment("SEQ", vec![vec!["Z98"]])],
            )
            .with_group(
                &["SG4", "SG8"],
                1,
                vec![make_segment("SEQ", vec![vec!["Z01"]])],
            );
        let ctx = EvaluationContext::with_navigator("55001", &external, &[], &nav);
        assert_eq!(ctx.group_instance_count(&["SG4", "SG8"]), 2);
    }

    #[test]
    fn test_has_segment_in_group() {
        let external = NoOpExternalProvider;
        let nav = MockGroupNavigator::new().with_group(
            &["SG4", "SG8"],
            0,
            vec![make_segment("SEQ", vec![vec!["Z98"]])],
        );
        let ctx = EvaluationContext::with_navigator("55001", &external, &[], &nav);
        assert!(ctx.has_segment_in_group("SEQ", &["SG4", "SG8"], 0));
        assert!(!ctx.has_segment_in_group("CCI", &["SG4", "SG8"], 0));
        assert!(!ctx.has_segment_in_group("SEQ", &["SG4", "SG5"], 0));
    }

    // --- High-level helper tests ---

    #[test]
    fn test_has_qualifier() {
        let segments = vec![
            make_segment("NAD", vec![vec!["MS"], vec!["111"]]),
            make_segment("NAD", vec![vec!["MR"], vec!["222"]]),
        ];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("11001", &external, &segments);

        assert_eq!(ctx.has_qualifier("NAD", 0, "MS"), ConditionResult::True);
        assert_eq!(ctx.has_qualifier("NAD", 0, "DP"), ConditionResult::False);
    }

    #[test]
    fn test_lacks_qualifier() {
        let segments = vec![make_segment("DTM", vec![vec!["92", "2025"]])];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("11001", &external, &segments);

        assert_eq!(ctx.lacks_qualifier("DTM", 0, "93"), ConditionResult::True);
        assert_eq!(ctx.lacks_qualifier("DTM", 0, "92"), ConditionResult::False);
    }

    #[test]
    fn test_has_qualified_value() {
        let segments = vec![make_segment("STS", vec![vec!["7"], vec![], vec!["ZG9"]])];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        assert_eq!(
            ctx.has_qualified_value("STS", 0, "7", 2, 0, &["ZG9", "ZH1", "ZH2"]),
            ConditionResult::True,
        );
        assert_eq!(
            ctx.has_qualified_value("STS", 0, "7", 2, 0, &["E01"]),
            ConditionResult::False,
        );
        // No STS+E01 → Unknown
        assert_eq!(
            ctx.has_qualified_value("STS", 0, "E01", 2, 0, &["Z01"]),
            ConditionResult::Unknown,
        );
    }

    #[test]
    fn test_any_group_has_qualifier() {
        let external = NoOpExternalProvider;
        let nav = MockGroupNavigator::new()
            .with_group(
                &["SG4", "SG8"],
                0,
                vec![make_segment("SEQ", vec![vec!["Z01"]])],
            )
            .with_group(
                &["SG4", "SG8"],
                1,
                vec![make_segment("SEQ", vec![vec!["Z98"]])],
            );
        let ctx = EvaluationContext::with_navigator("55001", &external, &[], &nav);

        assert_eq!(
            ctx.any_group_has_qualifier("SEQ", 0, "Z98", &["SG4", "SG8"]),
            ConditionResult::True,
        );
        assert_eq!(
            ctx.any_group_has_qualifier("SEQ", 0, "Z99", &["SG4", "SG8"]),
            ConditionResult::False,
        );
    }

    #[test]
    fn test_any_group_has_qualifier_fallback() {
        // No navigator — falls back to message-wide search
        let segments = vec![make_segment("SEQ", vec![vec!["Z98"]])];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        assert_eq!(
            ctx.any_group_has_qualifier("SEQ", 0, "Z98", &["SG4", "SG8"]),
            ConditionResult::True,
        );
    }

    #[test]
    fn test_any_group_has_any_qualifier() {
        let external = NoOpExternalProvider;
        let nav = MockGroupNavigator::new().with_group(
            &["SG4", "SG8"],
            0,
            vec![make_segment("SEQ", vec![vec!["Z80"]])],
        );
        let ctx = EvaluationContext::with_navigator("55001", &external, &[], &nav);

        assert_eq!(
            ctx.any_group_has_any_qualifier("SEQ", 0, &["Z01", "Z80", "Z81"], &["SG4", "SG8"]),
            ConditionResult::True,
        );
        assert_eq!(
            ctx.any_group_has_any_qualifier("SEQ", 0, &["Z98"], &["SG4", "SG8"]),
            ConditionResult::False,
        );
    }

    #[test]
    fn test_any_group_has_co_occurrence() {
        let external = NoOpExternalProvider;
        let nav = MockGroupNavigator::new().with_group(
            &["SG4", "SG8"],
            0,
            vec![
                make_segment("SEQ", vec![vec!["Z01"]]),
                make_segment("CCI", vec![vec!["Z30"], vec![], vec!["Z07"]]),
            ],
        );
        let ctx = EvaluationContext::with_navigator("55001", &external, &[], &nav);

        assert_eq!(
            ctx.any_group_has_co_occurrence(
                "SEQ",
                0,
                &["Z01"],
                "CCI",
                2,
                0,
                &["Z07"],
                &["SG4", "SG8"],
            ),
            ConditionResult::True,
        );
        // Wrong CCI value
        assert_eq!(
            ctx.any_group_has_co_occurrence(
                "SEQ",
                0,
                &["Z01"],
                "CCI",
                2,
                0,
                &["ZC0"],
                &["SG4", "SG8"],
            ),
            ConditionResult::False,
        );
    }

    // --- Parent-child navigation tests ---

    #[test]
    fn test_filtered_parent_child_has_qualifier() {
        let external = NoOpExternalProvider;
        // SG8[0] has SEQ+Z98, with SG10 child having CCI+Z23
        // SG8[1] has SEQ+Z01, no SG10 children
        let nav = MockGroupNavigator::new()
            .with_group(
                &["SG4", "SG8"],
                0,
                vec![make_segment("SEQ", vec![vec!["Z98"]])],
            )
            .with_group(
                &["SG4", "SG8"],
                1,
                vec![make_segment("SEQ", vec![vec!["Z01"]])],
            )
            .with_child_group(
                &["SG4", "SG8"],
                0,
                "SG10",
                0,
                vec![make_segment("CCI", vec![vec!["Z23"]])],
            );
        let ctx = EvaluationContext::with_navigator("55001", &external, &[], &nav);

        // SG8 with SEQ+Z98 has SG10 child with CCI+Z23 → True
        assert_eq!(
            ctx.filtered_parent_child_has_qualifier(
                &["SG4", "SG8"],
                "SEQ",
                0,
                "Z98",
                "SG10",
                "CCI",
                0,
                "Z23",
            ),
            ConditionResult::True,
        );
        // SG8 with SEQ+Z01 has no SG10 children → False
        assert_eq!(
            ctx.filtered_parent_child_has_qualifier(
                &["SG4", "SG8"],
                "SEQ",
                0,
                "Z01",
                "SG10",
                "CCI",
                0,
                "Z23",
            ),
            ConditionResult::False,
        );
        // Wrong child qualifier → False
        assert_eq!(
            ctx.filtered_parent_child_has_qualifier(
                &["SG4", "SG8"],
                "SEQ",
                0,
                "Z98",
                "SG10",
                "CCI",
                0,
                "Z99",
            ),
            ConditionResult::False,
        );
    }

    #[test]
    fn test_filtered_parent_child_fallback() {
        // No navigator — falls back to message-wide
        let segments = vec![
            make_segment("SEQ", vec![vec!["Z98"]]),
            make_segment("CCI", vec![vec!["Z23"]]),
        ];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        assert_eq!(
            ctx.filtered_parent_child_has_qualifier(
                &["SG4", "SG8"],
                "SEQ",
                0,
                "Z98",
                "SG10",
                "CCI",
                0,
                "Z23",
            ),
            ConditionResult::True,
        );
        // Missing child qualifier in message-wide → False
        assert_eq!(
            ctx.filtered_parent_child_has_qualifier(
                &["SG4", "SG8"],
                "SEQ",
                0,
                "Z98",
                "SG10",
                "CCI",
                0,
                "Z99",
            ),
            ConditionResult::False,
        );
    }

    #[test]
    fn test_any_group_has_qualifier_without() {
        let external = NoOpExternalProvider;
        // SG8[0]: SEQ+Z59 present, CCI+11 absent
        // SG8[1]: SEQ+Z01 present, CCI+11 present
        let nav = MockGroupNavigator::new()
            .with_group(
                &["SG4", "SG8"],
                0,
                vec![make_segment("SEQ", vec![vec!["Z59"]])],
            )
            .with_group(
                &["SG4", "SG8"],
                1,
                vec![
                    make_segment("SEQ", vec![vec!["Z01"]]),
                    make_segment("CCI", vec![vec!["11"]]),
                ],
            );
        let ctx = EvaluationContext::with_navigator("55001", &external, &[], &nav);

        // SG8[0] has SEQ+Z59 without CCI+11 → True
        assert_eq!(
            ctx.any_group_has_qualifier_without("SEQ", 0, "Z59", "CCI", 0, "11", &["SG4", "SG8"]),
            ConditionResult::True,
        );
        // Looking for SEQ+Z01 without CCI+11 → False (SG8[1] has both)
        assert_eq!(
            ctx.any_group_has_qualifier_without("SEQ", 0, "Z01", "CCI", 0, "11", &["SG4", "SG8"]),
            ConditionResult::False,
        );
        // Looking for SEQ+Z99 (doesn't exist) → False
        assert_eq!(
            ctx.any_group_has_qualifier_without("SEQ", 0, "Z99", "CCI", 0, "11", &["SG4", "SG8"]),
            ConditionResult::False,
        );
    }

    #[test]
    fn test_any_group_has_qualifier_without_fallback() {
        let segments = vec![make_segment("SEQ", vec![vec!["Z59"]])];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        // Message-wide: SEQ+Z59 present, CCI+11 absent → True
        assert_eq!(
            ctx.any_group_has_qualifier_without("SEQ", 0, "Z59", "CCI", 0, "11", &["SG4", "SG8"]),
            ConditionResult::True,
        );
    }

    #[test]
    fn test_collect_group_values() {
        let external = NoOpExternalProvider;
        let nav = MockGroupNavigator::new()
            .with_group(
                &["SG4", "SG6"],
                0,
                vec![make_segment("RFF", vec![vec!["Z49", "REF001"]])],
            )
            .with_group(
                &["SG4", "SG6"],
                1,
                vec![make_segment("RFF", vec![vec!["Z49", "REF002"]])],
            );
        let ctx = EvaluationContext::with_navigator("55001", &external, &[], &nav);

        let values = ctx.collect_group_values("RFF", 0, 1, &["SG4", "SG6"]);
        assert_eq!(values.len(), 2);
        assert_eq!(values[0], (0, "REF001".to_string()));
        assert_eq!(values[1], (1, "REF002".to_string()));
    }

    #[test]
    fn test_groups_share_qualified_value() {
        let external = NoOpExternalProvider;
        // SG6[0]: RFF+Z49 with value "TS001"
        // SG8[0]: SEQ with c286 value "TS001" (matches)
        // SG8[1]: SEQ with c286 value "TS999" (no match)
        let nav = MockGroupNavigator::new()
            .with_group(
                &["SG4", "SG6"],
                0,
                vec![make_segment("RFF", vec![vec!["Z49", "TS001"]])],
            )
            .with_group(
                &["SG4", "SG8"],
                0,
                vec![make_segment("SEQ", vec![vec!["Z98"], vec!["TS001"]])],
            )
            .with_group(
                &["SG4", "SG8"],
                1,
                vec![make_segment("SEQ", vec![vec!["Z01"], vec!["TS999"]])],
            );
        let ctx = EvaluationContext::with_navigator("55001", &external, &[], &nav);

        // RFF+Z49 value "TS001" matches SEQ value at [1][0] → True
        assert_eq!(
            ctx.groups_share_qualified_value(
                "RFF",
                0,
                "Z49",
                0,
                1,
                &["SG4", "SG6"],
                "SEQ",
                1,
                0,
                &["SG4", "SG8"],
            ),
            ConditionResult::True,
        );
    }

    #[test]
    fn test_groups_share_qualified_value_no_match() {
        let external = NoOpExternalProvider;
        let nav = MockGroupNavigator::new()
            .with_group(
                &["SG4", "SG6"],
                0,
                vec![make_segment("RFF", vec![vec!["Z49", "TS001"]])],
            )
            .with_group(
                &["SG4", "SG8"],
                0,
                vec![make_segment("SEQ", vec![vec!["Z98"], vec!["TS999"]])],
            );
        let ctx = EvaluationContext::with_navigator("55001", &external, &[], &nav);

        // No matching value → False
        assert_eq!(
            ctx.groups_share_qualified_value(
                "RFF",
                0,
                "Z49",
                0,
                1,
                &["SG4", "SG6"],
                "SEQ",
                1,
                0,
                &["SG4", "SG8"],
            ),
            ConditionResult::False,
        );
    }

    #[test]
    fn test_groups_share_qualified_value_no_source() {
        let external = NoOpExternalProvider;
        // No RFF+Z49 at all
        let nav = MockGroupNavigator::new()
            .with_group(
                &["SG4", "SG6"],
                0,
                vec![make_segment("RFF", vec![vec!["Z13", "55001"]])],
            )
            .with_group(
                &["SG4", "SG8"],
                0,
                vec![make_segment("SEQ", vec![vec!["Z98"], vec!["TS001"]])],
            );
        let ctx = EvaluationContext::with_navigator("55001", &external, &[], &nav);

        // No source qualifier match → Unknown
        assert_eq!(
            ctx.groups_share_qualified_value(
                "RFF",
                0,
                "Z49",
                0,
                1,
                &["SG4", "SG6"],
                "SEQ",
                1,
                0,
                &["SG4", "SG8"],
            ),
            ConditionResult::Unknown,
        );
    }

    #[test]
    fn test_groups_share_qualified_value_fallback() {
        // No navigator — falls back to message-wide
        let segments = vec![
            make_segment("RFF", vec![vec!["Z49", "TS001"]]),
            make_segment("SEQ", vec![vec!["Z98"], vec!["TS001"]]),
        ];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        assert_eq!(
            ctx.groups_share_qualified_value(
                "RFF",
                0,
                "Z49",
                0,
                1,
                &["SG4", "SG6"],
                "SEQ",
                1,
                0,
                &["SG4", "SG8"],
            ),
            ConditionResult::True,
        );
    }

    #[test]
    fn test_child_group_pass_throughs_no_navigator() {
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &[]);

        assert_eq!(
            ctx.child_group_instance_count(&["SG4", "SG8"], 0, "SG10"),
            0
        );
        assert!(ctx
            .find_segments_in_child_group("CCI", &["SG4", "SG8"], 0, "SG10", 0)
            .is_empty());
        assert_eq!(
            ctx.extract_value_in_group("SEQ", 0, 0, &["SG4", "SG8"], 0),
            None
        );
    }

    // --- has_segment_matching tests ---

    #[test]
    fn test_has_segment_matching_found() {
        let segments = vec![
            make_segment("STS", vec![vec!["7"], vec!["E01"], vec!["ZW4"]]),
            make_segment("STS", vec![vec!["Z20"], vec!["Z32"], vec!["A99"]]),
        ];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        assert_eq!(
            ctx.has_segment_matching("STS", &[(0, 0, "Z20"), (1, 0, "Z32"), (2, 0, "A99")]),
            ConditionResult::True,
        );
    }

    #[test]
    fn test_has_segment_matching_not_found() {
        let segments = vec![make_segment(
            "STS",
            vec![vec!["7"], vec!["E01"], vec!["ZW4"]],
        )];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        assert_eq!(
            ctx.has_segment_matching("STS", &[(0, 0, "Z20"), (1, 0, "Z32")]),
            ConditionResult::False,
        );
    }

    #[test]
    fn test_has_segment_matching_no_segments() {
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &[]);

        assert_eq!(
            ctx.has_segment_matching("STS", &[(0, 0, "Z20")]),
            ConditionResult::Unknown,
        );
    }

    #[test]
    fn test_has_segment_matching_in_group() {
        let nav = MockGroupNavigator::new()
            .with_group(
                &["SG4"],
                0,
                vec![make_segment("STS", vec![vec!["7"], vec!["E01"]])],
            )
            .with_group(
                &["SG4"],
                1,
                vec![make_segment("STS", vec![vec!["Z20"], vec!["Z32"]])],
            );
        let segments = vec![
            make_segment("STS", vec![vec!["7"], vec!["E01"]]),
            make_segment("STS", vec![vec!["Z20"], vec!["Z32"]]),
        ];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::with_navigator("55001", &external, &segments, &nav);

        assert_eq!(
            ctx.has_segment_matching_in_group("STS", &[(0, 0, "Z20"), (1, 0, "Z32")], &["SG4"]),
            ConditionResult::True,
        );
    }

    // --- DTM comparison tests ---

    #[test]
    fn test_dtm_ge() {
        let segments = vec![make_segment(
            "DTM",
            vec![vec!["137", "202601010000", "303"]],
        )];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        assert_eq!(ctx.dtm_ge("137", "202601010000"), ConditionResult::True);
        assert_eq!(ctx.dtm_ge("137", "202501010000"), ConditionResult::True);
        assert_eq!(ctx.dtm_ge("137", "202701010000"), ConditionResult::False);
        assert_eq!(ctx.dtm_ge("999", "202601010000"), ConditionResult::Unknown);
    }

    #[test]
    fn test_dtm_lt() {
        let segments = vec![make_segment(
            "DTM",
            vec![vec!["137", "202601010000", "303"]],
        )];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        assert_eq!(ctx.dtm_lt("137", "202701010000"), ConditionResult::True);
        assert_eq!(ctx.dtm_lt("137", "202601010000"), ConditionResult::False);
        assert_eq!(ctx.dtm_lt("137", "202501010000"), ConditionResult::False);
    }

    #[test]
    fn test_dtm_le() {
        let segments = vec![make_segment(
            "DTM",
            vec![vec!["137", "202601010000", "303"]],
        )];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        assert_eq!(ctx.dtm_le("137", "202601010000"), ConditionResult::True);
        assert_eq!(ctx.dtm_le("137", "202701010000"), ConditionResult::True);
        assert_eq!(ctx.dtm_le("137", "202501010000"), ConditionResult::False);
    }

    // --- Count helpers tests ---

    #[test]
    fn test_count_qualified_in_group() {
        let nav = MockGroupNavigator::new()
            .with_group(
                &["SG4", "SG8"],
                0,
                vec![
                    make_segment("CCI", vec![vec!["Z23"]]),
                    make_segment("CCI", vec![vec!["Z30"]]),
                ],
            )
            .with_group(
                &["SG4", "SG8"],
                1,
                vec![make_segment("CCI", vec![vec!["Z23"]])],
            );
        let segments = vec![
            make_segment("CCI", vec![vec!["Z23"]]),
            make_segment("CCI", vec![vec!["Z30"]]),
            make_segment("CCI", vec![vec!["Z23"]]),
        ];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::with_navigator("55001", &external, &segments, &nav);

        assert_eq!(
            ctx.count_qualified_in_group("CCI", 0, "Z23", &["SG4", "SG8"]),
            2
        );
        assert_eq!(
            ctx.count_qualified_in_group("CCI", 0, "Z30", &["SG4", "SG8"]),
            1
        );
        assert_eq!(
            ctx.count_qualified_in_group("CCI", 0, "Z99", &["SG4", "SG8"]),
            0
        );
    }

    #[test]
    fn test_count_in_group() {
        let nav = MockGroupNavigator::new()
            .with_group(
                &["SG4", "SG8"],
                0,
                vec![
                    make_segment("SEQ", vec![vec!["Z98"]]),
                    make_segment("CCI", vec![vec!["Z23"]]),
                ],
            )
            .with_group(
                &["SG4", "SG8"],
                1,
                vec![make_segment("SEQ", vec![vec!["Z01"]])],
            );
        let segments = vec![
            make_segment("SEQ", vec![vec!["Z98"]]),
            make_segment("CCI", vec![vec!["Z23"]]),
            make_segment("SEQ", vec![vec!["Z01"]]),
        ];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::with_navigator("55001", &external, &segments, &nav);

        assert_eq!(ctx.count_in_group("SEQ", &["SG4", "SG8"]), 2);
        assert_eq!(ctx.count_in_group("CCI", &["SG4", "SG8"]), 1);
        assert_eq!(ctx.count_in_group("DTM", &["SG4", "SG8"]), 0);
    }

    #[test]
    fn test_count_fallback_no_navigator() {
        let segments = vec![
            make_segment("CCI", vec![vec!["Z23"]]),
            make_segment("CCI", vec![vec!["Z30"]]),
            make_segment("CCI", vec![vec!["Z23"]]),
        ];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        // Falls back to message-wide count
        assert_eq!(
            ctx.count_qualified_in_group("CCI", 0, "Z23", &["SG4", "SG8"]),
            2
        );
        assert_eq!(ctx.count_in_group("CCI", &["SG4", "SG8"]), 3);
    }

    // --- format_check / format_check_qualified tests ---

    #[test]
    fn format_check_prefers_resolved_value() {
        // Segments have "WRONG" but resolved_value is "CORRECT"
        let segments = vec![make_segment("DTM", vec![vec!["92", "WRONG"]])];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments)
            .with_resolved(Some("CORRECT"), None);

        let result = ctx.format_check("DTM", 0, 1, |v| ConditionResult::from(v == "CORRECT"));
        assert_eq!(result, ConditionResult::True);
    }

    #[test]
    fn format_check_falls_back_to_segment_search() {
        // No resolved_value, segments have the value
        let segments = vec![make_segment("DTM", vec![vec!["92", "202501011200"]])];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        let result = ctx.format_check("DTM", 0, 1, |v| ConditionResult::from(v == "202501011200"));
        assert_eq!(result, ConditionResult::True);
    }

    #[test]
    fn format_check_returns_unknown_when_segment_absent() {
        // No resolved_value, no matching segments — we can't decide.
        let segments: Vec<OwnedSegment> = vec![];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        let result = ctx.format_check("DTM", 0, 1, |_| ConditionResult::True);
        assert_eq!(result, ConditionResult::Unknown);
    }

    #[test]
    fn format_check_returns_unknown_when_multiple_segments() {
        // Two DTMs, no resolved_value. Picking .first() would silently pick
        // one; Unknown is the honest answer when we can't tell which is being
        // validated.
        let segments = vec![
            make_segment("DTM", vec![vec!["92", "OK"]]),
            make_segment("DTM", vec![vec!["163", "BAD"]]),
        ];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        let result = ctx.format_check("DTM", 0, 1, |v| ConditionResult::from(v == "OK"));
        assert_eq!(result, ConditionResult::Unknown);
    }

    #[test]
    fn format_check_qualified_prefers_resolved_value() {
        // Two DTM segments but resolved_value overrides
        let segments = vec![
            make_segment("DTM", vec![vec!["92", "WRONG"]]),
            make_segment("DTM", vec![vec!["163", "ALSO_WRONG"]]),
        ];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments)
            .with_resolved(Some("CORRECT"), None);

        let result = ctx.format_check_qualified("DTM", 0, "163", 0, 1, |v| {
            ConditionResult::from(v == "CORRECT")
        });
        assert_eq!(result, ConditionResult::True);
    }

    #[test]
    fn format_check_qualified_falls_back_to_qualified_search() {
        // Two DTM segments with different qualifiers, no resolved_value
        let segments = vec![
            make_segment("DTM", vec![vec!["92", "2200"]]),
            make_segment("DTM", vec![vec!["163", "0800"]]),
        ];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        // Should find DTM+163 and extract "0800", not DTM+92's "2200"
        let result = ctx.format_check_qualified("DTM", 0, "163", 0, 1, |v| {
            ConditionResult::from(v == "0800")
        });
        assert_eq!(result, ConditionResult::True);

        // Verify it does NOT pick DTM+92's value
        let result2 = ctx.format_check_qualified("DTM", 0, "163", 0, 1, |v| {
            ConditionResult::from(v == "2200")
        });
        assert_eq!(result2, ConditionResult::False);
    }

    // --- self_segment_value / self_segment_value_equals tests ---

    #[test]
    fn self_segment_value_prefers_resolved_segment() {
        // Two DTM segments in the message: the first has "OTHER", the
        // resolved_segment (the one being validated) has "303". Per-field
        // condition must read "303", not "OTHER".
        let segments = vec![
            make_segment("DTM", vec![vec!["472", "", "OTHER"]]),
            make_segment("DTM", vec![vec!["Z25", "", "303"]]),
        ];
        let external = NoOpExternalProvider;
        let resolved_elements = vec![vec!["Z25".to_string(), String::new(), "303".to_string()]];
        let ctx = EvaluationContext::new("55001", &external, &segments)
            .with_resolved(None, Some(&resolved_elements));

        assert_eq!(ctx.self_segment_value("DTM", 0, 2), Some("303"));
        assert!(ctx.self_segment_value_equals("DTM", 0, 2, "303"));
        assert!(!ctx.self_segment_value_equals("DTM", 0, 2, "OTHER"));
    }

    #[test]
    fn self_segment_value_falls_back_when_no_resolved_segment() {
        // Outside tree context — fall back to the first tag match.
        let segments = vec![
            make_segment("DTM", vec![vec!["Z25", "", "303"]]),
            make_segment("DTM", vec![vec!["472", "", "OTHER"]]),
        ];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        assert_eq!(ctx.self_segment_value("DTM", 0, 2), Some("303"));
    }

    #[test]
    fn self_segment_value_missing_returns_none() {
        let segments: Vec<OwnedSegment> = vec![];
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);

        assert_eq!(ctx.self_segment_value("DTM", 0, 2), None);
        assert!(!ctx.self_segment_value_equals("DTM", 0, 2, "303"));
    }

    /// Build a UTILMD-like segment sequence where each SG8 is:
    ///   SEQ+Q[:zid] then PIA+5+<obis>
    /// The input `sg8s` is a list of `(qualifier, zeitraum_id, obis)`.
    fn make_sg8_sequence(sg8s: &[(&str, &str, &str)]) -> Vec<OwnedSegment> {
        let mut segments = Vec::new();
        for (i, (qual, zid, obis)) in sg8s.iter().enumerate() {
            segments.push(OwnedSegment {
                id: "SEQ".to_string(),
                elements: vec![vec![qual.to_string()], vec![zid.to_string()]],
                segment_number: (2 * i + 1) as u32,
            });
            segments.push(OwnedSegment {
                id: "PIA".to_string(),
                elements: vec![vec!["5".to_string()], vec![obis.to_string()]],
                segment_number: (2 * i + 2) as u32,
            });
        }
        segments
    }

    #[test]
    fn count_sg8_obis_matches_counts_matching_kumuliert() {
        // Two SG8s with same qualifier Z02 + zid "ZR1", two kumuliert OBIS.
        let segments = make_sg8_sequence(&[
            ("Z02", "ZR1", "1-1:1.8.0"), // kumuliert
            ("Z02", "ZR1", "1-1:2.8.0"), // kumuliert
            ("Z02", "ZR2", "1-1:1.8.0"), // different zid — shouldn't count
            ("ZA1", "ZR1", "1-1:1.8.0"), // different qualifier — shouldn't count
        ]);
        let external = NoOpExternalProvider;
        // Anchor on first SEQ (Z02, ZR1).
        let seq = &segments[0].elements;
        let ctx =
            EvaluationContext::new("55001", &external, &segments).with_resolved(None, Some(seq));

        let n = ctx
            .count_sg8_obis_matches(super::super::format_validators::is_obis_wirkarbeit_kumuliert);
        assert_eq!(n, 2);
    }

    #[test]
    fn count_sg8_obis_matches_returns_zero_without_resolved_segment() {
        let segments = make_sg8_sequence(&[("Z02", "ZR1", "1-1:1.8.0")]);
        let external = NoOpExternalProvider;
        let ctx = EvaluationContext::new("55001", &external, &segments);
        let n = ctx
            .count_sg8_obis_matches(super::super::format_validators::is_obis_wirkarbeit_kumuliert);
        assert_eq!(n, 0);
    }

    #[test]
    fn count_sg8_obis_matches_quarter_hour_and_kumuliert_are_disjoint() {
        let segments = make_sg8_sequence(&[
            ("Z02", "ZR1", "1-1:1.8.0"),  // kumuliert
            ("Z02", "ZR1", "1-1:1.29.0"), // 1/4 h
        ]);
        let external = NoOpExternalProvider;
        let seq = &segments[0].elements;
        let ctx =
            EvaluationContext::new("55001", &external, &segments).with_resolved(None, Some(seq));

        assert_eq!(
            ctx.count_sg8_obis_matches(
                super::super::format_validators::is_obis_wirkarbeit_kumuliert
            ),
            1
        );
        assert_eq!(
            ctx.count_sg8_obis_matches(
                super::super::format_validators::is_obis_wirkarbeit_quarter_hour
            ),
            1
        );
    }
}