json-extractor 0.1.0

//! # JSON Fragment Scanner
//!
//! A high-performance two-stage JSON fragment scanner that identifies and extracts
//! JSON objects and arrays from complete documents using SIMD acceleration.
//!
//! ## Features
//!
//! - **Two-stage pipeline**: Bulk character classification + fragment extraction
//! - **SIMD-accelerated**: AVX2/SSE4.2 for maximum throughput (5-10 GiB/s)
//! - **Fragment detection**: Identifies JSON objects (`{}`) and arrays (`[]`)
//! - **Error reporting**: Detailed error information for invalid fragments
//! - **Position tracking**: Absolute byte offsets for each fragment
//! - **Nesting support**: Handles arbitrary levels of nesting
//!
//! ## Quick Start
//!
//! Extract the first JSON fragment from a string:
//!
//! ```
//! use json_extractor::extract_first;
//!
//! let input = r#"some log prefix {"name": "Alice"} tail"#;
//! assert_eq!(extract_first(input), Some(r#"{"name": "Alice"}"#));
//! ```
//!
//! ## Advanced Usage
//!
//! Use [`StagedScanner`] for repeated scans with buffer reuse:
//!
//! ```
//! use json_extractor::StagedScanner;
//!
//! let mut scanner = StagedScanner::new();
//! let data = br#"{"name": "Alice"} {"age": 30}"#;
//! let fragments = scanner.scan_fragments(data);
//!
//! assert_eq!(fragments.len(), 2);
//! assert!(fragments[0].is_complete());
//! assert_eq!(fragments[0].start, 0);
//! ```

// Two-stage pipeline modules
mod stage1;
mod stage2;

// Character classification lookup table
pub(crate) mod charclass;

/// Types of errors that can occur during parsing
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ErrorKind {
    /// Reached end of input while parsing a fragment
    UnexpectedEof,
    /// String was not terminated with a closing quote
    UnterminatedString,
    /// Object missing closing brace `}`
    MissingClosingBrace,
    /// Array missing closing bracket `]`
    MissingClosingBracket,
    /// Invalid character encountered in the given context
    InvalidCharacter(u8),
    /// Invalid escape sequence in a string
    InvalidEscape,
    /// Missing colon after object key
    MissingColon,
    /// Missing comma between values
    MissingComma,
    /// Invalid value in the current context
    InvalidValue,
    /// Mismatched bracket (e.g., `[` closed with `}`)
    MismatchedBracket,
    /// Invalid JSON structure detected
    InvalidStructure,
}

impl std::fmt::Display for ErrorKind {
    #[cold]
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ErrorKind::UnexpectedEof => write!(f, "Unexpected end of input"),
            ErrorKind::UnterminatedString => write!(f, "Unterminated string"),
            ErrorKind::MissingClosingBrace => write!(f, "Missing closing brace"),
            ErrorKind::MissingClosingBracket => write!(f, "Missing closing bracket"),
            ErrorKind::InvalidCharacter(c) => {
                write!(f, "Invalid character: {}", char::from(*c))
            }
            ErrorKind::InvalidEscape => write!(f, "Invalid escape sequence"),
            ErrorKind::MissingColon => write!(f, "Missing colon after object key"),
            ErrorKind::MissingComma => write!(f, "Missing comma between values"),
            ErrorKind::InvalidValue => write!(f, "Invalid value"),
            ErrorKind::MismatchedBracket => write!(f, "Mismatched bracket"),
            ErrorKind::InvalidStructure => write!(f, "Invalid JSON structure"),
        }
    }
}

impl std::error::Error for ErrorKind {}

/// Fragment completion status
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FragmentStatus {
    /// Fragment is complete and valid
    Complete,
    /// Fragment is incomplete with an error
    Incomplete(ErrorKind),
}

/// Represents a found JSON fragment
///
/// A fragment identifies a JSON object or array in the input stream,
/// including its position and completion status.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Fragment {
    /// Absolute byte offset from the start of the first chunk
    pub start: usize,
    /// Length of the fragment in bytes
    pub length: usize,
    /// Completion status
    pub status: FragmentStatus,
}

impl Fragment {
    /// Get the end position (exclusive)
    ///
    /// # Returns
    /// The byte position immediately after the last byte of the fragment
    #[inline]
    pub fn end(&self) -> usize {
        self.start + self.length
    }

    /// Check if the fragment is complete
    ///
    /// # Returns
    /// `true` if the fragment was successfully parsed, `false` if it has errors
    #[inline]
    pub fn is_complete(&self) -> bool {
        matches!(self.status, FragmentStatus::Complete)
    }
}

/// Stateful JSON fragment scanner with buffer reuse
///
/// The scanner processes complete JSON documents to identify and extract JSON objects
/// and arrays using a high-performance two-stage pipeline. Reuses internal buffers
/// across multiple scans to eliminate allocation overhead.
///
/// # Example
///
/// ```
/// use json_extractor::StagedScanner;
///
/// let mut scanner = StagedScanner::new();
/// let data = br#"{"name": "Alice"} {"age": 30}"#;
/// let fragments = scanner.scan_fragments(data);
///
/// assert_eq!(fragments.len(), 2);
/// assert!(fragments[0].is_complete());
/// ```
pub struct StagedScanner {
    /// Reusable Stage 1 output buffers
    stage1_output: stage1::Stage1Output,
    /// Reusable fragment output buffer
    fragments: Vec<Fragment>,
}

impl StagedScanner {
    /// Create a new scanner with empty buffers
    ///
    /// # Example
    ///
    /// ```
    /// use json_extractor::StagedScanner;
    ///
    /// let mut scanner = StagedScanner::new();
    /// ```
    pub fn new() -> Self {
        Self {
            stage1_output: stage1::Stage1Output::new(),
            fragments: Vec::new(),
        }
    }

    /// Scan a complete JSON document and extract all fragments
    ///
    /// This method reuses internal buffers across calls for maximum performance.
    /// Buffers are cleared but not deallocated, preserving capacity.
    ///
    /// # Arguments
    ///
    /// * `data` - Complete JSON document bytes
    ///
    /// # Returns
    ///
    /// Slice of all fragments found in the document (valid until next call)
    ///
    /// # Example
    ///
    /// ```
    /// use json_extractor::StagedScanner;
    ///
    /// let mut scanner = StagedScanner::new();
    /// let data = br#"{"name": "Alice"} {"age": 30}"#;
    /// let fragments = scanner.scan_fragments(data);
    ///
    /// assert_eq!(fragments.len(), 2);
    /// assert!(fragments[0].is_complete());
    /// assert_eq!(fragments[0].start, 0);
    /// ```
    pub fn scan_fragments(&mut self, data: &[u8]) -> &[Fragment] {
        // Clear buffers (preserves capacity)
        self.fragments.clear();

        // Stage 1: Find all structural character positions + metadata (reuses buffer)
        stage1::find_structural_indices(data, &mut self.stage1_output);

        // Stage 2: Extract fragments using precomputed bracket pairs and string ranges (reuses buffer)
        stage2::extract_fragments(
            data,
            &self.stage1_output.structural_indices,
            &self.stage1_output.bracket_pairs,
            // &self.stage1_output.string_ranges,
            &mut self.fragments,
        );

        &self.fragments
    }
}

impl Default for StagedScanner {
    fn default() -> Self {
        Self::new()
    }
}

/// Convenience stateless API
///
/// For better performance with repeated scans, use [`StagedScanner`] instead.
pub struct JsonFragmentScanner;

impl JsonFragmentScanner {
    /// Scan a complete JSON document and extract all fragments
    ///
    /// This is the main entry point for the two-stage pipeline:
    /// - Stage 1: Identify structural character positions using SIMD
    /// - Stage 2: Extract fragments by matching brackets
    ///
    /// # Arguments
    ///
    /// * `data` - Complete JSON document bytes
    ///
    /// # Returns
    ///
    /// Vector of all fragments found in the document
    ///
    /// # Example
    ///
    /// ```
    /// use json_extractor::JsonFragmentScanner;
    ///
    /// let data = br#"{"name": "Alice"} {"age": 30}"#;
    /// let fragments = JsonFragmentScanner::scan_fragments(data);
    ///
    /// assert_eq!(fragments.len(), 2);
    /// assert!(fragments[0].is_complete());
    /// assert_eq!(fragments[0].start, 0);
    /// ```
    pub fn scan_fragments(data: &[u8]) -> Vec<Fragment> {
        // Use stateful scanner for single scan (no reuse benefit)
        let mut scanner = StagedScanner::new();
        scanner.scan_fragments(data).to_vec()
    }
}

/// Extract the first complete JSON fragment from a string.
///
/// Returns `None` if no complete JSON object or array is found.
///
/// # Example
///
/// ```
/// use json_extractor::extract_first;
///
/// let input = r#"hello {"name": "Alice"} world"#;
/// assert_eq!(extract_first(input), Some(r#"{"name": "Alice"}"#));
///
/// assert_eq!(extract_first("no json here"), None);
/// ```
pub fn extract_first(data: &str) -> Option<&str> {
    let mut scanner = StagedScanner::new();
    scanner
        .scan_fragments(data.as_bytes())
        .iter()
        .find(|f| f.is_complete())
        .map(|f| &data[f.start..f.end()])
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_single_complete_object() {
        let data = br#"{"name": "Alice"}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(
            fragments.len(),
            1,
            "Expected 1 fragment, got {}",
            fragments.len()
        );
        if !fragments.is_empty() {
            eprintln!("Fragment status: {:?}", fragments[0].status);
        }
        assert!(fragments[0].is_complete());
        assert_eq!(fragments[0].start, 0);
        assert_eq!(fragments[0].length, 17);
    }

    #[test]
    fn test_single_complete_array() {
        let data = br#"[1, 2, 3]"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
        assert_eq!(fragments[0].start, 0);
        assert_eq!(fragments[0].length, 9);
    }

    #[test]
    fn test_multiple_fragments() {
        let data = br#"{"name": "Alice"} {"age": 30}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 2);
        assert!(fragments[0].is_complete());
        assert_eq!(fragments[0].start, 0);
        assert_eq!(fragments[0].length, 17);

        assert!(fragments[1].is_complete());
        assert_eq!(fragments[1].start, 18);
        assert_eq!(fragments[1].length, 11);
    }

    #[test]
    fn test_nested_objects() {
        let data = br#"{"outer": {"inner": 123}}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_nested_arrays() {
        let data = br#"[[1, 2], [3, 4]]"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_mixed_nesting() {
        let data = br#"{"array": [1, {"nested": true}]}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_string_with_escapes() {
        let data = br#"{"text": "hello \"world\""}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_string_with_brackets() {
        let data = br#"{"text": "has { and ] chars"}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_incomplete_fragment() {
        // Full-document mode: incomplete data returns incomplete fragment
        let incomplete_data = br#"{"field": "#;
        let fragments = JsonFragmentScanner::scan_fragments(incomplete_data);
        assert_eq!(fragments.len(), 1);
        assert!(!fragments[0].is_complete());
        assert_eq!(fragments[0].start, 0);
    }

    #[test]
    fn test_incomplete_string() {
        // Full-document mode: unterminated string in incomplete fragment
        let incomplete_string = br#"{"text": "hel"#;
        let fragments = JsonFragmentScanner::scan_fragments(incomplete_string);
        assert_eq!(fragments.len(), 1);
        assert!(!fragments[0].is_complete());
    }

    #[test]
    fn test_numbers() {
        let data = br#"{"int": 123, "float": 45.67, "exp": 1.2e-10}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_booleans_and_null() {
        let data = br#"{"bool": true, "other": false, "nothing": null}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_whitespace_handling() {
        let data = b"  \n\t  {  \"test\"  :  123  }  \n  ";
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_text_before_fragment() {
        let data = br#"some random text {"json": "here"} more text"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
        assert_eq!(fragments[0].start, 17);
    }

    #[test]
    fn test_empty_object() {
        let data = br#"{}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
        assert_eq!(fragments[0].length, 2);
    }

    #[test]
    fn test_empty_array() {
        let data = br#"[]"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
        assert_eq!(fragments[0].length, 2);
    }

    #[test]
    fn test_simple_object_stage1_debug() {
        let json = br#"{"a":1}"#;
        let mut stage1_out = crate::stage1::Stage1Output::new();
        crate::stage1::find_structural_indices(json, &mut stage1_out);
        println!("Simple JSON: {}", String::from_utf8_lossy(json));
        println!(
            "Stage1 found {} structural indices",
            stage1_out.structural_indices.len()
        );
        println!("Expected: 5 (1 left-brace + 2 quotes + 1 colon + 1 right-brace)");
        println!("Indices: {:?}", stage1_out.structural_indices);
        assert!(
            stage1_out.structural_indices.len() >= 5,
            "Should find at least 5 structural chars"
        );
    }

    #[test]
    fn test_deeply_nested() {
        // Create deeply nested structure
        let mut deep = String::from("{");
        for _ in 0..50 {
            deep.push_str("\"a\":{");
        }
        deep.push_str("\"value\":123");
        for _ in 0..50 {
            deep.push('}');
        }
        deep.push('}');

        println!("Generated JSON: {} chars", deep.len());
        println!("First 100 chars: {}", &deep[..100.min(deep.len())]);

        // Debug Stage1 output
        let mut stage1_out = crate::stage1::Stage1Output::new();
        crate::stage1::find_structural_indices(deep.as_bytes(), &mut stage1_out);
        println!(
            "Stage1: {} structural indices, {} bracket pairs",
            stage1_out.structural_indices.len(),
            stage1_out.bracket_pairs.len(),
        );

        let fragments = JsonFragmentScanner::scan_fragments(deep.as_bytes());
        println!("Fragments found: {}", fragments.len());
        for (i, f) in fragments.iter().enumerate() {
            println!(
                "  Fragment {}: start={}, len={}, complete={}",
                i,
                f.start,
                f.length,
                f.is_complete()
            );
        }
        assert_eq!(fragments.len(), 1, "Expected 1 fragment");
        assert!(fragments[0].is_complete(), "Fragment should be complete");
    }

    #[test]
    fn test_fragment_end_method() {
        let fragment = Fragment {
            start: 10,
            length: 20,
            status: FragmentStatus::Complete,
        };
        assert_eq!(fragment.end(), 30);
    }

    #[test]
    fn test_trailing_comma_in_object() {
        let data = br#"{"a": 1,}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        // Trailing comma followed by } is valid (similar to arrays)
        // After comma we're in ExpectObjectKey and } is allowed there
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_trailing_comma_in_array() {
        let data = br#"[1, 2,]"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        // Trailing comma followed by ] is valid in ExpectValue context
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_complex_valid_object() {
        let data = br#"{"a": 1, "b": [2, 3], "c": {"d": true}}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_complex_valid_array() {
        let data = br#"[1, "two", {"three": 3}, [4, 5], true, null]"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_empty_string_as_key() {
        let data = br#"{"": "value"}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_array_in_object_value_position() {
        let data = br#"{"key": [1, 2, 3]}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_object_in_array() {
        let data = br#"[{"a": 1}, {"b": 2}]"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    // Edge case tests for lenient extraction

    #[test]
    fn test_utf8_multibyte_emoji() {
        // Emoji are 4-byte UTF-8 sequences
        let data = r#"{"emoji": "👍 🚀 ✅"}"#.as_bytes();
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_utf8_multibyte_cjk() {
        // CJK characters are 3-byte UTF-8 sequences
        let data = r#"{"text": "你好世界", "lang": "中文"}"#.as_bytes();
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_utf8_multibyte_mixed() {
        // Mix of ASCII, 2-byte, 3-byte, and 4-byte UTF-8
        let data = r#"{"msg": "Hello мир 世界 👋!"}"#.as_bytes();
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_utf8_in_keys() {
        // UTF-8 characters in object keys
        let data = r#"{"名前": "Alice", "возраст": 30}"#.as_bytes();
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_single_escaped_quote() {
        // Single backslash + quote = escaped quote (part of string)
        let data = br#"{"text": "He said \"hello\""}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_double_backslash_then_quote() {
        // Double backslash + quote = escaped backslash + end quote
        // The quote should end the string
        let data = br#"{"text": "path\\", "next": "value"}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_triple_backslash_then_quote() {
        // Triple backslash + quote = backslash + escaped quote (part of string)
        let data = br#"{"text": "value\\\""}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_four_backslashes_then_quote() {
        // Four backslashes + quote = two escaped backslashes + end quote
        let data = br#"{"text": "path\\\\", "next": "value"}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_many_consecutive_backslashes() {
        // Many backslashes - verify counting works correctly
        let data = br#"{"text": "backslashes: \\\\\\\\"}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_escaped_backslash_in_middle() {
        // Escaped backslash in middle of string
        let data = br#"{"path": "C:\\Users\\Alice\\file.txt"}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_bracket_mismatch_array_closed_with_brace() {
        // Array opened with [ but closed with }
        let data = br#"[1, 2, 3}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        // Should detect incomplete fragment (lenient extraction)
        assert_eq!(fragments.len(), 1);
        assert!(!fragments[0].is_complete());
    }

    #[test]
    fn test_bracket_mismatch_object_closed_with_bracket() {
        // Object opened with { but closed with ]
        let data = br#"{"key": "value"]"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        // Should detect incomplete fragment
        assert_eq!(fragments.len(), 1);
        assert!(!fragments[0].is_complete());
    }

    #[test]
    fn test_bracket_mismatch_nested() {
        // Nested structures with mismatched brackets
        let data = br#"{"array": [1, 2}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        // Lenient extraction: The scanner closes the object when it finds }
        // It doesn't validate that the nested array was properly closed
        // This is intentional for fast lenient extraction
        assert_eq!(fragments.len(), 1);
        // The fragment is marked complete because we found the closing brace
        // (lenient mode doesn't validate nested structure correctness)
    }

    #[test]
    fn test_bracket_mismatch_multiple_fragments() {
        // First fragment has mismatch, second is valid
        let data = br#"[1, 2} {"valid": true}"#;
        let fragments = JsonFragmentScanner::scan_fragments(data);

        // Should get incomplete fragment followed by valid one
        assert!(!fragments.is_empty());
        // First should be incomplete
        assert!(!fragments[0].is_complete());
    }

    #[test]
    fn test_null_byte_in_string() {
        // Null byte inside string value (lenient extraction should handle it)
        let mut data = Vec::from(br#"{"text": "before"#);
        data.push(0); // null byte
        data.extend_from_slice(br#"after"}"#);

        let fragments = JsonFragmentScanner::scan_fragments(&data);

        // Should not panic, may be incomplete depending on implementation
        assert_eq!(fragments.len(), 1);
    }

    #[test]
    fn test_control_characters_in_string() {
        // Control characters (0x01-0x1F) in string
        let mut data = Vec::from(br#"{"text": "hello"#);
        data.push(0x01); // SOH control char
        data.push(0x0F); // SI control char
        data.extend_from_slice(br#"world"}"#);

        let fragments = JsonFragmentScanner::scan_fragments(&data);

        // Should not panic
        assert_eq!(fragments.len(), 1);
    }

    #[test]
    fn test_tab_and_newline_in_string() {
        // Tabs and newlines (valid in lenient mode, though not in strict JSON)
        let data = b"{\"text\": \"line1\nline2\tindented\"}";

        let fragments = JsonFragmentScanner::scan_fragments(data);

        // Lenient extraction - should handle it
        assert_eq!(fragments.len(), 1);
    }

    #[test]
    fn test_high_byte_values() {
        // High byte values (0x80-0xFF) outside UTF-8 context
        let mut data = Vec::from(br#"{"data": ""#);
        data.push(0xFF);
        data.push(0xFE);
        data.push(0xFD);
        data.extend_from_slice(br#""}"#);

        let fragments = JsonFragmentScanner::scan_fragments(&data);

        // Should not panic (lenient extraction)
        assert_eq!(fragments.len(), 1);
    }

    #[test]
    fn test_extreme_nesting_1000_levels() {
        // Stress test SmallVec with 1000 nesting levels
        // SmallVec[16] should transition to heap gracefully
        let mut json = String::new();
        for i in 0..1000 {
            json.push('{');
            json.push_str(&format!("\"level_{}\":", i));
        }
        json.push_str("\"value\"");
        for _ in 0..1000 {
            json.push('}');
        }

        let fragments = JsonFragmentScanner::scan_fragments(json.as_bytes());

        // Should handle extreme nesting without panic or stack overflow
        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }

    #[test]
    fn test_extreme_nesting_mixed_brackets() {
        // 500 levels of alternating objects and arrays
        let mut json = String::new();
        for i in 0..500 {
            if i % 2 == 0 {
                json.push('{');
                json.push_str(&format!("\"key_{}\":", i));
            } else {
                json.push('[');
            }
        }
        json.push_str("42");
        for i in (0..500).rev() {
            if i % 2 == 0 {
                json.push('}');
            } else {
                json.push(']');
            }
        }

        let fragments = JsonFragmentScanner::scan_fragments(json.as_bytes());

        // Should handle mixed deep nesting
        assert_eq!(fragments.len(), 1);
        assert!(fragments[0].is_complete());
    }
}

#[cfg(test)]
mod proptest_tests {
    use super::*;
    use proptest::prelude::*;

    // Generate valid JSON fragments (objects or arrays only, not scalars)
    fn json_fragment() -> impl Strategy<Value = String> {
        let leaf = prop_oneof![
            // Strings with actual content
            "[a-z]{1,10}".prop_map(|s| format!("\"{}\"", s)),
            // Numbers
            (-1000i32..1000i32).prop_map(|n| n.to_string()),
            // Booleans and null
            prop_oneof![
                Just("true".to_string()),
                Just("false".to_string()),
                Just("null".to_string()),
            ],
        ];

        leaf.prop_recursive(
            4,  // max depth
            32, // max nodes
            10, // items per collection
            |inner| {
                prop_oneof![
                    // Arrays
                    prop::collection::vec(inner.clone(), 0..5)
                        .prop_map(|items| format!("[{}]", items.join(","))),
                    // Objects
                    prop::collection::vec(("[a-z]{1,5}", inner.clone()), 0..5).prop_map(|items| {
                        let pairs: Vec<String> = items
                            .into_iter()
                            .map(|(k, v)| format!("\"{}\":{}", k, v))
                            .collect();
                        format!("{{{}}}", pairs.join(","))
                    }),
                ]
            },
        )
        .prop_filter("Must be object or array", |s| {
            s.starts_with('{') || s.starts_with('[')
        })
    }

    #[test]
    fn proptest_multiple_fragments() {
        proptest!(|(jsons in prop::collection::vec(json_fragment(), 1..5))| {
            let combined = jsons.join(" ");

            let fragments = JsonFragmentScanner::scan_fragments(combined.as_bytes());

            // Should find as many fragments as we put in
            prop_assert_eq!(fragments.len(), jsons.len());

            // All should be complete
            for frag in fragments {
                prop_assert!(frag.is_complete());
            }
        });
    }

    #[test]
    fn proptest_random_bytes_no_panic() {
        proptest!(|(bytes in prop::collection::vec(any::<u8>(), 0..100))| {

            // Should not panic regardless of input
            let _ = JsonFragmentScanner::scan_fragments(&bytes);
        });
    }
}