interstellar 0.2.0

//! Coverage tests for GQL compiler (src/gql/compiler.rs).
//!
//! These tests target edge cases and uncovered code paths in the compiler,
//! including:
//! - Statement compilation (compile_statement, compile_statement_with_params)
//! - UNION queries with deduplication
//! - Error cases (DDL, mutation statements passed to read compiler)
//! - WITH clauses with aggregation, ordering, limiting
//! - LET clauses with aggregates
//! - CALL clauses
//! - GROUP BY with HAVING
//! - OPTIONAL MATCH handling
//! - path() function usage
//! - Edge variable patterns

#![allow(unused_variables)]
use std::collections::HashMap;
use std::sync::Arc;

use interstellar::gql::{
    compile, compile_statement, compile_statement_with_params, compile_with_params, parse,
    parse_statement, CompileError, Parameters,
};
use interstellar::storage::Graph;
use interstellar::value::Value;

// =============================================================================
// Helper Functions
// =============================================================================

/// Creates a test graph with Person and Software vertices plus edges.
fn create_test_graph() -> Arc<Graph> {
    let graph = Arc::new(Graph::new());

    // Add Person vertices
    let alice = graph.add_vertex(
        "Person",
        HashMap::from([
            ("name".to_string(), Value::String("Alice".to_string())),
            ("age".to_string(), Value::Int(30)),
            ("city".to_string(), Value::String("NYC".to_string())),
        ]),
    );

    let bob = graph.add_vertex(
        "Person",
        HashMap::from([
            ("name".to_string(), Value::String("Bob".to_string())),
            ("age".to_string(), Value::Int(25)),
            ("city".to_string(), Value::String("LA".to_string())),
        ]),
    );

    let charlie = graph.add_vertex(
        "Person",
        HashMap::from([
            ("name".to_string(), Value::String("Charlie".to_string())),
            ("age".to_string(), Value::Int(35)),
            ("city".to_string(), Value::String("NYC".to_string())),
        ]),
    );

    let diana = graph.add_vertex(
        "Person",
        HashMap::from([
            ("name".to_string(), Value::String("Diana".to_string())),
            ("age".to_string(), Value::Int(28)),
            ("city".to_string(), Value::String("Chicago".to_string())),
        ]),
    );

    // Add Software vertices
    let gremlin = graph.add_vertex(
        "Software",
        HashMap::from([
            ("name".to_string(), Value::String("Gremlin".to_string())),
            ("lang".to_string(), Value::String("Java".to_string())),
        ]),
    );

    let rust_proj = graph.add_vertex(
        "Software",
        HashMap::from([
            (
                "name".to_string(),
                Value::String("Interstellar".to_string()),
            ),
            ("lang".to_string(), Value::String("Rust".to_string())),
        ]),
    );

    // Add edges
    graph
        .add_edge(
            alice,
            bob,
            "KNOWS",
            HashMap::from([
                ("since".to_string(), Value::Int(2020)),
                ("weight".to_string(), Value::Float(0.8)),
            ]),
        )
        .unwrap();

    graph
        .add_edge(
            alice,
            charlie,
            "KNOWS",
            HashMap::from([("since".to_string(), Value::Int(2019))]),
        )
        .unwrap();

    graph
        .add_edge(
            bob,
            charlie,
            "KNOWS",
            HashMap::from([("since".to_string(), Value::Int(2021))]),
        )
        .unwrap();

    graph
        .add_edge(
            charlie,
            diana,
            "KNOWS",
            HashMap::from([("since".to_string(), Value::Int(2018))]),
        )
        .unwrap();

    graph
        .add_edge(
            alice,
            gremlin,
            "CREATED",
            HashMap::from([("year".to_string(), Value::Int(2015))]),
        )
        .unwrap();

    graph
        .add_edge(
            bob,
            rust_proj,
            "CREATED",
            HashMap::from([("year".to_string(), Value::Int(2023))]),
        )
        .unwrap();

    graph
}

// =============================================================================
// compile_statement and compile_statement_with_params tests
// =============================================================================

#[test]
fn test_compile_statement_basic_query() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let stmt = parse_statement("MATCH (n:Person) RETURN n.name").unwrap();
    let results = compile_statement(&stmt, &snapshot).unwrap();

    assert_eq!(results.len(), 4);
}

#[test]
fn test_compile_statement_with_params() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let stmt = parse_statement("MATCH (n:Person) WHERE n.age >= $minAge RETURN n.name").unwrap();

    let mut params = Parameters::new();
    params.insert("minAge".to_string(), Value::Int(28));

    let results = compile_statement_with_params(&stmt, &snapshot, &params).unwrap();

    // Alice (30), Charlie (35), Diana (28) match
    assert_eq!(results.len(), 3);
}

#[test]
fn test_compile_statement_mutation_error() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let stmt = parse_statement("CREATE (n:Person {name: 'Eve'})").unwrap();
    let result = compile_statement(&stmt, &snapshot);

    assert!(result.is_err());
    match result.unwrap_err() {
        CompileError::UnsupportedFeature(msg) => {
            assert!(msg.contains("Mutation"));
        }
        _ => panic!("Expected UnsupportedFeature error"),
    }
}

#[test]
fn test_compile_statement_ddl_error() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let stmt = parse_statement("CREATE NODE TYPE Person (name STRING NOT NULL, age INT)").unwrap();
    let result = compile_statement(&stmt, &snapshot);

    assert!(result.is_err());
    match result.unwrap_err() {
        CompileError::UnsupportedFeature(msg) => {
            assert!(msg.contains("DDL"));
        }
        _ => panic!("Expected UnsupportedFeature error"),
    }
}

// =============================================================================
// UNION query tests
// =============================================================================

#[test]
fn test_union_query_deduplication() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    // UNION should deduplicate results
    let stmt = parse_statement(
        r#"
        MATCH (a:Person) WHERE a.city = 'NYC' RETURN a.name
        UNION
        MATCH (b:Person) WHERE b.age > 28 RETURN b.name
        "#,
    )
    .unwrap();

    let results = compile_statement(&stmt, &snapshot).unwrap();

    // NYC: Alice, Charlie
    // Age > 28: Alice (30), Charlie (35)
    // Union (deduplicated): Alice, Charlie = 2 unique names
    assert_eq!(results.len(), 2);
}

#[test]
fn test_union_all_keeps_duplicates() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    // UNION ALL should keep duplicates
    let stmt = parse_statement(
        r#"
        MATCH (a:Person) WHERE a.city = 'NYC' RETURN a.name
        UNION ALL
        MATCH (b:Person) WHERE b.age > 28 RETURN b.name
        "#,
    )
    .unwrap();

    let results = compile_statement(&stmt, &snapshot).unwrap();

    // NYC: Alice, Charlie = 2
    // Age > 28: Alice (30), Charlie (35) = 2
    // Union All: 4 total
    assert_eq!(results.len(), 4);
}

#[test]
fn test_union_with_params() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let stmt = parse_statement(
        r#"
        MATCH (a:Person) WHERE a.age >= $age1 RETURN a.name
        UNION
        MATCH (b:Person) WHERE b.city = $city RETURN b.name
        "#,
    )
    .unwrap();

    let mut params = Parameters::new();
    params.insert("age1".to_string(), Value::Int(35));
    params.insert("city".to_string(), Value::String("LA".to_string()));

    let results = compile_statement_with_params(&stmt, &snapshot, &params).unwrap();

    // Age >= 35: Charlie = 1
    // City = LA: Bob = 1
    // Union: Charlie, Bob = 2
    assert_eq!(results.len(), 2);
}

// =============================================================================
// WITH clause tests
// =============================================================================

#[test]
fn test_with_clause_simple_projection() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        WITH n.name AS name, n.age AS age
        RETURN name, age
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();
    assert_eq!(results.len(), 4);
}

#[test]
fn test_with_clause_with_aggregation() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        WITH n.city AS city, COUNT(*) AS cnt
        RETURN city, cnt
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // NYC: 2 (Alice, Charlie)
    // LA: 1 (Bob)
    // Chicago: 1 (Diana)
    assert_eq!(results.len(), 3);
}

#[test]
fn test_with_clause_distinct() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        WITH DISTINCT n.city AS city
        RETURN city
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // 3 distinct cities: NYC, LA, Chicago
    assert_eq!(results.len(), 3);
}

#[test]
fn test_with_clause_with_where() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        WITH n.name AS name, n.age AS age WHERE age >= 28
        RETURN name
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // Alice (30), Charlie (35), Diana (28) = 3
    assert_eq!(results.len(), 3);
}

#[test]
fn test_with_clause_with_order_and_limit() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        WITH n.name AS name, n.age AS age ORDER BY age DESC LIMIT 2
        RETURN name
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // Top 2 by age DESC: Charlie (35), Alice (30)
    assert_eq!(results.len(), 2);
}

#[test]
fn test_with_global_aggregation() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    // WITH only aggregates (no group-by keys) = global aggregation
    // Use COUNT(n) instead of COUNT(*) - consistent with other tests
    let query = parse(
        r#"
        MATCH (n:Person)
        WITH COUNT(n) AS total
        RETURN total
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    assert_eq!(results.len(), 1);
    assert_eq!(results[0], Value::Int(4));
}

// =============================================================================
// LET clause tests
// =============================================================================

#[test]
fn test_let_clause_simple() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        LET doubled = n.age * 2
        RETURN n.name, doubled
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();
    assert_eq!(results.len(), 4);
}

#[test]
fn test_let_clause_with_aggregate() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    // LET with aggregate computes once over all rows
    // Using SUM which is more straightforward
    let query = parse(
        r#"
        MATCH (n:Person)
        LET totalAge = SUM(n.age)
        RETURN n.name, totalAge
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // Each row should have a totalAge value
    assert_eq!(results.len(), 4);
}

// =============================================================================
// CALL clause tests
// =============================================================================

#[test]
fn test_call_clause_subquery() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (p:Person)
        CALL {
            WITH p
            MATCH (p)-[:KNOWS]->(friend:Person)
            RETURN friend.name AS friendName
        }
        RETURN p.name, friendName
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // Alice knows Bob, Charlie (2)
    // Bob knows Charlie (1)
    // Charlie knows Diana (1)
    // Total: 4 results
    assert_eq!(results.len(), 4);
}

// =============================================================================
// GROUP BY with HAVING tests
// =============================================================================

#[test]
fn test_group_by_with_having() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        RETURN n.city AS city, COUNT(*) AS cnt
        GROUP BY n.city
        HAVING COUNT(*) > 1
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // Only NYC has count > 1 (2 people)
    assert_eq!(results.len(), 1);
    if let Value::Map(map) = &results[0] {
        assert_eq!(map.get("city"), Some(&Value::String("NYC".to_string())));
    }
}

#[test]
fn test_group_by_multiple_aggregates() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        RETURN n.city AS city, COUNT(*) AS cnt, AVG(n.age) AS avgAge
        GROUP BY n.city
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();
    assert_eq!(results.len(), 3); // 3 cities
}

// =============================================================================
// OPTIONAL MATCH tests
// =============================================================================

#[test]
fn test_optional_match_basic() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (p:Person)
        OPTIONAL MATCH (p)-[:CREATED]->(s:Software)
        RETURN p.name, s.name
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // Alice -> Gremlin
    // Bob -> Interstellar
    // Charlie -> null
    // Diana -> null
    assert_eq!(results.len(), 4);
}

#[test]
fn test_optional_match_with_filter() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (p:Person)
        OPTIONAL MATCH (p)-[e:KNOWS]->(friend:Person)
        RETURN p.name, friend.name
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();
    // Should have at least one result for each person with KNOWS relation
    // Alice (2 friends), Bob (1 friend), Charlie (1 friend), Diana (0 friends)
    // Optional match means Diana will still appear with null friend
    assert!(!results.is_empty());
}

// =============================================================================
// Edge variable patterns
// =============================================================================

#[test]
fn test_edge_variable_access() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (a:Person)-[e:KNOWS]->(b:Person)
        RETURN a.name, e.since, b.name
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // 4 KNOWS edges
    assert_eq!(results.len(), 4);

    // Verify edge property access works
    for result in &results {
        if let Value::Map(map) = result {
            assert!(map.get("e.since").is_some() || map.get("since").is_some());
        }
    }
}

#[test]
fn test_edge_property_filter() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (a:Person)-[e:KNOWS]->(b:Person)
        WHERE e.since >= 2020
        RETURN a.name, e.since, b.name
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // 2020: Alice->Bob, 2021: Bob->Charlie
    assert_eq!(results.len(), 2);
}

// =============================================================================
// path() function tests
// =============================================================================

#[test]
fn test_with_path_clause() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    // Use WITH PATH syntax which should work
    let query = parse(
        r#"
        MATCH (a:Person)-[:KNOWS]->(b:Person)
        WITH PATH
        RETURN a.name, b.name
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // Should return path objects
    assert_eq!(results.len(), 4);
}

// =============================================================================
// UNWIND tests
// =============================================================================

#[test]
fn test_unwind_inline_list() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    // UNWIND comes before WHERE in the grammar
    let query = parse(
        r#"
        MATCH (n:Person)
        UNWIND [1, 2, 3] AS x
        WHERE n.name = 'Alice'
        RETURN n.name, x
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // Alice x 3 = 3 rows
    assert_eq!(results.len(), 3);
}

#[test]
fn test_unwind_property_list() {
    // Create a graph with a list property for UNWIND testing
    let graph = Arc::new(Graph::new());
    graph.add_vertex(
        "Person",
        HashMap::from([
            ("name".to_string(), Value::String("Alice".to_string())),
            (
                "hobbies".to_string(),
                Value::List(vec![
                    Value::String("reading".to_string()),
                    Value::String("gaming".to_string()),
                ]),
            ),
        ]),
    );
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        UNWIND n.hobbies AS hobby
        RETURN n.name, hobby
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // 1 person x 2 hobbies = 2 rows
    assert_eq!(results.len(), 2);
}

#[test]
fn test_unwind_null_property() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    // UNWIND a null property produces no rows - use WHERE after UNWIND
    let query = parse(
        r#"
        MATCH (n:Person)
        UNWIND n.nonexistent AS x
        WHERE n.name = 'Alice'
        RETURN n.name, x
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // UNWIND null produces no rows
    assert_eq!(results.len(), 0);
}

#[test]
fn test_unwind_non_list_property() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    // UNWIND a non-list wraps it in a single-element list
    let query = parse(
        r#"
        MATCH (n:Person)
        UNWIND n.age AS x
        WHERE n.name = 'Alice'
        RETURN n.name, x
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // UNWIND scalar wraps in single-element list = 1 row per person who matches
    assert_eq!(results.len(), 1);
}

// =============================================================================
// Aggregate function edge cases
// =============================================================================

#[test]
fn test_aggregate_sum_with_floats() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (a:Person)-[e:KNOWS]->(b:Person)
        RETURN SUM(e.weight)
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();
    assert_eq!(results.len(), 1);

    // Only Alice->Bob edge has weight = 0.8, others are null
    if let Value::Float(sum) = &results[0] {
        assert!((sum - 0.8).abs() < 0.001);
    }
}

#[test]
fn test_aggregate_distinct_count() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        RETURN COUNT(DISTINCT n.city)
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();
    assert_eq!(results.len(), 1);
    assert_eq!(results[0], Value::Int(3)); // NYC, LA, Chicago
}

#[test]
fn test_aggregate_min_max() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        RETURN MIN(n.age), MAX(n.age)
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();
    assert_eq!(results.len(), 1);
}

#[test]
fn test_aggregate_avg_empty() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:NonExistent)
        RETURN AVG(n.value)
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // AVG of empty set is null
    assert!(results.is_empty() || results[0] == Value::Null);
}

#[test]
fn test_aggregate_collect() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        WHERE n.city = 'NYC'
        RETURN COLLECT(n.name)
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();
    assert_eq!(results.len(), 1);

    if let Value::List(names) = &results[0] {
        assert_eq!(names.len(), 2); // Alice, Charlie
    }
}

// =============================================================================
// ORDER BY edge cases
// =============================================================================

#[test]
fn test_order_by_null_values() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    // Add a vertex with null age
    // Since we can't modify the graph, test with optional match that produces nulls
    let query = parse(
        r#"
        MATCH (p:Person)
        OPTIONAL MATCH (p)-[:CREATED]->(s:Software)
        RETURN p.name, s.lang
        ORDER BY s.lang
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // Should handle null values in ordering
    assert_eq!(results.len(), 4);
}

#[test]
fn test_order_by_multiple_keys() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        RETURN n.city, n.name, n.age
        ORDER BY n.city, n.age DESC
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();
    assert_eq!(results.len(), 4);
}

// =============================================================================
// Error cases
// =============================================================================

#[test]
fn test_empty_pattern_error() {
    // This should fail at parse or compile time
    let result = parse("MATCH RETURN 1");
    assert!(result.is_err());
}

#[test]
fn test_unbound_variable_error() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse("MATCH (n:Person) RETURN m.name").unwrap();
    let result = compile(&query, &snapshot);

    assert!(result.is_err());
}

// =============================================================================
// Expression evaluation edge cases
// =============================================================================

#[test]
fn test_expression_with_binary_aggregate() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    // Simple aggregate return
    let query = parse(
        r#"
        MATCH (n:Person)
        RETURN COUNT(*) AS cnt
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();
    assert_eq!(results.len(), 1);

    // Verify we got a count value
    let cnt = match &results[0] {
        Value::Int(n) => *n,
        Value::Map(map) => map.get("cnt").and_then(|v| v.as_i64()).unwrap_or(0),
        _ => 0,
    };
    assert_eq!(cnt, 4);
}

#[test]
fn test_case_expression() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        RETURN n.name, 
               CASE WHEN n.age >= 30 THEN 'Senior' ELSE 'Junior' END AS level
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();
    assert_eq!(results.len(), 4);
}

#[test]
fn test_list_membership() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        WHERE n.city IN ['NYC', 'LA']
        RETURN n.name
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // NYC: Alice, Charlie; LA: Bob
    assert_eq!(results.len(), 3);
}

#[test]
fn test_not_in_list() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        WHERE n.city NOT IN ['NYC', 'LA']
        RETURN n.name
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // Chicago: Diana
    assert_eq!(results.len(), 1);
}

// =============================================================================
// Parameter edge cases
// =============================================================================

#[test]
fn test_parameter_in_where() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        WHERE n.name = $name
        RETURN n.name
        "#,
    )
    .unwrap();

    let mut params = Parameters::new();
    params.insert("name".to_string(), Value::String("Alice".to_string()));

    let results = compile_with_params(&query, &snapshot, &params).unwrap();
    assert_eq!(results.len(), 1);
}

#[test]
fn test_multiple_parameters() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        WHERE n.age >= $minAge AND n.city = $city
        RETURN n.name
        "#,
    )
    .unwrap();

    let mut params = Parameters::new();
    params.insert("minAge".to_string(), Value::Int(25));
    params.insert("city".to_string(), Value::String("NYC".to_string()));

    let results = compile_with_params(&query, &snapshot, &params).unwrap();

    // NYC with age >= 25: Alice (30), Charlie (35)
    assert_eq!(results.len(), 2);
}

// =============================================================================
// Row-based processing edge cases
// =============================================================================

#[test]
fn test_empty_rows_with_clause() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:NonExistent)
        WITH n.name AS name
        RETURN name
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();
    assert!(results.is_empty());
}

#[test]
fn test_empty_rows_let_clause() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:NonExistent)
        LET x = n.age * 2
        RETURN n.name, x
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();
    assert!(results.is_empty());
}

// =============================================================================
// expression_to_key tests (internal function)
// =============================================================================

#[test]
fn test_with_expression_keys() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    // Test various expression types that become keys in WITH
    let query = parse(
        r#"
        MATCH (n:Person)
        WITH n.name AS name, COUNT(*) AS cnt
        RETURN name, cnt
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();
    // With name as grouping key + COUNT, we should get 4 results (one per name)
    assert_eq!(results.len(), 4);
}

// =============================================================================
// Deduplicate results tests
// =============================================================================

#[test]
fn test_return_distinct() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (n:Person)
        RETURN DISTINCT n.city
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();
    assert_eq!(results.len(), 3); // NYC, LA, Chicago
}

// =============================================================================
// Variable-length path tests
// =============================================================================

#[test]
fn test_variable_length_path() {
    let graph = create_test_graph();
    let snapshot = graph.snapshot();

    let query = parse(
        r#"
        MATCH (a:Person)-[:KNOWS*1..2]->(b:Person)
        WHERE a.name = 'Alice'
        RETURN b.name
        "#,
    )
    .unwrap();

    let results = compile(&query, &snapshot).unwrap();

    // 1 hop: Bob, Charlie
    // 2 hops: Bob->Charlie, Charlie->Diana
    // So b can be: Bob, Charlie, Charlie, Diana = possibly 4 (with possible dups)
    assert!(results.len() >= 2);
}