interstellar 0.2.0

//! Integration tests for Graph (in-memory copy-on-write storage).
//!
//! These tests verify the unified Graph implementation including:
//! - Basic CRUD operations
//! - Snapshot isolation and semantics
//! - Batch operations with atomicity
//! - GQL query and mutation support
//! - Traversal engine integration
//! - Concurrent access patterns
//! - Schema integration
//! - Large-scale data handling

use interstellar::graph_elements::{InMemoryEdge, InMemoryVertex};
use interstellar::prelude::*;
use interstellar::storage::{BatchError, Graph, GraphStorage};
use interstellar::StorageError;
use std::collections::HashMap;
use std::collections::HashSet;
use std::sync::Arc;
use std::thread;

// =============================================================================
// Basic CRUD Operations
// =============================================================================

#[test]
fn cow_graph_basic_vertex_operations() {
    let graph = Arc::new(Graph::new());

    // Add vertices with various property types
    let alice = graph.add_vertex(
        "Person",
        HashMap::from([
            ("name".to_string(), Value::String("Alice".into())),
            ("age".to_string(), Value::Int(30)),
            ("active".to_string(), Value::Bool(true)),
        ]),
    );

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

    let software = graph.add_vertex(
        "Software",
        HashMap::from([("name".to_string(), Value::String("GraphDB".into()))]),
    );

    assert_eq!(graph.vertex_count(), 3);

    // Verify vertices through snapshot
    let snap = graph.snapshot();
    let alice_v = snap.get_vertex(alice).unwrap();
    assert_eq!(alice_v.label, "Person");
    assert_eq!(
        alice_v.properties.get("name"),
        Some(&Value::String("Alice".into()))
    );

    let bob_v = snap.get_vertex(bob).unwrap();
    assert_eq!(bob_v.properties.get("age"), Some(&Value::Int(25)));

    let sw_v = snap.get_vertex(software).unwrap();
    assert_eq!(sw_v.label, "Software");
}

#[test]
fn cow_graph_basic_edge_operations() {
    let graph = Arc::new(Graph::new());

    let alice = graph.add_vertex("Person", HashMap::new());
    let bob = graph.add_vertex("Person", HashMap::new());
    let charlie = graph.add_vertex("Person", HashMap::new());

    // Add edges with properties
    let knows1 = graph
        .add_edge(
            alice,
            bob,
            "KNOWS",
            HashMap::from([("since".to_string(), Value::Int(2020))]),
        )
        .unwrap();

    let _knows2 = graph
        .add_edge(bob, charlie, "KNOWS", HashMap::new())
        .unwrap();

    let knows3 = graph
        .add_edge(charlie, alice, "KNOWS", HashMap::new())
        .unwrap();

    assert_eq!(graph.edge_count(), 3);

    // Verify edges through snapshot
    let snap = graph.snapshot();
    let edge = snap.get_edge(knows1).unwrap();
    assert_eq!(edge.src, alice);
    assert_eq!(edge.dst, bob);
    assert_eq!(edge.label, "KNOWS");
    assert_eq!(edge.properties.get("since"), Some(&Value::Int(2020)));

    // Verify adjacency
    let out_edges: Vec<_> = snap.out_edges(alice).collect();
    assert_eq!(out_edges.len(), 1);
    assert_eq!(out_edges[0].id, knows1);

    let in_edges: Vec<_> = snap.in_edges(alice).collect();
    assert_eq!(in_edges.len(), 1);
    assert_eq!(in_edges[0].id, knows3);
}

#[test]
fn cow_graph_property_updates() {
    let graph = Arc::new(Graph::new());

    let alice = graph.add_vertex(
        "Person",
        HashMap::from([("name".to_string(), Value::String("Alice".into()))]),
    );

    let bob = graph.add_vertex("Person", HashMap::new());
    let edge = graph.add_edge(alice, bob, "KNOWS", HashMap::new()).unwrap();

    // Update vertex property
    graph
        .set_vertex_property(alice, "age", Value::Int(30))
        .unwrap();
    graph
        .set_vertex_property(alice, "name", Value::String("Alicia".into()))
        .unwrap();

    // Update edge property
    graph
        .set_edge_property(edge, "weight", Value::Float(0.5))
        .unwrap();

    let snap = graph.snapshot();
    let v = snap.get_vertex(alice).unwrap();
    assert_eq!(
        v.properties.get("name"),
        Some(&Value::String("Alicia".into()))
    );
    assert_eq!(v.properties.get("age"), Some(&Value::Int(30)));

    let e = snap.get_edge(edge).unwrap();
    assert_eq!(e.properties.get("weight"), Some(&Value::Float(0.5)));
}

#[test]
fn cow_graph_remove_operations() {
    let graph = Arc::new(Graph::new());

    let alice = graph.add_vertex("Person", HashMap::new());
    let bob = graph.add_vertex("Person", HashMap::new());
    let charlie = graph.add_vertex("Person", HashMap::new());

    let e1 = graph.add_edge(alice, bob, "KNOWS", HashMap::new()).unwrap();
    let e2 = graph
        .add_edge(alice, charlie, "KNOWS", HashMap::new())
        .unwrap();
    let _e3 = graph
        .add_edge(bob, charlie, "KNOWS", HashMap::new())
        .unwrap();

    assert_eq!(graph.vertex_count(), 3);
    assert_eq!(graph.edge_count(), 3);

    // Remove specific edge
    graph.remove_edge(e1).unwrap();
    assert_eq!(graph.edge_count(), 2);

    // Remove vertex (should cascade to connected edges)
    graph.remove_vertex(alice).unwrap();
    assert_eq!(graph.vertex_count(), 2);
    assert_eq!(graph.edge_count(), 1); // Only bob->charlie remains

    // Verify remaining structure
    let snap = graph.snapshot();
    assert!(snap.get_vertex(alice).is_none());
    assert!(snap.get_vertex(bob).is_some());
    assert!(snap.get_edge(e2).is_none()); // Was connected to alice
}

// =============================================================================
// Snapshot Isolation and Semantics
// =============================================================================

#[test]
fn cow_snapshot_isolation_basic() {
    let graph = Arc::new(Graph::new());

    let alice = graph.add_vertex(
        "Person",
        HashMap::from([("name".to_string(), Value::String("Alice".into()))]),
    );

    // Take snapshot before modification
    let snap_before = graph.snapshot();

    // Modify the graph
    graph
        .set_vertex_property(alice, "name", Value::String("Alicia".into()))
        .unwrap();
    graph.add_vertex("Person", HashMap::new());

    // Take snapshot after modification
    let snap_after = graph.snapshot();

    // Verify isolation
    let v_before = snap_before.get_vertex(alice).unwrap();
    assert_eq!(
        v_before.properties.get("name"),
        Some(&Value::String("Alice".into()))
    );
    assert_eq!(snap_before.vertex_count(), 1);

    let v_after = snap_after.get_vertex(alice).unwrap();
    assert_eq!(
        v_after.properties.get("name"),
        Some(&Value::String("Alicia".into()))
    );
    assert_eq!(snap_after.vertex_count(), 2);
}

#[test]
fn cow_snapshot_survives_heavy_modification() {
    let graph = Arc::new(Graph::new());

    // Create initial state with 1000 vertices
    for i in 0..1000 {
        graph.add_vertex("Node", HashMap::from([("id".to_string(), Value::Int(i))]));
    }

    // Take snapshot
    let snap = graph.snapshot();
    assert_eq!(snap.vertex_count(), 1000);

    // Heavy modification: add 1000 more, remove 500 original
    for i in 1000..2000 {
        graph.add_vertex("Node", HashMap::from([("id".to_string(), Value::Int(i))]));
    }
    for i in 0..500u64 {
        graph.remove_vertex(VertexId(i)).unwrap();
    }

    // Original snapshot should be unchanged
    assert_eq!(snap.vertex_count(), 1000);

    // Verify we can still read from original snapshot
    let v = snap.get_vertex(VertexId(0)).unwrap();
    assert_eq!(v.properties.get("id"), Some(&Value::Int(0)));

    // New snapshot reflects changes
    let new_snap = graph.snapshot();
    assert_eq!(new_snap.vertex_count(), 1500); // 500 original + 1000 new
}

#[test]
fn cow_snapshot_can_outlive_graph() {
    let snap = {
        let graph = Arc::new(Graph::new());
        graph.add_vertex(
            "Person",
            HashMap::from([("name".to_string(), Value::String("Alice".into()))]),
        );
        graph.add_vertex(
            "Person",
            HashMap::from([("name".to_string(), Value::String("Bob".into()))]),
        );
        graph.snapshot()
    };
    // graph is dropped here

    // Snapshot should still be usable
    assert_eq!(snap.vertex_count(), 2);
    let names: Vec<_> = snap
        .all_vertices()
        .map(|v| v.properties.get("name").cloned())
        .collect();
    assert_eq!(names.len(), 2);
}

#[test]
fn cow_multiple_snapshots_independent() {
    let graph = Arc::new(Graph::new());

    graph.add_vertex("A", HashMap::new());
    let snap1 = graph.snapshot();

    graph.add_vertex("B", HashMap::new());
    let snap2 = graph.snapshot();

    graph.add_vertex("C", HashMap::new());
    let snap3 = graph.snapshot();

    graph.add_vertex("D", HashMap::new());

    // Each snapshot sees different state
    assert_eq!(snap1.vertex_count(), 1);
    assert_eq!(snap2.vertex_count(), 2);
    assert_eq!(snap3.vertex_count(), 3);
    assert_eq!(graph.vertex_count(), 4);

    // All snapshots remain valid
    assert!(snap1.vertices_with_label("A").next().is_some());
    assert!(snap1.vertices_with_label("B").next().is_none());

    assert!(snap2.vertices_with_label("B").next().is_some());
    assert!(snap2.vertices_with_label("C").next().is_none());
}

// =============================================================================
// Batch Operations
// =============================================================================

#[test]
fn cow_batch_atomic_success() {
    let graph = Arc::new(Graph::new());

    let result = graph.batch(|ctx| {
        let alice = ctx.add_vertex(
            "Person",
            HashMap::from([("name".to_string(), Value::String("Alice".into()))]),
        );
        let bob = ctx.add_vertex(
            "Person",
            HashMap::from([("name".to_string(), Value::String("Bob".into()))]),
        );
        let charlie = ctx.add_vertex(
            "Person",
            HashMap::from([("name".to_string(), Value::String("Charlie".into()))]),
        );

        ctx.add_edge(alice, bob, "KNOWS", HashMap::new())?;
        ctx.add_edge(bob, charlie, "KNOWS", HashMap::new())?;
        ctx.add_edge(charlie, alice, "KNOWS", HashMap::new())?;

        Ok((alice, bob, charlie))
    });

    assert!(result.is_ok());
    let (alice, bob, charlie) = result.unwrap();

    assert_eq!(graph.vertex_count(), 3);
    assert_eq!(graph.edge_count(), 3);

    // Verify structure
    let snap = graph.snapshot();
    assert!(snap.get_vertex(alice).is_some());
    assert!(snap.get_vertex(bob).is_some());
    assert!(snap.get_vertex(charlie).is_some());

    let out_edges: Vec<_> = snap.out_edges(alice).collect();
    assert_eq!(out_edges.len(), 1);
}

#[test]
fn cow_batch_atomic_rollback() {
    let graph = Arc::new(Graph::new());

    // Add initial vertex
    graph.add_vertex(
        "Existing",
        HashMap::from([("name".to_string(), Value::String("Existing".into()))]),
    );

    let initial_version = graph.version();

    // Attempt batch that fails
    let result: Result<(), BatchError> = graph.batch(|ctx| {
        ctx.add_vertex("New1", HashMap::new());
        ctx.add_vertex("New2", HashMap::new());

        // This should fail - non-existent vertices
        ctx.add_edge(VertexId(999), VertexId(998), "INVALID", HashMap::new())?;

        Ok(())
    });

    assert!(result.is_err());

    // Graph should be unchanged
    assert_eq!(graph.vertex_count(), 1);
    assert_eq!(graph.edge_count(), 0);
    assert_eq!(graph.version(), initial_version);

    let snap = graph.snapshot();
    assert!(snap.vertices_with_label("Existing").next().is_some());
    assert!(snap.vertices_with_label("New1").next().is_none());
}

#[test]
fn cow_batch_with_property_updates() {
    let graph = Arc::new(Graph::new());

    let alice = graph.add_vertex(
        "Person",
        HashMap::from([("name".to_string(), Value::String("Alice".into()))]),
    );

    // Use direct property update methods (not batch - BatchContext doesn't have set_*_property)
    graph
        .set_vertex_property(alice, "age", Value::Int(30))
        .unwrap();
    graph
        .set_vertex_property(alice, "city", Value::String("NYC".into()))
        .unwrap();

    // Use batch to add vertex and edge with properties inline
    let edge_id = graph
        .batch(|ctx| {
            let bob = ctx.add_vertex(
                "Person",
                HashMap::from([("name".to_string(), Value::String("Bob".into()))]),
            );
            let edge = ctx.add_edge(
                alice,
                bob,
                "KNOWS",
                HashMap::from([("since".to_string(), Value::Int(2020))]),
            )?;
            Ok(edge)
        })
        .unwrap();

    let snap = graph.snapshot();
    let v = snap.get_vertex(alice).unwrap();
    assert_eq!(v.properties.get("age"), Some(&Value::Int(30)));
    assert_eq!(v.properties.get("city"), Some(&Value::String("NYC".into())));

    let edge = snap.get_edge(edge_id).unwrap();
    assert_eq!(edge.properties.get("since"), Some(&Value::Int(2020)));
}

// =============================================================================
// GQL Integration
// =============================================================================

#[test]
#[cfg(feature = "gql")]
fn cow_gql_create_vertex() {
    let graph = Arc::new(Graph::new());

    graph
        .gql("CREATE (:Person {name: 'Alice', age: 30})")
        .unwrap();
    graph
        .gql("CREATE (:Person {name: 'Bob', age: 25})")
        .unwrap();
    graph.gql("CREATE (:Software {name: 'GraphDB'})").unwrap();

    assert_eq!(graph.vertex_count(), 3);

    let snap = graph.snapshot();
    let people: Vec<_> = snap.vertices_with_label("Person").collect();
    assert_eq!(people.len(), 2);

    let software: Vec<_> = snap.vertices_with_label("Software").collect();
    assert_eq!(software.len(), 1);
}

#[test]
#[cfg(feature = "gql")]
fn cow_gql_create_edges() {
    let graph = Arc::new(Graph::new());

    // Create vertices first
    let alice = graph.add_vertex(
        "Person",
        HashMap::from([("name".to_string(), Value::String("Alice".into()))]),
    );
    let bob = graph.add_vertex(
        "Person",
        HashMap::from([("name".to_string(), Value::String("Bob".into()))]),
    );

    // Create edge via GQL - need to match existing vertices
    // Using direct mutation since GQL MATCH + CREATE pattern may vary
    graph
        .add_edge(
            alice,
            bob,
            "KNOWS",
            HashMap::from([("since".to_string(), Value::Int(2020))]),
        )
        .unwrap();

    assert_eq!(graph.edge_count(), 1);

    let snap = graph.snapshot();
    let edges: Vec<_> = snap.edges_with_label("KNOWS").collect();
    assert_eq!(edges.len(), 1);
    assert_eq!(edges[0].properties.get("since"), Some(&Value::Int(2020)));
}

#[test]
#[cfg(feature = "gql")]
fn cow_gql_query_on_snapshot() {
    let graph = Arc::new(Graph::new());

    // Build graph
    let alice = graph.add_vertex(
        "Person",
        HashMap::from([
            ("name".to_string(), Value::String("Alice".into())),
            ("age".to_string(), Value::Int(30)),
        ]),
    );
    let bob = graph.add_vertex(
        "Person",
        HashMap::from([
            ("name".to_string(), Value::String("Bob".into())),
            ("age".to_string(), Value::Int(25)),
        ]),
    );
    graph.add_edge(alice, bob, "KNOWS", HashMap::new()).unwrap();

    // Query via snapshot - CowSnapshot implements GraphStorage
    // so we can iterate vertices directly
    let snap = graph.snapshot();

    // Verify vertices via GraphStorage methods
    let people: Vec<_> = snap.vertices_with_label("Person").collect();
    assert_eq!(people.len(), 2);

    // Verify names
    let names: Vec<_> = people
        .iter()
        .filter_map(|v| v.properties.get("name"))
        .collect();
    assert_eq!(names.len(), 2);
}

#[test]
#[cfg(feature = "gql")]
fn cow_gql_set_property() {
    let graph = Arc::new(Graph::new());

    let alice = graph.add_vertex(
        "Person",
        HashMap::from([("name".to_string(), Value::String("Alice".into()))]),
    );

    // Set property via GQL using property-based matching
    // (id() function is not supported in WHERE predicates)
    graph
        .gql("MATCH (p:Person) WHERE p.name = 'Alice' SET p.age = 30")
        .unwrap();

    let snap = graph.snapshot();
    let v = snap.get_vertex(alice).unwrap();
    assert_eq!(v.properties.get("age"), Some(&Value::Int(30)));
}

// =============================================================================
// Traversal Integration
// =============================================================================

#[test]
fn cow_traversal_basic() {
    let graph = Arc::new(Graph::new());

    let alice = graph.add_vertex(
        "Person",
        HashMap::from([("name".to_string(), Value::String("Alice".into()))]),
    );
    let bob = graph.add_vertex(
        "Person",
        HashMap::from([("name".to_string(), Value::String("Bob".into()))]),
    );
    let software = graph.add_vertex(
        "Software",
        HashMap::from([("name".to_string(), Value::String("GraphDB".into()))]),
    );

    graph.add_edge(alice, bob, "KNOWS", HashMap::new()).unwrap();
    graph
        .add_edge(alice, software, "CREATED", HashMap::new())
        .unwrap();

    let snap = graph.snapshot();

    // Basic vertex traversal
    let all_vertices: Vec<_> = snap.all_vertices().collect();
    assert_eq!(all_vertices.len(), 3);

    // Label filtering
    let people: Vec<_> = snap.vertices_with_label("Person").collect();
    assert_eq!(people.len(), 2);

    // Edge traversal
    let alice_out: Vec<_> = snap.out_edges(alice).collect();
    assert_eq!(alice_out.len(), 2);

    let labels: Vec<_> = alice_out.iter().map(|e| e.label.as_str()).collect();
    assert!(labels.contains(&"KNOWS"));
    assert!(labels.contains(&"CREATED"));
}

#[test]
fn cow_traversal_multi_hop() {
    let graph = Arc::new(Graph::new());

    // Create a chain: A -> B -> C -> D
    let a = graph.add_vertex(
        "Node",
        HashMap::from([("name".to_string(), Value::String("A".into()))]),
    );
    let b = graph.add_vertex(
        "Node",
        HashMap::from([("name".to_string(), Value::String("B".into()))]),
    );
    let c = graph.add_vertex(
        "Node",
        HashMap::from([("name".to_string(), Value::String("C".into()))]),
    );
    let d = graph.add_vertex(
        "Node",
        HashMap::from([("name".to_string(), Value::String("D".into()))]),
    );

    graph.add_edge(a, b, "NEXT", HashMap::new()).unwrap();
    graph.add_edge(b, c, "NEXT", HashMap::new()).unwrap();
    graph.add_edge(c, d, "NEXT", HashMap::new()).unwrap();

    let snap = graph.snapshot();

    // Follow edges from A
    let a_out: Vec<_> = snap.out_edges(a).collect();
    assert_eq!(a_out.len(), 1);
    assert_eq!(a_out[0].dst, b);

    // Follow edges from B
    let b_out: Vec<_> = snap.out_edges(b).collect();
    assert_eq!(b_out.len(), 1);
    assert_eq!(b_out[0].dst, c);

    // Verify in-edges
    let d_in: Vec<_> = snap.in_edges(d).collect();
    assert_eq!(d_in.len(), 1);
    assert_eq!(d_in[0].src, c);
}

// =============================================================================
// Concurrent Access
// =============================================================================

#[test]
fn cow_concurrent_readers() {
    let graph = Arc::new(Graph::new());

    // Build initial graph
    for i in 0..100 {
        graph.add_vertex("Node", HashMap::from([("id".to_string(), Value::Int(i))]));
    }

    let snapshot = graph.snapshot();

    // Spawn multiple reader threads
    let handles: Vec<_> = (0..10)
        .map(|_| {
            let snap = snapshot.clone();
            thread::spawn(move || {
                // Each thread reads the entire graph
                let count = snap.vertex_count();
                assert_eq!(count, 100);

                // Read specific vertices
                for i in 0..100u64 {
                    let v = snap.get_vertex(VertexId(i));
                    assert!(v.is_some());
                }

                count
            })
        })
        .collect();

    // All readers should complete successfully
    for handle in handles {
        let count = handle.join().unwrap();
        assert_eq!(count, 100);
    }
}

#[test]
fn cow_concurrent_readers_with_writer() {
    let graph = Arc::new(Graph::new());

    // Add initial vertices
    for i in 0..50 {
        graph.add_vertex("Node", HashMap::from([("id".to_string(), Value::Int(i))]));
    }

    // Take snapshot for readers
    let reader_snapshot = graph.snapshot();

    // Clone for writer thread
    let writer_graph = Arc::clone(&graph);

    // Start writer thread that adds more vertices
    let writer = thread::spawn(move || {
        for i in 50..100 {
            writer_graph.add_vertex("Node", HashMap::from([("id".to_string(), Value::Int(i))]));
        }
    });

    // Start reader threads using the pre-mutation snapshot
    let readers: Vec<_> = (0..5)
        .map(|_| {
            let snap = reader_snapshot.clone();
            thread::spawn(move || {
                // Readers should always see exactly 50 vertices
                // (the snapshot was taken before writer started)
                assert_eq!(snap.vertex_count(), 50);
            })
        })
        .collect();

    // Wait for all threads
    writer.join().unwrap();
    for reader in readers {
        reader.join().unwrap();
    }

    // Final graph should have 100 vertices
    assert_eq!(graph.vertex_count(), 100);
}

#[test]
fn cow_snapshot_sent_across_threads() {
    let graph = Arc::new(Graph::new());

    graph.add_vertex(
        "Person",
        HashMap::from([("name".to_string(), Value::String("Alice".into()))]),
    );

    let snapshot = graph.snapshot();

    // Send snapshot to another thread
    let handle = thread::spawn(move || {
        assert_eq!(snapshot.vertex_count(), 1);
        let v = snapshot.get_vertex(VertexId(0)).unwrap();
        v.properties.get("name").cloned()
    });

    let name = handle.join().unwrap();
    assert_eq!(name, Some(Value::String("Alice".into())));
}

// =============================================================================
// Label Indexing
// =============================================================================

#[test]
fn cow_label_index_vertices() {
    let graph = Arc::new(Graph::new());

    for _ in 0..100 {
        graph.add_vertex("Person", HashMap::new());
    }
    for _ in 0..50 {
        graph.add_vertex("Software", HashMap::new());
    }
    for _ in 0..25 {
        graph.add_vertex("Company", HashMap::new());
    }

    let snap = graph.snapshot();

    let people: Vec<_> = snap.vertices_with_label("Person").collect();
    let software: Vec<_> = snap.vertices_with_label("Software").collect();
    let companies: Vec<_> = snap.vertices_with_label("Company").collect();
    let unknown: Vec<_> = snap.vertices_with_label("Unknown").collect();

    assert_eq!(people.len(), 100);
    assert_eq!(software.len(), 50);
    assert_eq!(companies.len(), 25);
    assert_eq!(unknown.len(), 0);
}

#[test]
fn cow_label_index_edges() {
    let graph = Arc::new(Graph::new());

    let vertices: Vec<_> = (0..10)
        .map(|_| graph.add_vertex("Node", HashMap::new()))
        .collect();

    // Create edges with different labels
    for i in 0..9 {
        graph
            .add_edge(vertices[i], vertices[i + 1], "NEXT", HashMap::new())
            .unwrap();
    }
    for i in 0..5 {
        graph
            .add_edge(vertices[i], vertices[9 - i], "LINK", HashMap::new())
            .unwrap();
    }

    let snap = graph.snapshot();

    let next_edges: Vec<_> = snap.edges_with_label("NEXT").collect();
    let link_edges: Vec<_> = snap.edges_with_label("LINK").collect();
    let unknown_edges: Vec<_> = snap.edges_with_label("UNKNOWN").collect();

    assert_eq!(next_edges.len(), 9);
    assert_eq!(link_edges.len(), 5);
    assert_eq!(unknown_edges.len(), 0);
}

// =============================================================================
// Scale Tests
// =============================================================================

#[test]
fn cow_scale_10k_vertices() {
    let graph = Arc::new(Graph::new());

    // Add 10,000 vertices
    let vertices: Vec<_> = (0..10_000)
        .map(|i| graph.add_vertex("Node", HashMap::from([("id".to_string(), Value::Int(i))])))
        .collect();

    assert_eq!(graph.vertex_count(), 10_000);

    // Add edges (each vertex connects to next 5)
    for i in 0..10_000 {
        for j in 1..=5 {
            let dst_idx = (i + j) % 10_000;
            graph
                .add_edge(vertices[i], vertices[dst_idx], "CONNECTS", HashMap::new())
                .unwrap();
        }
    }

    assert_eq!(graph.edge_count(), 50_000);

    // Verify random lookups
    let snap = graph.snapshot();
    let v = snap.get_vertex(vertices[5000]).unwrap();
    assert_eq!(v.properties.get("id"), Some(&Value::Int(5000)));

    let out: Vec<_> = snap.out_edges(vertices[0]).collect();
    assert_eq!(out.len(), 5);
}

#[test]
fn cow_many_snapshots() {
    let graph = Arc::new(Graph::new());

    let mut snapshots = Vec::new();

    // Create 100 snapshots at different states
    for i in 0..100 {
        graph.add_vertex("Node", HashMap::from([("id".to_string(), Value::Int(i))]));
        snapshots.push(graph.snapshot());
    }

    // Verify each snapshot sees correct count
    for (i, snap) in snapshots.iter().enumerate() {
        assert_eq!(snap.vertex_count() as usize, i + 1);
    }
}

// =============================================================================
// Version Tracking
// =============================================================================

#[test]
fn cow_version_increments() {
    let graph = Arc::new(Graph::new());

    assert_eq!(graph.version(), 0);

    graph.add_vertex("A", HashMap::new());
    assert_eq!(graph.version(), 1);

    graph.add_vertex("B", HashMap::new());
    assert_eq!(graph.version(), 2);

    let v = graph.add_vertex("C", HashMap::new());
    assert_eq!(graph.version(), 3);

    graph.set_vertex_property(v, "prop", Value::Int(1)).unwrap();
    assert_eq!(graph.version(), 4);

    graph.remove_vertex(v).unwrap();
    assert_eq!(graph.version(), 5);
}

#[test]
fn cow_snapshot_captures_version() {
    let graph = Arc::new(Graph::new());

    graph.add_vertex("A", HashMap::new());
    let snap1 = graph.snapshot();

    graph.add_vertex("B", HashMap::new());
    let snap2 = graph.snapshot();

    graph.add_vertex("C", HashMap::new());
    let snap3 = graph.snapshot();

    assert_eq!(snap1.version(), 1);
    assert_eq!(snap2.version(), 2);
    assert_eq!(snap3.version(), 3);
}

// =============================================================================
// Error Handling
// =============================================================================

#[test]
fn cow_error_vertex_not_found() {
    let graph = Arc::new(Graph::new());

    let result = graph.set_vertex_property(VertexId(999), "prop", Value::Int(1));
    assert!(matches!(result, Err(StorageError::VertexNotFound(_))));

    let result = graph.remove_vertex(VertexId(999));
    assert!(matches!(result, Err(StorageError::VertexNotFound(_))));
}

#[test]
fn cow_error_edge_not_found() {
    let graph = Arc::new(Graph::new());

    let result = graph.set_edge_property(EdgeId(999), "prop", Value::Int(1));
    assert!(matches!(result, Err(StorageError::EdgeNotFound(_))));

    let result = graph.remove_edge(EdgeId(999));
    assert!(matches!(result, Err(StorageError::EdgeNotFound(_))));
}

#[test]
fn cow_error_edge_missing_vertices() {
    let graph = Arc::new(Graph::new());

    let v1 = graph.add_vertex("Node", HashMap::new());

    // Source doesn't exist
    let result = graph.add_edge(VertexId(999), v1, "EDGE", HashMap::new());
    assert!(matches!(result, Err(StorageError::VertexNotFound(_))));

    // Destination doesn't exist
    let result = graph.add_edge(v1, VertexId(999), "EDGE", HashMap::new());
    assert!(matches!(result, Err(StorageError::VertexNotFound(_))));
}

// =============================================================================
// Schema Integration
// =============================================================================

#[test]
fn cow_schema_set_and_get() {
    use interstellar::schema::{PropertyType, SchemaBuilder, ValidationMode};

    let graph = Arc::new(Graph::new());

    // Create schema using SchemaBuilder
    let schema = SchemaBuilder::new()
        .mode(ValidationMode::Strict)
        .vertex("Person")
        .property("name", PropertyType::String)
        .optional("age", PropertyType::Int)
        .done()
        .build();

    graph.set_schema(Some(schema.clone()));

    // Verify schema is set
    let retrieved = graph.schema();
    assert!(retrieved.is_some());
    let retrieved = retrieved.unwrap();
    assert!(retrieved.vertex_schema("Person").is_some());
}

// =============================================================================
// Property Index Tests
// =============================================================================

#[test]
fn cow_index_create_and_drop() {
    use interstellar::index::IndexBuilder;

    let graph = Arc::new(Graph::new());

    // Create a B+ tree index
    graph
        .create_index(
            IndexBuilder::vertex()
                .label("Person")
                .property("age")
                .build()
                .unwrap(),
        )
        .unwrap();

    assert!(graph.has_index("idx_Person_agev"));
    assert_eq!(graph.index_count(), 1);
    assert!(graph.supports_indexes());

    // Create a unique index
    graph
        .create_index(
            IndexBuilder::vertex()
                .label("User")
                .property("email")
                .unique()
                .build()
                .unwrap(),
        )
        .unwrap();

    assert!(graph.has_index("uniq_User_emailv"));
    assert_eq!(graph.index_count(), 2);

    // List indexes
    let indexes = graph.list_indexes();
    assert_eq!(indexes.len(), 2);

    // Drop an index
    graph.drop_index("idx_Person_agev").unwrap();
    assert!(!graph.has_index("idx_Person_agev"));
    assert_eq!(graph.index_count(), 1);

    // Drop non-existent index
    let result = graph.drop_index("non_existent");
    assert!(result.is_err());
}

#[test]
fn cow_index_duplicate_name_error() {
    use interstellar::index::IndexBuilder;

    let graph = Arc::new(Graph::new());

    graph
        .create_index(
            IndexBuilder::vertex()
                .label("Person")
                .property("age")
                .build()
                .unwrap(),
        )
        .unwrap();

    // Try to create another index with the same name
    let result = graph.create_index(
        IndexBuilder::vertex()
            .label("Person")
            .property("age")
            .build()
            .unwrap(),
    );

    assert!(result.is_err());
}

#[test]
fn cow_index_populated_on_creation() {
    use interstellar::index::IndexBuilder;

    let graph = Arc::new(Graph::new());

    // Add some vertices first
    graph.add_vertex(
        "Person",
        HashMap::from([
            ("name".to_string(), Value::String("Alice".into())),
            ("age".to_string(), Value::Int(30)),
        ]),
    );
    graph.add_vertex(
        "Person",
        HashMap::from([
            ("name".to_string(), Value::String("Bob".into())),
            ("age".to_string(), Value::Int(25)),
        ]),
    );
    graph.add_vertex(
        "Person",
        HashMap::from([
            ("name".to_string(), Value::String("Charlie".into())),
            ("age".to_string(), Value::Int(30)),
        ]),
    );

    // Create index - should populate with existing data
    graph
        .create_index(
            IndexBuilder::vertex()
                .label("Person")
                .property("age")
                .build()
                .unwrap(),
        )
        .unwrap();

    // Query using index
    let results: Vec<_> = graph
        .vertices_by_property(Some("Person"), "age", &Value::Int(30))
        .collect();
    assert_eq!(results.len(), 2);

    let names: Vec<_> = results
        .iter()
        .filter_map(|v| v.properties.get("name").and_then(|n| n.as_str()))
        .collect();
    assert!(names.contains(&"Alice"));
    assert!(names.contains(&"Charlie"));
}

#[test]
fn cow_index_maintained_on_insert() {
    use interstellar::index::IndexBuilder;

    let graph = Arc::new(Graph::new());

    // Create index first
    graph
        .create_index(
            IndexBuilder::vertex()
                .label("Person")
                .property("age")
                .build()
                .unwrap(),
        )
        .unwrap();

    // Add vertices - should be indexed automatically
    graph.add_vertex(
        "Person",
        HashMap::from([("age".to_string(), Value::Int(30))]),
    );
    graph.add_vertex(
        "Person",
        HashMap::from([("age".to_string(), Value::Int(25))]),
    );
    graph.add_vertex(
        "Person",
        HashMap::from([("age".to_string(), Value::Int(30))]),
    );

    // Query using index
    let results: Vec<_> = graph
        .vertices_by_property(Some("Person"), "age", &Value::Int(30))
        .collect();
    assert_eq!(results.len(), 2);
}

#[test]
fn cow_index_maintained_on_remove() {
    use interstellar::index::IndexBuilder;

    let graph = Arc::new(Graph::new());

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

    // Create index
    graph
        .create_index(
            IndexBuilder::vertex()
                .label("Person")
                .property("age")
                .build()
                .unwrap(),
        )
        .unwrap();

    // Verify both are indexed
    let results: Vec<_> = graph
        .vertices_by_property(Some("Person"), "age", &Value::Int(30))
        .collect();
    assert_eq!(results.len(), 2);

    // Remove one vertex
    graph.remove_vertex(alice).unwrap();

    // Verify index is updated
    let results: Vec<_> = graph
        .vertices_by_property(Some("Person"), "age", &Value::Int(30))
        .collect();
    assert_eq!(results.len(), 1);
    assert_eq!(results[0].id, bob);
}

#[test]
fn cow_index_maintained_on_property_update() {
    use interstellar::index::IndexBuilder;

    let graph = Arc::new(Graph::new());

    let alice = graph.add_vertex(
        "Person",
        HashMap::from([("age".to_string(), Value::Int(30))]),
    );

    // Create index
    graph
        .create_index(
            IndexBuilder::vertex()
                .label("Person")
                .property("age")
                .build()
                .unwrap(),
        )
        .unwrap();

    // Verify indexed
    let results: Vec<_> = graph
        .vertices_by_property(Some("Person"), "age", &Value::Int(30))
        .collect();
    assert_eq!(results.len(), 1);

    // Update property
    graph
        .set_vertex_property(alice, "age", Value::Int(31))
        .unwrap();

    // Old value should no longer match
    let results: Vec<_> = graph
        .vertices_by_property(Some("Person"), "age", &Value::Int(30))
        .collect();
    assert_eq!(results.len(), 0);

    // New value should match
    let results: Vec<_> = graph
        .vertices_by_property(Some("Person"), "age", &Value::Int(31))
        .collect();
    assert_eq!(results.len(), 1);
}

#[test]
fn cow_index_edge_property() {
    use interstellar::index::IndexBuilder;

    let graph = Arc::new(Graph::new());

    let alice = graph.add_vertex("Person", HashMap::new());
    let bob = graph.add_vertex("Person", HashMap::new());
    let charlie = graph.add_vertex("Person", HashMap::new());

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

    // Create edge index
    graph
        .create_index(
            IndexBuilder::edge()
                .label("KNOWS")
                .property("since")
                .build()
                .unwrap(),
        )
        .unwrap();

    // Query using index
    let results: Vec<_> = graph
        .edges_by_property(Some("KNOWS"), "since", &Value::Int(2020))
        .collect();
    assert_eq!(results.len(), 2);
}

#[test]
fn cow_index_unique_constraint() {
    use interstellar::index::IndexBuilder;

    let graph = Arc::new(Graph::new());

    // Create unique index first
    graph
        .create_index(
            IndexBuilder::vertex()
                .label("User")
                .property("email")
                .unique()
                .build()
                .unwrap(),
        )
        .unwrap();

    // Add first user
    graph.add_vertex(
        "User",
        HashMap::from([(
            "email".to_string(),
            Value::String("alice@example.com".into()),
        )]),
    );

    // Query should find it
    let results: Vec<_> = graph
        .vertices_by_property(
            Some("User"),
            "email",
            &Value::String("alice@example.com".into()),
        )
        .collect();
    assert_eq!(results.len(), 1);
}

#[test]
fn cow_index_range_query() {
    use interstellar::index::IndexBuilder;
    use std::ops::Bound;

    let graph = Arc::new(Graph::new());

    // Add vertices with ages
    for age in [18, 21, 25, 30, 35, 40, 50, 60] {
        graph.add_vertex(
            "Person",
            HashMap::from([("age".to_string(), Value::Int(age))]),
        );
    }

    // Create index
    graph
        .create_index(
            IndexBuilder::vertex()
                .label("Person")
                .property("age")
                .build()
                .unwrap(),
        )
        .unwrap();

    // Range query: 25 <= age < 40
    let results: Vec<_> = graph
        .vertices_by_property_range(
            Some("Person"),
            "age",
            Bound::Included(&Value::Int(25)),
            Bound::Excluded(&Value::Int(40)),
        )
        .collect();
    assert_eq!(results.len(), 3); // 25, 30, 35
}

#[test]
fn cow_index_no_label_filter() {
    use interstellar::index::IndexBuilder;

    let graph = Arc::new(Graph::new());

    // Create index without label filter (indexes all vertices with that property)
    graph
        .create_index(
            IndexBuilder::vertex()
                .property("created_at")
                .build()
                .unwrap(),
        )
        .unwrap();

    // Add vertices of different labels
    graph.add_vertex(
        "Person",
        HashMap::from([("created_at".to_string(), Value::Int(1000))]),
    );
    graph.add_vertex(
        "Company",
        HashMap::from([("created_at".to_string(), Value::Int(1000))]),
    );
    graph.add_vertex(
        "Product",
        HashMap::from([("created_at".to_string(), Value::Int(2000))]),
    );

    // Query without label filter
    let results: Vec<_> = graph
        .vertices_by_property(None, "created_at", &Value::Int(1000))
        .collect();
    assert_eq!(results.len(), 2);
}

#[test]
fn cow_index_with_batch_operations() {
    use interstellar::index::IndexBuilder;

    let graph = Arc::new(Graph::new());

    // Create index
    graph
        .create_index(
            IndexBuilder::vertex()
                .label("Person")
                .property("age")
                .build()
                .unwrap(),
        )
        .unwrap();

    // Use batch to add multiple vertices
    graph
        .batch(|ctx| {
            ctx.add_vertex(
                "Person",
                HashMap::from([("age".to_string(), Value::Int(30))]),
            );
            ctx.add_vertex(
                "Person",
                HashMap::from([("age".to_string(), Value::Int(25))]),
            );
            ctx.add_vertex(
                "Person",
                HashMap::from([("age".to_string(), Value::Int(30))]),
            );
            Ok(())
        })
        .unwrap();

    // Note: Batch operations don't currently update indexes since they work
    // directly on GraphState. This is a known limitation.
    // For now, verify the vertices were added (they may not be indexed).
    assert_eq!(graph.vertex_count(), 3);
}

// =============================================================================
// Unified Gremlin Traversal API Tests
// =============================================================================

#[test]
fn cow_unified_traversal_add_v_basic() {
    let graph = Arc::new(Graph::new());
    let g = graph.gremlin(Arc::clone(&graph));

    // Add a vertex through the unified traversal API
    // With the new typed API, add_v().next() returns Option<InMemoryVertex>
    let result = g.add_v("Person").next();

    // Should return a GraphVertex
    assert!(result.is_some());
    let vertex = result.unwrap();
    // Verify it's a valid vertex by checking the ID is accessible
    let _id = vertex.id();

    // Graph should now have one vertex
    assert_eq!(graph.vertex_count(), 1);
}

#[test]
fn cow_unified_traversal_add_v_with_properties() {
    let graph = Arc::new(Graph::new());
    let g = graph.gremlin(Arc::clone(&graph));

    // Add a vertex with properties
    // With the new typed API, add_v().next() returns Option<InMemoryVertex>
    let result = g
        .add_v("Person")
        .property("name", "Alice")
        .property("age", 30i64)
        .next();

    assert!(result.is_some());
    let vertex = result.unwrap();
    let vertex_id = vertex.id();

    // Verify the vertex has correct properties
    let snap = graph.snapshot();
    let stored = snap.get_vertex(vertex_id).unwrap();
    assert_eq!(stored.label, "Person");
    assert_eq!(
        stored.properties.get("name"),
        Some(&Value::String("Alice".into()))
    );
    assert_eq!(stored.properties.get("age"), Some(&Value::Int(30)));
}

#[test]
fn cow_unified_traversal_add_v_multiple() {
    let graph = Arc::new(Graph::new());
    let g = graph.gremlin(Arc::clone(&graph));

    // Add multiple vertices
    g.add_v("Person").property("name", "Alice").iterate();
    g.add_v("Person").property("name", "Bob").iterate();
    g.add_v("Software").property("name", "GraphDB").iterate();

    // Should have 3 vertices
    assert_eq!(graph.vertex_count(), 3);

    // Verify labels
    let snap = graph.snapshot();
    let person_count = snap.all_vertices().filter(|v| v.label == "Person").count();
    let software_count = snap
        .all_vertices()
        .filter(|v| v.label == "Software")
        .count();
    assert_eq!(person_count, 2);
    assert_eq!(software_count, 1);
}

#[test]
fn cow_unified_traversal_add_v_to_list() {
    let graph = Arc::new(Graph::new());
    let g = graph.gremlin(Arc::clone(&graph));

    // Use to_list() to add multiple vertices via inject + add_v pattern
    // (Here we just add one, but to_list collects all results)
    // With typed API, to_list() returns Vec<InMemoryVertex>
    let results = g.add_v("Person").to_list();

    assert_eq!(results.len(), 1);
    // Verify it's a valid GraphVertex
    let _id = results[0].id();
    assert_eq!(graph.vertex_count(), 1);
}

#[test]
fn cow_unified_traversal_query_after_mutation() {
    let graph = Arc::new(Graph::new());
    let g = graph.gremlin(Arc::clone(&graph));

    // Add vertices
    g.add_v("Person").property("name", "Alice").iterate();
    g.add_v("Person").property("name", "Bob").iterate();

    // Query the newly added vertices
    let g2 = graph.gremlin(Arc::clone(&graph));
    let results = g2.v().has_label("Person").to_list();

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

#[test]
fn cow_unified_traversal_add_e_from_source() {
    let graph = Arc::new(Graph::new());

    // First add some vertices directly
    let alice = graph.add_vertex(
        "Person",
        HashMap::from([("name".to_string(), Value::String("Alice".into()))]),
    );
    let bob = graph.add_vertex(
        "Person",
        HashMap::from([("name".to_string(), Value::String("Bob".into()))]),
    );

    // Now use traversal API to add an edge
    // With typed API, add_e().next() returns Option<InMemoryEdge>
    let g = graph.gremlin(Arc::clone(&graph));
    let result = g.add_e("KNOWS").from_id(alice).to_id(bob).next();

    assert!(result.is_some());
    let edge = result.unwrap();
    // Verify it's a valid edge by accessing ID
    let _id = edge.id();

    // Graph should have one edge
    assert_eq!(graph.edge_count(), 1);
}

#[test]
fn cow_unified_traversal_add_e_with_properties() {
    let graph = Arc::new(Graph::new());

    let alice = graph.add_vertex("Person", HashMap::new());
    let bob = graph.add_vertex("Person", HashMap::new());

    // With typed API, add_e().next() returns Option<InMemoryEdge>
    let g = graph.gremlin(Arc::clone(&graph));
    let result = g
        .add_e("KNOWS")
        .from_id(alice)
        .to_id(bob)
        .property("since", 2020i64)
        .next();

    let edge = result.unwrap();
    let edge_id = edge.id();

    // Verify the edge has correct properties
    let snap = graph.snapshot();
    let stored = snap.get_edge(edge_id).unwrap();
    assert_eq!(stored.label, "KNOWS");
    assert_eq!(stored.properties.get("since"), Some(&Value::Int(2020)));
}

#[test]
fn cow_unified_traversal_full_workflow() {
    // Test the complete workflow: add vertices with traversal, add edges, then query
    let graph = Arc::new(Graph::new());
    let g = graph.gremlin(Arc::clone(&graph));

    // Add vertices through traversal API
    // With typed API, add_v().next() returns Option<InMemoryVertex>
    let alice_vertex = g
        .add_v("Person")
        .property("name", "Alice")
        .property("age", 30i64)
        .next()
        .unwrap();
    let bob_vertex = g
        .add_v("Person")
        .property("name", "Bob")
        .property("age", 25i64)
        .next()
        .unwrap();

    // Extract vertex IDs from GraphVertex objects
    let alice_id = alice_vertex.id();
    let bob_id = bob_vertex.id();

    // Add edge through traversal API
    g.add_e("KNOWS")
        .from_id(alice_id)
        .to_id(bob_id)
        .property("since", 2020i64)
        .iterate();

    // Verify the graph structure
    assert_eq!(graph.vertex_count(), 2);
    assert_eq!(graph.edge_count(), 1);

    // Query through traversal API
    let g2 = graph.gremlin(Arc::clone(&graph));

    // Get all people
    let people = g2.v().has_label("Person").to_list();
    assert_eq!(people.len(), 2);

    // Get Alice's outgoing connections
    let g3 = graph.gremlin(Arc::clone(&graph));
    let alice_out = g3.v_id(alice_id).out_label("KNOWS").to_list();
    assert_eq!(alice_out.len(), 1);
}

#[test]
fn cow_unified_traversal_drop_vertex() {
    let graph = Arc::new(Graph::new());
    let g = graph.gremlin(Arc::clone(&graph));

    // Add a vertex - now returns GraphVertex
    let vertex = g.add_v("Person").property("name", "Alice").next().unwrap();
    let vertex_id = vertex.id();

    assert_eq!(graph.vertex_count(), 1);

    // Drop the vertex
    let g2 = graph.gremlin(Arc::clone(&graph));
    g2.v_id(vertex_id).drop().iterate();

    assert_eq!(graph.vertex_count(), 0);
}

#[test]
fn cow_unified_traversal_drop_edge() {
    let graph = Arc::new(Graph::new());

    let alice = graph.add_vertex("Person", HashMap::new());
    let bob = graph.add_vertex("Person", HashMap::new());
    let edge = graph.add_edge(alice, bob, "KNOWS", HashMap::new()).unwrap();

    assert_eq!(graph.edge_count(), 1);

    // Drop the edge through traversal API
    let g = graph.gremlin(Arc::clone(&graph));
    // Note: We need to use e_id to start from a specific edge
    // The e() method exists but e_id() for single edge might need to be added
    // For now, let's use e_ids with a single element
    g.e_ids([edge]).drop().iterate();

    assert_eq!(graph.edge_count(), 0);
    // Vertices should still exist
    assert_eq!(graph.vertex_count(), 2);
}

#[test]
fn cow_unified_traversal_v_returns_all_vertices() {
    let graph = Arc::new(Graph::new());

    // Add vertices directly
    graph.add_vertex("Person", HashMap::new());
    graph.add_vertex("Person", HashMap::new());
    graph.add_vertex("Software", HashMap::new());

    // Query through traversal
    let g = graph.gremlin(Arc::clone(&graph));
    let results = g.v().to_list();

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

#[test]
fn cow_unified_traversal_v_id_returns_specific_vertex() {
    let graph = Arc::new(Graph::new());

    let alice = graph.add_vertex(
        "Person",
        HashMap::from([("name".to_string(), Value::String("Alice".into()))]),
    );
    graph.add_vertex("Person", HashMap::new());

    let g = graph.gremlin(Arc::clone(&graph));
    let results = g.v_id(alice).to_list();

    assert_eq!(results.len(), 1);
    // Now returns GraphVertex, check ID directly
    assert_eq!(results[0].id(), alice);
}

#[test]
fn cow_unified_traversal_chained_steps() {
    let graph = Arc::new(Graph::new());

    let alice = graph.add_vertex(
        "Person",
        HashMap::from([("name".to_string(), Value::String("Alice".into()))]),
    );
    let bob = graph.add_vertex(
        "Person",
        HashMap::from([("name".to_string(), Value::String("Bob".into()))]),
    );
    let software = graph.add_vertex("Software", HashMap::new());

    graph.add_edge(alice, bob, "KNOWS", HashMap::new()).unwrap();
    graph
        .add_edge(alice, software, "CREATED", HashMap::new())
        .unwrap();
    graph
        .add_edge(bob, software, "USES", HashMap::new())
        .unwrap();

    let g = graph.gremlin(Arc::clone(&graph));

    // Alice's friends
    let friends = g.v_id(alice).out_label("KNOWS").to_list();
    assert_eq!(friends.len(), 1);

    // All people who created or use software
    let g2 = graph.gremlin(Arc::clone(&graph));
    let sw_related = g2.v_id(software).in_().has_label("Person").to_list();
    assert_eq!(sw_related.len(), 2);
}

#[test]
fn cow_unified_traversal_count() {
    let graph = Arc::new(Graph::new());
    let g = graph.gremlin(Arc::clone(&graph));

    g.add_v("Person").iterate();
    g.add_v("Person").iterate();
    g.add_v("Software").iterate();

    let g2 = graph.gremlin(Arc::clone(&graph));
    let total = g2.v().count();
    assert_eq!(total, 3);

    let g3 = graph.gremlin(Arc::clone(&graph));
    let people = g3.v().has_label("Person").count();
    assert_eq!(people, 2);
}

#[test]
fn cow_unified_traversal_has_next() {
    let graph = Arc::new(Graph::new());
    let g = graph.gremlin(Arc::clone(&graph));

    // Empty graph should not have vertices
    assert!(!g.v().has_next());

    // Add a vertex
    let g2 = graph.gremlin(Arc::clone(&graph));
    g2.add_v("Person").iterate();

    // Now should have vertices
    let g3 = graph.gremlin(Arc::clone(&graph));
    assert!(g3.v().has_next());
}

// =============================================================================
// Spec 36: Mutation ID Extraction Tests
// =============================================================================

#[test]
fn cow_add_v_id_returns_integer() {
    let graph = Arc::new(Graph::new());
    let g = graph.gremlin(Arc::clone(&graph));

    // Using .id() after add_v() should return the ID as an integer (Value)
    let result = g.add_v("Person").property("name", "Alice").id().next();

    assert!(result.is_some());
    match result.unwrap() {
        Value::Int(id) => assert!(id >= 0),
        other => panic!("Expected Int, got {:?}", other),
    }

    // Verify vertex was actually created
    assert_eq!(graph.vertex_count(), 1);
}

#[test]
fn cow_add_v_without_id_returns_vertex() {
    let graph = Arc::new(Graph::new());
    let g = graph.gremlin(Arc::clone(&graph));

    // Without .id(), add_v().next() now returns GraphVertex with typed API
    let result = g.add_v("Person").next();

    assert!(result.is_some());
    // Just verify we got a valid GraphVertex by accessing its ID
    let _vertex_id = result.unwrap().id();
}

#[test]
fn cow_add_e_id_returns_integer() {
    let graph = Arc::new(Graph::new());
    let alice = graph.add_vertex("Person", HashMap::new());
    let bob = graph.add_vertex("Person", HashMap::new());

    let g = graph.gremlin(Arc::clone(&graph));

    // Note: With typed API, add_e().next() returns GraphEdge
    let result = g.add_e("KNOWS").from_id(alice).to_id(bob).next();

    assert!(result.is_some());
    // Verify we got a valid GraphEdge by accessing its ID
    let edge = result.unwrap();
    let _edge_id = edge.id();

    // Verify edge was created
    assert_eq!(graph.edge_count(), 1);
}

#[test]
fn cow_add_v_id_to_list_returns_integers() {
    let graph = Arc::new(Graph::new());
    let g = graph.gremlin(Arc::clone(&graph));

    // Create multiple vertices and get their IDs
    // Using .id() returns Scalar marker, so we get Value
    let id1 = g.add_v("Person").id().next().unwrap();
    let id2 = g.add_v("Person").id().next().unwrap();
    let id3 = g.add_v("Software").id().next().unwrap();

    // All should be integers
    assert!(matches!(id1, Value::Int(_)));
    assert!(matches!(id2, Value::Int(_)));
    assert!(matches!(id3, Value::Int(_)));

    // IDs should be different
    assert_ne!(id1, id2);
    assert_ne!(id2, id3);

    // Three vertices should exist
    assert_eq!(graph.vertex_count(), 3);
}

#[test]
fn cow_add_v_id_can_be_used_for_edges() {
    let graph = Arc::new(Graph::new());
    let g = graph.gremlin(Arc::clone(&graph));

    // Create vertices using .id() to get integer IDs (Scalar marker)
    let alice_id = match g.add_v("Person").property("name", "Alice").id().next() {
        Some(Value::Int(id)) => VertexId(id as u64),
        other => panic!("Expected Int, got {:?}", other),
    };

    let bob_id = match g.add_v("Person").property("name", "Bob").id().next() {
        Some(Value::Int(id)) => VertexId(id as u64),
        other => panic!("Expected Int, got {:?}", other),
    };

    // Use IDs to create edge
    g.add_e("KNOWS")
        .from_id(alice_id)
        .to_id(bob_id)
        .property("since", 2020i64)
        .iterate();

    // Verify graph structure
    assert_eq!(graph.vertex_count(), 2);
    assert_eq!(graph.edge_count(), 1);

    // Verify edge connects correct vertices
    let g2 = graph.gremlin(Arc::clone(&graph));
    let alice_friends: Vec<Value> = g2
        .v_id(alice_id)
        .out_label("KNOWS")
        .values("name")
        .to_list();
    assert_eq!(alice_friends.len(), 1);
    assert_eq!(alice_friends[0], Value::String("Bob".to_string()));
}

// =============================================================================
// Plan 30: Typed Terminal Method Tests
// =============================================================================
//
// These tests use explicit type annotations to verify at COMPILE TIME that
// terminal methods return the correct types (GraphVertex, GraphEdge, Value).
// If the return types were changed, these tests would fail to compile.

/// Helper to create a test graph with vertices and edges
fn create_typed_test_graph() -> Arc<Graph> {
    let graph = Arc::new(Graph::new());

    let alice = graph.add_vertex(
        "person",
        HashMap::from([("name".to_string(), Value::String("Alice".into()))]),
    );
    let bob = graph.add_vertex(
        "person",
        HashMap::from([("name".to_string(), Value::String("Bob".into()))]),
    );
    let charlie = graph.add_vertex(
        "person",
        HashMap::from([("name".to_string(), Value::String("Charlie".into()))]),
    );

    graph.add_edge(alice, bob, "knows", HashMap::new()).unwrap();
    graph
        .add_edge(bob, charlie, "knows", HashMap::new())
        .unwrap();

    graph
}

// -----------------------------------------------------------------------------
// VertexMarker Terminal Methods
// -----------------------------------------------------------------------------

#[test]
fn cow_typed_vertex_next_returns_graph_vertex() {
    let graph = create_typed_test_graph();
    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: next() must return Option<InMemoryVertex>
    let vertex: Option<InMemoryVertex> = g.v().next();

    assert!(vertex.is_some());
    let v = vertex.unwrap();
    // Verify GraphVertex methods work
    assert!(v.label().is_some());
    assert!(v.property("name").is_some());
}

#[test]
fn cow_typed_vertex_to_list_returns_vec_graph_vertex() {
    let graph = create_typed_test_graph();
    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: to_list() must return Vec<InMemoryVertex>
    let vertices: Vec<InMemoryVertex> = g.v().to_list();

    assert_eq!(vertices.len(), 3);
    for v in &vertices {
        assert!(v.label().is_some());
    }
}

#[test]
fn cow_typed_vertex_one_returns_result_graph_vertex() {
    let graph = create_typed_test_graph();
    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: one() must return Result<InMemoryVertex, TraversalError>
    let result: Result<InMemoryVertex, interstellar::error::TraversalError> =
        g.v().has_value("name", Value::String("Alice".into())).one();

    assert!(result.is_ok());
    let alice = result.unwrap();
    assert_eq!(alice.property("name"), Some(Value::String("Alice".into())));
}

#[test]
fn cow_typed_vertex_to_set_returns_hashset_graph_vertex() {
    let graph = create_typed_test_graph();
    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: to_set() must return HashSet<InMemoryVertex>
    let vertices: HashSet<InMemoryVertex> = g.v().to_set();

    assert_eq!(vertices.len(), 3);
}

#[test]
fn cow_typed_vertex_count_returns_u64() {
    let graph = create_typed_test_graph();
    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: count() must return u64
    let count: u64 = g.v().count();

    assert_eq!(count, 3);
}

// -----------------------------------------------------------------------------
// EdgeMarker Terminal Methods
// -----------------------------------------------------------------------------

#[test]
fn cow_typed_edge_next_returns_graph_edge() {
    let graph = create_typed_test_graph();
    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: next() must return Option<InMemoryEdge>
    let edge: Option<InMemoryEdge> = g.e().next();

    assert!(edge.is_some());
    let e = edge.unwrap();
    // Verify GraphEdge methods work
    assert_eq!(e.label(), Some("knows".to_string()));
    assert!(e.out_v().is_some());
    assert!(e.in_v().is_some());
}

#[test]
fn cow_typed_edge_to_list_returns_vec_graph_edge() {
    let graph = create_typed_test_graph();
    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: to_list() must return Vec<InMemoryEdge>
    let edges: Vec<InMemoryEdge> = g.e().to_list();

    assert_eq!(edges.len(), 2);
    for e in &edges {
        assert_eq!(e.label(), Some("knows".to_string()));
    }
}

#[test]
fn cow_typed_edge_one_returns_result_graph_edge() {
    let graph = Arc::new(Graph::new());
    let a = graph.add_vertex("person", HashMap::new());
    let b = graph.add_vertex("person", HashMap::new());
    graph.add_edge(a, b, "knows", HashMap::new()).unwrap();

    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: one() must return Result<InMemoryEdge, TraversalError>
    let result: Result<InMemoryEdge, interstellar::error::TraversalError> = g.e().one();

    assert!(result.is_ok());
    assert_eq!(result.unwrap().label(), Some("knows".to_string()));
}

#[test]
fn cow_typed_edge_to_set_returns_hashset_graph_edge() {
    let graph = create_typed_test_graph();
    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: to_set() must return HashSet<InMemoryEdge>
    let edges: HashSet<InMemoryEdge> = g.e().to_set();

    assert_eq!(edges.len(), 2);
}

#[test]
fn cow_typed_edge_count_returns_u64() {
    let graph = create_typed_test_graph();
    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: count() must return u64
    let count: u64 = g.e().count();

    assert_eq!(count, 2);
}

// -----------------------------------------------------------------------------
// Scalar Terminal Methods (via .values() or .id())
// -----------------------------------------------------------------------------

#[test]
fn cow_typed_scalar_next_returns_value() {
    let graph = create_typed_test_graph();
    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: values().next() must return Option<Value>
    let value: Option<Value> = g.v().values("name").next();

    assert!(value.is_some());
    assert!(matches!(value.unwrap(), Value::String(_)));
}

#[test]
fn cow_typed_scalar_to_list_returns_vec_value() {
    let graph = create_typed_test_graph();
    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: values().to_list() must return Vec<Value>
    let values: Vec<Value> = g.v().values("name").to_list();

    assert_eq!(values.len(), 3);
    for v in &values {
        assert!(matches!(v, Value::String(_)));
    }
}

#[test]
fn cow_typed_scalar_count_returns_u64() {
    let graph = create_typed_test_graph();
    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: values().count() must return u64
    let count: u64 = g.v().values("name").count();

    assert_eq!(count, 3);
}

// -----------------------------------------------------------------------------
// Mutation Terminal Methods (add_v, add_e)
// -----------------------------------------------------------------------------

#[test]
fn cow_typed_add_v_next_returns_graph_vertex() {
    let graph = Arc::new(Graph::new());
    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: add_v().next() must return Option<InMemoryVertex>
    let vertex: Option<InMemoryVertex> = g.add_v("person").property("name", "Test").next();

    assert!(vertex.is_some());
    let v = vertex.unwrap();
    assert_eq!(v.label(), Some("person".to_string()));
    assert_eq!(v.property("name"), Some(Value::String("Test".into())));
}

#[test]
fn cow_typed_add_v_to_list_returns_vec_graph_vertex() {
    let graph = Arc::new(Graph::new());
    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: add_v().to_list() must return Vec<InMemoryVertex>
    let vertices: Vec<InMemoryVertex> = g.add_v("person").to_list();

    assert_eq!(vertices.len(), 1);
    assert_eq!(vertices[0].label(), Some("person".to_string()));
}

#[test]
fn cow_typed_add_e_next_returns_graph_edge() {
    let graph = Arc::new(Graph::new());
    let a = graph.add_vertex("person", HashMap::new());
    let b = graph.add_vertex("person", HashMap::new());

    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: add_e().next() must return Option<InMemoryEdge>
    let edge: Option<InMemoryEdge> = g.add_e("knows").from_id(a).to_id(b).next();

    assert!(edge.is_some());
    let e = edge.unwrap();
    assert_eq!(e.label(), Some("knows".to_string()));
}

#[test]
fn cow_typed_add_e_to_list_returns_vec_graph_edge() {
    let graph = Arc::new(Graph::new());
    let a = graph.add_vertex("person", HashMap::new());
    let b = graph.add_vertex("person", HashMap::new());

    let g = graph.gremlin(Arc::clone(&graph));

    // COMPILE-TIME CHECK: add_e().to_list() must return Vec<InMemoryEdge>
    let edges: Vec<InMemoryEdge> = g.add_e("knows").from_id(a).to_id(b).to_list();

    assert_eq!(edges.len(), 1);
    assert_eq!(edges[0].label(), Some("knows".to_string()));
}

// -----------------------------------------------------------------------------
// Traversal Step Type Transformations
// -----------------------------------------------------------------------------

#[test]
fn cow_typed_vertex_to_edge_transformation() {
    let graph = create_typed_test_graph();
    let g = graph.gremlin(Arc::clone(&graph));

    // Start with vertices, transform to edges via out_e()
    // COMPILE-TIME CHECK: out_e().to_list() must return Vec<InMemoryEdge>
    let edges: Vec<InMemoryEdge> = g.v().out_e().to_list();

    assert_eq!(edges.len(), 2);
}

#[test]
fn cow_typed_edge_to_vertex_transformation() {
    let graph = create_typed_test_graph();
    let g = graph.gremlin(Arc::clone(&graph));

    // Start with edges, transform to vertices via out_v()
    // COMPILE-TIME CHECK: out_v().to_list() must return Vec<InMemoryVertex>
    let vertices: Vec<InMemoryVertex> = g.e().out_v().to_list();

    assert_eq!(vertices.len(), 2);
}

#[test]
fn cow_typed_vertex_to_scalar_transformation() {
    let graph = create_typed_test_graph();
    let g = graph.gremlin(Arc::clone(&graph));

    // Start with vertices, transform to scalars via values()
    // COMPILE-TIME CHECK: values().to_list() must return Vec<Value>
    let names: Vec<Value> = g.v().values("name").to_list();

    assert_eq!(names.len(), 3);
}

// -----------------------------------------------------------------------------
// GraphVertex/GraphEdge Object Methods
// -----------------------------------------------------------------------------

#[test]
fn cow_typed_graph_vertex_methods() {
    let graph = create_typed_test_graph();
    let g = graph.gremlin(Arc::clone(&graph));

    let alice: InMemoryVertex = g
        .v()
        .has_value("name", Value::String("Alice".into()))
        .one()
        .unwrap();

    // Verify all GraphVertex methods work
    let _id: VertexId = alice.id();
    let _label: Option<String> = alice.label();
    let _prop: Option<Value> = alice.property("name");
    let _props: HashMap<String, Value> = alice.properties();
    let _exists: bool = alice.exists();

    // Can traverse from GraphVertex
    let friends: Vec<InMemoryVertex> = alice.out("knows").to_list();
    assert_eq!(friends.len(), 1);
}

#[test]
fn cow_typed_graph_edge_methods() {
    let graph = Arc::new(Graph::new());
    let a = graph.add_vertex("person", HashMap::new());
    let b = graph.add_vertex("person", HashMap::new());
    graph.add_edge(a, b, "knows", HashMap::new()).unwrap();

    let g = graph.gremlin(Arc::clone(&graph));

    // Use one() since there's exactly one edge
    let edge: InMemoryEdge = g.e().one().unwrap();

    // Verify all GraphEdge methods work
    let _id: EdgeId = edge.id();
    let _label: Option<String> = edge.label();
    let _out_v: Option<InMemoryVertex> = edge.out_v();
    let _in_v: Option<InMemoryVertex> = edge.in_v();
    let _both: Option<(InMemoryVertex, InMemoryVertex)> = edge.both_v();
    let _props: HashMap<String, Value> = edge.properties();
    let _exists: bool = edge.exists();
}