hiroz 0.2.0

//! Graph API tests
//!
//! These tests verify the graph introspection functionality, including:
//! - Getting topic/service names and types
//! - Counting publishers/subscribers/clients/services
//! - Waiting for graph changes
//! - Node discovery and information
//! - Service availability checking

use std::time::Duration;

use hiroz::{
    Builder, Result,
    context::ZContextBuilder,
    entity::{EndpointKind, NodeKey},
};
use hiroz_msgs::{example_interfaces::srv::AddTwoInts, std_msgs::String as RosString};
/// Helper to create a test context and node
async fn setup_test_node(
    node_name: &str,
) -> Result<(hiroz::context::ZContext, hiroz::node::ZNode)> {
    let ctx = ZContextBuilder::default().build()?;
    let node = ctx.create_node(node_name).build()?;

    // Allow time for node discovery
    tokio::time::sleep(Duration::from_millis(100)).await;

    Ok((ctx, node))
}

/// Helper to wait for publishers on a topic
async fn wait_for_publishers(
    node: &hiroz::node::ZNode,
    topic: &str,
    expected_count: usize,
    timeout_ms: u64,
) -> Result<bool> {
    let start = std::time::Instant::now();
    let timeout = Duration::from_millis(timeout_ms);
    loop {
        let count = node.graph().count(EndpointKind::Publisher, topic);
        if count >= expected_count {
            return Ok(true);
        }
        if start.elapsed() >= timeout {
            return Ok(false);
        }
        tokio::time::sleep(Duration::from_millis(10)).await;
    }
}

/// Helper to wait for subscribers on a topic
async fn wait_for_subscribers(
    node: &hiroz::node::ZNode,
    topic: &str,
    expected_count: usize,
    timeout_ms: u64,
) -> Result<bool> {
    let start = std::time::Instant::now();
    let timeout = Duration::from_millis(timeout_ms);
    loop {
        let count = node.graph().count(EndpointKind::Subscription, topic);
        if count >= expected_count {
            return Ok(true);
        }
        if start.elapsed() >= timeout {
            return Ok(false);
        }
        tokio::time::sleep(Duration::from_millis(10)).await;
    }
}

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

    /// Tests getting topic names and types from the graph
    #[tokio::test(flavor = "multi_thread")]
    async fn test_get_topic_names_and_types() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;

        // Get topic names and types - should succeed
        let graph = node.graph().clone();
        let topics = graph.get_topic_names_and_types();

        // Should return a valid result (even if empty or contains only rosout)
        // In a fresh system, we might see /rosout or /parameter_events
        assert!(
            topics.is_empty()
                || topics
                    .iter()
                    .any(|(name, _)| name.contains("rosout") || name.contains("parameter_events"))
        );

        Ok(())
    }

    /// Tests getting service names and types from the graph
    #[tokio::test(flavor = "multi_thread")]
    async fn test_get_service_names_and_types() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;

        // Get service names and types - should succeed
        let graph = node.graph().clone();
        let services = graph.get_service_names_and_types();

        // Should return a valid result (might have node-related services)
        // Fresh node typically has parameter services
        assert!(
            services.is_empty()
                || services
                    .iter()
                    .any(|(name, _)| name.contains("parameter")
                        || name.contains("describe_parameters"))
        );

        Ok(())
    }

    /// Tests counting publishers on a topic
    #[tokio::test(flavor = "multi_thread")]
    async fn test_count_publishers() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;
        let topic_name = "/test_count_publishers";

        // Count publishers on a topic that doesn't exist yet
        let graph = node.graph().clone();
        let count = graph.count(EndpointKind::Publisher, topic_name);

        // Should be 0 or at least return successfully
        assert_eq!(count, 0, "Expected 0 publishers on non-existent topic");

        // Create a publisher
        let _pub = node.create_pub::<RosString>(topic_name).build()?;

        // Allow discovery
        tokio::time::sleep(Duration::from_millis(200)).await;

        // Count again - should see our publisher
        let count = graph.count(EndpointKind::Publisher, topic_name);
        assert!(
            count >= 1,
            "Expected at least 1 publisher after creating one"
        );

        Ok(())
    }

    /// Tests counting subscribers on a topic
    #[tokio::test(flavor = "multi_thread")]
    async fn test_count_subscribers() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;
        let topic_name = "/test_count_subscribers";

        // Count subscribers on a topic that doesn't exist yet
        let graph = node.graph().clone();
        let count = graph.count(EndpointKind::Subscription, topic_name);
        assert_eq!(count, 0, "Expected 0 subscribers on non-existent topic");

        // Create a subscriber
        let _sub = node.create_sub::<RosString>(topic_name).build()?;

        // Allow discovery
        tokio::time::sleep(Duration::from_millis(200)).await;

        // Count again - should see our subscriber
        let count = graph.count(EndpointKind::Subscription, topic_name);
        assert!(
            count >= 1,
            "Expected at least 1 subscriber after creating one"
        );

        Ok(())
    }

    /// Tests counting clients on a service
    #[tokio::test(flavor = "multi_thread")]
    async fn test_count_clients() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;
        let service_name = "/test_count_clients";

        // Count clients on a service that doesn't exist yet
        let graph = node.graph().clone();
        let count = graph.count(EndpointKind::Client, service_name);

        // Should be 0 or at least return successfully
        assert_eq!(count, 0, "Expected 0 clients on non-existent service");

        // Create a client
        let _client = node.create_client::<AddTwoInts>(service_name).build()?;

        // Allow discovery
        tokio::time::sleep(Duration::from_millis(200)).await;

        // Count again - should see our client
        let count = graph.count(EndpointKind::Client, service_name);
        assert!(count >= 1, "Expected at least 1 client after creating one");

        Ok(())
    }

    /// Tests counting services on a service name
    #[tokio::test(flavor = "multi_thread")]
    async fn test_count_services() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;
        let service_name = "/test_count_services";

        // Count services on a service that doesn't exist yet
        let graph = node.graph().clone();
        let count = graph.count(EndpointKind::Service, service_name);

        // Should be 0 or at least return successfully
        assert_eq!(count, 0, "Expected 0 services on non-existent service");

        // Create a service
        let _service = node.create_service::<AddTwoInts>(service_name).build()?;

        // Allow discovery
        tokio::time::sleep(Duration::from_millis(200)).await;

        // Count again - should see our service
        let count = graph.count(EndpointKind::Service, service_name);
        println!("Service count after creation: {}", count);
        assert!(count >= 1, "Expected at least 1 service after creating one");

        Ok(())
    }

    /// Tests getting publisher names and types for a specific node
    #[tokio::test(flavor = "multi_thread")]
    async fn test_get_publisher_names_and_types_by_node() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;
        let topic_name = "/test_pub_by_node";

        // Create a publisher
        let _pub = node.create_pub::<RosString>(topic_name).build()?;

        // Allow discovery
        tokio::time::sleep(Duration::from_millis(500)).await;

        // Get publishers by node
        let graph = node.graph().clone();
        let node_key: NodeKey = ("/".to_string(), "test_graph_node".to_string());

        let entities = graph.get_entities_by_node(EndpointKind::Publisher, node_key);

        // FIXME: In hiroz, local entities may not always be reflected in the graph immediately
        // This test verifies the API works but may return empty for local-only entities
        // The important part is that it doesn't crash and returns a valid result
        if !entities.is_empty() {
            assert!(
                entities
                    .iter()
                    .any(|e| e.topic.contains("test_pub_by_node")),
                "If entities found, should include our specific publisher"
            );
        }

        Ok(())
    }

    /// Tests getting subscriber names and types for a specific node
    #[tokio::test(flavor = "multi_thread")]
    async fn test_get_subscriber_names_and_types_by_node() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;
        let topic_name = "/test_sub_by_node";

        // Create a subscriber
        let _sub = node.create_sub::<RosString>(topic_name).build()?;

        // Allow discovery
        tokio::time::sleep(Duration::from_millis(500)).await;

        // Get subscribers by node
        let graph = node.graph().clone();
        let node_key: NodeKey = ("/".to_string(), "test_graph_node".to_string());

        let entities = graph.get_entities_by_node(EndpointKind::Subscription, node_key);

        // FIXME: In hiroz, local entities may not always be reflected in the graph immediately
        // This test verifies the API works but may return empty for local-only entities
        if !entities.is_empty() {
            assert!(
                entities
                    .iter()
                    .any(|e| e.topic.contains("test_sub_by_node")),
                "If entities found, should include our specific subscriber"
            );
        }

        Ok(())
    }

    /// Tests getting service names and types for a specific node
    #[tokio::test(flavor = "multi_thread")]
    async fn test_get_service_names_and_types_by_node() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;
        let service_name = "/test_service_by_node";

        // Create a service
        let _service = node.create_service::<AddTwoInts>(service_name).build()?;

        // Allow discovery
        tokio::time::sleep(Duration::from_millis(200)).await;

        // Get services by node
        let graph = node.graph().clone();
        // Note: "/" namespace is normalized to "" in NodeEntity::key()
        let node_key: NodeKey = ("".to_string(), "test_graph_node".to_string());

        let entities = graph.get_entities_by_node(EndpointKind::Service, node_key);

        // Should find our service
        assert!(!entities.is_empty(), "Expected to find service by node");
        assert!(
            entities
                .iter()
                .any(|e| e.topic.contains("test_service_by_node")),
            "Expected to find our specific service"
        );

        Ok(())
    }

    /// Tests getting client names and types for a specific node
    #[tokio::test(flavor = "multi_thread")]
    async fn test_get_client_names_and_types_by_node() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;
        let service_name = "/test_client_by_node";

        // Create a client
        let _client = node.create_client::<AddTwoInts>(service_name).build()?;

        // Allow discovery
        tokio::time::sleep(Duration::from_millis(200)).await;

        // Get clients by node
        let graph = node.graph().clone();
        // Note: "/" namespace is normalized to "" in NodeEntity::key()
        let node_key: NodeKey = ("".to_string(), "test_graph_node".to_string());

        let entities = graph.get_entities_by_node(EndpointKind::Client, node_key);

        // Should find our client
        assert!(!entities.is_empty(), "Expected to find client by node");
        assert!(
            entities
                .iter()
                .any(|e| e.topic.contains("test_client_by_node")),
            "Expected to find our specific client"
        );

        Ok(())
    }

    /// Tests graph queries with a hand-crafted graph
    #[tokio::test(flavor = "multi_thread")]
    async fn test_graph_query_functions() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;
        let topic_name = format!(
            "/test_graph_query_{}",
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_nanos()
        );

        let graph = node.graph().clone();

        // Initially, topic should not exist
        let count_pubs = graph.count(EndpointKind::Publisher, &topic_name);
        let count_subs = graph.count(EndpointKind::Subscription, &topic_name);
        assert_eq!(count_pubs, 0, "Expected 0 publishers initially");
        assert_eq!(count_subs, 0, "Expected 0 subscribers initially");

        // Create a publisher
        let pub_handle = node.create_pub::<RosString>(&topic_name).build()?;

        tokio::time::sleep(Duration::from_millis(300)).await;

        // Should see 1 publisher
        let count_pubs = graph.count(EndpointKind::Publisher, &topic_name);
        assert!(
            count_pubs >= 1,
            "Expected at least 1 publisher after creation"
        );

        // Create a subscriber
        let sub_handle = node.create_sub::<RosString>(&topic_name).build()?;

        tokio::time::sleep(Duration::from_millis(300)).await;

        // Should see 1 publisher and 1 subscriber
        let count_pubs = graph.count(EndpointKind::Publisher, &topic_name);
        let count_subs = graph.count(EndpointKind::Subscription, &topic_name);
        assert!(count_pubs >= 1, "Expected at least 1 publisher");
        assert!(count_subs >= 1, "Expected at least 1 subscriber");

        // Drop publisher
        drop(pub_handle);
        tokio::time::sleep(Duration::from_millis(300)).await;

        // Should see 0 publishers, 1 subscriber
        let count_pubs = graph.count(EndpointKind::Publisher, &topic_name);
        let count_subs = graph.count(EndpointKind::Subscription, &topic_name);
        assert_eq!(count_pubs, 0, "Expected 0 publishers after drop");
        assert!(count_subs >= 1, "Expected at least 1 subscriber still");

        // Drop subscriber
        drop(sub_handle);
        tokio::time::sleep(Duration::from_millis(300)).await;

        // Should see 0 publishers, 0 subscribers
        let count_pubs = graph.count(EndpointKind::Publisher, &topic_name);
        let count_subs = graph.count(EndpointKind::Subscription, &topic_name);
        assert_eq!(count_pubs, 0, "Expected 0 publishers after all drops");
        assert_eq!(count_subs, 0, "Expected 0 subscribers after all drops");

        Ok(())
    }

    /// Tests getting all node names from the graph
    #[tokio::test(flavor = "multi_thread")]
    async fn test_get_node_names() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;

        // Get node names
        let graph = node.graph().clone();
        let nodes = graph.get_node_names();

        // Should at least see our own node
        assert!(!nodes.is_empty(), "Expected to find at least one node");
        assert!(
            nodes.iter().any(|(name, _)| name == "test_graph_node"),
            "Expected to find our test node"
        );

        Ok(())
    }

    /// Tests getting all node names with enclaves from the graph
    #[tokio::test(flavor = "multi_thread")]
    async fn test_get_node_names_with_enclaves() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;

        // Get node names with enclaves
        let graph = node.graph().clone();
        let nodes = graph.get_node_names_with_enclaves();

        // Should at least see our own node
        assert!(!nodes.is_empty(), "Expected to find at least one node");
        assert!(
            nodes.iter().any(|(name, _, _)| name == "test_graph_node"),
            "Expected to find our test node with enclave"
        );

        Ok(())
    }

    /// Tests discovering publishers from multiple nodes
    #[tokio::test(flavor = "multi_thread")]
    async fn test_multi_node_publishers() -> Result<()> {
        let (_ctx1, node1) = setup_test_node("test_node_1").await?;
        let (_ctx2, node2) = setup_test_node("test_node_2").await?;

        let topic_name = "/test_multi_node_pub";

        // Create publishers on both nodes
        let _pub1 = node1.create_pub::<RosString>(topic_name).build()?;
        let _pub2 = node2.create_pub::<RosString>(topic_name).build()?;

        // Allow more time for inter-node discovery
        tokio::time::sleep(Duration::from_millis(800)).await;

        // Check from node1's perspective
        let graph1 = node1.graph();
        let count = graph1.count(EndpointKind::Publisher, topic_name);
        // Should see at least one publisher (itself), ideally both
        assert!(
            count >= 1,
            "Expected at least 1 publisher from node1's view, got {}",
            count
        );

        // Check from node2's perspective
        let graph2 = node2.graph();
        let count = graph2.count(EndpointKind::Publisher, topic_name);
        assert!(
            count >= 1,
            "Expected at least 1 publisher from node2's view, got {}",
            count
        );

        Ok(())
    }

    /// Tests discovering subscribers from multiple nodes
    #[tokio::test(flavor = "multi_thread")]
    async fn test_multi_node_subscribers() -> Result<()> {
        let (_ctx1, node1) = setup_test_node("test_node_1").await?;
        let (_ctx2, node2) = setup_test_node("test_node_2").await?;

        let topic_name = "/test_multi_node_sub";

        // Create subscribers on both nodes
        let _sub1 = node1.create_sub::<RosString>(topic_name).build()?;
        let _sub2 = node2.create_sub::<RosString>(topic_name).build()?;

        // Allow more time for inter-node discovery
        tokio::time::sleep(Duration::from_millis(800)).await;

        // Check from node1's perspective
        let graph1 = node1.graph();
        let count = graph1.count(EndpointKind::Subscription, topic_name);
        // Should see at least one subscriber (itself), ideally both
        assert!(
            count >= 1,
            "Expected at least 1 subscriber from node1's view, got {}",
            count
        );

        // Check from node2's perspective
        let graph2 = node2.graph();
        let count = graph2.count(EndpointKind::Subscription, topic_name);
        assert!(
            count >= 1,
            "Expected at least 1 subscriber from node2's view, got {}",
            count
        );

        Ok(())
    }

    /// Tests discovering services from multiple nodes
    #[tokio::test(flavor = "multi_thread")]
    async fn test_multi_node_services() -> Result<()> {
        // Create a single context and multiple nodes to share the graph
        let ctx = ZContextBuilder::default().build()?;
        let node1 = ctx.create_node("test_node_1").build()?;
        let node2 = ctx.create_node("test_node_2").build()?;

        let service_name1 = "/test_multi_node_service_1";
        let service_name2 = "/test_multi_node_service_2";

        // Create services on different nodes
        let _srv1 = node1.create_service::<AddTwoInts>(service_name1).build()?;
        let _srv2 = node2.create_service::<AddTwoInts>(service_name2).build()?;

        tokio::time::sleep(Duration::from_millis(300)).await;

        // Check service discovery from node1's perspective
        let graph1 = node1.graph();
        let services = graph1.get_service_names_and_types();

        // Should see both services
        assert!(
            services.iter().any(|(name, _)| name.contains("service_1")),
            "Expected to find service_1"
        );
        assert!(
            services.iter().any(|(name, _)| name.contains("service_2")),
            "Expected to find service_2"
        );

        Ok(())
    }

    /// Tests discovering clients from multiple nodes
    #[tokio::test(flavor = "multi_thread")]
    async fn test_multi_node_clients() -> Result<()> {
        // Create a single context and multiple nodes to share the graph
        let ctx = ZContextBuilder::default().build()?;
        let node1 = ctx.create_node("test_node_1").build()?;
        let node2 = ctx.create_node("test_node_2").build()?;

        let service_name = "/test_multi_node_client";

        // Create service and clients
        let _srv = node1.create_service::<AddTwoInts>(service_name).build()?;
        let _client1 = node1.create_client::<AddTwoInts>(service_name).build()?;
        let _client2 = node2.create_client::<AddTwoInts>(service_name).build()?;

        tokio::time::sleep(Duration::from_millis(300)).await;

        // Check from graph
        let graph1 = node1.graph();
        let count = graph1.count(EndpointKind::Client, service_name);
        assert!(count >= 2, "Expected at least 2 clients");

        Ok(())
    }

    /// Tests checking if a service server is available
    #[tokio::test(flavor = "multi_thread")]
    async fn test_service_server_is_available() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;
        let service_name = "/test_service_available";

        // Create client
        let client = node.create_client::<AddTwoInts>(service_name).build()?;

        tokio::time::sleep(Duration::from_millis(100)).await;

        // Service should not be available yet
        let graph = node.graph().clone();
        let count = graph.count(EndpointKind::Service, service_name);
        assert_eq!(count, 0, "Expected 0 services before creating server");

        // Create the service
        let _service = node.create_service::<AddTwoInts>(service_name).build()?;

        tokio::time::sleep(Duration::from_millis(300)).await;

        // Service should now be available
        let count = graph.count(EndpointKind::Service, service_name);
        assert!(count >= 1, "Expected at least 1 service after creation");

        // Drop service
        drop(_service);
        tokio::time::sleep(Duration::from_millis(300)).await;

        // Service should no longer be available
        let count = graph.count(EndpointKind::Service, service_name);
        assert_eq!(count, 0, "Expected 0 services after dropping server");

        drop(client);
        Ok(())
    }

    /// Tests the get_entities_by_topic functionality
    #[tokio::test(flavor = "multi_thread")]
    async fn test_get_entities_by_topic() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;
        let topic_name = "/test_entities_by_topic";

        // Create publisher and subscriber
        let _pub = node.create_pub::<RosString>(topic_name).build()?;
        let _sub = node.create_sub::<RosString>(topic_name).build()?;

        tokio::time::sleep(Duration::from_millis(300)).await;

        // Get entities by topic
        let graph = node.graph().clone();
        let pubs = graph.get_entities_by_topic(EndpointKind::Publisher, topic_name);
        let subs = graph.get_entities_by_topic(EndpointKind::Subscription, topic_name);

        // Should find both
        assert!(!pubs.is_empty(), "Expected to find publishers");
        assert!(!subs.is_empty(), "Expected to find subscribers");

        Ok(())
    }

    /// Tests waiting for publishers on a topic
    #[tokio::test(flavor = "multi_thread")]
    async fn test_wait_for_publishers() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;
        let topic_name = "/test_wait_for_publishers";

        // Valid call (expect timeout since there are no publishers)
        let success = wait_for_publishers(&node, topic_name, 1, 100).await?;
        assert!(!success, "Expected timeout since no publishers");

        Ok(())
    }

    /// Tests waiting for subscribers on a topic
    #[tokio::test(flavor = "multi_thread")]
    async fn test_wait_for_subscribers() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;
        let topic_name = "/test_wait_for_subscribers";

        // Valid call (expect timeout since there are no subscribers)
        let success = wait_for_subscribers(&node, topic_name, 1, 100).await?;
        assert!(!success, "Expected timeout since no subscribers");

        Ok(())
    }

    /// Tests getting action names and types from the graph
    #[tokio::test(flavor = "multi_thread")]
    async fn test_action_names_and_types() -> Result<()> {
        let (_ctx, node) = setup_test_node("test_graph_node").await?;

        // Get action names and types
        let graph = node.graph().clone();
        let actions = graph.get_action_names_and_types();

        // FIXME: Should return successfully (may be empty)
        assert!(actions.is_empty() || !actions.is_empty());

        Ok(())
    }
}