use super::*;

#[test]
fn test_parse_basic_query() {
    let input = r#"
query get_person($name: String) {
match {
    $p: Person { name: $name }
}
return { $p.name, $p.age }
}
"#;
    let qf = parse_query(input).unwrap();
    assert_eq!(qf.queries.len(), 1);
    let q = &qf.queries[0];
    assert_eq!(q.name, "get_person");
    assert_eq!(q.params.len(), 1);
    assert_eq!(q.params[0].name, "name");
    assert_eq!(q.match_clause.len(), 1);
    assert_eq!(q.return_clause.len(), 2);
}

#[test]
fn test_parse_query_metadata_annotations() {
    let input = r#"
query semantic_search($q: String)
@description("Find semantically similar documents.")
@instruction("Use for conceptual search; prefer keyword_search for exact terms.")
{
match {
    $d: Doc
}
return { $d.slug }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(
        q.description.as_deref(),
        Some("Find semantically similar documents.")
    );
    assert_eq!(
        q.instruction.as_deref(),
        Some("Use for conceptual search; prefer keyword_search for exact terms.")
    );
}

#[test]
fn test_duplicate_query_description_is_rejected() {
    let input = r#"
query q()
@description("one")
@description("two")
{
match {
    $p: Person
}
return { $p.name }
}
"#;
    let err = parse_query(input).unwrap_err();
    assert!(err.to_string().contains("duplicate @description"));
}

#[test]
fn test_parse_no_params() {
    let input = r#"
query adults() {
match {
    $p: Person
    $p.age > 30
}
return { $p.name, $p.age }
order { $p.age desc }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.name, "adults");
    assert!(q.params.is_empty());
    assert_eq!(q.match_clause.len(), 2);
    assert_eq!(q.order_clause.len(), 1);
    assert!(q.order_clause[0].descending);
}

#[test]
fn test_parse_traversal() {
    let input = r#"
query friends_of($name: String) {
match {
    $p: Person { name: $name }
    $p knows $f
}
return { $f.name, $f.age }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.match_clause.len(), 2);
    match &q.match_clause[1] {
        Clause::Traversal(t) => {
            assert_eq!(t.src, "p");
            assert_eq!(t.edge_name, "knows");
            assert_eq!(t.dst, "f");
            assert_eq!(t.min_hops, 1);
            assert_eq!(t.max_hops, Some(1));
        }
        _ => panic!("expected Traversal"),
    }
}

#[test]
fn test_parse_negation() {
    let input = r#"
query unemployed() {
match {
    $p: Person
    not { $p worksAt $_ }
}
return { $p.name }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.match_clause.len(), 2);
    match &q.match_clause[1] {
        Clause::Negation(clauses) => {
            assert_eq!(clauses.len(), 1);
            match &clauses[0] {
                Clause::Traversal(t) => {
                    assert_eq!(t.src, "p");
                    assert_eq!(t.edge_name, "worksAt");
                    assert_eq!(t.dst, "_");
                    assert_eq!(t.min_hops, 1);
                    assert_eq!(t.max_hops, Some(1));
                }
                _ => panic!("expected Traversal inside negation"),
            }
        }
        _ => panic!("expected Negation"),
    }
}

#[test]
fn test_parse_aggregation() {
    let input = r#"
query friend_counts() {
match {
    $p: Person
    $p knows $f
}
return {
    $p.name
    count($f) as friends
}
order { friends desc }
limit 20
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.return_clause.len(), 2);
    match &q.return_clause[1].expr {
        Expr::Aggregate { func, .. } => {
            assert_eq!(*func, AggFunc::Count);
        }
        _ => panic!("expected Aggregate"),
    }
    assert_eq!(q.return_clause[1].alias.as_deref(), Some("friends"));
    assert_eq!(q.limit, Some(20));
}

#[test]
fn test_parse_two_hop() {
    let input = r#"
query friends_of_friends($name: String) {
match {
    $p: Person { name: $name }
    $p knows $mid
    $mid knows $fof
}
return { $fof.name }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.match_clause.len(), 3);
}

#[test]
fn test_parse_reverse_traversal() {
    let input = r#"
query employees_of($company: String) {
match {
    $c: Company { name: $company }
    $p worksAt $c
}
return { $p.name }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.match_clause.len(), 2);
    match &q.match_clause[1] {
        Clause::Traversal(t) => {
            assert_eq!(t.src, "p");
            assert_eq!(t.edge_name, "worksAt");
            assert_eq!(t.dst, "c");
            assert_eq!(t.min_hops, 1);
            assert_eq!(t.max_hops, Some(1));
        }
        _ => panic!("expected Traversal"),
    }
}

#[test]
fn test_parse_bounded_traversal() {
    let input = r#"
query q() {
match {
    $a: Person
    $a knows{1,3} $b
}
return { $b.name }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    match &q.match_clause[1] {
        Clause::Traversal(t) => {
            assert_eq!(t.min_hops, 1);
            assert_eq!(t.max_hops, Some(3));
        }
        _ => panic!("expected Traversal"),
    }
}

#[test]
fn test_parse_unbounded_traversal() {
    let input = r#"
query q() {
match {
    $a: Person
    $a knows{1,} $b
}
return { $b.name }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    match &q.match_clause[1] {
        Clause::Traversal(t) => {
            assert_eq!(t.min_hops, 1);
            assert_eq!(t.max_hops, None);
        }
        _ => panic!("expected Traversal"),
    }
}

#[test]
fn test_parse_multi_query_file() {
    let input = r#"
query q1() {
match { $p: Person }
return { $p.name }
}
query q2() {
match { $c: Company }
return { $c.name }
}
"#;
    let qf = parse_query(input).unwrap();
    assert_eq!(qf.queries.len(), 2);
}

#[test]
fn test_parse_complex_negation() {
    let input = r#"
query knows_alice_not_bob() {
match {
    $a: Person { name: "Alice" }
    $b: Person { name: "Bob" }
    $p: Person
    $p knows $a
    not { $p knows $b }
}
return { $p.name }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.match_clause.len(), 5);
}

#[test]
fn test_parse_filter_string() {
    let input = r#"
query test() {
match {
    $p: Person
    $p.name != "Bob"
}
return { $p.name }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    match &q.match_clause[1] {
        Clause::Filter(f) => {
            assert_eq!(f.op, CompOp::Ne);
        }
        _ => panic!("expected Filter"),
    }
}

#[test]
fn test_parse_filter_string_decodes_escapes() {
    let input = r#"
query test() {
match {
    $p: Person
    $p.name = "Bob\n\"Builder\"\t\\"
}
return { $p.name }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    match &q.match_clause[1] {
        Clause::Filter(f) => match &f.right {
            Expr::Literal(Literal::String(value)) => {
                assert_eq!(value, "Bob\n\"Builder\"\t\\");
            }
            other => panic!("expected string literal, got {:?}", other),
        },
        _ => panic!("expected Filter"),
    }
}

#[test]
fn test_parse_string_literal_rejects_unknown_escape() {
    let input = r#"
query test() {
match {
    $p: Person
    $p.name = "Bob\q"
}
return { $p.name }
}
"#;
    let err = parse_query(input).unwrap_err();
    assert!(err.to_string().contains("unsupported escape sequence"));
}

#[test]
fn test_parse_bool_literals() {
    let input = r#"
query flags() {
match {
    $p: Person
    $p.active = true
    $p.active != false
}
return { $p.name }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    match &q.match_clause[1] {
        Clause::Filter(f) => match &f.right {
            Expr::Literal(Literal::Bool(value)) => assert!(*value),
            other => panic!("expected bool literal, got {:?}", other),
        },
        _ => panic!("expected Filter"),
    }
    match &q.match_clause[2] {
        Clause::Filter(f) => match &f.right {
            Expr::Literal(Literal::Bool(value)) => assert!(!*value),
            other => panic!("expected bool literal, got {:?}", other),
        },
        _ => panic!("expected Filter"),
    }
}

#[test]
fn test_parse_contains_filter() {
    let input = r#"
query tagged($tag: String) {
match {
    $p: Person
    $p.tags contains $tag
}
return { $p.name }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    match &q.match_clause[1] {
        Clause::Filter(f) => {
            assert_eq!(f.op, CompOp::Contains);
            assert!(matches!(
                &f.left,
                Expr::PropAccess { variable, property } if variable == "p" && property == "tags"
            ));
            assert!(matches!(&f.right, Expr::Variable(v) if v == "tag"));
        }
        _ => panic!("expected Filter"),
    }
}

#[test]
fn test_parse_contains_is_rejected_in_mutation_predicate() {
    let input = r#"
query drop_person($tag: String) {
delete Person where tags contains $tag
}
"#;
    assert!(parse_query(input).is_err());
}

#[test]
fn test_parse_triangle() {
    let input = r#"
query triangles($name: String) {
match {
    $a: Person { name: $name }
    $a knows $b
    $b knows $c
    $c knows $a
}
return { $b.name, $c.name }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.match_clause.len(), 4);
}

#[test]
fn test_parse_avg_aggregation() {
    let input = r#"
query avg_age_by_company() {
match {
    $p: Person
    $p worksAt $c
}
return {
    $c.name
    avg($p.age) as avg_age
    count($p) as headcount
}
order { headcount desc }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.return_clause.len(), 3);
}

#[test]
fn test_parse_insert_mutation() {
    let input = r#"
query add_person($name: String, $age: I32) {
insert Person {
    name: $name
    age: $age
}
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    match q.mutations.first().expect("expected mutation") {
        Mutation::Insert(ins) => {
            assert_eq!(ins.type_name, "Person");
            assert_eq!(ins.assignments.len(), 2);
        }
        _ => panic!("expected Insert mutation"),
    }
}

#[test]
fn test_parse_update_mutation() {
    let input = r#"
query set_age($name: String, $age: I32) {
update Person set {
    age: $age
} where name = $name
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    match q.mutations.first().expect("expected mutation") {
        Mutation::Update(upd) => {
            assert_eq!(upd.type_name, "Person");
            assert_eq!(upd.assignments.len(), 1);
            assert_eq!(upd.predicate.property, "name");
            assert_eq!(upd.predicate.op, CompOp::Eq);
        }
        _ => panic!("expected Update mutation"),
    }
}

#[test]
fn test_parse_delete_mutation() {
    let input = r#"
query drop_person($name: String) {
delete Person where name = $name
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    match q.mutations.first().expect("expected mutation") {
        Mutation::Delete(del) => {
            assert_eq!(del.type_name, "Person");
            assert_eq!(del.predicate.property, "name");
            assert_eq!(del.predicate.op, CompOp::Eq);
        }
        _ => panic!("expected Delete mutation"),
    }
}

#[test]
fn test_parse_date_and_datetime_literals() {
    let input = r#"
query dated() {
match {
    $e: Event
    $e.on = date("2026-02-14")
    $e.at >= datetime("2026-02-14T10:00:00Z")
}
return { $e.id }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    match &q.match_clause[1] {
        Clause::Filter(f) => match &f.right {
            Expr::Literal(Literal::Date(v)) => assert_eq!(v, "2026-02-14"),
            other => panic!("expected date literal, got {:?}", other),
        },
        _ => panic!("expected Filter"),
    }
    match &q.match_clause[2] {
        Clause::Filter(f) => match &f.right {
            Expr::Literal(Literal::DateTime(v)) => assert_eq!(v, "2026-02-14T10:00:00Z"),
            other => panic!("expected datetime literal, got {:?}", other),
        },
        _ => panic!("expected Filter"),
    }
}

#[test]
fn test_parse_now_expression_and_mutation_value() {
    let input = r#"
query clock() {
match {
    $e: Event
    $e.at <= now()
}
return { now() as ts }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    match &q.match_clause[1] {
        Clause::Filter(f) => assert!(matches!(f.right, Expr::Now)),
        _ => panic!("expected Filter"),
    }
    assert!(matches!(q.return_clause[0].expr, Expr::Now));

    let mutation = parse_query(
        r#"
query stamp() {
update Event set { updated_at: now() } where created_at <= now()
}
"#,
    )
    .unwrap();
    match mutation.queries[0].mutations.first().unwrap() {
        Mutation::Update(update) => {
            assert!(matches!(update.assignments[0].value, MatchValue::Now));
            assert!(matches!(update.predicate.value, MatchValue::Now));
        }
        _ => panic!("expected update mutation"),
    }
}

#[test]
fn test_parse_multi_mutation() {
    let input = r#"
query add_and_link($name: String, $age: I32, $friend: String) {
insert Person { name: $name, age: $age }
insert Knows { from: $name, to: $friend }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.mutations.len(), 2);
    assert!(matches!(&q.mutations[0], Mutation::Insert(ins) if ins.type_name == "Person"));
    assert!(matches!(&q.mutations[1], Mutation::Insert(ins) if ins.type_name == "Knows"));
}

#[test]
fn test_parse_multi_mutation_mixed_ops() {
    let input = r#"
query create_and_clean($name: String, $age: I32, $old: String) {
insert Person { name: $name, age: $age }
delete Person where name = $old
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.mutations.len(), 2);
    assert!(matches!(&q.mutations[0], Mutation::Insert(_)));
    assert!(matches!(&q.mutations[1], Mutation::Delete(_)));
}

#[test]
fn test_parse_single_mutation_backward_compat() {
    let input = r#"
query add($name: String, $age: I32) {
insert Person { name: $name, age: $age }
}
"#;
    let qf = parse_query(input).unwrap();
    assert_eq!(qf.queries[0].mutations.len(), 1);
}

#[test]
fn test_parse_list_literal() {
    let input = r#"
query listy() {
match { $p: Person { tags: ["rust", "db"] } }
return { $p.tags }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    match &q.match_clause[0] {
        Clause::Binding(b) => match &b.prop_matches[0].value {
            MatchValue::Literal(Literal::List(items)) => {
                assert_eq!(items.len(), 2);
            }
            other => panic!("expected list literal, got {:?}", other),
        },
        _ => panic!("expected Binding"),
    }
}

#[test]
fn test_parse_nearest_ordering_and_vector_param_type() {
    let input = r#"
query similar($q: Vector(3)) {
match { $d: Doc }
return { $d.id }
order { nearest($d.embedding, $q) }
limit 5
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.params[0].type_name, "Vector(3)");
    assert_eq!(q.order_clause.len(), 1);
    assert!(!q.order_clause[0].descending);
    match &q.order_clause[0].expr {
        Expr::Nearest {
            variable,
            property,
            query,
        } => {
            assert_eq!(variable, "d");
            assert_eq!(property, "embedding");
            assert!(matches!(query.as_ref(), Expr::Variable(v) if v == "q"));
        }
        other => panic!("expected nearest ordering, got {:?}", other),
    }
}

#[test]
fn test_parse_nearest_with_spaced_vector_param_type() {
    let input = r#"
query similar($q: Vector( 3 ) ?) {
match { $d: Doc }
return { $d.id }
order { nearest($d.embedding, $q) }
limit 5
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.params[0].type_name, "Vector(3)");
    assert!(q.params[0].nullable);
}

#[test]
fn test_parse_list_and_datetime_param_types() {
    let input = r#"
query tasks($tags: [String], $days: [Date]?, $due_at: DateTime) {
match { $t: Task }
return { $t.slug }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.params[0].type_name, "[String]");
    assert!(!q.params[0].nullable);
    assert_eq!(q.params[1].type_name, "[Date]");
    assert!(q.params[1].nullable);
    assert_eq!(q.params[2].type_name, "DateTime");
}

#[test]
fn test_parse_nearest_rejects_direction_modifier() {
    let input = r#"
query similar($q: Vector(3)) {
match { $d: Doc }
return { $d.id }
order { nearest($d.embedding, $q) desc }
limit 5
}
"#;
    assert!(parse_query(input).is_err());
}

#[test]
fn test_parse_nearest_expression_in_return_projection() {
    let input = r#"
query similar($q: Vector(3)) {
match { $d: Doc }
return { $d.id, nearest($d.embedding, $q) as score }
order { nearest($d.embedding, $q) }
limit 5
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.return_clause.len(), 2);
    match &q.return_clause[1].expr {
        Expr::Nearest {
            variable,
            property,
            query,
        } => {
            assert_eq!(variable, "d");
            assert_eq!(property, "embedding");
            assert!(matches!(query.as_ref(), Expr::Variable(v) if v == "q"));
        }
        other => panic!(
            "expected nearest expression in return projection, got {:?}",
            other
        ),
    }
    assert_eq!(q.return_clause[1].alias.as_deref(), Some("score"));
}

#[test]
fn test_parse_search_clause_sugar() {
    let input = r#"
query q($q: String) {
match {
    $s: Signal
    search($s.summary, $q)
}
return { $s.slug }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.match_clause.len(), 2);
    match &q.match_clause[1] {
        Clause::Filter(Filter { left, op, right }) => {
            assert_eq!(*op, CompOp::Eq);
            assert!(matches!(right, Expr::Literal(Literal::Bool(true))));
            match left {
                Expr::Search { field, query } => {
                    assert!(matches!(
                        field.as_ref(),
                        Expr::PropAccess { variable, property } if variable == "s" && property == "summary"
                    ));
                    assert!(matches!(query.as_ref(), Expr::Variable(v) if v == "q"));
                }
                other => panic!("expected search expression, got {:?}", other),
            }
        }
        other => panic!("expected filter clause, got {:?}", other),
    }
}

#[test]
fn test_parse_fuzzy_clause_with_max_edits() {
    let input = r#"
query q($q: String) {
match {
    $s: Signal
    fuzzy($s.summary, $q, 2)
}
return { $s.slug }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.match_clause.len(), 2);
    match &q.match_clause[1] {
        Clause::Filter(Filter { left, op, right }) => {
            assert_eq!(*op, CompOp::Eq);
            assert!(matches!(right, Expr::Literal(Literal::Bool(true))));
            match left {
                Expr::Fuzzy {
                    field,
                    query,
                    max_edits,
                } => {
                    assert!(matches!(
                        field.as_ref(),
                        Expr::PropAccess { variable, property } if variable == "s" && property == "summary"
                    ));
                    assert!(matches!(query.as_ref(), Expr::Variable(v) if v == "q"));
                    assert!(matches!(
                        max_edits.as_deref(),
                        Some(Expr::Literal(Literal::Integer(2)))
                    ));
                }
                other => panic!("expected fuzzy expression, got {:?}", other),
            }
        }
        other => panic!("expected filter clause, got {:?}", other),
    }
}

#[test]
fn test_parse_match_text_clause_sugar() {
    let input = r#"
query q($q: String) {
match {
    $s: Signal
    match_text($s.summary, $q)
}
return { $s.slug }
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.match_clause.len(), 2);
    match &q.match_clause[1] {
        Clause::Filter(Filter { left, op, right }) => {
            assert_eq!(*op, CompOp::Eq);
            assert!(matches!(right, Expr::Literal(Literal::Bool(true))));
            match left {
                Expr::MatchText { field, query } => {
                    assert!(matches!(
                        field.as_ref(),
                        Expr::PropAccess { variable, property } if variable == "s" && property == "summary"
                    ));
                    assert!(matches!(query.as_ref(), Expr::Variable(v) if v == "q"));
                }
                other => panic!("expected match_text expression, got {:?}", other),
            }
        }
        other => panic!("expected filter clause, got {:?}", other),
    }
}

#[test]
fn test_parse_bm25_expression_in_order() {
    let input = r#"
query q($q: String) {
match { $s: Signal }
return { $s.slug, bm25($s.summary, $q) as score }
order { bm25($s.summary, $q) desc }
limit 5
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.return_clause.len(), 2);
    match &q.return_clause[1].expr {
        Expr::Bm25 { field, query } => {
            assert!(matches!(
                field.as_ref(),
                Expr::PropAccess { variable, property } if variable == "s" && property == "summary"
            ));
            assert!(matches!(query.as_ref(), Expr::Variable(v) if v == "q"));
        }
        other => panic!("expected bm25 expression, got {:?}", other),
    }
    assert_eq!(q.order_clause.len(), 1);
    assert!(q.order_clause[0].descending);
}

#[test]
fn test_parse_rrf_ordering_with_nearest_and_bm25() {
    let input = r#"
query q($vq: Vector(3), $tq: String) {
match { $s: Signal }
return { $s.slug }
order { rrf(nearest($s.embedding, $vq), bm25($s.summary, $tq), 60) desc }
limit 5
}
"#;
    let qf = parse_query(input).unwrap();
    let q = &qf.queries[0];
    assert_eq!(q.order_clause.len(), 1);
    assert!(q.order_clause[0].descending);
    match &q.order_clause[0].expr {
        Expr::Rrf {
            primary,
            secondary,
            k,
        } => {
            assert!(matches!(primary.as_ref(), Expr::Nearest { .. }));
            assert!(matches!(secondary.as_ref(), Expr::Bm25 { .. }));
            assert!(matches!(
                k.as_deref(),
                Some(Expr::Literal(Literal::Integer(60)))
            ));
        }
        other => panic!("expected rrf expression, got {:?}", other),
    }
}

#[test]
fn test_parse_error_diagnostic_has_span() {
    let input = r#"
query q() {
match {
    $p: Person
}
return { $p.name
}
"#;
    let err = parse_query_diagnostic(input).unwrap_err();
    assert!(err.span.is_some());
}