quamina 0.4.1

//! Mutable pattern matchers for single-threaded pattern building.
//!
//! This module contains the mutable (RefCell-based) matchers used during pattern building:
//! - `MutableFieldMatcher`: Mutable field matcher with RefCell-based interior mutability
//! - `MutableValueMatcher`: Mutable value matcher with singleton optimization
//! - `CoreMatcher`: Single-threaded core matcher that builds and matches patterns

use std::cell::{Cell, RefCell};
use std::collections::{HashMap, HashSet};
use std::rc::Rc;
use std::sync::Arc;

use super::arena::{
    insert_string_into_arena, insert_suffix_into_arena, make_anything_but_arena_fa,
    make_cidr_arena_fa, make_monocase_arena_fa, make_numeric_greater_arena_fa,
    make_numeric_less_arena_fa, make_numeric_range_arena_fa, make_prefix_arena_fa,
    make_shellstyle_arena_fa, make_string_arena_fa, make_suffix_dfa, make_wildcard_arena_fa,
    merge_arena_nfas, traverse_arena_dfa, traverse_arena_dfa_backward, traverse_arena_nfa,
    ArenaNfaBuffers, StateArena, StateId,
};
use super::small_table::{FieldMatcher, NfaBuffers};
use crate::regexp::make_regexp_nfa_arena;

/// Wrap a byte slice in quotes: `val` → `"val"`.
///
/// Used by `add_transition()` to wrap string pattern values so that
/// the automaton can distinguish strings from numbers. Event values
/// from the flattener retain their JSON quotes, so pattern FAs must
/// also include quotes to match correctly.
#[inline]
fn quote_wrap(val: &[u8]) -> Vec<u8> {
    let mut result = Vec::with_capacity(val.len() + 2);
    result.push(b'"');
    result.extend_from_slice(val);
    result.push(b'"');
    result
}

/// A condition NFA for lookaround verification.
///
/// Each condition is an automaton that must match (or not match, if negative)
/// the full value for the overall pattern to succeed.
#[derive(Clone, Debug)]
pub struct ConditionNfa {
    pub arena: StateArena,
    pub start: StateId,
    /// True for negative conditions ((?!...) or (?<!...))
    pub is_negative: bool,
}

/// Arena NFA with conditions for multi-condition patterns (lookarounds).
///
/// The primary automaton is matched first. If it produces transitions,
/// all conditions are verified against the full value.
#[derive(Clone)]
pub struct MultiConditionNfa {
    pub primary_arena: StateArena,
    pub primary_start: StateId,
    /// Field matcher pointer for transition mapping
    pub field_matcher_ptr: *const FieldMatcher,
    /// Conditions to verify after primary matches
    pub conditions: Vec<ConditionNfa>,
}

/// Build a combined pattern for lookbehind verification.
///
/// For `(?<=foo)bar`: lookbehind="foo", primary="bar" -> combined="foobar"
/// The combined pattern is used to check if the full value matches.
fn build_lookbehind_combined_pattern(
    lookbehind: &crate::regexp::RegexpRoot,
    primary: &crate::regexp::RegexpRoot,
) -> crate::regexp::RegexpRoot {
    use crate::regexp::RegexpBranch;

    // Handle empty cases
    if lookbehind.is_empty() {
        return primary.clone();
    }
    if primary.is_empty() {
        return lookbehind.clone();
    }

    // Simple case: single branch in each
    if lookbehind.len() == 1 && primary.len() == 1 {
        let mut combined: RegexpBranch = lookbehind[0].clone();
        combined.extend(primary[0].clone());
        return vec![combined];
    }

    // Complex case: alternation in one or both
    // Create all combinations: (lb1|lb2)(p1|p2) -> lb1p1|lb1p2|lb2p1|lb2p2
    let mut combined_branches = Vec::new();
    for lb_branch in lookbehind {
        for p_branch in primary {
            let mut combined: RegexpBranch = lb_branch.clone();
            combined.extend(p_branch.clone());
            combined_branches.push(combined);
        }
    }
    combined_branches
}

/// A mutable field matcher used during pattern building.
/// This is similar to Go's fieldMatcher with its updateable atomic pointer.
#[derive(Default)]
pub struct MutableFieldMatcher<X: Clone + Eq + std::hash::Hash> {
    /// Map from field paths to value matchers
    pub transitions: RefCell<HashMap<String, Rc<MutableValueMatcher<X>>>>,
    /// Pattern identifiers that match when arriving at this state
    pub matches: RefCell<Vec<X>>,
    /// exists:true patterns - map from field path to next field matcher
    pub exists_true: RefCell<HashMap<String, Rc<Self>>>,
    /// exists:false patterns - map from field path to next field matcher
    pub exists_false: RefCell<HashMap<String, Rc<Self>>>,
}

impl<X: Clone + Eq + std::hash::Hash> MutableFieldMatcher<X> {
    pub fn new() -> Self {
        Self {
            transitions: RefCell::new(HashMap::new()),
            matches: RefCell::new(Vec::new()),
            exists_true: RefCell::new(HashMap::new()),
            exists_false: RefCell::new(HashMap::new()),
        }
    }

    /// Add a match identifier to this state
    pub fn add_match(&self, x: X) {
        self.matches.borrow_mut().push(x);
    }

    /// Add an exists transition (true or false)
    pub fn add_exists(&self, exists: bool, path: &str) -> Rc<Self> {
        let map = if exists {
            &self.exists_true
        } else {
            &self.exists_false
        };

        let mut map_borrow = map.borrow_mut();
        if let Some(existing) = map_borrow.get(path) {
            existing.clone()
        } else {
            let new_fm = Rc::new(Self::new());
            map_borrow.insert(path.to_string(), new_fm.clone());
            new_fm
        }
    }

    /// Add a value transition, returns the next field matchers
    pub fn add_transition(
        &self,
        path: &str,
        matchers: &[crate::json::Matcher],
        arena_byte_budget: usize,
    ) -> Result<Vec<Rc<Self>>, crate::QuaminaError> {
        use crate::json::Matcher;

        let mut transitions = self.transitions.borrow_mut();
        let vm = transitions
            .entry(path.to_string())
            .or_insert_with(|| Rc::new(MutableValueMatcher::with_budget(arena_byte_budget)));

        // Check if all matchers are Exact strings - use bulk optimization
        // Note: Exact values are pre-quoted for strings in json.rs value_to_string()
        let all_exact: Vec<&[u8]> = matchers
            .iter()
            .filter_map(|m| match m {
                Matcher::Exact(s) => Some(s.as_bytes()),
                _ => None,
            })
            .collect();

        if all_exact.len() == matchers.len() && all_exact.len() > 1 {
            // All matchers are Exact strings and there's more than one - use bulk method
            let next_fm = vm.add_string_transitions_bulk(&all_exact)?;
            return Ok(vec![next_fm]);
        }

        // Fall back to one-by-one processing
        let mut next_states = Vec::new();
        for matcher in matchers {
            let next_fm = vm.add_transition(matcher)?;
            next_states.push(next_fm);
        }
        Ok(next_states)
    }

    /// Transition on a field value during matching
    pub fn transition_on(
        &self,
        path: &str,
        value: &[u8],
        is_number: bool,
        bufs: &mut NfaBuffers,
    ) -> Vec<Rc<Self>> {
        let transitions = self.transitions.borrow();
        if let Some(vm) = transitions.get(path) {
            vm.transition_on(value, is_number, bufs)
        } else {
            vec![]
        }
    }
}

/// A mutable value matcher used during pattern building.
/// Similar to Go's valueMatcher with singleton optimization and automaton.
pub struct MutableValueMatcher<X: Clone + Eq + std::hash::Hash> {
    /// Optimization: for single exact match, store it directly
    pub(crate) singleton_match: RefCell<Option<Vec<u8>>>,
    /// Transition for singleton match
    pub(crate) singleton_transition: RefCell<Option<Rc<MutableFieldMatcher<X>>>>,
    /// Whether this matcher has numeric patterns (for Q-number conversion)
    pub(crate) has_numbers: Cell<bool>,
    /// Mapping from `Arc<FieldMatcher>` to `Rc<MutableFieldMatcher<X>>`
    /// This bridges the automaton's field transitions to our mutable field matchers
    pub(crate) transition_map: RefCell<HashMap<*const FieldMatcher, Rc<MutableFieldMatcher<X>>>>,
    /// Multi-condition NFAs for lookaround patterns
    /// NOTE: Kept separate from main_arena for lookaround verification
    pub(crate) multi_condition_nfas: RefCell<Vec<MultiConditionNfa>>,
    /// Buffers for arena NFA traversal
    pub(crate) arena_bufs: RefCell<ArenaNfaBuffers>,
    /// Unified arena-based FA for all pattern types
    pub(crate) main_arena: RefCell<Option<(StateArena, StateId)>>,
    /// Whether main_arena contains NFA states (epsilon transitions or spinout).
    /// When false, the fast traverse_arena_dfa path can be used instead of traverse_arena_nfa.
    pub(crate) main_arena_is_nfa: RefCell<bool>,
    /// Separate DFA trie for suffix patterns, traversed backward (right-to-left).
    /// Contains reversed suffix bytes; uses traverse_arena_dfa_backward at match time.
    pub(crate) suffix_arena: RefCell<Option<(StateArena, StateId)>>,
    /// Arena byte budget for pattern complexity limiting
    pub(crate) arena_byte_budget: usize,
}

impl<X: Clone + Eq + std::hash::Hash> Default for MutableValueMatcher<X> {
    fn default() -> Self {
        Self::new()
    }
}

impl<X: Clone + Eq + std::hash::Hash> MutableValueMatcher<X> {
    pub fn new() -> Self {
        Self {
            singleton_match: RefCell::new(None),
            singleton_transition: RefCell::new(None),
            has_numbers: Cell::new(false),
            transition_map: RefCell::new(HashMap::new()),
            multi_condition_nfas: RefCell::new(Vec::new()),
            arena_bufs: RefCell::new(ArenaNfaBuffers::new()),
            main_arena: RefCell::new(None),
            main_arena_is_nfa: RefCell::new(false),
            suffix_arena: RefCell::new(None),
            arena_byte_budget: usize::MAX,
        }
    }

    pub fn with_budget(budget: usize) -> Self {
        Self {
            singleton_match: RefCell::new(None),
            singleton_transition: RefCell::new(None),
            has_numbers: Cell::new(false),
            transition_map: RefCell::new(HashMap::new()),
            multi_condition_nfas: RefCell::new(Vec::new()),
            arena_bufs: RefCell::new(ArenaNfaBuffers::new()),
            main_arena: RefCell::new(None),
            main_arena_is_nfa: RefCell::new(false),
            suffix_arena: RefCell::new(None),
            arena_byte_budget: budget,
        }
    }

    /// Check whether the given arena size exceeds the budget.
    fn check_budget(&self, size: usize) -> Result<(), crate::QuaminaError> {
        if size > self.arena_byte_budget {
            return Err(crate::QuaminaError::PatternTooComplex(format!(
                "automaton byte size ({} bytes) exceeds budget ({} bytes)",
                size, self.arena_byte_budget
            )));
        }
        Ok(())
    }

    /// Check main_arena budget. Call after any in-place arena mutation.
    fn check_main_arena_budget(&self) -> Result<(), crate::QuaminaError> {
        let main = self.main_arena.borrow();
        if let Some((arena, _)) = main.as_ref() {
            self.check_budget(arena.estimated_byte_size())
        } else {
            Ok(())
        }
    }

    /// Helper to merge an arena FA into main_arena.
    /// If main_arena is empty, just set it. Otherwise, merge using merge_arena_nfas.
    /// Checks the arena byte budget before and after merging.
    fn merge_into_main_arena(
        &self,
        new_arena: StateArena,
        new_start: StateId,
    ) -> Result<(), crate::QuaminaError> {
        self.check_budget(new_arena.estimated_byte_size())?;

        let mut main = self.main_arena.borrow_mut();
        if let Some((existing_arena, existing_start)) = main.take() {
            let (merged, merged_start) =
                merge_arena_nfas(&existing_arena, existing_start, &new_arena, new_start);
            let merged_size = merged.estimated_byte_size();
            if merged_size > self.arena_byte_budget {
                // Restore existing arena on failure
                *main = Some((existing_arena, existing_start));
                return Err(crate::QuaminaError::PatternTooComplex(format!(
                    "automaton byte size ({} bytes) exceeds budget ({} bytes)",
                    merged_size, self.arena_byte_budget
                )));
            }
            *main = Some((merged, merged_start));
        } else {
            *main = Some((new_arena, new_start));
        }
        Ok(())
    }

    /// Consume the pending singleton (if any) into a standalone arena.
    /// Returns `Some((arena, start))` if there was a singleton, `None` otherwise.
    /// Registers the singleton's FieldMatcher in transition_map.
    fn take_singleton_as_arena(&self) -> Option<(StateArena, StateId)> {
        if self.singleton_match.borrow().is_none() {
            return None;
        }
        let singleton_val = self.singleton_match.borrow().clone().unwrap();
        let singleton_trans = self.singleton_transition.borrow().clone().unwrap();
        let singleton_arc = Arc::new(FieldMatcher::new());
        self.transition_map
            .borrow_mut()
            .insert(Arc::as_ptr(&singleton_arc), singleton_trans);

        let result = make_string_arena_fa(&singleton_val, singleton_arc);

        *self.singleton_match.borrow_mut() = None;
        *self.singleton_transition.borrow_mut() = None;

        Some(result)
    }

    /// Merge a new arena FA into main_arena, incorporating any pending singleton.
    ///
    /// This is the single entry point for all non-string pattern types
    /// (prefix, shellstyle, wildcard, anything-but, monocase, regexp,
    /// numeric-range, CIDR). It:
    ///   1. Consumes the singleton (if any) into an arena
    ///   2. Merges the singleton arena with the new arena
    ///   3. Merges the result into main_arena (with budget check)
    fn merge_with_singleton(
        &self,
        new_arena: StateArena,
        new_start: StateId,
    ) -> Result<(), crate::QuaminaError> {
        if let Some((singleton_arena, singleton_start)) = self.take_singleton_as_arena() {
            let (merged, merged_start) =
                merge_arena_nfas(&singleton_arena, singleton_start, &new_arena, new_start);
            self.merge_into_main_arena(merged, merged_start)
        } else {
            self.merge_into_main_arena(new_arena, new_start)
        }
    }

    /// Ensure main_arena exists, bootstrapping it from the singleton if needed.
    /// After this call, main_arena is guaranteed to be Some and singleton is cleared.
    fn ensure_main_arena_with_singleton(&self) -> Result<(), crate::QuaminaError> {
        if self.main_arena.borrow().is_some() {
            // Already exists — but if there's a pending singleton, fold it in.
            // Build a standalone arena from the singleton, then merge into main.
            if let Some((singleton_arena, singleton_start)) = self.take_singleton_as_arena() {
                self.merge_into_main_arena(singleton_arena, singleton_start)?;
            }
            return Ok(());
        }

        // No main_arena yet — create one
        if let Some((arena, start)) = self.take_singleton_as_arena() {
            self.check_budget(arena.estimated_byte_size())?;
            *self.main_arena.borrow_mut() = Some((arena, start));
        } else {
            // Create empty arena with a start state
            let mut arena = StateArena::new();
            let start = arena.alloc();
            arena.precompute_epsilon_closures();
            *self.main_arena.borrow_mut() = Some((arena, start));
        }
        Ok(())
    }

    /// Add a transition for a matcher, returns the next field matcher.
    ///
    /// String-based pattern values are wrapped in quotes before building FAs.
    /// This ensures string values (which retain quotes from the flattener) only
    /// match string patterns, not number events with identical digit content.
    pub fn add_transition(
        &self,
        matcher: &crate::json::Matcher,
    ) -> Result<Rc<MutableFieldMatcher<X>>, crate::QuaminaError> {
        use crate::json::Matcher;

        match matcher {
            // Exact values are pre-quoted for strings in json.rs value_to_string().
            // Boolean/null values remain unquoted, matching flattener output.
            Matcher::Exact(s) => self.add_string_transition(s.as_bytes()),
            Matcher::NumericExact(n) => self.add_numeric_transition(*n),
            Matcher::Prefix(s) => {
                // Prefix only needs opening quote — the FA matches prefix then
                // accepts anything after (including closing quote and VT)
                let mut quoted = Vec::with_capacity(s.len() + 1);
                quoted.push(b'"');
                quoted.extend_from_slice(s.as_bytes());
                self.add_prefix_transition(&quoted)
            }
            Matcher::Shellstyle(s) => self.add_shellstyle_transition(&quote_wrap(s.as_bytes())),
            Matcher::Wildcard(s) => self.add_wildcard_transition(&quote_wrap(s.as_bytes())),
            Matcher::AnythingBut(excluded) => {
                let excluded_bytes: Vec<Vec<u8>> =
                    excluded.iter().map(|s| quote_wrap(s.as_bytes())).collect();
                self.add_anything_but_transition(&excluded_bytes)
            }
            Matcher::AnythingButNumeric(excluded) => {
                // Mark as having numbers so values get Q-number conversion
                self.has_numbers.set(true);
                self.add_anything_but_numeric_transition(excluded)
            }
            Matcher::EqualsIgnoreCase(s) => self.add_monocase_transition(&quote_wrap(s.as_bytes())),
            Matcher::ParsedRegexp(ref tree) => self.add_regexp_transition(tree),
            Matcher::MultiCondition(ref mc) => self.add_multi_condition_transition(mc),
            Matcher::Suffix(s) => self.add_suffix_transition(s),
            Matcher::Numeric(cmp) => {
                // Numeric ranges use Q-number ordering in the automaton
                self.has_numbers.set(true);
                self.add_numeric_range_transition(cmp)
            }
            Matcher::Cidr(ref cidr) => self.add_cidr_transition(cidr),
            // Catch-all for any future matcher types
            _ => Ok(Rc::new(MutableFieldMatcher::new())),
        }
    }

    /// Add multiple string transitions.
    ///
    /// All values share the same next field matcher.
    /// Uses in-place arena insertion for O(n*L) total cost instead of O(n²).
    fn add_string_transitions_bulk(
        &self,
        values: &[&[u8]],
    ) -> Result<Rc<MutableFieldMatcher<X>>, crate::QuaminaError> {
        if values.is_empty() {
            return Ok(Rc::new(MutableFieldMatcher::new()));
        }

        // If only one value, use the normal path (singleton optimization)
        if values.len() == 1 {
            return self.add_string_transition(values[0]);
        }

        // Create a shared next state for all new values
        let next_fm = Rc::new(MutableFieldMatcher::new());
        let next_arc = Arc::new(FieldMatcher::new());
        self.transition_map
            .borrow_mut()
            .insert(Arc::as_ptr(&next_arc), next_fm.clone());

        // Ensure main_arena exists (bootstrap with first value if needed)
        self.ensure_main_arena_with_singleton()?;

        {
            let mut main = self.main_arena.borrow_mut();
            let (arena, start) = main.as_mut().unwrap();

            // Insert all values directly into the arena trie
            for val in values {
                insert_string_into_arena(arena, *start, val, next_arc.clone());
            }
            if *self.main_arena_is_nfa.borrow() {
                arena.precompute_epsilon_closures();
            }
        }
        self.check_main_arena_budget()?;

        Ok(next_fm)
    }

    fn add_string_transition(
        &self,
        val: &[u8],
    ) -> Result<Rc<MutableFieldMatcher<X>>, crate::QuaminaError> {
        // Check singleton optimization - only use if no automaton exists yet
        let singleton = self.singleton_match.borrow();
        let singleton_trans = self.singleton_transition.borrow();

        // Check if virgin state (no singleton, no main_arena, no suffix_arena)
        let is_virgin = singleton.is_none()
            && self.main_arena.borrow().is_none()
            && self.suffix_arena.borrow().is_none();

        if is_virgin {
            // Virgin state - use singleton optimization
            drop(singleton);
            drop(singleton_trans);

            let next_fm = Rc::new(MutableFieldMatcher::new());
            *self.singleton_match.borrow_mut() = Some(val.to_vec());
            *self.singleton_transition.borrow_mut() = Some(next_fm.clone());
            return Ok(next_fm);
        }

        // Check if singleton matches
        if let Some(ref existing) = *singleton {
            if existing == val {
                return Ok(singleton_trans.as_ref().unwrap().clone());
            }
        }
        drop(singleton);
        drop(singleton_trans);

        // Need to build arena-based automaton
        let next_fm = Rc::new(MutableFieldMatcher::new());
        let next_arc = Arc::new(FieldMatcher::new());
        // Register the mapping from Arc<FieldMatcher> to Rc<MutableFieldMatcher>
        self.transition_map
            .borrow_mut()
            .insert(Arc::as_ptr(&next_arc), next_fm.clone());

        // Ensure main_arena exists (bootstrap with singleton if needed)
        self.ensure_main_arena_with_singleton()?;

        // Insert directly into the arena trie — O(L) instead of O(arena_size)
        {
            let mut main = self.main_arena.borrow_mut();
            let (arena, start) = main.as_mut().unwrap();
            insert_string_into_arena(arena, *start, val, next_arc);
            if *self.main_arena_is_nfa.borrow() {
                arena.precompute_epsilon_closures();
            }
        }
        self.check_main_arena_budget()?;

        Ok(next_fm)
    }

    /// Add a numeric transition that supports Q-number matching.
    /// Builds both a string FA for the text representation and a Q-number FA.
    fn add_numeric_transition(
        &self,
        num: f64,
    ) -> Result<Rc<MutableFieldMatcher<X>>, crate::QuaminaError> {
        // Mark that this matcher has numeric patterns
        self.has_numbers.set(true);

        let val_str = num.to_string();
        let val = val_str.as_bytes();

        // Get Q-number representation
        let q_num = crate::numbits::q_num_from_f64(num);

        let next_fm = Rc::new(MutableFieldMatcher::new());
        let next_arc = Arc::new(FieldMatcher::new());
        self.transition_map
            .borrow_mut()
            .insert(Arc::as_ptr(&next_arc), next_fm.clone());

        // Ensure main_arena exists (bootstrap with singleton if needed)
        self.ensure_main_arena_with_singleton()?;

        // Insert both representations directly into the arena trie — O(L) each
        {
            let mut main = self.main_arena.borrow_mut();
            let (arena, start) = main.as_mut().unwrap();
            insert_string_into_arena(arena, *start, val, next_arc.clone());
            insert_string_into_arena(arena, *start, &q_num, next_arc);
            if *self.main_arena_is_nfa.borrow() {
                arena.precompute_epsilon_closures();
            }
        }
        self.check_main_arena_budget()?;

        Ok(next_fm)
    }

    fn add_prefix_transition(
        &self,
        prefix: &[u8],
    ) -> Result<Rc<MutableFieldMatcher<X>>, crate::QuaminaError> {
        let next_fm = Rc::new(MutableFieldMatcher::new());
        let next_arc = Arc::new(FieldMatcher::new());
        self.transition_map
            .borrow_mut()
            .insert(Arc::as_ptr(&next_arc), next_fm.clone());

        let (new_arena, new_start) = make_prefix_arena_fa(prefix, next_arc);
        self.merge_with_singleton(new_arena, new_start)?;

        Ok(next_fm)
    }

    fn add_shellstyle_transition(
        &self,
        pattern: &[u8],
    ) -> Result<Rc<MutableFieldMatcher<X>>, crate::QuaminaError> {
        let next_fm = Rc::new(MutableFieldMatcher::new());
        let next_arc = Arc::new(FieldMatcher::new());
        self.transition_map
            .borrow_mut()
            .insert(Arc::as_ptr(&next_arc), next_fm.clone());

        *self.main_arena_is_nfa.borrow_mut() = true;
        let (new_arena, new_start) = make_shellstyle_arena_fa(pattern, next_arc);
        self.merge_with_singleton(new_arena, new_start)?;

        Ok(next_fm)
    }

    /// Add a suffix pattern using a reversed DFA trie.
    ///
    /// Builds reversed bytes: `['"', reversed(suffix)]` (closing quote + reversed suffix).
    /// Inserts into a separate `suffix_arena` that is traversed backward at match time.
    /// This is O(max_suffix_len) instead of the O(value_len * NFA_states) shellstyle approach.
    fn add_suffix_transition(
        &self,
        suffix: &str,
    ) -> Result<Rc<MutableFieldMatcher<X>>, crate::QuaminaError> {
        // If there's a pending singleton, fold it into main_arena first
        // so transition_on doesn't short-circuit past suffix_arena
        if self.singleton_match.borrow().is_some() {
            if let Some((singleton_arena, singleton_start)) = self.take_singleton_as_arena() {
                self.merge_into_main_arena(singleton_arena, singleton_start)?;
            }
        }

        let next_fm = Rc::new(MutableFieldMatcher::new());
        let next_arc = Arc::new(FieldMatcher::new());
        self.transition_map
            .borrow_mut()
            .insert(Arc::as_ptr(&next_arc), next_fm.clone());

        // Build reversed suffix bytes: closing quote + reversed suffix
        let suffix_bytes = suffix.as_bytes();
        let mut reversed = Vec::with_capacity(suffix_bytes.len() + 1);
        reversed.push(b'"'); // closing JSON quote (first byte when scanning backward)
        reversed.extend(suffix_bytes.iter().rev());

        // Insert into suffix arena (separate DFA trie from main_arena)
        let mut suffix_arena = self.suffix_arena.borrow_mut();
        if let Some((ref mut arena, start)) = *suffix_arena {
            insert_suffix_into_arena(arena, start, &reversed, next_arc);
        } else {
            let (arena, start) = make_suffix_dfa(&reversed, next_arc);
            *suffix_arena = Some((arena, start));
        }

        Ok(next_fm)
    }

    fn add_wildcard_transition(
        &self,
        pattern: &[u8],
    ) -> Result<Rc<MutableFieldMatcher<X>>, crate::QuaminaError> {
        let next_fm = Rc::new(MutableFieldMatcher::new());
        let next_arc = Arc::new(FieldMatcher::new());
        self.transition_map
            .borrow_mut()
            .insert(Arc::as_ptr(&next_arc), next_fm.clone());

        *self.main_arena_is_nfa.borrow_mut() = true;
        let (new_arena, new_start) = make_wildcard_arena_fa(pattern, next_arc);
        self.merge_with_singleton(new_arena, new_start)?;

        Ok(next_fm)
    }

    fn add_anything_but_transition(
        &self,
        excluded: &[Vec<u8>],
    ) -> Result<Rc<MutableFieldMatcher<X>>, crate::QuaminaError> {
        let next_fm = Rc::new(MutableFieldMatcher::new());
        let next_arc = Arc::new(FieldMatcher::new());
        self.transition_map
            .borrow_mut()
            .insert(Arc::as_ptr(&next_arc), next_fm.clone());

        let (new_arena, new_start) = make_anything_but_arena_fa(excluded, next_arc);
        self.merge_with_singleton(new_arena, new_start)?;

        Ok(next_fm)
    }

    /// Add a numeric anything-but transition using Q-number FA.
    ///
    /// Matches any numeric value NOT in the excluded list.
    /// Values are compared using Q-number representation for proper numeric ordering.
    fn add_anything_but_numeric_transition(
        &self,
        excluded: &[f64],
    ) -> Result<Rc<MutableFieldMatcher<X>>, crate::QuaminaError> {
        let next_fm = Rc::new(MutableFieldMatcher::new());
        let next_arc = Arc::new(FieldMatcher::new());
        self.transition_map
            .borrow_mut()
            .insert(Arc::as_ptr(&next_arc), next_fm.clone());

        let excluded_q_nums: Vec<Vec<u8>> = excluded
            .iter()
            .map(|&n| crate::numbits::q_num_from_f64(n))
            .collect();

        let (new_arena, new_start) = make_anything_but_arena_fa(&excluded_q_nums, next_arc);
        self.merge_with_singleton(new_arena, new_start)?;

        Ok(next_fm)
    }

    fn add_monocase_transition(
        &self,
        val: &[u8],
    ) -> Result<Rc<MutableFieldMatcher<X>>, crate::QuaminaError> {
        let next_fm = Rc::new(MutableFieldMatcher::new());
        let next_arc = Arc::new(FieldMatcher::new());
        self.transition_map
            .borrow_mut()
            .insert(Arc::as_ptr(&next_arc), next_fm.clone());

        let (new_arena, new_start) = make_monocase_arena_fa(val, next_arc);
        self.merge_with_singleton(new_arena, new_start)?;

        Ok(next_fm)
    }

    fn add_regexp_transition(
        &self,
        tree: &crate::regexp::RegexpRoot,
    ) -> Result<Rc<MutableFieldMatcher<X>>, crate::QuaminaError> {
        let next_fm = Rc::new(MutableFieldMatcher::new());

        let (arena, start, field_matcher_arc) = make_regexp_nfa_arena(tree.clone());
        if arena.is_nondeterministic() {
            *self.main_arena_is_nfa.borrow_mut() = true;
        }

        self.transition_map
            .borrow_mut()
            .insert(Arc::as_ptr(&field_matcher_arc), next_fm.clone());

        self.merge_with_singleton(arena, start)?;

        Ok(next_fm)
    }

    /// Add a multi-condition transition for lookaround patterns.
    ///
    /// Multi-condition patterns have a primary pattern plus conditions (lookarounds):
    /// - Primary pattern is built as an arena NFA
    /// - Condition automata are built for verification during matching
    ///
    /// For lookahead: condition stores combined pattern (AB), build automaton directly.
    /// For lookbehind: condition stores B, combine with primary (A) to get BA.
    fn add_multi_condition_transition(
        &self,
        mc: &crate::json::MultiConditionPattern,
    ) -> Result<Rc<MutableFieldMatcher<X>>, crate::QuaminaError> {
        use crate::json::LookaroundCondition;

        let next_fm = Rc::new(MutableFieldMatcher::new());

        // Build primary pattern automaton (with quote transitions for field values)
        let (primary_arena, primary_start, field_matcher_arc) =
            make_regexp_nfa_arena(mc.primary.clone());

        self.transition_map
            .borrow_mut()
            .insert(Arc::as_ptr(&field_matcher_arc), next_fm.clone());

        // Build condition automata
        let mut condition_nfas = Vec::new();

        for condition in &mc.conditions {
            let (combined_pattern, is_negative) = match condition {
                LookaroundCondition::PositiveLookahead(pattern) => {
                    // Lookahead already stores the combined pattern (primary + lookahead)
                    (pattern.clone(), false)
                }
                LookaroundCondition::NegativeLookahead(pattern) => {
                    // Same as positive, but negative check
                    (pattern.clone(), true)
                }
                LookaroundCondition::PositiveLookbehind { pattern, .. } => {
                    // Lookbehind stores just the prefix pattern, combine with primary
                    // (?<=foo)bar: pattern="foo", primary="bar" -> combined="foobar"
                    let combined = build_lookbehind_combined_pattern(pattern, &mc.primary);
                    (combined, false)
                }
                LookaroundCondition::NegativeLookbehind { pattern, .. } => {
                    // Same as positive, but negative check
                    let combined = build_lookbehind_combined_pattern(pattern, &mc.primary);
                    (combined, true)
                }
            };

            // Build automaton for the combined pattern (with quote transitions)
            let (arena, start, _) = make_regexp_nfa_arena(combined_pattern);
            condition_nfas.push(ConditionNfa {
                arena,
                start,
                is_negative,
            });
        }

        // Check budget for the primary arena and all condition arenas
        self.check_budget(primary_arena.estimated_byte_size())?;
        for cond in &condition_nfas {
            self.check_budget(cond.arena.estimated_byte_size())?;
        }

        // Store in multi_condition_nfas for condition verification during matching
        self.multi_condition_nfas
            .borrow_mut()
            .push(MultiConditionNfa {
                primary_arena,
                primary_start,
                field_matcher_ptr: Arc::as_ptr(&field_matcher_arc),
                conditions: condition_nfas,
            });

        Ok(next_fm)
    }

    /// Add a numeric range transition using arena-based FA for better performance.
    ///
    /// For two-sided ranges (e.g., >= 5, < 100), we build a combined arena FA.
    /// For single-sided ranges (e.g., < 100), we build the relevant arena FA.
    /// Multiple numeric patterns are merged into main_arena using merge_arena_nfas.
    fn add_numeric_range_transition(
        &self,
        cmp: &crate::json::NumericComparison,
    ) -> Result<Rc<MutableFieldMatcher<X>>, crate::QuaminaError> {
        let next_fm = Rc::new(MutableFieldMatcher::new());
        let next_arc = Arc::new(FieldMatcher::new());
        self.transition_map
            .borrow_mut()
            .insert(Arc::as_ptr(&next_arc), next_fm.clone());

        // Build the arena FA based on the comparison operators
        let (new_arena, new_start) = match (&cmp.lower, &cmp.upper) {
            (Some((lower_incl, lower_val)), Some((upper_incl, upper_val))) => {
                // Two-sided range: build a combined arena FA
                make_numeric_range_arena_fa(
                    *lower_val,
                    *lower_incl,
                    *upper_val,
                    *upper_incl,
                    next_arc,
                )
            }
            (Some((incl, val)), None) => {
                // Lower bound only: >= or >
                make_numeric_greater_arena_fa(*val, *incl, next_arc)
            }
            (None, Some((incl, val))) => {
                // Upper bound only: <= or <
                make_numeric_less_arena_fa(*val, *incl, next_arc)
            }
            (None, None) => {
                // No bounds specified - match any number
                // This shouldn't happen in practice
                return Ok(next_fm);
            }
        };

        self.merge_with_singleton(new_arena, new_start)?;

        Ok(next_fm)
    }

    /// Add a CIDR pattern transition using automaton-based IP matching.
    ///
    /// Builds an arena-based FA that matches IP addresses in the specified CIDR range.
    fn add_cidr_transition(
        &self,
        cidr: &crate::json::CidrPattern,
    ) -> Result<Rc<MutableFieldMatcher<X>>, crate::QuaminaError> {
        let next_fm = Rc::new(MutableFieldMatcher::new());
        let next_arc = Arc::new(FieldMatcher::new());
        self.transition_map
            .borrow_mut()
            .insert(Arc::as_ptr(&next_arc), next_fm.clone());

        *self.main_arena_is_nfa.borrow_mut() = true;
        let (new_arena, new_start) = make_cidr_arena_fa(cidr, next_arc);
        self.merge_with_singleton(new_arena, new_start)?;

        Ok(next_fm)
    }

    /// Transition on a value during matching
    pub fn transition_on(
        &self,
        value: &[u8],
        is_number: bool,
        _bufs: &mut NfaBuffers,
    ) -> Vec<Rc<MutableFieldMatcher<X>>> {
        // Singleton fast path: when no multi-condition NFAs coexist with singleton,
        // we can short-circuit without touching transition_map.
        if self.multi_condition_nfas.borrow().is_empty() {
            if let Some(ref singleton_val) = *self.singleton_match.borrow() {
                if singleton_val == value {
                    if let Some(ref trans) = *self.singleton_transition.borrow() {
                        return vec![trans.clone()];
                    }
                }
                return vec![];
            }
        }

        let transition_map = self.transition_map.borrow();
        let mut result = Vec::new();

        // Check singleton match (when multi-condition NFAs coexist with singleton,
        // we couldn't use the fast path above)
        let has_singleton = if let Some(ref singleton_val) = *self.singleton_match.borrow() {
            if singleton_val == value {
                if let Some(ref trans) = *self.singleton_transition.borrow() {
                    result.push(trans.clone());
                }
            }
            true
        } else {
            false
        };

        // Try with Q-number conversion if this matcher has numbers and value is numeric
        // Use stack-allocated QNumberStack to avoid heap allocation
        let q_num_storage: Option<crate::numbits::QNumberStack> =
            if self.has_numbers.get() && is_number {
                // Try to parse as f64 and convert to Q-number
                if let Ok(s) = std::str::from_utf8(value) {
                    if let Ok(n) = s.parse::<f64>() {
                        Some(crate::numbits::q_num_stack(n))
                    } else {
                        None
                    }
                } else {
                    None
                }
            } else {
                None
            };
        let value_to_match: &[u8] = match &q_num_storage {
            Some(q) => q.as_slice(),
            None => value,
        };

        // When singleton is active, main_arena and suffix_arena are empty — skip them.
        if !has_singleton {
            // Traverse main_arena (unified arena for all pattern types)
            if let Some((ref arena, start)) = *self.main_arena.borrow() {
                let mut arena_bufs = self.arena_bufs.borrow_mut();
                if *self.main_arena_is_nfa.borrow() {
                    traverse_arena_nfa(arena, start, value_to_match, &mut arena_bufs);
                } else {
                    arena_bufs.transitions.clear();
                    traverse_arena_dfa(arena, start, value_to_match, &mut arena_bufs.transitions);
                }

                // Map Arc<FieldMatcher> transitions to Rc<MutableFieldMatcher<X>>
                for arc_fm in &arena_bufs.transitions {
                    let ptr = Arc::as_ptr(arc_fm);
                    if let Some(mutable_fm) = transition_map.get(&ptr) {
                        result.push(mutable_fm.clone());
                    }
                }
            }

            // Traverse suffix_arena backward (right-to-left DFA for suffix patterns)
            if let Some((ref arena, start)) = *self.suffix_arena.borrow() {
                let mut arena_bufs = self.arena_bufs.borrow_mut();
                arena_bufs.transitions.clear();
                traverse_arena_dfa_backward(
                    arena,
                    start,
                    value_to_match,
                    &mut arena_bufs.transitions,
                );

                for arc_fm in &arena_bufs.transitions {
                    let ptr = Arc::as_ptr(arc_fm);
                    if let Some(mutable_fm) = transition_map.get(&ptr) {
                        result.push(mutable_fm.clone());
                    }
                }
            }
        }

        // Traverse multi-condition NFAs (for lookaround patterns)
        // For lookaround patterns, we check conditions directly on the full value.
        // The conditions contain the combined patterns that capture full matching semantics:
        // - PositiveLookahead("foobar"): "foobar" must match full value
        // - NegativeLookahead("foobar"): "foobar" must NOT match full value
        // - Lookbehind conditions are pre-combined with primary during build
        let multi_condition_nfas = self.multi_condition_nfas.borrow();
        if !multi_condition_nfas.is_empty() {
            let mut condition_bufs = self.arena_bufs.borrow_mut();

            for mc_nfa in multi_condition_nfas.iter() {
                // Verify all conditions against the full value
                let mut all_conditions_pass = true;

                for condition in &mc_nfa.conditions {
                    // Traverse the condition automaton on the full value
                    traverse_arena_nfa(
                        &condition.arena,
                        condition.start,
                        value_to_match,
                        &mut condition_bufs,
                    );

                    let condition_matched = !condition_bufs.transitions.is_empty();

                    // Check if condition passes:
                    // - Positive condition: must match
                    // - Negative condition: must NOT match
                    let condition_passes = if condition.is_negative {
                        !condition_matched
                    } else {
                        condition_matched
                    };

                    if !condition_passes {
                        all_conditions_pass = false;
                        break; // Fast-fail: one condition failed, no need to check others
                    }
                }

                // Only add transitions if all conditions pass
                if all_conditions_pass {
                    let ptr = mc_nfa.field_matcher_ptr;
                    if let Some(mutable_fm) = transition_map.get(&ptr) {
                        // Avoid duplicates
                        if !result.iter().any(|r| Rc::ptr_eq(r, mutable_fm)) {
                            result.push(mutable_fm.clone());
                        }
                    }
                }
            }
        }

        result
    }
}

/// An event field for matching (simplified version of json::Field)
#[derive(Clone, Debug)]
pub struct EventField {
    pub path: String,
    pub value: String,
    pub array_trail: Vec<crate::json::ArrayPos>,
    /// True if the value is a JSON number (for Q-number conversion during matching)
    pub is_number: bool,
}

impl From<&crate::json::Field> for EventField {
    fn from(f: &crate::json::Field) -> Self {
        Self {
            path: f.path.clone(),
            value: f.value.clone(),
            array_trail: f.array_trail.clone(),
            is_number: f.is_number,
        }
    }
}

/// Zero-copy event field for matching.
/// Borrows path and value bytes directly from the flattened fields.
#[derive(Clone, Debug)]
pub struct EventFieldRef<'a> {
    /// Path as a string slice (converted from bytes)
    pub path: &'a str,
    /// Value as raw bytes
    pub value: &'a [u8],
    /// Array position tracking (borrowed slice)
    pub array_trail: &'a [crate::flatten_json::ArrayPos],
    /// True if the value is a JSON number
    pub is_number: bool,
}

/// Check if two array trails have no conflicts (using flatten_json::ArrayPos)
fn no_array_trail_conflict_ref(
    from: &[crate::flatten_json::ArrayPos],
    to: &[crate::flatten_json::ArrayPos],
) -> bool {
    for from_pos in from {
        for to_pos in to {
            if from_pos.array == to_pos.array && from_pos.pos != to_pos.pos {
                return false;
            }
        }
    }
    true
}

/// Check if two array trails have no conflicts
fn no_array_trail_conflict(from: &[crate::json::ArrayPos], to: &[crate::json::ArrayPos]) -> bool {
    for from_pos in from {
        for to_pos in to {
            if from_pos.array == to_pos.array && from_pos.pos != to_pos.pos {
                return false;
            }
        }
    }
    true
}

/// A set of matches (deduplicated)
struct MatchSet<X: Clone + Eq + std::hash::Hash> {
    seen: HashSet<X>,
    matches: Vec<X>,
}

impl<X: Clone + Eq + std::hash::Hash> MatchSet<X> {
    fn new() -> Self {
        Self {
            seen: HashSet::new(),
            matches: Vec::new(),
        }
    }

    fn add(&mut self, x: X) {
        if self.seen.insert(x.clone()) {
            self.matches.push(x);
        }
    }

    fn into_vec(self) -> Vec<X> {
        self.matches
    }
}

/// Core matcher that uses automaton-based matching for multiple fields.
///
/// This implements the Go quamina matching algorithm:
/// 1. Patterns are added by building a graph of FieldMatcher -> MutableValueMatcher -> FieldMatcher
/// 2. Event fields are sorted and matched against the automaton
/// 3. Matching recursively tries subsequent fields to find complete pattern matches
#[derive(Default)]
pub struct CoreMatcher<X: Clone + Eq + std::hash::Hash> {
    /// Root field matcher - the start state of the automaton
    root: Rc<MutableFieldMatcher<X>>,
    /// Arena byte budget for pattern complexity limiting
    arena_byte_budget: usize,
}

impl<X: Clone + Eq + std::hash::Hash> CoreMatcher<X> {
    /// Create a new CoreMatcher with default arena budget (10 MB).
    pub fn new() -> Self {
        Self {
            root: Rc::new(MutableFieldMatcher::new()),
            arena_byte_budget: crate::PatternLimits::default().arena_byte_budget,
        }
    }

    /// Add a pattern with the given identifier.
    ///
    /// The pattern_fields should be a list of (path, matchers) tuples.
    /// Fields are automatically sorted by path for matching.
    pub fn add_pattern(
        &self,
        x: X,
        pattern_fields: &[(String, Vec<crate::json::Matcher>)],
    ) -> Result<(), crate::QuaminaError> {
        // Sort fields lexically by path (like Go)
        let mut sorted_fields: Vec<_> = pattern_fields.to_vec();
        sorted_fields.sort_by(|a, b| a.0.cmp(&b.0));

        // Start with the root state
        let mut states: Vec<Rc<MutableFieldMatcher<X>>> = vec![self.root.clone()];

        for (path, matchers) in &sorted_fields {
            if matchers.is_empty() {
                continue;
            }

            let mut next_states = Vec::new();

            for state in &states {
                // Check for exists patterns
                let first_matcher = &matchers[0];
                match first_matcher {
                    crate::json::Matcher::Exists(true) => {
                        let next = state.add_exists(true, path);
                        next_states.push(next);
                    }
                    crate::json::Matcher::Exists(false) => {
                        let next = state.add_exists(false, path);
                        next_states.push(next);
                    }
                    _ => {
                        // Value matcher transition
                        let nexts = state.add_transition(path, matchers, self.arena_byte_budget)?;
                        next_states.extend(nexts);
                    }
                }
            }

            states = next_states;
        }

        // Mark terminal states with the pattern identifier
        for state in states {
            state.add_match(x.clone());
        }
        Ok(())
    }

    /// Match fields against patterns and return matching pattern identifiers.
    ///
    /// Fields should already be sorted by path.
    pub fn matches_for_fields(&self, fields: &[EventField]) -> Vec<X> {
        if fields.is_empty() {
            // Still need to check exists:false patterns
            return self.collect_exists_false_matches(&self.root);
        }

        let mut matches = MatchSet::new();
        let mut bufs = NfaBuffers::new();

        // For each field, try to match from the start state
        for i in 0..fields.len() {
            self.try_to_match(fields, i, &self.root, &mut matches, &mut bufs);
        }

        matches.into_vec()
    }

    /// Recursively try to match fields starting from the given index and state
    fn try_to_match(
        &self,
        fields: &[EventField],
        index: usize,
        state: &Rc<MutableFieldMatcher<X>>,
        matches: &mut MatchSet<X>,
        bufs: &mut NfaBuffers,
    ) {
        let field = &fields[index];

        // Check exists:true transition
        if let Some(exists_trans) = state.exists_true.borrow().get(&field.path) {
            // Add matches from this state
            for m in exists_trans.matches.borrow().iter() {
                matches.add(m.clone());
            }
            // Try subsequent fields
            for next_idx in (index + 1)..fields.len() {
                if no_array_trail_conflict(&field.array_trail, &fields[next_idx].array_trail) {
                    self.try_to_match(fields, next_idx, exists_trans, matches, bufs);
                }
            }
            // Check exists:false at end
            self.check_exists_false(state, fields, index, matches, bufs);
        }

        // Check exists:false (field doesn't exist)
        self.check_exists_false(state, fields, index, matches, bufs);

        // Try value transitions
        let next_states =
            state.transition_on(&field.path, field.value.as_bytes(), field.is_number, bufs);

        for next_state in next_states {
            // Add matches from next state
            for m in next_state.matches.borrow().iter() {
                matches.add(m.clone());
            }

            // Try subsequent fields
            for next_idx in (index + 1)..fields.len() {
                if no_array_trail_conflict(&field.array_trail, &fields[next_idx].array_trail) {
                    self.try_to_match(fields, next_idx, &next_state, matches, bufs);
                }
            }

            // Check exists:false at end
            self.check_exists_false(&next_state, fields, index, matches, bufs);
        }
    }

    /// Check exists:false patterns - field must NOT exist
    fn check_exists_false(
        &self,
        state: &Rc<MutableFieldMatcher<X>>,
        fields: &[EventField],
        index: usize,
        matches: &mut MatchSet<X>,
        bufs: &mut NfaBuffers,
    ) {
        for (path, exists_trans) in state.exists_false.borrow().iter() {
            // Check if this path exists in the fields
            let field_exists = fields.iter().any(|f| &f.path == path);

            if !field_exists {
                // Field doesn't exist - exists:false matches
                for m in exists_trans.matches.borrow().iter() {
                    matches.add(m.clone());
                }
                // Continue matching from this state
                self.try_to_match(fields, index, exists_trans, matches, bufs);
            }
        }
    }

    /// Collect matches from exists:false patterns when there are no fields
    fn collect_exists_false_matches(&self, state: &Rc<MutableFieldMatcher<X>>) -> Vec<X> {
        let mut result = Vec::new();
        for exists_trans in state.exists_false.borrow().values() {
            result.extend(exists_trans.matches.borrow().iter().cloned());
        }
        result
    }

    /// Match fields against patterns using zero-copy field references.
    ///
    /// Fields should already be sorted by path.
    /// The `bufs` parameter should be a reusable NfaBuffers instance for reduced allocations.
    pub fn matches_for_fields_ref(
        &self,
        fields: &[EventFieldRef<'_>],
        bufs: &mut NfaBuffers,
    ) -> Vec<X> {
        if fields.is_empty() {
            return self.collect_exists_false_matches(&self.root);
        }

        let mut matches = MatchSet::new();
        bufs.clear(); // Reset buffers for reuse

        for i in 0..fields.len() {
            self.try_to_match_ref(fields, i, &self.root, &mut matches, bufs);
        }

        matches.into_vec()
    }

    /// Recursively try to match fields (zero-copy version)
    fn try_to_match_ref(
        &self,
        fields: &[EventFieldRef<'_>],
        index: usize,
        state: &Rc<MutableFieldMatcher<X>>,
        matches: &mut MatchSet<X>,
        bufs: &mut NfaBuffers,
    ) {
        let field = &fields[index];

        // Check exists:true transition
        if let Some(exists_trans) = state.exists_true.borrow().get(field.path) {
            for m in exists_trans.matches.borrow().iter() {
                matches.add(m.clone());
            }
            for next_idx in (index + 1)..fields.len() {
                if no_array_trail_conflict_ref(field.array_trail, fields[next_idx].array_trail) {
                    self.try_to_match_ref(fields, next_idx, exists_trans, matches, bufs);
                }
            }
            self.check_exists_false_ref(state, fields, index, matches, bufs);
        }

        // Check exists:false
        self.check_exists_false_ref(state, fields, index, matches, bufs);

        // Try value transitions
        let next_states = state.transition_on(field.path, field.value, field.is_number, bufs);

        for next_state in next_states {
            for m in next_state.matches.borrow().iter() {
                matches.add(m.clone());
            }

            for next_idx in (index + 1)..fields.len() {
                if no_array_trail_conflict_ref(field.array_trail, fields[next_idx].array_trail) {
                    self.try_to_match_ref(fields, next_idx, &next_state, matches, bufs);
                }
            }

            self.check_exists_false_ref(&next_state, fields, index, matches, bufs);
        }
    }

    /// Check exists:false patterns (zero-copy version)
    fn check_exists_false_ref(
        &self,
        state: &Rc<MutableFieldMatcher<X>>,
        fields: &[EventFieldRef<'_>],
        index: usize,
        matches: &mut MatchSet<X>,
        bufs: &mut NfaBuffers,
    ) {
        for (path, exists_trans) in state.exists_false.borrow().iter() {
            let field_exists = fields.iter().any(|f| f.path == path);

            if !field_exists {
                for m in exists_trans.matches.borrow().iter() {
                    matches.add(m.clone());
                }
                self.try_to_match_ref(fields, index, exists_trans, matches, bufs);
            }
        }
    }

    /// Match fields against patterns using flattened fields directly.
    ///
    /// This avoids the intermediate EventFieldRef allocation by working
    /// directly with flatten_json::Field. Fields should already be sorted by path.
    pub fn matches_for_fields_direct(
        &self,
        fields: &[crate::flatten_json::Field<'_>],
        bufs: &mut NfaBuffers,
    ) -> Vec<X> {
        if fields.is_empty() {
            return self.collect_exists_false_matches(&self.root);
        }

        let mut matches = MatchSet::new();
        bufs.clear();

        for i in 0..fields.len() {
            self.try_to_match_direct(fields, i, &self.root, &mut matches, bufs);
        }

        matches.into_vec()
    }

    /// Recursively try to match fields (direct Field version)
    fn try_to_match_direct(
        &self,
        fields: &[crate::flatten_json::Field<'_>],
        index: usize,
        state: &Rc<MutableFieldMatcher<X>>,
        matches: &mut MatchSet<X>,
        bufs: &mut NfaBuffers,
    ) {
        let field = &fields[index];
        let path = field.path_str();
        let value = field.value_bytes();
        let array_trail = field.array_trail_slice();

        // Check exists:true transition
        if let Some(exists_trans) = state.exists_true.borrow().get(path) {
            for m in exists_trans.matches.borrow().iter() {
                matches.add(m.clone());
            }
            for next_idx in (index + 1)..fields.len() {
                if no_array_trail_conflict_ref(array_trail, fields[next_idx].array_trail_slice()) {
                    self.try_to_match_direct(fields, next_idx, exists_trans, matches, bufs);
                }
            }
            self.check_exists_false_direct(state, fields, index, matches, bufs);
        }

        // Check exists:false
        self.check_exists_false_direct(state, fields, index, matches, bufs);

        // Try value transitions
        let next_states = state.transition_on(path, value, field.is_number, bufs);

        for next_state in next_states {
            for m in next_state.matches.borrow().iter() {
                matches.add(m.clone());
            }

            for next_idx in (index + 1)..fields.len() {
                if no_array_trail_conflict_ref(array_trail, fields[next_idx].array_trail_slice()) {
                    self.try_to_match_direct(fields, next_idx, &next_state, matches, bufs);
                }
            }

            self.check_exists_false_direct(&next_state, fields, index, matches, bufs);
        }
    }

    /// Check exists:false patterns (direct Field version)
    fn check_exists_false_direct(
        &self,
        state: &Rc<MutableFieldMatcher<X>>,
        fields: &[crate::flatten_json::Field<'_>],
        index: usize,
        matches: &mut MatchSet<X>,
        bufs: &mut NfaBuffers,
    ) {
        for (path, exists_trans) in state.exists_false.borrow().iter() {
            let field_exists = fields.iter().any(|f| f.path_str() == path);

            if !field_exists {
                for m in exists_trans.matches.borrow().iter() {
                    matches.add(m.clone());
                }
                self.try_to_match_direct(fields, index, exists_trans, matches, bufs);
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::json::Matcher;
    use crate::regexp::parse_regexp;

    #[test]
    fn test_value_matcher_regexp_with_plus() {
        // Test that MutableValueMatcher correctly uses arena for regexp with +
        let vm: MutableValueMatcher<String> = MutableValueMatcher::new();

        // Create a regexp pattern with + quantifier
        let regexp_tree = parse_regexp("[a-z]+@example~.com").unwrap();
        let matcher = Matcher::ParsedRegexp(regexp_tree);

        let next_fm = vm.add_transition(&matcher).unwrap();

        // Verify arena was used (all patterns now use main_arena)
        assert!(
            vm.main_arena.borrow().is_some(),
            "main_arena should be set for regexp"
        );
        // Test matching
        let mut bufs = NfaBuffers::new();
        let value = qv(b"alice@example.com");
        let results = vm.transition_on(&value, false, &mut bufs);

        assert_eq!(
            results.len(),
            1,
            "Should match 'alice@example.com', got {} results",
            results.len()
        );
        assert!(
            Rc::ptr_eq(&results[0], &next_fm),
            "Should return the next field matcher"
        );

        // Test non-matching
        bufs.clear();
        let no_match_value = qv(b"alice@exampleXcom");
        let no_results = vm.transition_on(&no_match_value, false, &mut bufs);
        assert!(
            no_results.is_empty(),
            "Should not match 'alice@exampleXcom'"
        );
    }

    #[test]
    fn test_value_matcher_regexp_without_plus() {
        // Test that MutableValueMatcher uses arena for all regexp patterns
        let vm: MutableValueMatcher<String> = MutableValueMatcher::new();

        // Create a regexp pattern without + or * quantifier
        let regexp_tree = parse_regexp("[abc]").unwrap();
        let matcher = Matcher::ParsedRegexp(regexp_tree);

        let next_fm = vm.add_transition(&matcher).unwrap();

        // Verify arena was used (all patterns now use main_arena)
        assert!(
            vm.main_arena.borrow().is_some(),
            "main_arena should be set for regexp"
        );
        // Test matching
        let mut bufs = NfaBuffers::new();
        let value = qv(b"a");
        let results = vm.transition_on(&value, false, &mut bufs);

        assert_eq!(results.len(), 1, "Should match 'a'");
        assert!(
            Rc::ptr_eq(&results[0], &next_fm),
            "Should return the next field matcher"
        );
    }

    #[test]
    fn test_core_matcher_with_arena_regexp() {
        // Test the full CoreMatcher path with a regexp pattern using arena
        let cm: CoreMatcher<String> = CoreMatcher::new();

        // Parse the pattern like Quamina would
        let pattern_json = r#"{"email": [{"regex": "[a-z]+@example~.com"}]}"#;
        let pattern =
            crate::json::parse_pattern(pattern_json, &crate::PatternLimits::default()).unwrap();
        let pattern_vec: Vec<_> = pattern.into_iter().collect();

        cm.add_pattern("p1".to_string(), &pattern_vec).unwrap();

        // Create a field like the flattener would (strings retain JSON quotes)
        let fields = vec![EventField {
            path: "email".to_string(),
            value: "\"alice@example.com\"".to_string(),
            array_trail: vec![],
            is_number: false,
        }];

        let matches = cm.matches_for_fields(&fields);
        assert_eq!(matches, vec!["p1".to_string()], "Should match the pattern");

        // Test non-match
        let fields_no_match = vec![EventField {
            path: "email".to_string(),
            value: "\"alice@exampleXcom\"".to_string(),
            array_trail: vec![],
            is_number: false,
        }];

        let no_matches = cm.matches_for_fields(&fields_no_match);
        assert!(no_matches.is_empty(), "Should not match");
    }

    #[test]
    fn test_core_matcher_direct_with_arena_regexp() {
        // Test matches_for_fields_direct specifically (the path used by Quamina::matches_for_event)
        use std::sync::Arc;

        let cm: CoreMatcher<String> = CoreMatcher::new();

        // Parse the pattern like Quamina would
        let pattern_json = r#"{"email": [{"regex": "[a-z]+@example~.com"}]}"#;
        let pattern =
            crate::json::parse_pattern(pattern_json, &crate::PatternLimits::default()).unwrap();
        let pattern_vec: Vec<_> = pattern.into_iter().collect();

        cm.add_pattern("p1".to_string(), &pattern_vec).unwrap();

        // Create fields like matches_for_fields_direct expects (strings retain JSON quotes)
        let fields = vec![crate::flatten_json::Field {
            path: Arc::from(b"email".as_slice()),
            val: crate::flatten_json::FieldValue::Borrowed(b"\"alice@example.com\""),
            array_trail: [].as_slice().into(),
            is_number: false,
        }];

        let mut bufs = NfaBuffers::new();
        let matches = cm.matches_for_fields_direct(&fields, &mut bufs);
        assert_eq!(
            matches,
            vec!["p1".to_string()],
            "Should match the pattern via matches_for_fields_direct"
        );
    }

    /// Helper: wrap a byte slice in quotes to simulate flattener output for strings.
    /// The flattener preserves JSON quotes on string values, so test values
    /// passed to `transition_on` must include them.
    fn qv(s: &[u8]) -> Vec<u8> {
        let mut v = Vec::with_capacity(s.len() + 2);
        v.push(b'"');
        v.extend_from_slice(s);
        v.push(b'"');
        v
    }

    // =========================================================================
    // Integration tests for Arena-Only Migration (Step 2.3)
    // These tests verify behavior that must remain unchanged after migration
    // =========================================================================

    #[test]
    fn test_arena_migration_string_single() {
        // Test single exact string match
        let vm: MutableValueMatcher<String> = MutableValueMatcher::new();
        // Matcher::Exact for strings contains quoted value (like json.rs value_to_string produces)
        let matcher = Matcher::Exact("\"hello\"".to_string());
        let next_fm = vm.add_transition(&matcher).unwrap();

        let mut bufs = NfaBuffers::new();

        // Should match (quoted, like flattener output for strings)
        let results = vm.transition_on(&qv(b"hello"), false, &mut bufs);
        assert_eq!(results.len(), 1);
        assert!(Rc::ptr_eq(&results[0], &next_fm));

        // Should not match
        bufs.clear();
        let results = vm.transition_on(&qv(b"world"), false, &mut bufs);
        assert!(results.is_empty());
    }

    #[test]
    fn test_arena_migration_string_multiple() {
        // Test multiple exact string matches
        let vm: MutableValueMatcher<String> = MutableValueMatcher::new();

        // Matcher::Exact for strings contains quoted values (like json.rs value_to_string produces)
        let fm1 = vm
            .add_transition(&Matcher::Exact("\"foo\"".to_string()))
            .unwrap();
        let fm2 = vm
            .add_transition(&Matcher::Exact("\"bar\"".to_string()))
            .unwrap();
        let fm3 = vm
            .add_transition(&Matcher::Exact("\"baz\"".to_string()))
            .unwrap();

        let mut bufs = NfaBuffers::new();

        // Each should match (quoted)
        let results = vm.transition_on(&qv(b"foo"), false, &mut bufs);
        assert_eq!(results.len(), 1);
        assert!(Rc::ptr_eq(&results[0], &fm1));

        bufs.clear();
        let results = vm.transition_on(&qv(b"bar"), false, &mut bufs);
        assert_eq!(results.len(), 1);
        assert!(Rc::ptr_eq(&results[0], &fm2));

        bufs.clear();
        let results = vm.transition_on(&qv(b"baz"), false, &mut bufs);
        assert_eq!(results.len(), 1);
        assert!(Rc::ptr_eq(&results[0], &fm3));

        // None should match
        bufs.clear();
        let results = vm.transition_on(&qv(b"qux"), false, &mut bufs);
        assert!(results.is_empty());
    }

    #[test]
    fn test_arena_migration_prefix() {
        // Test prefix pattern
        let vm: MutableValueMatcher<String> = MutableValueMatcher::new();
        let matcher = Matcher::Prefix("hello".to_string());
        let next_fm = vm.add_transition(&matcher).unwrap();

        let mut bufs = NfaBuffers::new();

        // Should match any string starting with "hello" (quoted)
        let results = vm.transition_on(&qv(b"hello"), false, &mut bufs);
        assert_eq!(results.len(), 1);
        assert!(Rc::ptr_eq(&results[0], &next_fm));

        bufs.clear();
        let results = vm.transition_on(&qv(b"helloworld"), false, &mut bufs);
        assert_eq!(results.len(), 1);

        bufs.clear();
        let results = vm.transition_on(&qv(b"hello123"), false, &mut bufs);
        assert_eq!(results.len(), 1);

        // Should not match
        bufs.clear();
        let results = vm.transition_on(&qv(b"hell"), false, &mut bufs);
        assert!(results.is_empty());

        bufs.clear();
        let results = vm.transition_on(&qv(b"world"), false, &mut bufs);
        assert!(results.is_empty());
    }

    #[test]
    fn test_arena_migration_shellstyle() {
        // Test shellstyle wildcard pattern
        let vm: MutableValueMatcher<String> = MutableValueMatcher::new();
        let matcher = Matcher::Shellstyle("hello*world".to_string());
        let next_fm = vm.add_transition(&matcher).unwrap();

        let mut bufs = NfaBuffers::new();

        // Should match (quoted)
        let results = vm.transition_on(&qv(b"helloworld"), false, &mut bufs);
        assert_eq!(results.len(), 1);
        assert!(Rc::ptr_eq(&results[0], &next_fm));

        bufs.clear();
        let results = vm.transition_on(&qv(b"hello_world"), false, &mut bufs);
        assert_eq!(results.len(), 1);

        bufs.clear();
        let results = vm.transition_on(&qv(b"hello123world"), false, &mut bufs);
        assert_eq!(results.len(), 1);

        // Should not match
        bufs.clear();
        let results = vm.transition_on(&qv(b"helloworl"), false, &mut bufs);
        assert!(results.is_empty());

        bufs.clear();
        let results = vm.transition_on(&qv(b"worldhello"), false, &mut bufs);
        assert!(results.is_empty());
    }

    #[test]
    fn test_arena_migration_wildcard_escape() {
        // Test wildcard with escape sequences
        let vm: MutableValueMatcher<String> = MutableValueMatcher::new();
        // Pattern "foo\\*bar" should match literal "foo*bar"
        let matcher = Matcher::Wildcard("foo\\*bar".to_string());
        let next_fm = vm.add_transition(&matcher).unwrap();

        let mut bufs = NfaBuffers::new();

        // Should match literal * (quoted)
        let results = vm.transition_on(&qv(b"foo*bar"), false, &mut bufs);
        assert_eq!(results.len(), 1);
        assert!(Rc::ptr_eq(&results[0], &next_fm));

        // Should not match without *
        bufs.clear();
        let results = vm.transition_on(&qv(b"foobar"), false, &mut bufs);
        assert!(results.is_empty());
    }

    #[test]
    fn test_arena_migration_anything_but() {
        // Test anything-but pattern
        let vm: MutableValueMatcher<String> = MutableValueMatcher::new();
        let matcher = Matcher::AnythingBut(vec!["foo".to_string(), "bar".to_string()]);
        let next_fm = vm.add_transition(&matcher).unwrap();

        let mut bufs = NfaBuffers::new();

        // Should match anything except foo and bar (quoted)
        let results = vm.transition_on(&qv(b"baz"), false, &mut bufs);
        assert_eq!(results.len(), 1);
        assert!(Rc::ptr_eq(&results[0], &next_fm));

        bufs.clear();
        let results = vm.transition_on(&qv(b"qux"), false, &mut bufs);
        assert_eq!(results.len(), 1);

        // Should not match excluded values
        bufs.clear();
        let results = vm.transition_on(&qv(b"foo"), false, &mut bufs);
        assert!(results.is_empty());

        bufs.clear();
        let results = vm.transition_on(&qv(b"bar"), false, &mut bufs);
        assert!(results.is_empty());
    }

    #[test]
    fn test_arena_migration_monocase() {
        // Test case-insensitive matching
        let vm: MutableValueMatcher<String> = MutableValueMatcher::new();
        let matcher = Matcher::EqualsIgnoreCase("Hello".to_string());
        let next_fm = vm.add_transition(&matcher).unwrap();

        let mut bufs = NfaBuffers::new();

        // Should match any case combination (quoted)
        let results = vm.transition_on(&qv(b"Hello"), false, &mut bufs);
        assert_eq!(results.len(), 1);
        assert!(Rc::ptr_eq(&results[0], &next_fm));

        bufs.clear();
        let results = vm.transition_on(&qv(b"hello"), false, &mut bufs);
        assert_eq!(results.len(), 1);

        bufs.clear();
        let results = vm.transition_on(&qv(b"HELLO"), false, &mut bufs);
        assert_eq!(results.len(), 1);

        bufs.clear();
        let results = vm.transition_on(&qv(b"hElLo"), false, &mut bufs);
        assert_eq!(results.len(), 1);

        // Should not match different strings
        bufs.clear();
        let results = vm.transition_on(&qv(b"world"), false, &mut bufs);
        assert!(results.is_empty());
    }

    #[test]
    fn test_arena_migration_numeric_range() {
        use crate::json::NumericComparison;

        // Test numeric range patterns
        let vm: MutableValueMatcher<String> = MutableValueMatcher::new();

        // Match 10 <= x < 100
        let cmp = NumericComparison {
            lower: Some((true, 10.0)),   // >= 10
            upper: Some((false, 100.0)), // < 100
        };
        let matcher = Matcher::Numeric(cmp);
        let next_fm = vm.add_transition(&matcher).unwrap();

        let mut bufs = NfaBuffers::new();

        // Should match values in range (as numbers)
        let results = vm.transition_on(b"10", true, &mut bufs);
        assert_eq!(results.len(), 1);
        assert!(Rc::ptr_eq(&results[0], &next_fm));

        bufs.clear();
        let results = vm.transition_on(b"50", true, &mut bufs);
        assert_eq!(results.len(), 1);

        bufs.clear();
        let results = vm.transition_on(b"99", true, &mut bufs);
        assert_eq!(results.len(), 1);

        // Should not match values outside range
        bufs.clear();
        let results = vm.transition_on(b"9", true, &mut bufs);
        assert!(results.is_empty());

        bufs.clear();
        let results = vm.transition_on(b"100", true, &mut bufs);
        assert!(results.is_empty());
    }

    #[test]
    fn test_arena_migration_mixed_patterns() {
        // Test mixing different pattern types in same value matcher
        let vm: MutableValueMatcher<String> = MutableValueMatcher::new();

        // Add various pattern types
        // Exact values contain quotes (like json.rs value_to_string produces for strings)
        let fm_exact = vm
            .add_transition(&Matcher::Exact("\"exact\"".to_string()))
            .unwrap();
        let fm_prefix = vm
            .add_transition(&Matcher::Prefix("pre".to_string()))
            .unwrap();
        let fm_shell = vm
            .add_transition(&Matcher::Shellstyle("*wild*".to_string()))
            .unwrap();

        let mut bufs = NfaBuffers::new();

        // Test exact match (quoted like flattener output)
        let results = vm.transition_on(&qv(b"exact"), false, &mut bufs);
        assert_eq!(results.len(), 1);
        assert!(Rc::ptr_eq(&results[0], &fm_exact));

        // Test prefix match (quoted)
        bufs.clear();
        let results = vm.transition_on(&qv(b"prefix_value"), false, &mut bufs);
        assert_eq!(results.len(), 1);
        assert!(Rc::ptr_eq(&results[0], &fm_prefix));

        // Test shellstyle match (quoted)
        bufs.clear();
        let results = vm.transition_on(&qv(b"something_wild_here"), false, &mut bufs);
        assert_eq!(results.len(), 1);
        assert!(Rc::ptr_eq(&results[0], &fm_shell));

        // Test value matching multiple patterns (quoted)
        bufs.clear();
        let results = vm.transition_on(&qv(b"prewild"), false, &mut bufs);
        // Should match both prefix and shellstyle
        assert!(!results.is_empty());
    }

    // MIRI SKIP RATIONALE: CIDR /24 pattern construction + 4 IP traversals takes ~46s under
    // Miri. Coverage: test_cidr_arena_fa_ipv4_exact and test_cidr_arena_fa_ipv4_range
    // exercise the same arena CIDR construction/matching at the arena level.
    #[test]
    #[cfg_attr(miri, ignore)]
    fn test_arena_migration_cidr_v4() {
        use crate::json::CidrPattern;

        // Test IPv4 CIDR pattern
        let vm: MutableValueMatcher<String> = MutableValueMatcher::new();
        let cidr = CidrPattern::V4 {
            network: [192, 168, 1, 0],
            prefix_len: 24,
        };
        let matcher = Matcher::Cidr(cidr);
        let next_fm = vm.add_transition(&matcher).unwrap();

        let mut bufs = NfaBuffers::new();

        // Should match IPs in the /24 range (quoted, like flattener output for strings)
        let results = vm.transition_on(&qv(b"192.168.1.1"), false, &mut bufs);
        assert_eq!(results.len(), 1);
        assert!(Rc::ptr_eq(&results[0], &next_fm));

        bufs.clear();
        let results = vm.transition_on(&qv(b"192.168.1.255"), false, &mut bufs);
        assert_eq!(results.len(), 1);

        // Should not match IPs outside the range
        bufs.clear();
        let results = vm.transition_on(&qv(b"192.168.2.1"), false, &mut bufs);
        assert!(results.is_empty());

        bufs.clear();
        let results = vm.transition_on(&qv(b"10.0.0.1"), false, &mut bufs);
        assert!(results.is_empty());
    }

    #[test]
    fn test_arena_migration_core_matcher_all_types() {
        // End-to-end test with CoreMatcher using various pattern types
        let cm: CoreMatcher<String> = CoreMatcher::new();

        // Add patterns of different types
        // Matcher::Exact for strings contains quoted values (like json.rs value_to_string produces)
        cm.add_pattern(
            "exact".to_string(),
            &[(
                "field".to_string(),
                vec![Matcher::Exact("\"hello\"".to_string())],
            )],
        )
        .unwrap();
        cm.add_pattern(
            "prefix".to_string(),
            &[(
                "field".to_string(),
                vec![Matcher::Prefix("pre".to_string())],
            )],
        )
        .unwrap();
        cm.add_pattern(
            "shell".to_string(),
            &[(
                "field".to_string(),
                vec![Matcher::Shellstyle("*wild*".to_string())],
            )],
        )
        .unwrap();

        // Test exact match (string values include quotes like flattener output)
        let fields = vec![EventField {
            path: "field".to_string(),
            value: "\"hello\"".to_string(),
            array_trail: vec![],
            is_number: false,
        }];
        let matches = cm.matches_for_fields(&fields);
        assert!(matches.contains(&"exact".to_string()));

        // Test prefix match
        let fields = vec![EventField {
            path: "field".to_string(),
            value: "\"prefix_value\"".to_string(),
            array_trail: vec![],
            is_number: false,
        }];
        let matches = cm.matches_for_fields(&fields);
        assert!(matches.contains(&"prefix".to_string()));

        // Test shellstyle match
        let fields = vec![EventField {
            path: "field".to_string(),
            value: "\"something_wild_here\"".to_string(),
            array_trail: vec![],
            is_number: false,
        }];
        let matches = cm.matches_for_fields(&fields);
        assert!(matches.contains(&"shell".to_string()));
    }
}