jarq 0.8.3

/// Result of extracting partial eval text
pub struct PartialEvalResult {
    pub eval_text: String,
    /// Byte ranges to highlight (may be discontinuous when unwrapping brackets)
    pub highlight_ranges: Vec<(usize, usize)>,
}

/// A bracket pair: opening position and closing position (byte offsets)
struct BracketPair {
    open: usize,
    close: usize,
}

/// Check if a character at the given position is preceded by an accessor context.
/// Accessor brackets follow: `.`, `]`, `)`, identifier chars, or digits.
/// Array construction brackets follow: start, `|`, `,`, `(`, `[`, or whitespace after these.
fn is_accessor_context(filter_text: &str, bracket_pos: usize) -> bool {
    // Find the last non-whitespace character before this bracket
    let before = &filter_text[..bracket_pos];
    let prev_char = before.chars().rev().find(|c| !c.is_whitespace());

    match prev_char {
        Some('.') | Some(']') | Some(')') => true,
        Some(c) if c.is_alphanumeric() || c == '_' => true,
        _ => false,
    }
}

/// Find all array construction bracket pairs in the filter.
/// Skips accessor brackets (those following `.`, `]`, `)`, or identifiers).
fn find_array_construction_brackets(filter_text: &str) -> Vec<BracketPair> {
    let mut pairs = Vec::new();
    let mut stack: Vec<(usize, bool)> = Vec::new(); // (position, is_array_construction)

    let bytes = filter_text.as_bytes();
    let mut in_string = false;
    let mut i = 0;

    while i < bytes.len() {
        let c = bytes[i];

        // Handle string escapes
        if in_string {
            if c == b'\\' && i + 1 < bytes.len() {
                i += 2; // Skip escaped character
                continue;
            }
            if c == b'"' {
                in_string = false;
            }
            i += 1;
            continue;
        }

        match c {
            b'"' => {
                in_string = true;
            }
            b'[' => {
                let is_construction = !is_accessor_context(filter_text, i);
                stack.push((i, is_construction));
            }
            b']' => {
                if let Some((open_pos, is_construction)) = stack.pop()
                    && is_construction
                {
                    pairs.push(BracketPair {
                        open: open_pos,
                        close: i,
                    });
                }
            }
            _ => {}
        }
        i += 1;
    }

    pairs
}

/// Count unclosed parens in text, respecting strings.
fn count_unclosed_parens(text: &str) -> usize {
    let mut depth = 0i32;
    let mut in_string = false;
    let bytes = text.as_bytes();
    let mut i = 0;

    while i < bytes.len() {
        let c = bytes[i];

        if in_string {
            if c == b'\\' && i + 1 < bytes.len() {
                i += 2;
                continue;
            }
            if c == b'"' {
                in_string = false;
            }
            i += 1;
            continue;
        }

        match c {
            b'"' => in_string = true,
            b'(' => depth += 1,
            b')' => depth -= 1,
            _ => {}
        }
        i += 1;
    }

    depth.max(0) as usize
}

/// Extract partial eval text, unwrapping innermost array if cursor is inside.
/// When inside an array construction like `prefix | [inner]`, we evaluate `prefix | inner`
/// so you can see the values that will be collected into the array.
/// Also auto-closes unclosed parens to make function calls valid.
pub fn extract_partial_eval_text(filter_text: &str, cursor_byte_pos: usize) -> PartialEvalResult {
    let pairs = find_array_construction_brackets(filter_text);

    // Filter to pairs where open < cursor <= close (cursor is inside)
    // We use <= close because cursor at close position is still "inside" for evaluation
    let containing: Vec<_> = pairs
        .into_iter()
        .filter(|p| p.open < cursor_byte_pos && cursor_byte_pos <= p.close)
        .collect();

    // Pick the innermost (highest open position)
    let (mut eval_text, highlight_ranges) =
        if let Some(innermost) = containing.into_iter().max_by_key(|p| p.open) {
            // Extract content inside the brackets, up to cursor
            let inner_start = innermost.open + 1;
            let inner_end = cursor_byte_pos.min(innermost.close);
            let inner_text = filter_text[inner_start..inner_end].trim();

            if inner_text.is_empty() {
                // Empty array construction, nothing useful to evaluate
                // Fall back to simple truncation
                (
                    filter_text[..cursor_byte_pos].to_string(),
                    vec![(0, cursor_byte_pos)],
                )
            } else {
                // Include prefix before the bracket + unwrapped inner content
                let prefix = &filter_text[..innermost.open];
                let eval_text = format!("{}{}", prefix, inner_text);

                // Highlight prefix (if any) and inner content separately, skipping the bracket
                let mut ranges = Vec::new();
                if innermost.open > 0 {
                    ranges.push((0, innermost.open));
                }
                ranges.push((inner_start, inner_end));

                (eval_text, ranges)
            }
        } else {
            // No containing array construction bracket, use simple truncation
            (
                filter_text[..cursor_byte_pos].to_string(),
                vec![(0, cursor_byte_pos)],
            )
        };

    // Auto-close unclosed parens to make function calls valid
    let unclosed = count_unclosed_parens(&eval_text);
    for _ in 0..unclosed {
        eval_text.push(')');
    }

    PartialEvalResult {
        eval_text,
        highlight_ranges,
    }
}

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

    /// Validate partial eval extraction at every cursor position for "[.[] | .count] | add"
    #[test]
    fn test_all_positions_array_wrapped_filter() {
        let filter = "[.[] | .count] | add";
        let expected = [
            "",                     // 0: |[.[] | .count] | add
            "[",                    // 1: [|.[] | .count] | add
            ".",                    // 2: [.|[] | .count] | add
            ".[",                   // 3: [.[|] | .count] | add
            ".[]",                  // 4: [.[]| | .count] | add
            ".[]",                  // 5: [.[] || .count] | add
            ".[] |",                // 6: [.[] || .count] | add
            ".[] |",                // 7: [.[] | |.count] | add
            ".[] | .",              // 8: [.[] | .|count] | add
            ".[] | .c",             // 9: [.[] | .c|ount] | add
            ".[] | .co",            // 10: [.[] | .co|unt] | add
            ".[] | .cou",           // 11: [.[] | .cou|nt] | add
            ".[] | .coun",          // 12: [.[] | .coun|t] | add
            ".[] | .count",         // 13: [.[] | .count|] | add
            "[.[] | .count]",       // 14: [.[] | .count]| | add
            "[.[] | .count] ",      // 15: [.[] | .count] || add
            "[.[] | .count] |",     // 16: [.[] | .count] || add
            "[.[] | .count] | ",    // 17: [.[] | .count] | |add
            "[.[] | .count] | a",   // 18: [.[] | .count] | a|dd
            "[.[] | .count] | ad",  // 19: [.[] | .count] | ad|d
            "[.[] | .count] | add", // 20: [.[] | .count] | add|
        ];

        for (pos, exp) in expected.iter().enumerate() {
            let result = extract_partial_eval_text(filter, pos);
            assert_eq!(
                result.eval_text,
                *exp,
                "pos {}: cursor at {}|{}",
                pos,
                &filter[..pos],
                &filter[pos..]
            );
        }
    }

    /// Validate partial eval extraction at every cursor position for ".foo | [.bar]"
    #[test]
    fn test_all_positions_trailing_array() {
        let filter = ".foo | [.bar]";
        let expected = [
            "",              // 0: |.foo | [.bar]
            ".",             // 1: .|foo | [.bar]
            ".f",            // 2: .f|oo | [.bar]
            ".fo",           // 3: .fo|o | [.bar]
            ".foo",          // 4: .foo| | [.bar]
            ".foo ",         // 5: .foo || [.bar]
            ".foo |",        // 6: .foo || [.bar]
            ".foo | ",       // 7: .foo | |[.bar]
            ".foo | [",      // 8: .foo | [|.bar]
            ".foo | .",      // 9: .foo | [.|bar] - prefix + inner
            ".foo | .b",     // 10: .foo | [.b|ar]
            ".foo | .ba",    // 11: .foo | [.ba|r]
            ".foo | .bar",   // 12: .foo | [.bar|]
            ".foo | [.bar]", // 13: .foo | [.bar]|
        ];

        for (pos, exp) in expected.iter().enumerate() {
            let result = extract_partial_eval_text(filter, pos);
            assert_eq!(
                result.eval_text,
                *exp,
                "pos {}: cursor at {}|{}",
                pos,
                &filter[..pos],
                &filter[pos..]
            );
        }
    }

    /// Validate partial eval extraction at every cursor position for "[[.x]]"
    #[test]
    fn test_all_positions_nested_arrays() {
        let filter = "[[.x]]";
        let expected = [
            "",       // 0: |[[.x]]
            "[",      // 1: [|[.x]]
            "[[",     // 2: [[|.x]]
            "[.",     // 3: [[.|x]] - prefix "[" + inner "."
            "[.x",    // 4: [[.x|]] - prefix "[" + inner ".x"
            "[.x]",   // 5: [[.x]|] - inside outer only, prefix "" + inner "[.x]"
            "[[.x]]", // 6: [[.x]]|
        ];

        for (pos, exp) in expected.iter().enumerate() {
            let result = extract_partial_eval_text(filter, pos);
            assert_eq!(
                result.eval_text,
                *exp,
                "pos {}: cursor at {}|{}",
                pos,
                &filter[..pos],
                &filter[pos..]
            );
        }
    }

    /// Validate the user's example: [.[].name] | [. | {name: .}]
    /// When cursor is inside the second array, we want prefix + inner content
    #[test]
    fn test_chained_array_constructions() {
        let filter = "[.[].name] | [. | {name: .}]";
        // Second array starts at position 13, ends at position 27
        // Cursor just before closing bracket (position 27)
        let result = extract_partial_eval_text(filter, 27);
        assert_eq!(result.eval_text, "[.[].name] | . | {name: .}");
    }

    /// Validate partial eval extraction at every cursor position for ".foo[0]" (accessor bracket)
    #[test]
    fn test_all_positions_accessor_bracket() {
        let filter = ".foo[0]";
        let expected = [
            "",        // 0: |.foo[0]
            ".",       // 1: .|foo[0]
            ".f",      // 2: .f|oo[0]
            ".fo",     // 3: .fo|o[0]
            ".foo",    // 4: .foo|[0]
            ".foo[",   // 5: .foo[|0]
            ".foo[0",  // 6: .foo[0|]
            ".foo[0]", // 7: .foo[0]|
        ];

        for (pos, exp) in expected.iter().enumerate() {
            let result = extract_partial_eval_text(filter, pos);
            assert_eq!(
                result.eval_text,
                *exp,
                "pos {}: cursor at {}|{}",
                pos,
                &filter[..pos],
                &filter[pos..]
            );
        }
    }

    #[test]
    fn test_array_wrapper_at_start() {
        // [.[] | .count] | add    cursor after .count  →  eval: .[] | .count
        let filter = "[.[] | .count] | add";
        // The closing ] of the outer array is at position 13
        // [.[] | .count] | add
        // 0         1
        // 0123456789012345678
        let cursor = 13; // Position of outer closing ]
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, ".[] | .count");
    }

    #[test]
    fn test_cursor_outside_array() {
        // [.[] | .count] | add    cursor after add  →  eval: [.[] | .count] | add
        let filter = "[.[] | .count] | add";
        let cursor = filter.len();
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, "[.[] | .count] | add");
    }

    #[test]
    fn test_array_construction_mid_filter() {
        // .foo | [.bar]    cursor after .bar  →  eval: .foo | .bar (prefix + inner)
        let filter = ".foo | [.bar]";
        let cursor = filter.find(']').unwrap();
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, ".foo | .bar");
    }

    #[test]
    fn test_nested_arrays_innermost() {
        // [[.x]]    cursor after .x  →  eval: [.x (prefix "[" + inner ".x")
        let filter = "[[.x]]";
        let cursor = filter.find(']').unwrap();
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, "[.x");
    }

    #[test]
    fn test_accessor_bracket_no_unwrap() {
        // .foo[0]    cursor after 0  →  no unwrap (accessor)
        let filter = ".foo[0]";
        let cursor = filter.find(']').unwrap();
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, ".foo[0");
    }

    #[test]
    fn test_dot_accessor_no_unwrap() {
        // .[0]    cursor after 0  →  no unwrap (accessor)
        let filter = ".[0]";
        let cursor = filter.find(']').unwrap();
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, ".[0");
    }

    #[test]
    fn test_empty_array_no_unwrap() {
        // []    cursor inside  →  no useful inner content
        let filter = "[]";
        let cursor = 1;
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, "[");
    }

    #[test]
    fn test_multiple_elements() {
        // [.x, .y]    cursor after .x  →  eval: .x
        let filter = "[.x, .y]";
        let cursor = filter.find(',').unwrap();
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, ".x");
    }

    #[test]
    fn test_string_with_bracket() {
        // ["[test]"]    cursor inside string shouldn't match
        let filter = "[\"[test]\"]";
        // Cursor after the string but before closing ]
        let cursor = filter.rfind(']').unwrap();
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, "\"[test]\"");
    }

    #[test]
    fn test_highlights_correct_range() {
        // Array at start - no prefix, just inner content highlighted
        let filter = "[.[] | .count] | add";
        let cursor = 13; // Position of outer closing ]
        let result = extract_partial_eval_text(filter, cursor);
        // No prefix (bracket at position 0), inner from 1 to 13
        assert_eq!(result.highlight_ranges, vec![(1, cursor)]);
    }

    #[test]
    fn test_no_array_simple_truncation() {
        let filter = ".foo | .bar";
        let cursor = 5; // After ".foo "
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, ".foo ");
        assert_eq!(result.highlight_ranges, vec![(0, 5)]);
    }

    #[test]
    fn test_highlight_skips_bracket() {
        // When inside second array, highlight should skip the opening bracket
        // Filter: [.[].name] | [. | {name: .}]
        //         0         1          2
        //         0123456789012345678901234567890
        let filter = "[.[].name] | [. | {name: .}]";
        let cursor = 27; // Just before closing ]
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, "[.[].name] | . | {name: .}");
        // Highlight: prefix 0..13 ("[.[].name] | ") and inner 14..27 (". | {name: .}")
        // Skips the bracket at position 13
        assert_eq!(result.highlight_ranges, vec![(0, 13), (14, 27)]);
    }

    #[test]
    fn test_paren_before_bracket() {
        // map([.x])    the [ after ( is array construction
        // prefix "map(" + inner ".x" = "map(.x" + auto-close = "map(.x)"
        let filter = "map([.x])";
        let cursor = filter.find(']').unwrap();
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, "map(.x)");
    }

    #[test]
    fn test_closing_paren_before_bracket() {
        // (foo)[0]    the [ after ) is an accessor
        let filter = "(foo)[0]";
        let cursor = filter.rfind(']').unwrap();
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, "(foo)[0");
    }

    #[test]
    fn test_auto_close_select_partial() {
        // select(.x > 10 and .x < 100)  cursor after "10"
        // Should evaluate: select(.x > 10)
        let filter = "select(.x > 10 and .x < 100)";
        let cursor = filter.find(" and").unwrap();
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, "select(.x > 10)");
    }

    #[test]
    fn test_auto_close_nested_functions() {
        // map(select(.x > 0))  cursor after ".x"
        // Should evaluate: map(select(.x))
        let filter = "map(select(.x > 0))";
        let cursor = filter.find(" >").unwrap();
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, "map(select(.x))");
    }

    #[test]
    fn test_auto_close_with_pipe() {
        // .items | select(.price > 100)  cursor after ".price"
        // Should evaluate: .items | select(.price)
        let filter = ".items | select(.price > 100)";
        let cursor = filter.find(" >").unwrap();
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, ".items | select(.price)");
    }

    #[test]
    fn test_no_auto_close_when_balanced() {
        // select(.x > 10)  cursor at end - parens already balanced
        let filter = "select(.x > 10)";
        let cursor = filter.len();
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, "select(.x > 10)");
    }

    #[test]
    fn test_auto_close_ignores_parens_in_strings() {
        // select(.x == "(test")  cursor after the string
        // The ( inside the string shouldn't count
        let filter = r#"select(.x == "(test")"#;
        let cursor = filter.rfind(')').unwrap();
        let result = extract_partial_eval_text(filter, cursor);
        assert_eq!(result.eval_text, r#"select(.x == "(test")"#);
    }
}