use gigabrain::Graph;
use gigabrain::visualization::{GraphVisualizer, VisualizationOptions, VisualizationFormat, LayoutAlgorithm};
use std::sync::Arc;

#[tokio::test]
async fn test_ascii_visualization() {
    let graph = Arc::new(Graph::new());
    
    // Create some test data
    let alice = graph.create_node();
    let bob = graph.create_node();
    
    // Add labels and properties
    {
        let mut schema = graph.schema().write();
        let person_label = schema.get_or_create_label("Person");
        let name_prop = schema.get_or_create_property_key("name");
        let knows_rel = schema.get_or_create_relationship_type("KNOWS");
        drop(schema);
        
        // Add properties and labels to nodes
        graph.update_node(alice, |node| {
            node.add_label(person_label);
            node.properties.insert(name_prop, gigabrain::core::PropertyValue::String("Alice".to_string()));
        }).unwrap();
        
        graph.update_node(bob, |node| {
            node.add_label(person_label);
            node.properties.insert(name_prop, gigabrain::core::PropertyValue::String("Bob".to_string()));
        }).unwrap();
        
        // Create relationship
        let _rel = graph.create_relationship(alice, bob, knows_rel).unwrap();
    }
    
    // Test ASCII visualization
    let options = VisualizationOptions {
        format: VisualizationFormat::Ascii,
        max_nodes: Some(10),
        max_relationships: Some(10),
        include_properties: true,
        include_labels: true,
        layout: LayoutAlgorithm::Hierarchical,
        color_scheme: gigabrain::visualization::ColorScheme::Default,
        node_size: gigabrain::visualization::NodeSize::Medium,
        font_size: gigabrain::visualization::FontSize::Medium,
    };
    
    let visualizer = GraphVisualizer::with_options(graph.clone(), options);
    let result = visualizer.visualize().await;
    
    assert!(result.is_ok());
    let output = result.unwrap();
    assert!(output.contains("Graph Visualization"));
    assert!(output.contains("Alice"));
    assert!(output.contains("Bob"));
    assert!(output.contains("KNOWS"));
}

#[tokio::test]
async fn test_json_visualization() {
    let graph = Arc::new(Graph::new());
    
    // Create test data
    let node1 = graph.create_node();
    let node2 = graph.create_node();
    
    {
        let mut schema = graph.schema().write();
        let test_rel = schema.get_or_create_relationship_type("TEST");
        drop(schema);
        
        let _rel = graph.create_relationship(node1, node2, test_rel).unwrap();
    }
    
    // Test JSON visualization
    let options = VisualizationOptions {
        format: VisualizationFormat::Json,
        max_nodes: Some(5),
        max_relationships: Some(5),
        include_properties: false,
        include_labels: false,
        layout: LayoutAlgorithm::Spring,
        color_scheme: gigabrain::visualization::ColorScheme::Default,
        node_size: gigabrain::visualization::NodeSize::Medium,
        font_size: gigabrain::visualization::FontSize::Medium,
    };
    
    let visualizer = GraphVisualizer::with_options(graph.clone(), options);
    let result = visualizer.visualize().await;
    
    assert!(result.is_ok());
    let output = result.unwrap();
    
    // Parse as JSON to verify it's valid
    let json: serde_json::Value = serde_json::from_str(&output).unwrap();
    assert!(json["nodes"].is_array());
    assert!(json["edges"].is_array());
    assert!(json["metadata"].is_object());
    
    let nodes = json["nodes"].as_array().unwrap();
    let edges = json["edges"].as_array().unwrap();
    
    assert_eq!(nodes.len(), 2);
    assert_eq!(edges.len(), 1);
}

#[tokio::test]
async fn test_dot_visualization() {
    let graph = Arc::new(Graph::new());
    
    // Create simple test data
    let node1 = graph.create_node();
    let node2 = graph.create_node();
    
    {
        let mut schema = graph.schema().write();
        let connects_rel = schema.get_or_create_relationship_type("CONNECTS");
        drop(schema);
        
        let _rel = graph.create_relationship(node1, node2, connects_rel).unwrap();
    }
    
    // Test DOT visualization
    let options = VisualizationOptions {
        format: VisualizationFormat::Dot,
        max_nodes: Some(5),
        max_relationships: Some(5),
        include_properties: true,
        include_labels: true,
        layout: LayoutAlgorithm::Spring,
        color_scheme: gigabrain::visualization::ColorScheme::Light,
        node_size: gigabrain::visualization::NodeSize::Large,
        font_size: gigabrain::visualization::FontSize::Large,
    };
    
    let visualizer = GraphVisualizer::with_options(graph.clone(), options);
    let result = visualizer.visualize().await;
    
    assert!(result.is_ok());
    let output = result.unwrap();
    
    // Check DOT format basics
    assert!(output.starts_with("digraph G"));
    assert!(output.contains("layout=fdp"));
    assert!(output.contains("CONNECTS"));
    assert!(output.ends_with("}\n"));
}

#[tokio::test]
async fn test_svg_visualization() {
    let graph = Arc::new(Graph::new());
    
    // Create test data
    let _node1 = graph.create_node();
    
    // Test SVG visualization
    let options = VisualizationOptions {
        format: VisualizationFormat::Svg,
        max_nodes: Some(1),
        max_relationships: Some(0),
        include_properties: false,
        include_labels: false,
        layout: LayoutAlgorithm::Circular,
        color_scheme: gigabrain::visualization::ColorScheme::Colorful,
        node_size: gigabrain::visualization::NodeSize::Small,
        font_size: gigabrain::visualization::FontSize::Small,
    };
    
    let visualizer = GraphVisualizer::with_options(graph.clone(), options);
    let result = visualizer.visualize().await;
    
    assert!(result.is_ok());
    let output = result.unwrap();
    
    // Check SVG format basics
    assert!(output.starts_with("<svg"));
    assert!(output.contains("xmlns=\"http://www.w3.org/2000/svg\""));
    assert!(output.contains("Graph Visualization"));
    assert!(output.ends_with("</svg>\n"));
}

#[tokio::test]
async fn test_empty_graph_visualization() {
    let graph = Arc::new(Graph::new());
    
    let options = VisualizationOptions::default();
    let visualizer = GraphVisualizer::with_options(graph.clone(), options);
    let result = visualizer.visualize().await;
    
    assert!(result.is_ok());
    let output = result.unwrap();
    assert!(output.contains("Empty graph"));
}

#[test]
fn test_visualization_stats() {
    let graph = Arc::new(Graph::new());
    
    // Create test data
    let node1 = graph.create_node();
    let node2 = graph.create_node();
    
    {
        let mut schema = graph.schema().write();
        let test_rel = schema.get_or_create_relationship_type("TEST");
        drop(schema);
        
        let _rel = graph.create_relationship(node1, node2, test_rel).unwrap();
    }
    
    let visualizer = GraphVisualizer::new(graph);
    let stats = visualizer.get_stats();
    
    assert_eq!(stats.node_count, 2);
    assert_eq!(stats.edge_count, 1);
    assert!(stats.avg_degree > 0.0);
    assert!(stats.max_degree > 0);
}