erpc_analysis/

db_trait.rs

use async_trait::async_trait;
use std::collections::HashMap;
use thiserror::Error;

use crate::models::metrics::{
    CentralityAnalysisResult, GraphMetrics, NodeMetrics, PathAnalysisResult,
    PathResult,
};
use crate::models::partitions::ComponentAnalysisResult;

/// Represents errors that can occur during analysis operations, including
/// database interactions.
#[derive(Error, Debug)]
pub enum AnalysisError {
    /// An error originating from the underlying database driver (neo4rs).
    #[error("Database Driver Error: {0}")]
    DriverError(#[from] neo4rs::Error),

    /// Failed to establish an initial connection to the database.
    #[error("Failed to connect to database: {0}")]
    ConnectionFailed(String),

    /// An error occurred while attempting to drop an existing
    /// GDS graph projection.
    #[error(
        "Failed to drop graph projection '{projection_name}': {source_error}"
    )]
    ProjectionDropFailed {
        projection_name: String,
        source_error: String,
    },

    /// An error occurred during the creation of a GDS graph projection.
    #[error(
        "Failed to create graph projection '{projection_name}': {source_error}"
    )]
    ProjectionCreationFailed {
        projection_name: String,
        source_error: String,
    },

    /// A generic error for database query execution failures not covered by
    /// other specific variants.
    #[error("Database query execution failed: {0}")]
    QueryFailed(String),

    /// Indicates that a requested GDS graph projection was not found.
    #[error("GDS graph projection '{0}' not found.")]
    ProjectionNotFound(String),

    /// Indicates that a GDS graph projection already exists when it
    /// was not expected.
    #[error("GDS graph projection '{0}' already exists.")]
    ProjectionAlreadyExists(String),

    /// An error occurred during the execution of a graph algorithm.
    #[error("Graph algorithm execution failed: {0}")]
    AlgorithmError(String),

    /// For configuration-related errors during analysis setup.
    #[error("Analysis configuration error: {0}")]
    ConfigurationError(String),

    /// For I/O errors that might occur (e.g., reading a script file
    /// for a query).
    #[error("I/O error: {0}")]
    IoError(#[from] std::io::Error),

    /// For any other general error encountered during analysis.
    #[error("An unexpected analysis error occurred: {0}")]
    Generic(String),
}

/// Parameters for creating a GDS graph projection.
#[derive(Debug, Clone)]
pub struct GraphProjectionParams {
    pub projection_name: String,
    pub node_label: String,
    pub relationship_types: HashMap<String, String>,
    pub relationship_properties_to_project: Option<Vec<String>>,
}

/// Trait defining the interface for database operations required by
/// the eRPC analysis engine.
#[async_trait]
pub trait AnalysisDatabase: Send + Sync {
    /// Creates or recreates a GDS graph projection.
    /// If a projection with the same name exists, it should ideally be dropped
    /// and recreated.
    async fn create_graph_projection(
        &self,
        params: &GraphProjectionParams,
    ) -> Result<(), AnalysisError>;

    /// Deletes an existing GDS graph projection if it exists.
    /// Should succeed even if the projection does not exist (making
    /// it idempotent).
    async fn delete_graph_projection(
        &self,
        projection_name: &str,
    ) -> Result<(), AnalysisError>;

    /// Checks if a GDS graph projection with the given name exists.
    async fn check_graph_projection_exists(
        &self,
        projection_name: &str,
    ) -> Result<bool, AnalysisError>;

    /// Calculates node-level degree metrics for all nodes in a
    /// given GDS projection.
    /// Returns a vector of NodeMetrics containing in-degree,
    /// out-degree, and total degree for each node in the graph.
    async fn calculate_node_degrees(
        &self,
        projection_name: &str,
    ) -> Result<Vec<NodeMetrics>, AnalysisError>;

    /// Calculates comprehensive graph metrics for a given GDS projection
    /// including basic counts, degree distribution, and degree statistics.
    async fn calculate_graph_metrics(
        &self,
        projection_name: &str,
    ) -> Result<GraphMetrics, AnalysisError>;

    /// Calculates weakly connected components using Neo4j GDS WCC algorithm.
    /// Returns analysis results containing components, sizes, and statistics.
    async fn calculate_weakly_connected_components(
        &self,
        projection_name: &str,
    ) -> Result<ComponentAnalysisResult, AnalysisError>;

    /// Calculates strongly connected components using Neo4j GDS SCC algorithm.
    /// Returns analysis results containing components, sizes, and statistics.
    async fn calculate_strongly_connected_components(
        &self,
        projection_name: &str,
    ) -> Result<ComponentAnalysisResult, AnalysisError>;

    /// Calculates communities using Neo4j GDS Louvain algorithm.
    /// Returns analysis results containing communities, sizes, and statistics.
    async fn calculate_louvain_communities(
        &self,
        projection_name: &str,
        params: &crate::config::LouvainConfig,
    ) -> Result<ComponentAnalysisResult, AnalysisError>;

    /// Calculates communities using Neo4j GDS Label Propagation algorithm.
    /// Returns analysis results containing communities, sizes, and statistics.
    async fn calculate_label_propagation_communities(
        &self,
        projection_name: &str,
        params: &crate::config::LabelPropagationConfig,
    ) -> Result<ComponentAnalysisResult, AnalysisError>;

    /// Calculates modularity score for a given community assignment.
    /// Higher modularity indicates better community structure.
    async fn calculate_modularity(
        &self,
        projection_name: &str,
        community_property: &str,
    ) -> Result<f64, AnalysisError>;

    /// Classifies connected components by geographic location (country).
    /// Groups relays by country and analyzes their distribution across
    /// components.
    async fn classify_components_by_geography(
        &self,
        components: &[crate::models::partitions::ConnectedComponent],
    ) -> Result<
        crate::models::partitions::PartitionClassificationResult,
        AnalysisError,
    >;

    /// Classifies connected components by ASN.
    /// Groups relays by ASN and analyzes their distribution across components.
    async fn classify_components_by_asn(
        &self,
        components: &[crate::models::partitions::ConnectedComponent],
    ) -> Result<
        crate::models::partitions::PartitionClassificationResult,
        AnalysisError,
    >;

    /// Classifies connected components by relay family relationships.
    /// Groups relays by family membership and analyzes their distribution
    /// across components.
    async fn classify_components_by_family(
        &self,
        components: &[crate::models::partitions::ConnectedComponent],
    ) -> Result<
        crate::models::partitions::PartitionClassificationResult,
        AnalysisError,
    >;

    /// Calculates betweenness centrality for nodes in a GDS projection.
    /// Uses Neo4j GDS betweenness centrality algorithm to identify nodes
    /// that act as bridges between other nodes.
    async fn calculate_betweenness_centrality(
        &self,
        projection_name: &str,
        sampling_size: Option<usize>,
        sampling_seed: Option<u64>,
    ) -> Result<CentralityAnalysisResult, AnalysisError>;

    /// Calculates closeness centrality for nodes in a GDS projection.
    /// Uses Neo4j GDS closeness centrality algorithm to identify nodes
    /// that are close to all other nodes in the network.
    async fn calculate_closeness_centrality(
        &self,
        projection_name: &str,
        use_wasserman_faust: Option<bool>,
    ) -> Result<CentralityAnalysisResult, AnalysisError>;

    /// Calculates both betweenness and closeness centrality
    async fn calculate_combined_centrality(
        &self,
        projection_name: &str,
        betweenness_sampling_size: Option<usize>,
        betweenness_sampling_seed: Option<u64>,
        use_wasserman_faust: Option<bool>,
    ) -> Result<CentralityAnalysisResult, AnalysisError>;

    /// Analyzes shortest paths between nodes from different communities.
    /// Uses Neo4j GDS shortest path algorithms to understand
    /// inter-community connectivity.
    async fn analyze_paths_between_communities(
        &self,
        projection_name: &str,
        source_nodes: &[String],
        target_nodes: &[String],
    ) -> Result<PathAnalysisResult, AnalysisError>;
}

/// Mock database implementation for testing purposes
pub mod mock {
    use super::*;
    use std::collections::HashMap;
    use std::sync::RwLock;

    use crate::models::metrics::{CentralityDistribution, CentralityMetrics};
    use crate::models::partitions::ConnectedComponent;

    /// Simple in-memory mock database for testing
    #[derive(Debug)]
    pub struct MockDatabase {
        pub projections: RwLock<HashMap<String, MockProjection>>,
        pub should_fail_on: Option<String>, // Operation that should fail
        pub call_count: RwLock<HashMap<String, usize>>, // Track method calls
    }

    #[derive(Debug, Clone)]
    pub struct MockProjection {
        pub name: String,
        pub node_count: i64,
        pub relationship_count: i64,
        pub nodes: Vec<NodeMetrics>,
    }

    impl Default for MockDatabase {
        fn default() -> Self {
            Self {
                projections: RwLock::new(HashMap::new()),
                should_fail_on: None,
                call_count: RwLock::new(HashMap::new()),
            }
        }
    }

    impl MockDatabase {
        pub fn new() -> Self {
            Self::default()
        }

        /// Add a test projection with predefined data
        pub fn with_projection(
            self,
            name: &str,
            nodes: Vec<NodeMetrics>,
        ) -> Self {
            let node_count = nodes.len() as i64;
            let relationship_count =
                nodes.iter().map(|n| n.total_degree).sum::<i64>();

            self.projections.write().unwrap().insert(
                name.to_string(),
                MockProjection {
                    name: name.to_string(),
                    node_count,
                    relationship_count,
                    nodes,
                },
            );
            self
        }

        /// Configure the mock to fail on a specific operation
        pub fn fail_on(mut self, operation: &str) -> Self {
            self.should_fail_on = Some(operation.to_string());
            self
        }

        /// Get the number of times a method was called
        pub fn get_call_count(&self, method: &str) -> usize {
            self.call_count
                .read()
                .unwrap()
                .get(method)
                .copied()
                .unwrap_or(0)
        }

        fn increment_call_count(&self, method: &str) {
            *self
                .call_count
                .write()
                .unwrap()
                .entry(method.to_string())
                .or_insert(0) += 1;
        }

        fn should_fail(&self, operation: &str) -> bool {
            self.should_fail_on
                .as_ref()
                .is_some_and(|fail_op| fail_op == operation)
        }

        // Helper function to deterministically assign countries based on relay
        // fingerprint
        fn get_mock_country_for_relay(relay: &str) -> String {
            let hash = relay.bytes().map(|b| b as u32).sum::<u32>();
            match hash % 4 {
                0 => "US".to_string(),
                1 => "DE".to_string(),
                2 => "FR".to_string(),
                _ => "NL".to_string(),
            }
        }

        // Helper function to deterministically assign ASNs based on relay
        // fingerprint
        fn get_mock_asn_for_relay(relay: &str) -> String {
            let hash = relay.bytes().map(|b| b as u32).sum::<u32>();
            match hash % 3 {
                0 => "13335".to_string(),  // Cloudflare
                1 => "210558".to_string(), // Tor-related ASN
                _ => "64512".to_string(),  // Private ASN
            }
        }

        // Helper function to deterministically assign families based on relay
        // fingerprint
        fn get_mock_family_for_relay(relay: &str) -> Option<String> {
            let hash = relay.bytes().map(|b| b as u32).sum::<u32>();
            match hash % 5 {
                0 => Some("family_torproject_main".to_string()),
                1 => Some("family_hackingteam".to_string()),
                2 => Some("family_small_fragmented".to_string()),
                3 => Some("family_test_small".to_string()),
                _ => None,
            }
        }

        /// Calculates classification metrics for partition analysis groups
        fn calculate_classification_metrics(
            groups: &[crate::models::partitions::ClassificationGroup],
            components: &[crate::models::partitions::ConnectedComponent],
        ) -> crate::models::partitions::ClassificationMetrics {
            // Calculate basic metrics
            let total_relays: usize =
                components.iter().map(|c| c.relay_fingerprints.len()).sum();
            let total_classified: usize =
                groups.iter().map(|g| g.relay_fingerprints.len()).sum();

            let coverage = if total_relays > 0 {
                (total_classified as f64 / total_relays as f64) * 100.0
            } else {
                0.0
            };

            let groups_with_partitions = groups
                .iter()
                .filter(|g| g.component_mapping.len() > 1)
                .count();

            let largest_group_size = groups
                .iter()
                .map(|g| g.relay_fingerprints.len())
                .max()
                .unwrap_or(0);

            let average_group_size = if !groups.is_empty() {
                total_classified as f64 / groups.len() as f64
            } else {
                0.0
            };

            // Calculate diversity score (Shannon entropy-like metric)
            let diversity_score = if !groups.is_empty() && total_classified > 0
            {
                let total_relays_f64 = total_classified as f64;
                let entropy = groups
                    .iter()
                    .map(|g| {
                        g.relay_fingerprints.len() as f64 / total_relays_f64
                    })
                    .filter(|&p| p > 0.0)
                    .map(|p| -p * p.ln())
                    .sum::<f64>();

                entropy / (groups.len() as f64).ln()
            } else {
                0.0
            };

            // Calculate partition correlation
            let partition_correlation = if !groups.is_empty() {
                groups.iter().map(|g| g.isolation_score).sum::<f64>()
                    / groups.len() as f64
                    / 100.0
            } else {
                0.0
            };

            crate::models::partitions::ClassificationMetrics {
                total_groups: groups.len(),
                groups_with_partitions,
                classification_coverage: coverage,
                largest_group_size,
                average_group_size,
                diversity_score,
                partition_correlation,
            }
        }
    }

    #[async_trait]
    impl AnalysisDatabase for MockDatabase {
        async fn create_graph_projection(
            &self,
            params: &GraphProjectionParams,
        ) -> Result<(), AnalysisError> {
            self.increment_call_count("create_graph_projection");

            if self.should_fail("create_graph_projection") {
                return Err(AnalysisError::ProjectionCreationFailed {
                    projection_name: params.projection_name.clone(),
                    source_error: "Mock failure".to_string(),
                });
            }

            // Mock successful creation
            self.projections.write().unwrap().insert(
                params.projection_name.clone(),
                MockProjection {
                    name: params.projection_name.clone(),
                    node_count: 0,
                    relationship_count: 0,
                    nodes: vec![],
                },
            );

            Ok(())
        }

        async fn delete_graph_projection(
            &self,
            projection_name: &str,
        ) -> Result<(), AnalysisError> {
            self.increment_call_count("delete_graph_projection");

            if self.should_fail("delete_graph_projection") {
                return Err(AnalysisError::ProjectionDropFailed {
                    projection_name: projection_name.to_string(),
                    source_error: "Mock failure".to_string(),
                });
            }

            // Always succeed (idempotent)
            self.projections.write().unwrap().remove(projection_name);
            Ok(())
        }

        async fn check_graph_projection_exists(
            &self,
            projection_name: &str,
        ) -> Result<bool, AnalysisError> {
            self.increment_call_count("check_graph_projection_exists");

            if self.should_fail("check_graph_projection_exists") {
                return Err(AnalysisError::QueryFailed(
                    "Mock failure".to_string(),
                ));
            }

            Ok(self
                .projections
                .read()
                .unwrap()
                .contains_key(projection_name))
        }

        async fn calculate_node_degrees(
            &self,
            projection_name: &str,
        ) -> Result<Vec<NodeMetrics>, AnalysisError> {
            self.increment_call_count("calculate_node_degrees");

            if self.should_fail("calculate_node_degrees") {
                return Err(AnalysisError::QueryFailed(
                    "Mock failure".to_string(),
                ));
            }

            match self.projections.read().unwrap().get(projection_name) {
                Some(projection) => Ok(projection.nodes.clone()),
                None => Err(AnalysisError::ProjectionNotFound(
                    projection_name.to_string(),
                )),
            }
        }

        async fn calculate_graph_metrics(
            &self,
            projection_name: &str,
        ) -> Result<GraphMetrics, AnalysisError> {
            self.increment_call_count("calculate_graph_metrics");

            if self.should_fail("calculate_graph_metrics") {
                return Err(AnalysisError::QueryFailed(
                    "Mock failure".to_string(),
                ));
            }

            match self.projections.read().unwrap().get(projection_name) {
                Some(projection) => {
                    let mut degree_distribution = HashMap::new();
                    let mut total_degree_sum = 0i64;
                    let mut max_degree = 0i64;
                    let mut min_degree = i64::MAX;

                    for node in &projection.nodes {
                        let degree = node.total_degree;
                        *degree_distribution.entry(degree).or_insert(0) += 1;
                        total_degree_sum += degree;
                        max_degree = max_degree.max(degree);
                        min_degree = min_degree.min(degree);
                    }

                    if min_degree == i64::MAX {
                        min_degree = 0;
                    }

                    let average_degree = if !projection.nodes.is_empty() {
                        total_degree_sum as f64 / projection.nodes.len() as f64
                    } else {
                        0.0
                    };

                    Ok(GraphMetrics {
                        node_count: Some(projection.node_count),
                        relationship_count: Some(
                            projection.relationship_count,
                        ),
                        degree_distribution: Some(degree_distribution),
                        average_degree: Some(average_degree),
                        max_degree: Some(max_degree),
                        min_degree: Some(min_degree),
                    })
                }
                None => Err(AnalysisError::ProjectionNotFound(
                    projection_name.to_string(),
                )),
            }
        }

        async fn calculate_weakly_connected_components(
            &self,
            projection_name: &str,
        ) -> Result<ComponentAnalysisResult, AnalysisError> {
            self.increment_call_count("calculate_weakly_connected_components");

            if self.should_fail("calculate_weakly_connected_components") {
                return Err(AnalysisError::AlgorithmError(
                    "Mock failure".to_string(),
                ));
            }

            match self.projections.read().unwrap().get(projection_name) {
                Some(projection) => {
                    // Mock WCC analysis: create realistic mock components
                    let mut components = Vec::new();

                    if !projection.nodes.is_empty() {
                        // For mock purposes, create varied component structures
                        if projection.nodes.len() > 2 {
                            // First component with first half of nodes
                            let mid = projection.nodes.len() / 2;
                            let first_component_fingerprints: Vec<String> =
                                projection.nodes[0..mid]
                                    .iter()
                                    .map(|n| n.fingerprint.clone())
                                    .collect();

                            components.push(ConnectedComponent {
                                component_id: 0,
                                relay_fingerprints:
                                    first_component_fingerprints.clone(),
                                size: first_component_fingerprints.len(),
                            });

                            // Second component with remaining nodes
                            let second_component_fingerprints: Vec<String> =
                                projection.nodes[mid..]
                                    .iter()
                                    .map(|n| n.fingerprint.clone())
                                    .collect();

                            components.push(ConnectedComponent {
                                component_id: 1,
                                relay_fingerprints:
                                    second_component_fingerprints.clone(),
                                size: second_component_fingerprints.len(),
                            });
                        } else {
                            // Single component with all nodes
                            let all_fingerprints: Vec<String> = projection
                                .nodes
                                .iter()
                                .map(|n| n.fingerprint.clone())
                                .collect();

                            components.push(ConnectedComponent {
                                component_id: 0,
                                relay_fingerprints: all_fingerprints.clone(),
                                size: all_fingerprints.len(),
                            });
                        }
                    }

                    // Sort components by size (largest first)
                    components.sort_by(|a, b| b.size.cmp(&a.size));

                    // Calculate statistics
                    let total_components = components.len();
                    let largest_component_size =
                        components.first().map(|c| c.size).unwrap_or(0);
                    let smallest_component_size =
                        components.last().map(|c| c.size).unwrap_or(0);

                    // Calculate size distribution
                    let mut component_size_distribution = HashMap::new();
                    for component in &components {
                        *component_size_distribution
                            .entry(component.size)
                            .or_insert(0) += 1;
                    }

                    // Calculate isolation ratio
                    let total_nodes = projection.nodes.len();
                    let isolation_ratio = if total_nodes > 0 {
                        (largest_component_size as f64 / total_nodes as f64)
                            * 100.0
                    } else {
                        0.0
                    };

                    Ok(ComponentAnalysisResult {
                        components,
                        total_components: Some(total_components),
                        largest_component_size: Some(largest_component_size),
                        smallest_component_size: Some(smallest_component_size),
                        component_size_distribution: Some(
                            component_size_distribution,
                        ),
                        isolation_ratio: Some(isolation_ratio),
                        // WCC analysis doesn't calculate modularity
                        modularity: None,
                    })
                }
                None => Err(AnalysisError::ProjectionNotFound(
                    projection_name.to_string(),
                )),
            }
        }

        async fn calculate_strongly_connected_components(
            &self,
            projection_name: &str,
        ) -> Result<ComponentAnalysisResult, AnalysisError> {
            self.increment_call_count(
                "calculate_strongly_connected_components",
            );

            if self.should_fail("calculate_strongly_connected_components") {
                return Err(AnalysisError::AlgorithmError(
                    "Mock failure".to_string(),
                ));
            }

            match self.projections.read().unwrap().get(projection_name) {
                Some(projection) => {
                    // Mock SCC analysis: create realistic mock components
                    let mut components = Vec::new();

                    if !projection.nodes.is_empty() {
                        // For mock purposes, create varied component structures
                        if projection.nodes.len() > 2 {
                            // First component with first half of nodes
                            let mid = projection.nodes.len() / 2;
                            let first_component_fingerprints: Vec<String> =
                                projection.nodes[0..mid]
                                    .iter()
                                    .map(|n| n.fingerprint.clone())
                                    .collect();

                            components.push(ConnectedComponent {
                                component_id: 0,
                                relay_fingerprints:
                                    first_component_fingerprints.clone(),
                                size: first_component_fingerprints.len(),
                            });

                            // Second component with remaining nodes
                            let second_component_fingerprints: Vec<String> =
                                projection.nodes[mid..]
                                    .iter()
                                    .map(|n| n.fingerprint.clone())
                                    .collect();

                            components.push(ConnectedComponent {
                                component_id: 1,
                                relay_fingerprints:
                                    second_component_fingerprints.clone(),
                                size: second_component_fingerprints.len(),
                            });
                        } else {
                            // Single component with all nodes
                            let all_fingerprints: Vec<String> = projection
                                .nodes
                                .iter()
                                .map(|n| n.fingerprint.clone())
                                .collect();

                            components.push(ConnectedComponent {
                                component_id: 0,
                                relay_fingerprints: all_fingerprints.clone(),
                                size: all_fingerprints.len(),
                            });
                        }
                    }

                    // Sort components by size (largest first)
                    components.sort_by(|a, b| b.size.cmp(&a.size));

                    // Calculate statistics
                    let total_components = components.len();
                    let largest_component_size =
                        components.first().map(|c| c.size).unwrap_or(0);
                    let smallest_component_size =
                        components.last().map(|c| c.size).unwrap_or(0);

                    // Calculate size distribution correctly
                    let mut component_size_distribution = HashMap::new();
                    for component in &components {
                        *component_size_distribution
                            .entry(component.size)
                            .or_insert(0) += 1;
                    }

                    // Calculate isolation ratio
                    let total_nodes = projection.nodes.len();
                    let isolation_ratio = if total_nodes > 0 {
                        (largest_component_size as f64 / total_nodes as f64)
                            * 100.0
                    } else {
                        0.0
                    };

                    Ok(ComponentAnalysisResult {
                        components,
                        total_components: Some(total_components),
                        largest_component_size: Some(largest_component_size),
                        smallest_component_size: Some(smallest_component_size),
                        component_size_distribution: Some(
                            component_size_distribution,
                        ),
                        isolation_ratio: Some(isolation_ratio),
                        // SCC analysis doesn't calculate modularity
                        modularity: None,
                    })
                }
                None => Err(AnalysisError::ProjectionNotFound(
                    projection_name.to_string(),
                )),
            }
        }

        async fn calculate_louvain_communities(
            &self,
            projection_name: &str,
            _params: &crate::config::LouvainConfig,
        ) -> Result<ComponentAnalysisResult, AnalysisError> {
            self.increment_call_count("calculate_louvain_communities");

            if self.should_fail("calculate_louvain_communities") {
                return Err(AnalysisError::AlgorithmError(
                    "Mock failure".to_string(),
                ));
            }

            match self.projections.read().unwrap().get(projection_name) {
                Some(projection) => {
                    let mut communities = Vec::new();

                    if !projection.nodes.is_empty() {
                        // For mock purposes, create varied community
                        // structures
                        if projection.nodes.len() > 2 {
                            // First community with first half of nodes
                            let mid = projection.nodes.len() / 2;
                            let first_community_fingerprints: Vec<String> =
                                projection.nodes[0..mid]
                                    .iter()
                                    .map(|n| n.fingerprint.clone())
                                    .collect();

                            communities.push(ConnectedComponent {
                                component_id: 0,
                                relay_fingerprints:
                                    first_community_fingerprints.clone(),
                                size: first_community_fingerprints.len(),
                            });

                            // Second community with remaining nodes
                            let second_community_fingerprints: Vec<String> =
                                projection.nodes[mid..]
                                    .iter()
                                    .map(|n| n.fingerprint.clone())
                                    .collect();

                            communities.push(ConnectedComponent {
                                component_id: 1,
                                relay_fingerprints:
                                    second_community_fingerprints.clone(),
                                size: second_community_fingerprints.len(),
                            });
                        } else {
                            // Single community with all nodes
                            let all_fingerprints: Vec<String> = projection
                                .nodes
                                .iter()
                                .map(|n| n.fingerprint.clone())
                                .collect();

                            communities.push(ConnectedComponent {
                                component_id: 0,
                                relay_fingerprints: all_fingerprints.clone(),
                                size: all_fingerprints.len(),
                            });
                        }
                    }

                    // Sort communities by size (largest first)
                    communities.sort_by(|a, b| b.size.cmp(&a.size));

                    // Calculate statistics
                    let total_communities = communities.len();
                    let largest_community_size =
                        communities.first().map(|c| c.size).unwrap_or(0);
                    let smallest_community_size =
                        communities.last().map(|c| c.size).unwrap_or(0);

                    // Calculate size distribution
                    let mut community_size_distribution = HashMap::new();
                    for community in &communities {
                        *community_size_distribution
                            .entry(community.size)
                            .or_insert(0) += 1;
                    }

                    // Calculate isolation ratio
                    let total_nodes = projection.nodes.len();
                    let isolation_ratio = if total_nodes > 0 {
                        (largest_community_size as f64 / total_nodes as f64)
                            * 100.0
                    } else {
                        0.0
                    };

                    Ok(ComponentAnalysisResult {
                        components: communities,
                        total_components: Some(total_communities),
                        largest_component_size: Some(largest_community_size),
                        smallest_component_size: Some(smallest_community_size),
                        component_size_distribution: Some(
                            community_size_distribution,
                        ),
                        isolation_ratio: Some(isolation_ratio),
                        // Mock modularity score for Louvain comm. detection
                        modularity: Some(0.42),
                    })
                }
                None => Err(AnalysisError::ProjectionNotFound(
                    projection_name.to_string(),
                )),
            }
        }

        async fn calculate_label_propagation_communities(
            &self,
            projection_name: &str,
            _params: &crate::config::LabelPropagationConfig,
        ) -> Result<ComponentAnalysisResult, AnalysisError> {
            self.increment_call_count(
                "calculate_label_propagation_communities",
            );

            if self.should_fail("calculate_label_propagation_communities") {
                return Err(AnalysisError::AlgorithmError(
                    "Mock failure".to_string(),
                ));
            }

            match self.projections.read().unwrap().get(projection_name) {
                Some(projection) => {
                    let mut communities = Vec::new();

                    if !projection.nodes.is_empty() {
                        // For mock purposes, create varied community
                        // structures
                        // Label Propagation tends to create more communities
                        // than Louvain
                        if projection.nodes.len() > 3 {
                            let third = projection.nodes.len() / 3;

                            // First community
                            let first_community_fingerprints: Vec<String> =
                                projection.nodes[0..third]
                                    .iter()
                                    .map(|n| n.fingerprint.clone())
                                    .collect();

                            communities.push(ConnectedComponent {
                                component_id: 0,
                                relay_fingerprints:
                                    first_community_fingerprints.clone(),
                                size: first_community_fingerprints.len(),
                            });

                            // Second community
                            let second_community_fingerprints: Vec<String> =
                                projection.nodes[third..2 * third]
                                    .iter()
                                    .map(|n| n.fingerprint.clone())
                                    .collect();

                            communities.push(ConnectedComponent {
                                component_id: 1,
                                relay_fingerprints:
                                    second_community_fingerprints.clone(),
                                size: second_community_fingerprints.len(),
                            });

                            // Third community with remaining nodes
                            let third_community_fingerprints: Vec<String> =
                                projection.nodes[2 * third..]
                                    .iter()
                                    .map(|n| n.fingerprint.clone())
                                    .collect();

                            communities.push(ConnectedComponent {
                                component_id: 2,
                                relay_fingerprints:
                                    third_community_fingerprints.clone(),
                                size: third_community_fingerprints.len(),
                            });
                        } else {
                            // Single community with all nodes for small graphs
                            let all_fingerprints: Vec<String> = projection
                                .nodes
                                .iter()
                                .map(|n| n.fingerprint.clone())
                                .collect();

                            communities.push(ConnectedComponent {
                                component_id: 0,
                                relay_fingerprints: all_fingerprints.clone(),
                                size: all_fingerprints.len(),
                            });
                        }
                    }

                    // Sort communities by size (largest first)
                    communities.sort_by(|a, b| b.size.cmp(&a.size));

                    // Calculate statistics
                    let total_communities = communities.len();
                    let largest_community_size =
                        communities.first().map(|c| c.size).unwrap_or(0);
                    let smallest_community_size =
                        communities.last().map(|c| c.size).unwrap_or(0);

                    // Calculate size distribution
                    let mut community_size_distribution = HashMap::new();
                    for community in &communities {
                        *community_size_distribution
                            .entry(community.size)
                            .or_insert(0) += 1;
                    }

                    // Calculate isolation ratio
                    let total_nodes = projection.nodes.len();
                    let isolation_ratio = if total_nodes > 0 {
                        (largest_community_size as f64 / total_nodes as f64)
                            * 100.0
                    } else {
                        0.0
                    };

                    Ok(ComponentAnalysisResult {
                        components: communities,
                        total_components: Some(total_communities),
                        largest_component_size: Some(largest_community_size),
                        smallest_component_size: Some(smallest_community_size),
                        component_size_distribution: Some(
                            community_size_distribution,
                        ),
                        isolation_ratio: Some(isolation_ratio),
                        // Mock modularity score for LPA community detection
                        modularity: Some(0.42),
                    })
                }
                None => Err(AnalysisError::ProjectionNotFound(
                    projection_name.to_string(),
                )),
            }
        }

        async fn calculate_modularity(
            &self,
            projection_name: &str,
            _community_property: &str,
        ) -> Result<f64, AnalysisError> {
            self.increment_call_count("calculate_modularity");

            if self.should_fail("calculate_modularity") {
                return Err(AnalysisError::AlgorithmError(
                    "Mock failure".to_string(),
                ));
            }

            match self.projections.read().unwrap().get(projection_name) {
                Some(_) => {
                    Ok(0.42) // Mock modularity score
                }
                None => Err(AnalysisError::ProjectionNotFound(
                    projection_name.to_string(),
                )),
            }
        }

        async fn classify_components_by_geography(
            &self,
            components: &[crate::models::partitions::ConnectedComponent],
        ) -> Result<
            crate::models::partitions::PartitionClassificationResult,
            AnalysisError,
        > {
            self.increment_call_count("classify_components_by_geography");

            if self.should_fail("classify_components_by_geography") {
                return Err(AnalysisError::AlgorithmError(
                    "Mock failure".to_string(),
                ));
            }

            use crate::models::partitions::{
                ClassificationGroup, ClassificationMetrics,
                ClassificationType, PartitionClassificationResult,
            };
            use std::collections::HashMap;

            let mut groups: Vec<ClassificationGroup> = Vec::new();
            let unclassified_relays = Vec::new();

            if components.is_empty() {
                return Ok(PartitionClassificationResult {
                    classification_type: ClassificationType::Geographic,
                    groups,
                    metrics: ClassificationMetrics {
                        total_groups: 0,
                        groups_with_partitions: 0,
                        classification_coverage: 0.0,
                        largest_group_size: 0,
                        average_group_size: 0.0,
                        diversity_score: 0.0,
                        partition_correlation: 0.0,
                    },
                    unclassified_relays,
                });
            }

            // Create deterministic geographic assignment based on relay
            // fingerprint
            let mut country_relays: HashMap<String, Vec<String>> =
                HashMap::new();
            let mut relay_to_component: HashMap<String, i64> = HashMap::new();

            // Build relay-to-component mapping from input
            for component in components {
                for relay in &component.relay_fingerprints {
                    relay_to_component
                        .insert(relay.clone(), component.component_id);
                }
            }

            // Assign countries based on relay fingerprint hash
            for component in components {
                for relay in &component.relay_fingerprints {
                    let country = Self::get_mock_country_for_relay(relay);
                    country_relays
                        .entry(country)
                        .or_default()
                        .push(relay.clone());
                }
            }

            // Create classification groups for each country
            for (country, relays) in country_relays {
                if relays.is_empty() {
                    continue;
                }

                let mut component_mapping: HashMap<i64, usize> =
                    HashMap::new();

                // Count relays per component for this country
                for relay in &relays {
                    if let Some(&component_id) = relay_to_component.get(relay)
                    {
                        *component_mapping.entry(component_id).or_insert(0) +=
                            1;
                    }
                }

                // Calculate isolation score (% of relays NOT in largest
                // component)
                let largest_component_size =
                    component_mapping.values().max().copied().unwrap_or(0);
                let total_relays_in_country = relays.len();
                let fragmented_relays =
                    total_relays_in_country - largest_component_size;

                let isolation_score = if total_relays_in_country > 0 {
                    (fragmented_relays as f64 / total_relays_in_country as f64)
                        * 100.0
                } else {
                    0.0
                };

                groups.push(ClassificationGroup {
                    identifier: country,
                    relay_fingerprints: relays,
                    component_mapping,
                    isolation_score,
                });
            }

            // Calculate metrics
            let metrics =
                Self::calculate_classification_metrics(&groups, components);

            Ok(PartitionClassificationResult {
                classification_type: ClassificationType::Geographic,
                groups,
                metrics,
                unclassified_relays,
            })
        }

        async fn classify_components_by_asn(
            &self,
            components: &[crate::models::partitions::ConnectedComponent],
        ) -> Result<
            crate::models::partitions::PartitionClassificationResult,
            AnalysisError,
        > {
            self.increment_call_count("classify_components_by_asn");

            if self.should_fail("classify_components_by_asn") {
                return Err(AnalysisError::AlgorithmError(
                    "Mock failure".to_string(),
                ));
            }

            use crate::models::partitions::{
                ClassificationGroup, ClassificationMetrics,
                ClassificationType, PartitionClassificationResult,
            };
            use std::collections::HashMap;

            let mut groups: Vec<ClassificationGroup> = Vec::new();
            let unclassified_relays = Vec::new();

            if components.is_empty() {
                return Ok(PartitionClassificationResult {
                    classification_type: ClassificationType::ASN,
                    groups,
                    metrics: ClassificationMetrics {
                        total_groups: 0,
                        groups_with_partitions: 0,
                        classification_coverage: 0.0,
                        largest_group_size: 0,
                        average_group_size: 0.0,
                        diversity_score: 0.0,
                        partition_correlation: 0.0,
                    },
                    unclassified_relays,
                });
            }

            // Create deterministic ASN assignment based on relay fingerprint
            let mut asn_relays: HashMap<String, Vec<String>> = HashMap::new();
            let mut relay_to_component: HashMap<String, i64> = HashMap::new();

            // Build relay-to-component mapping from input
            for component in components {
                for relay in &component.relay_fingerprints {
                    relay_to_component
                        .insert(relay.clone(), component.component_id);
                }
            }

            // Assign ASNs based on relay fingerprint hash
            for component in components {
                for relay in &component.relay_fingerprints {
                    let asn = Self::get_mock_asn_for_relay(relay);
                    asn_relays.entry(asn).or_default().push(relay.clone());
                }
            }

            // Create classification groups for each ASN
            for (asn, relays) in asn_relays {
                if relays.is_empty() {
                    continue;
                }

                let mut component_mapping: HashMap<i64, usize> =
                    HashMap::new();

                // Count relays per component for this ASN
                for relay in &relays {
                    if let Some(&component_id) = relay_to_component.get(relay)
                    {
                        *component_mapping.entry(component_id).or_insert(0) +=
                            1;
                    }
                }

                // Calculate isolation score
                let largest_component_size =
                    component_mapping.values().max().copied().unwrap_or(0);
                let total_relays_in_asn = relays.len();
                let fragmented_relays =
                    total_relays_in_asn - largest_component_size;

                let isolation_score = if total_relays_in_asn > 0 {
                    (fragmented_relays as f64 / total_relays_in_asn as f64)
                        * 100.0
                } else {
                    0.0
                };

                groups.push(ClassificationGroup {
                    identifier: asn,
                    relay_fingerprints: relays,
                    component_mapping,
                    isolation_score,
                });
            }

            // Calculate metrics
            let metrics =
                Self::calculate_classification_metrics(&groups, components);

            Ok(PartitionClassificationResult {
                classification_type: ClassificationType::ASN,
                groups,
                metrics,
                unclassified_relays,
            })
        }

        async fn classify_components_by_family(
            &self,
            components: &[crate::models::partitions::ConnectedComponent],
        ) -> Result<
            crate::models::partitions::PartitionClassificationResult,
            AnalysisError,
        > {
            self.increment_call_count("classify_components_by_family");

            if self.should_fail("classify_components_by_family") {
                return Err(AnalysisError::AlgorithmError(
                    "Mock failure".to_string(),
                ));
            }

            use crate::models::partitions::{
                ClassificationGroup, ClassificationMetrics,
                ClassificationType, PartitionClassificationResult,
            };
            use std::collections::HashMap;

            let mut groups: Vec<ClassificationGroup> = Vec::new();
            let mut unclassified_relays = Vec::new();

            if components.is_empty() {
                return Ok(PartitionClassificationResult {
                    classification_type: ClassificationType::Family,
                    groups,
                    metrics: ClassificationMetrics {
                        total_groups: 0,
                        groups_with_partitions: 0,
                        classification_coverage: 0.0,
                        largest_group_size: 0,
                        average_group_size: 0.0,
                        diversity_score: 0.0,
                        partition_correlation: 0.0,
                    },
                    unclassified_relays,
                });
            }

            // Create deterministic family assignment based on relay
            // fingerprint
            let mut family_relays: HashMap<String, Vec<String>> =
                HashMap::new();
            let mut relay_to_component: HashMap<String, i64> = HashMap::new();

            // Build relay-to-component mapping from input
            for component in components {
                for relay in &component.relay_fingerprints {
                    relay_to_component
                        .insert(relay.clone(), component.component_id);
                }
            }

            // Assign families based on relay fingerprint hash
            // Some relays are in families, others are unclassified
            for component in components {
                for relay in &component.relay_fingerprints {
                    if let Some(family) =
                        Self::get_mock_family_for_relay(relay)
                    {
                        family_relays
                            .entry(family)
                            .or_default()
                            .push(relay.clone());
                    } else {
                        unclassified_relays.push(relay.clone());
                    }
                }
            }

            // Create classification groups for each family
            for (family, relays) in family_relays {
                if relays.is_empty() {
                    continue;
                }

                let mut component_mapping: HashMap<i64, usize> =
                    HashMap::new();

                // Count relays per component for this family
                for relay in &relays {
                    if let Some(&component_id) = relay_to_component.get(relay)
                    {
                        *component_mapping.entry(component_id).or_insert(0) +=
                            1;
                    }
                }

                // Calculate isolation score
                let largest_component_size =
                    component_mapping.values().max().copied().unwrap_or(0);
                let total_relays_in_family = relays.len();
                let fragmented_relays =
                    total_relays_in_family - largest_component_size;

                let isolation_score = if total_relays_in_family > 0 {
                    (fragmented_relays as f64 / total_relays_in_family as f64)
                        * 100.0
                } else {
                    0.0
                };

                groups.push(ClassificationGroup {
                    identifier: family,
                    relay_fingerprints: relays,
                    component_mapping,
                    isolation_score,
                });
            }

            // Calculate metrics
            let metrics =
                Self::calculate_classification_metrics(&groups, components);

            Ok(PartitionClassificationResult {
                classification_type: ClassificationType::Family,
                groups,
                metrics,
                unclassified_relays,
            })
        }

        async fn calculate_betweenness_centrality(
            &self,
            projection_name: &str,
            sampling_size: Option<usize>,
            sampling_seed: Option<u64>,
        ) -> Result<CentralityAnalysisResult, AnalysisError> {
            self.increment_call_count("calculate_betweenness_centrality");

            if self.should_fail("calculate_betweenness_centrality") {
                return Err(AnalysisError::AlgorithmError(
                    "Mock failure".to_string(),
                ));
            }

            match self.projections.read().unwrap().get(projection_name) {
                Some(projection) => {
                    let mut centrality_metrics = Vec::new();

                    if projection.nodes.is_empty() {
                        return Ok(CentralityAnalysisResult {
                            centrality_metrics: vec![],
                            total_nodes_analyzed: Some(0),
                            betweenness_distribution: None,
                            closeness_distribution: None,
                        });
                    }

                    // Respect sampling parameters
                    let nodes_to_analyze =
                        if let Some(sample_size) = sampling_size {
                            let sample_size =
                                sample_size.min(projection.nodes.len());

                            // Use seed for deterministic sampling
                            let mut nodes = projection.nodes.clone();
                            if let Some(seed) = sampling_seed {
                                nodes.sort_by(|a, b| {
                                    let hash_a = a
                                        .fingerprint
                                        .bytes()
                                        .map(|b| b as u32)
                                        .sum::<u32>()
                                        .wrapping_add(seed as u32);
                                    let hash_b = b
                                        .fingerprint
                                        .bytes()
                                        .map(|b| b as u32)
                                        .sum::<u32>()
                                        .wrapping_add(seed as u32);
                                    hash_a.cmp(&hash_b)
                                });
                            }

                            nodes.into_iter().take(sample_size).collect()
                        } else {
                            projection.nodes.clone()
                        };

                    // Create mock centrality metrics for analyzed nodes
                    for node in &nodes_to_analyze {
                        let mut hash = node
                            .fingerprint
                            .bytes()
                            .map(|b| b as u32)
                            .sum::<u32>();

                        if let Some(seed) = sampling_seed {
                            hash = hash.wrapping_add(seed as u32);
                        }

                        let betweenness_score = (hash % 100) as f64 / 100.0;

                        centrality_metrics.push(CentralityMetrics {
                            fingerprint: node.fingerprint.clone(),
                            betweenness_centrality: Some(betweenness_score),
                            closeness_centrality: None,
                        });
                    }

                    // Calculate mock distribution
                    let scores: Vec<f64> = centrality_metrics
                        .iter()
                        .filter_map(|m| m.betweenness_centrality)
                        .collect();

                    let distribution = if !scores.is_empty() {
                        let min = scores
                            .iter()
                            .copied()
                            .fold(f64::INFINITY, f64::min);
                        let max = scores
                            .iter()
                            .copied()
                            .fold(f64::NEG_INFINITY, f64::max);
                        let mean =
                            scores.iter().sum::<f64>() / scores.len() as f64;

                        // Sort scores for percentile calculation
                        let mut sorted_scores = scores.clone();
                        sorted_scores
                            .sort_by(|a, b| a.partial_cmp(b).unwrap());
                        let len = sorted_scores.len();

                        let get_percentile = |p: f64| -> f64 {
                            let index =
                                ((len as f64 - 1.0) * p).round() as usize;
                            sorted_scores[index.min(len - 1)]
                        };

                        Some(CentralityDistribution {
                            min,
                            max,
                            mean,
                            p50: get_percentile(0.50),
                            p75: get_percentile(0.75),
                            p90: get_percentile(0.90),
                            p95: get_percentile(0.95),
                            p99: get_percentile(0.99),
                            p999: get_percentile(0.999),
                        })
                    } else {
                        None
                    };

                    Ok(CentralityAnalysisResult {
                        centrality_metrics,
                        total_nodes_analyzed: Some(nodes_to_analyze.len()),
                        betweenness_distribution: distribution,
                        closeness_distribution: None,
                    })
                }
                None => Err(AnalysisError::ProjectionNotFound(
                    projection_name.to_string(),
                )),
            }
        }

        async fn calculate_closeness_centrality(
            &self,
            projection_name: &str,
            use_wasserman_faust: Option<bool>,
        ) -> Result<CentralityAnalysisResult, AnalysisError> {
            self.increment_call_count("calculate_closeness_centrality");

            if self.should_fail("calculate_closeness_centrality") {
                return Err(AnalysisError::AlgorithmError(
                    "Mock failure".to_string(),
                ));
            }

            match self.projections.read().unwrap().get(projection_name) {
                Some(projection) => {
                    let mut centrality_metrics = Vec::new();

                    if projection.nodes.is_empty() {
                        return Ok(CentralityAnalysisResult {
                            centrality_metrics: vec![],
                            total_nodes_analyzed: Some(0),
                            betweenness_distribution: None,
                            closeness_distribution: None,
                        });
                    }

                    // Create mock centrality metrics for each node
                    for node in &projection.nodes {
                        let hash = node
                            .fingerprint
                            .bytes()
                            .map(|b| b as u32)
                            .sum::<u32>();

                        // Adjust scoring based on Wasserman-Faust parameter
                        let closeness_score =
                            if use_wasserman_faust.unwrap_or(false) {
                                (hash % 90 + 10) as f64 / 100.0 // 0.1 to 1.0
                            } else {
                                // Standard normalization
                                (hash % 80 + 20) as f64 / 100.0 // 0.2 to 1.0
                            };

                        centrality_metrics.push(CentralityMetrics {
                            fingerprint: node.fingerprint.clone(),
                            betweenness_centrality: None,
                            closeness_centrality: Some(closeness_score),
                        });
                    }

                    // Calculate mock distribution
                    let scores: Vec<f64> = centrality_metrics
                        .iter()
                        .filter_map(|m| m.closeness_centrality)
                        .collect();

                    let distribution = if !scores.is_empty() {
                        let min = scores
                            .iter()
                            .copied()
                            .fold(f64::INFINITY, f64::min);
                        let max = scores
                            .iter()
                            .copied()
                            .fold(f64::NEG_INFINITY, f64::max);
                        let mean =
                            scores.iter().sum::<f64>() / scores.len() as f64;

                        // Sort scores for percentile calculation
                        let mut sorted_scores = scores.clone();
                        sorted_scores
                            .sort_by(|a, b| a.partial_cmp(b).unwrap());
                        let len = sorted_scores.len();

                        let get_percentile = |p: f64| -> f64 {
                            let index =
                                ((len as f64 - 1.0) * p).round() as usize;
                            sorted_scores[index.min(len - 1)]
                        };

                        Some(CentralityDistribution {
                            min,
                            max,
                            mean,
                            p50: get_percentile(0.50),
                            p75: get_percentile(0.75),
                            p90: get_percentile(0.90),
                            p95: get_percentile(0.95),
                            p99: get_percentile(0.99),
                            p999: get_percentile(0.999),
                        })
                    } else {
                        None
                    };

                    Ok(CentralityAnalysisResult {
                        centrality_metrics,
                        total_nodes_analyzed: Some(projection.nodes.len()),
                        betweenness_distribution: None,
                        closeness_distribution: distribution,
                    })
                }
                None => Err(AnalysisError::ProjectionNotFound(
                    projection_name.to_string(),
                )),
            }
        }

        async fn calculate_combined_centrality(
            &self,
            projection_name: &str,
            betweenness_sampling_size: Option<usize>,
            betweenness_sampling_seed: Option<u64>,
            use_wasserman_faust: Option<bool>,
        ) -> Result<CentralityAnalysisResult, AnalysisError> {
            self.increment_call_count("calculate_combined_centrality");

            if self.should_fail("calculate_combined_centrality") {
                return Err(AnalysisError::AlgorithmError(
                    "Mock failure".to_string(),
                ));
            }

            // Call individual centrality methods and merge results
            let betweenness_result = self
                .calculate_betweenness_centrality(
                    projection_name,
                    betweenness_sampling_size,
                    betweenness_sampling_seed,
                )
                .await?;

            let closeness_result = self
                .calculate_closeness_centrality(
                    projection_name,
                    use_wasserman_faust,
                )
                .await?;

            let mut combined_metrics = std::collections::HashMap::new();

            // Add betweenness centrality metrics
            for metric in betweenness_result.centrality_metrics {
                combined_metrics.insert(metric.fingerprint.clone(), metric);
            }

            // Add closeness centrality metrics
            for metric in closeness_result.centrality_metrics {
                if let Some(existing) =
                    combined_metrics.get_mut(&metric.fingerprint)
                {
                    existing.closeness_centrality =
                        metric.closeness_centrality;
                } else {
                    combined_metrics
                        .insert(metric.fingerprint.clone(), metric);
                }
            }

            let centrality_metrics: Vec<CentralityMetrics> =
                combined_metrics.into_values().collect();

            Ok(CentralityAnalysisResult {
                centrality_metrics,
                total_nodes_analyzed: betweenness_result.total_nodes_analyzed,
                betweenness_distribution: betweenness_result
                    .betweenness_distribution,
                closeness_distribution: closeness_result
                    .closeness_distribution,
            })
        }

        async fn analyze_paths_between_communities(
            &self,
            projection_name: &str,
            source_nodes: &[String],
            target_nodes: &[String],
        ) -> Result<PathAnalysisResult, AnalysisError> {
            self.increment_call_count("analyze_paths_between_communities");

            if self.should_fail("analyze_paths_between_communities") {
                return Err(AnalysisError::AlgorithmError(
                    "Mock failure".to_string(),
                ));
            }

            if !self.check_graph_projection_exists(projection_name).await? {
                return Err(AnalysisError::ProjectionNotFound(
                    projection_name.to_string(),
                ));
            }

            let mut path_results = Vec::new();

            for source in source_nodes {
                for target in target_nodes {
                    if source != target {
                        // Mock high connectivity: 100% connected, length based on fingerprints
                        let path_length =
                            ((source.len() + target.len()) % 10) + 4;
                        path_results.push(PathResult {
                            source_fingerprint: source.clone(),
                            target_fingerprint: target.clone(),
                            path_exists: true,
                            path_length: Some(path_length),
                            path_cost: Some(path_length as f64 - 1.0),
                            intermediate_nodes: Some(vec![]),
                        });
                    }
                }
            }

            let connected_pairs =
                path_results.iter().filter(|p| p.path_exists).count();
            let total_pairs = path_results.len();

            let average_path_length = if connected_pairs > 0 {
                Some(
                    path_results
                        .iter()
                        .filter(|p| p.path_exists)
                        .map(|p| p.path_length.unwrap_or(0) as f64)
                        .sum::<f64>()
                        / connected_pairs as f64,
                )
            } else {
                None
            };

            let max_path_length = path_results
                .iter()
                .map(|p| p.path_length.unwrap_or(0))
                .max();

            let min_path_length = path_results
                .iter()
                .filter(|p| p.path_exists)
                .map(|p| p.path_length.unwrap_or(0))
                .min();

            Ok(PathAnalysisResult {
                path_results,
                total_paths_analyzed: Some(total_pairs),
                connected_community_pairs: Some(connected_pairs),
                disconnected_community_pairs: Some(
                    total_pairs - connected_pairs,
                ),
                average_path_length,
                max_path_length,
                min_path_length,
            })
        }
    }
}

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

    #[tokio::test]
    async fn test_mock_database_basic_operations() {
        let db = MockDatabase::new();

        // Test projection doesn't exist initially
        let exists = db.check_graph_projection_exists("test").await.unwrap();
        assert!(!exists);

        // Create projection
        let params = GraphProjectionParams {
            projection_name: "test".to_string(),
            node_label: "Relay".to_string(),
            relationship_types: HashMap::new(),
            relationship_properties_to_project: None,
        };

        db.create_graph_projection(&params).await.unwrap();

        // Check it exists now
        let exists = db.check_graph_projection_exists("test").await.unwrap();
        assert!(exists);

        // Delete projection
        db.delete_graph_projection("test").await.unwrap();

        // Check it doesn't exist anymore
        let exists = db.check_graph_projection_exists("test").await.unwrap();
        assert!(!exists);
    }

    #[tokio::test]
    async fn test_mock_with_test_data() {
        let nodes = vec![
            NodeMetrics {
                fingerprint: "RELAY001".to_string(),
                in_degree: 3,
                out_degree: 2,
                total_degree: 5,
            },
            NodeMetrics {
                fingerprint: "RELAY002".to_string(),
                in_degree: 1,
                out_degree: 4,
                total_degree: 5,
            },
        ];

        let db = MockDatabase::new().with_projection("test_proj", nodes);

        let result = db.calculate_node_degrees("test_proj").await.unwrap();
        assert_eq!(result.len(), 2);
        assert_eq!(result[0].fingerprint, "RELAY001");
        assert_eq!(result[0].total_degree, 5);
    }

    #[tokio::test]
    async fn test_mock_wcc_edge_cases() {
        let db = MockDatabase::new();

        // Test projection not found
        let result = db
            .calculate_weakly_connected_components("nonexistent")
            .await;
        assert!(result.is_err());

        // Test with only 2 nodes (should create single component)
        let nodes = vec![
            NodeMetrics {
                fingerprint: "RELAY001".to_string(),
                in_degree: 1,
                out_degree: 1,
                total_degree: 2,
            },
            NodeMetrics {
                fingerprint: "RELAY002".to_string(),
                in_degree: 1,
                out_degree: 1,
                total_degree: 2,
            },
        ];

        let db_with_data =
            MockDatabase::new().with_projection("single_component", nodes);

        let result = db_with_data
            .calculate_weakly_connected_components("single_component")
            .await
            .unwrap();

        // Should have 1 component with both nodes
        assert_eq!(result.total_components.unwrap(), 1);
        assert_eq!(result.components.len(), 1);
        assert_eq!(result.components[0].size, 2);
        assert_eq!(result.isolation_ratio.unwrap(), 100.0);
    }

    #[tokio::test]
    async fn test_mock_scc_edge_cases_and_failures() {
        let db = MockDatabase::new();

        // Test projection not found
        let result = db
            .calculate_strongly_connected_components("nonexistent")
            .await;
        assert!(result.is_err());

        // Test with only 2 nodes (should create single component)
        let nodes = vec![
            NodeMetrics {
                fingerprint: "SCC_SINGLE_001".to_string(),
                in_degree: 1,
                out_degree: 1,
                total_degree: 2,
            },
            NodeMetrics {
                fingerprint: "SCC_SINGLE_002".to_string(),
                in_degree: 1,
                out_degree: 1,
                total_degree: 2,
            },
        ];

        let db_single =
            MockDatabase::new().with_projection("single_scc", nodes);

        let result = db_single
            .calculate_strongly_connected_components("single_scc")
            .await
            .unwrap();

        // Should have only 1 component
        assert_eq!(result.total_components.unwrap(), 1);
        assert_eq!(result.components.len(), 1);
        assert_eq!(result.components[0].size, 2);
        assert_eq!(result.isolation_ratio.unwrap(), 100.0);

        // Test failure scenario
        let fail_nodes = vec![NodeMetrics {
            fingerprint: "FAIL_RELAY001".to_string(),
            in_degree: 1,
            out_degree: 1,
            total_degree: 2,
        }];

        let db_fail = MockDatabase::new()
            .with_projection("fail_test", fail_nodes)
            .fail_on("calculate_strongly_connected_components");

        let fail_result = db_fail
            .calculate_strongly_connected_components("fail_test")
            .await;
        assert!(fail_result.is_err());
        assert_eq!(
            db_fail.get_call_count("calculate_strongly_connected_components"),
            1
        );
    }

    #[tokio::test]
    async fn test_mock_path_analysis_with_self_loops() {
        let db = MockDatabase::new().with_projection("test_proj", vec![]);

        // Test with overlapping source and target nodes
        let source_nodes = vec!["RELAY_A".to_string(), "RELAY_B".to_string()];
        let target_nodes = vec!["RELAY_A".to_string(), "RELAY_C".to_string()]; // overlaps

        let result = db
            .analyze_paths_between_communities(
                "test_proj",
                &source_nodes,
                &target_nodes,
            )
            .await
            .expect("Path analysis should succeed");

        // Total pairs should exclude self-loops: 2×2 - 1 overlap = 3
        assert_eq!(result.total_paths_analyzed, Some(3));
        assert_eq!(result.connected_community_pairs, Some(3));
        assert_eq!(result.path_results.len(), 3);

        // Verify no self-loops in results
        for path in &result.path_results {
            assert_ne!(path.source_fingerprint, path.target_fingerprint);
        }
    }

    #[tokio::test]
    async fn test_combined_centrality_functionality() {
        let nodes = vec![
            NodeMetrics {
                fingerprint: "RELAY_A".to_string(),
                in_degree: 5,
                out_degree: 3,
                total_degree: 8,
            },
            NodeMetrics {
                fingerprint: "RELAY_B".to_string(),
                in_degree: 2,
                out_degree: 4,
                total_degree: 6,
            },
        ];

        let db = MockDatabase::new().with_projection("test_combined", nodes);

        let result = db
            .calculate_combined_centrality(
                "test_combined",
                Some(1000),
                Some(42),
                Some(true),
            )
            .await
            .expect("Combined centrality should succeed");

        // Should have combined metrics for both nodes
        assert_eq!(result.centrality_metrics.len(), 2);
        assert!(result.total_nodes_analyzed.is_some());
        assert!(result.betweenness_distribution.is_some());
        assert!(result.closeness_distribution.is_some());

        // Verify both centrality types are present
        for metric in &result.centrality_metrics {
            assert!(metric.betweenness_centrality.is_some());
            assert!(metric.closeness_centrality.is_some());
        }
    }

    #[tokio::test]
    async fn test_centrality_with_sampling() {
        let nodes = vec![
            NodeMetrics {
                fingerprint: "RELAY_A".to_string(),
                in_degree: 5,
                out_degree: 3,
                total_degree: 8,
            },
            NodeMetrics {
                fingerprint: "RELAY_B".to_string(),
                in_degree: 2,
                out_degree: 4,
                total_degree: 6,
            },
            NodeMetrics {
                fingerprint: "RELAY_C".to_string(),
                in_degree: 1,
                out_degree: 2,
                total_degree: 3,
            },
        ];

        let db = MockDatabase::new().with_projection("test_sampling", nodes);

        // Test with sampling
        let result = db
            .calculate_betweenness_centrality(
                "test_sampling",
                Some(2), // Sample only 2 nodes
                Some(42),
            )
            .await
            .expect("Betweenness centrality should succeed");

        // Should only analyze 2 nodes due to sampling
        assert_eq!(result.total_nodes_analyzed, Some(2));
        assert_eq!(result.centrality_metrics.len(), 2);

        // Test without sampling
        let result_full = db
            .calculate_betweenness_centrality("test_sampling", None, None)
            .await
            .expect("Betweenness centrality should succeed");

        // Should analyze all 3 nodes
        assert_eq!(result_full.total_nodes_analyzed, Some(3));
        assert_eq!(result_full.centrality_metrics.len(), 3);
    }

    #[tokio::test]
    async fn test_wasserman_faust_parameter() {
        let nodes = vec![NodeMetrics {
            fingerprint: "RELAY_A".to_string(),
            in_degree: 5,
            out_degree: 3,
            total_degree: 8,
        }];

        let db = MockDatabase::new().with_projection("test_wf", nodes);

        // Test with Wasserman-Faust
        let result_wf = db
            .calculate_closeness_centrality("test_wf", Some(true))
            .await
            .expect("Closeness centrality should succeed");

        // Test without Wasserman-Faust
        let result_normal = db
            .calculate_closeness_centrality("test_wf", Some(false))
            .await
            .expect("Closeness centrality should succeed");

        // Results should be different due to different scoring ranges
        let wf_score = result_wf.centrality_metrics[0]
            .closeness_centrality
            .unwrap();
        let normal_score = result_normal.centrality_metrics[0]
            .closeness_centrality
            .unwrap();

        // Both should be valid but potentially different
        assert!((0.0..=1.0).contains(&wf_score));
        assert!((0.0..=1.0).contains(&normal_score));
    }

    #[tokio::test]
    async fn test_projection_not_found_errors() {
        let db = MockDatabase::new();

        // Test centrality operations with non-existent projection
        let result = db
            .calculate_betweenness_centrality("non_existent", None, None)
            .await;
        assert!(result.is_err());
        assert!(matches!(
            result.unwrap_err(),
            AnalysisError::ProjectionNotFound(_)
        ));

        let result = db
            .calculate_closeness_centrality("non_existent", None)
            .await;
        assert!(result.is_err());
        assert!(matches!(
            result.unwrap_err(),
            AnalysisError::ProjectionNotFound(_)
        ));

        let result = db
            .analyze_paths_between_communities(
                "non_existent",
                &["A".to_string()],
                &["B".to_string()],
            )
            .await;
        assert!(result.is_err());
        assert!(matches!(
            result.unwrap_err(),
            AnalysisError::ProjectionNotFound(_)
        ));
    }
}