scirs2-metrics 0.3.0

//! Graph generation evaluation metrics for Graph Neural Networks
//!
//! This module provides metrics for evaluating graph generation quality,
//! structural similarity, and diversity of generated graphs.

#![allow(clippy::too_many_arguments)]
#![allow(dead_code)]

use super::core::{DistributionStatistics, SpectralProperties};
use crate::error::{MetricsError, Result};
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, HashMap};

/// Graph generation evaluation metrics
#[derive(Debug, Clone, Default)]
pub struct GraphGenerationMetrics {
    /// Structural similarity metrics
    pub structural_similarity: StructuralSimilarityMetrics,
    /// Statistical similarity metrics
    pub statistical_similarity: StatisticalSimilarityMetrics,
    /// Spectral similarity metrics
    pub spectral_similarity: SpectralSimilarityMetrics,
    /// Generation diversity metrics
    pub diversity_metrics: GenerationDiversityMetrics,
}

/// Structural similarity between generated and reference graphs
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StructuralSimilarityMetrics {
    /// Degree distribution KL divergence
    pub degree_distribution_kl: f64,
    /// Clustering coefficient difference
    pub clustering_coefficient_diff: f64,
    /// Average path length difference
    pub path_length_diff: f64,
    /// Connected components similarity
    pub components_similarity: f64,
    /// Motif frequency similarity
    pub motif_similarity: f64,
}

/// Statistical similarity metrics
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct StatisticalSimilarityMetrics {
    /// Node count statistics
    pub node_count_stats: DistributionStatistics,
    /// Edge count statistics
    pub edge_count_stats: DistributionStatistics,
    /// Density statistics
    pub density_stats: DistributionStatistics,
}

/// Spectral similarity metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SpectralSimilarityMetrics {
    /// Eigenvalue distribution similarity
    pub eigenvalue_similarity: f64,
    /// Spectral gap similarity
    pub spectral_gap_similarity: f64,
    /// Laplacian spectrum similarity
    pub laplacian_spectrum_similarity: f64,
}

/// Generation diversity metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GenerationDiversityMetrics {
    /// Pairwise graph edit distance
    pub pairwise_ged: f64,
    /// Structural diversity score
    pub structural_diversity: f64,
    /// Novelty score
    pub novelty_score: f64,
    /// Coverage score
    pub coverage_score: f64,
}

impl Default for StructuralSimilarityMetrics {
    fn default() -> Self {
        Self {
            degree_distribution_kl: 0.0,
            clustering_coefficient_diff: 0.0,
            path_length_diff: 0.0,
            components_similarity: 0.0,
            motif_similarity: 0.0,
        }
    }
}

impl Default for SpectralSimilarityMetrics {
    fn default() -> Self {
        Self {
            eigenvalue_similarity: 0.0,
            spectral_gap_similarity: 0.0,
            laplacian_spectrum_similarity: 0.0,
        }
    }
}

impl Default for GenerationDiversityMetrics {
    fn default() -> Self {
        Self {
            pairwise_ged: 0.0,
            structural_diversity: 0.0,
            novelty_score: 0.0,
            coverage_score: 0.0,
        }
    }
}

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

    /// Evaluate generated graphs against reference graphs
    pub fn evaluate_generation_quality(
        &mut self,
        generated_graphs: &[Vec<Vec<f64>>], // Adjacency matrices
        reference_graphs: &[Vec<Vec<f64>>],
    ) -> Result<()> {
        if generated_graphs.is_empty() || reference_graphs.is_empty() {
            return Err(MetricsError::InvalidInput(
                "Graph sets cannot be empty".to_string(),
            ));
        }

        // Compute structural similarity
        self.compute_structural_similarity(generated_graphs, reference_graphs)?;

        // Compute statistical similarity
        self.compute_statistical_similarity(generated_graphs, reference_graphs)?;

        // Compute diversity metrics
        self.compute_diversity_metrics(generated_graphs)?;

        Ok(())
    }

    fn compute_structural_similarity(
        &mut self,
        generated_graphs: &[Vec<Vec<f64>>],
        reference_graphs: &[Vec<Vec<f64>>],
    ) -> Result<()> {
        // Compute degree distributions
        let gen_degree_dist = self.compute_degree_distribution(generated_graphs);
        let ref_degree_dist = self.compute_degree_distribution(reference_graphs);

        // KL divergence between degree distributions
        self.structural_similarity.degree_distribution_kl =
            self.compute_kl_divergence(&gen_degree_dist, &ref_degree_dist);

        // Clustering coefficient difference
        let gen_clustering = generated_graphs
            .iter()
            .map(|g| self.compute_clustering_coefficient(g))
            .collect::<Vec<_>>();
        let ref_clustering = reference_graphs
            .iter()
            .map(|g| self.compute_clustering_coefficient(g))
            .collect::<Vec<_>>();

        let gen_avg_clustering = gen_clustering.iter().sum::<f64>() / gen_clustering.len() as f64;
        let ref_avg_clustering = ref_clustering.iter().sum::<f64>() / ref_clustering.len() as f64;

        self.structural_similarity.clustering_coefficient_diff =
            (gen_avg_clustering - ref_avg_clustering).abs();

        Ok(())
    }

    fn compute_statistical_similarity(
        &mut self,
        generated_graphs: &[Vec<Vec<f64>>],
        reference_graphs: &[Vec<Vec<f64>>],
    ) -> Result<()> {
        // Node count statistics
        let gen_node_counts: Vec<f64> = generated_graphs.iter().map(|g| g.len() as f64).collect();
        let ref_node_counts: Vec<f64> = reference_graphs.iter().map(|g| g.len() as f64).collect();

        self.statistical_similarity.node_count_stats =
            self.compute_distribution_stats(&gen_node_counts, &ref_node_counts);

        // Edge count statistics
        let gen_edge_counts: Vec<f64> = generated_graphs
            .iter()
            .map(|g| self.count_edges(g) as f64)
            .collect();
        let ref_edge_counts: Vec<f64> = reference_graphs
            .iter()
            .map(|g| self.count_edges(g) as f64)
            .collect();

        self.statistical_similarity.edge_count_stats =
            self.compute_distribution_stats(&gen_edge_counts, &ref_edge_counts);

        // Density statistics
        let gen_densities: Vec<f64> = generated_graphs
            .iter()
            .map(|g| self.compute_density(g))
            .collect();
        let ref_densities: Vec<f64> = reference_graphs
            .iter()
            .map(|g| self.compute_density(g))
            .collect();

        self.statistical_similarity.density_stats =
            self.compute_distribution_stats(&gen_densities, &ref_densities);

        Ok(())
    }

    fn compute_diversity_metrics(&mut self, generated_graphs: &[Vec<Vec<f64>>]) -> Result<()> {
        if generated_graphs.len() < 2 {
            return Ok(());
        }

        // Compute pairwise distances
        let mut total_distance = 0.0;
        let mut pair_count = 0;

        for i in 0..generated_graphs.len() {
            for j in (i + 1)..generated_graphs.len() {
                let distance =
                    self.compute_graph_edit_distance(&generated_graphs[i], &generated_graphs[j]);
                total_distance += distance;
                pair_count += 1;
            }
        }

        self.diversity_metrics.pairwise_ged = if pair_count > 0 {
            total_distance / pair_count as f64
        } else {
            0.0
        };

        // Structural diversity (simplified)
        let degree_variances: Vec<f64> = generated_graphs
            .iter()
            .map(|g| self.compute_degree_variance(g))
            .collect();

        self.diversity_metrics.structural_diversity =
            degree_variances.iter().sum::<f64>() / degree_variances.len() as f64;

        Ok(())
    }

    fn compute_degree_distribution(&self, graphs: &[Vec<Vec<f64>>]) -> HashMap<usize, f64> {
        let mut degree_counts: HashMap<usize, usize> = HashMap::new();
        let mut total_nodes = 0;

        for graph in graphs {
            for i in 0..graph.len() {
                let degree = graph[i].iter().filter(|&&x| x > 0.0).count();
                *degree_counts.entry(degree).or_insert(0) += 1;
                total_nodes += 1;
            }
        }

        degree_counts
            .into_iter()
            .map(|(degree, count)| (degree, count as f64 / total_nodes as f64))
            .collect()
    }

    fn compute_kl_divergence(
        &self,
        dist1: &HashMap<usize, f64>,
        dist2: &HashMap<usize, f64>,
    ) -> f64 {
        let mut kl_div = 0.0;
        let epsilon = 1e-10;

        let all_keys: std::collections::HashSet<usize> =
            dist1.keys().chain(dist2.keys()).cloned().collect();

        for key in all_keys {
            let p = dist1.get(&key).unwrap_or(&epsilon);
            let q = dist2.get(&key).unwrap_or(&epsilon);

            if *p > 0.0 && *q > 0.0 {
                kl_div += p * (p / q).ln();
            }
        }

        kl_div
    }

    fn compute_clustering_coefficient(&self, graph: &[Vec<f64>]) -> f64 {
        let n = graph.len();
        if n < 3 {
            return 0.0;
        }

        let mut total_clustering = 0.0;
        let mut node_count = 0;

        for i in 0..n {
            let neighbors: Vec<usize> = (0..n).filter(|&j| i != j && graph[i][j] > 0.0).collect();

            if neighbors.len() < 2 {
                continue;
            }

            let mut triangle_count = 0;
            for &u in &neighbors {
                for &v in &neighbors {
                    if u < v && graph[u][v] > 0.0 {
                        triangle_count += 1;
                    }
                }
            }

            let possible_triangles = neighbors.len() * (neighbors.len() - 1) / 2;
            if possible_triangles > 0 {
                total_clustering += triangle_count as f64 / possible_triangles as f64;
                node_count += 1;
            }
        }

        if node_count > 0 {
            total_clustering / node_count as f64
        } else {
            0.0
        }
    }

    fn count_edges(&self, graph: &[Vec<f64>]) -> usize {
        let mut edge_count = 0;
        for i in 0..graph.len() {
            for j in (i + 1)..graph.len() {
                if graph[i][j] > 0.0 {
                    edge_count += 1;
                }
            }
        }
        edge_count
    }

    fn compute_density(&self, graph: &[Vec<f64>]) -> f64 {
        let n = graph.len();
        if n <= 1 {
            return 0.0;
        }

        let edge_count = self.count_edges(graph);
        let max_edges = n * (n - 1) / 2;

        if max_edges > 0 {
            edge_count as f64 / max_edges as f64
        } else {
            0.0
        }
    }

    fn compute_distribution_stats(&self, dist1: &[f64], dist2: &[f64]) -> DistributionStatistics {
        // Simplified implementation - compute basic statistics difference
        let mean1 = dist1.iter().sum::<f64>() / dist1.len() as f64;
        let mean2 = dist2.iter().sum::<f64>() / dist2.len() as f64;

        let var1 = dist1.iter().map(|x| (x - mean1).powi(2)).sum::<f64>() / dist1.len() as f64;
        let var2 = dist2.iter().map(|x| (x - mean2).powi(2)).sum::<f64>() / dist2.len() as f64;

        DistributionStatistics {
            mean: (mean1 - mean2).abs(),
            std_dev: (var1.sqrt() - var2.sqrt()).abs(),
            skewness: 0.0, // Simplified
            kurtosis: 0.0, // Simplified
            min: dist1.iter().fold(f64::INFINITY, |a, &b| a.min(b)),
            max: dist1.iter().fold(f64::NEG_INFINITY, |a, &b| a.max(b)),
            median: 0.0, // Simplified
            percentiles: BTreeMap::new(),
        }
    }

    fn compute_graph_edit_distance(&self, graph1: &[Vec<f64>], graph2: &[Vec<f64>]) -> f64 {
        // Simplified GED approximation based on structural differences
        let n1 = graph1.len();
        let n2 = graph2.len();

        let node_diff = (n1 as i32 - n2 as i32).abs() as f64;
        let edge_diff =
            (self.count_edges(graph1) as i32 - self.count_edges(graph2) as i32).abs() as f64;

        node_diff + edge_diff
    }

    fn compute_degree_variance(&self, graph: &[Vec<f64>]) -> f64 {
        let degrees: Vec<f64> = (0..graph.len())
            .map(|i| graph[i].iter().filter(|&&x| x > 0.0).count() as f64)
            .collect();

        if degrees.is_empty() {
            return 0.0;
        }

        let mean = degrees.iter().sum::<f64>() / degrees.len() as f64;
        degrees.iter().map(|d| (d - mean).powi(2)).sum::<f64>() / degrees.len() as f64
    }
}

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

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

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

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