optirs-core 0.3.1

// Privacy-Utility Tradeoff Analysis
//
// This module provides comprehensive analysis tools for understanding and optimizing
// the tradeoffs between privacy guarantees and model utility in privacy-preserving
// machine learning systems.

use crate::error::Result;
use crate::privacy::{DifferentialPrivacyConfig, NoiseMechanism, PrivacyBudget};
use scirs2_core::ndarray::{ArrayBase, Data, Dimension};
use scirs2_core::numeric::Float;
use scirs2_core::random::{thread_rng, Rng};
use std::collections::HashMap;
use std::fmt::Debug;

/// Comprehensive privacy-utility tradeoff analyzer
pub struct PrivacyUtilityAnalyzer<T: Float + Debug + Send + Sync + 'static> {
    /// Configuration for analysis
    config: AnalysisConfig,

    /// Privacy parameter space explorer
    parameter_explorer: PrivacyParameterExplorer<T>,

    /// Utility metric calculator
    utility_calculator: UtilityMetricCalculator<T>,

    /// Pareto frontier analyzer
    pareto_analyzer: ParetoFrontierAnalyzer<T>,

    /// Sensitivity analyzer
    sensitivity_analyzer: SensitivityAnalyzer<T>,

    /// Robustness evaluator
    robustness_evaluator: RobustnessEvaluator<T>,

    /// Privacy budget optimizer
    budget_optimizer: PrivacyBudgetOptimizer<T>,

    /// Multi-objective optimizer for privacy-utility
    multi_objective_optimizer: MultiObjectiveOptimizer<T>,

    /// Empirical privacy estimator
    empirical_estimator: EmpiricalPrivacyEstimator<T>,

    /// Utility degradation predictor
    degradation_predictor: UtilityDegradationPredictor<T>,
}

/// Configuration for privacy-utility analysis
#[derive(Debug, Clone)]
pub struct AnalysisConfig {
    /// Privacy parameters to analyze
    pub privacy_parameters: PrivacyParameterSpace,

    /// Utility metrics to evaluate
    pub utility_metrics: Vec<UtilityMetric>,

    /// Number of samples for Monte Carlo analysis
    pub monte_carlo_samples: usize,

    /// Analysis granularity
    pub analysis_granularity: AnalysisGranularity,

    /// Enable sensitivity analysis
    pub enable_sensitivity_analysis: bool,

    /// Enable robustness evaluation
    pub enable_robustness_evaluation: bool,

    /// Pareto frontier resolution
    pub pareto_resolution: usize,

    /// Budget optimization method
    pub budget_optimization_method: BudgetOptimizationMethod,

    /// Confidence level for statistical analysis
    pub confidence_level: f64,

    /// Enable adaptive analysis
    pub adaptive_analysis: bool,
}

/// Privacy parameter space definition
#[derive(Debug, Clone)]
pub struct PrivacyParameterSpace {
    /// Epsilon values to analyze
    pub epsilon_range: ParameterRange,

    /// Delta values to analyze
    pub delta_range: ParameterRange,

    /// Noise multiplier values
    pub noise_multiplier_range: ParameterRange,

    /// Clipping threshold values
    pub clipping_threshold_range: ParameterRange,

    /// Sampling probability values
    pub sampling_probability_range: ParameterRange,

    /// Number of iterations to analyze
    pub iterations_range: ParameterRange,

    /// Batch size values
    pub batch_size_range: ParameterRange,

    /// Learning rate values
    pub learning_rate_range: ParameterRange,
}

/// Parameter range specification
#[derive(Debug, Clone)]
pub struct ParameterRange {
    /// Minimum value
    pub min: f64,

    /// Maximum value
    pub max: f64,

    /// Number of samples
    pub num_samples: usize,

    /// Sampling strategy
    pub sampling_strategy: SamplingStrategy,
}

/// Sampling strategies for parameter space exploration
#[derive(Debug, Clone)]
pub enum SamplingStrategy {
    /// Linear sampling
    Linear,

    /// Logarithmic sampling
    Logarithmic,

    /// Random sampling
    Random,

    /// Latin hypercube sampling
    LatinHypercube,

    /// Sobol sequence sampling
    Sobol,

    /// Adaptive sampling based on gradients
    Adaptive,
}

/// Utility metrics for evaluation
#[derive(Debug, Clone)]
pub enum UtilityMetric {
    /// Model accuracy
    Accuracy,

    /// Model precision
    Precision,

    /// Model recall
    Recall,

    /// F1 score
    F1Score,

    /// Area under ROC curve
    AUROC,

    /// Area under precision-recall curve
    AUPRC,

    /// Mean squared error
    MSE,

    /// Mean absolute error
    MAE,

    /// Cross-entropy loss
    CrossEntropy,

    /// Log-likelihood
    LogLikelihood,

    /// Mutual information
    MutualInformation,

    /// Convergence rate
    ConvergenceRate,

    /// Training stability
    TrainingStability,

    /// Generalization gap
    GeneralizationGap,

    /// Custom metric
    Custom(String),
}

/// Analysis granularity levels
#[derive(Debug, Clone)]
pub enum AnalysisGranularity {
    /// Coarse-grained analysis
    Coarse,

    /// Medium-grained analysis
    Medium,

    /// Fine-grained analysis
    Fine,

    /// Advanced-fine analysis
    AdvancedFine,

    /// Adaptive granularity
    Adaptive,
}

/// Budget optimization methods
#[derive(Debug, Clone)]
pub enum BudgetOptimizationMethod {
    /// Grid search optimization
    GridSearch,

    /// Bayesian optimization
    BayesianOptimization,

    /// Genetic algorithm
    GeneticAlgorithm,

    /// Particle swarm optimization
    ParticleSwarm,

    /// Simulated annealing
    SimulatedAnnealing,

    /// Multi-objective evolutionary algorithm
    NSGA2,

    /// Gradient-based optimization
    GradientBased,

    /// Reinforcement learning based
    ReinforcementLearning,
}

/// Privacy-utility analysis results
#[derive(Debug, Clone)]
pub struct PrivacyUtilityResults<T: Float + Debug + Send + Sync + 'static> {
    /// Pareto frontier points
    pub pareto_frontier: Vec<ParetoPoint<T>>,

    /// Optimal privacy-utility configurations
    pub optimal_configurations: Vec<OptimalConfiguration<T>>,

    /// Sensitivity analysis results
    pub sensitivity_results: SensitivityResults<T>,

    /// Robustness evaluation results
    pub robustness_results: RobustnessResults<T>,

    /// Budget allocation recommendations
    pub budget_recommendations: BudgetRecommendations<T>,

    /// Utility degradation predictions
    pub degradation_predictions: Vec<DegradationPrediction<T>>,

    /// Privacy risk assessment
    pub privacy_risk_assessment: PrivacyRiskAssessment<T>,

    /// Statistical significance tests
    pub statistical_tests: StatisticalTestResults<T>,

    /// Analysis metadata
    pub metadata: AnalysisMetadata,
}

/// Point on Pareto frontier
#[derive(Debug, Clone)]
pub struct ParetoPoint<T: Float + Debug + Send + Sync + 'static> {
    /// Privacy guarantee (epsilon)
    pub privacy_guarantee: T,

    /// Utility metric value
    pub utility_value: T,

    /// Configuration parameters
    pub configuration: PrivacyConfiguration<T>,

    /// Confidence interval
    pub confidence_interval: (T, T),

    /// Statistical significance
    pub statistical_significance: T,

    /// Privacy cost (for internal computation)
    pub privacy_cost: T,

    /// Whether this point is dominated by others
    pub dominated: bool,

    /// Distance to ideal point
    pub distance_to_ideal: T,
}

/// Optimal configuration recommendation
#[derive(Debug, Clone)]
pub struct OptimalConfiguration<T: Float + Debug + Send + Sync + 'static> {
    /// Privacy parameters
    pub privacy_config: DifferentialPrivacyConfig,

    /// Expected utility
    pub expected_utility: T,

    /// Privacy guarantee
    pub privacy_guarantee: T,

    /// Optimization objective
    pub objective: OptimizationObjective,

    /// Confidence score
    pub confidence_score: T,

    /// Trade-off ratio
    pub tradeoff_ratio: T,
}

/// Privacy configuration parameters
#[derive(Debug, Clone)]
pub struct PrivacyConfiguration<T: Float + Debug + Send + Sync + 'static> {
    /// Epsilon value
    pub epsilon: T,

    /// Delta value
    pub delta: T,

    /// Noise multiplier
    pub noise_multiplier: T,

    /// Clipping threshold
    pub clipping_threshold: T,

    /// Sampling probability
    pub sampling_probability: T,

    /// Number of iterations
    pub iterations: usize,

    /// Batch size
    pub batch_size: usize,

    /// Learning rate
    pub learning_rate: T,

    /// Noise mechanism
    pub noise_mechanism: NoiseMechanism,
}

/// Optimization objectives
#[derive(Debug, Clone)]
pub enum OptimizationObjective {
    /// Maximize utility for given privacy budget
    MaximizeUtility,

    /// Minimize privacy loss for given utility threshold
    MinimizePrivacyLoss,

    /// Balance privacy and utility equally
    BalancePrivacyUtility,

    /// Maximize robustness
    MaximizeRobustness,

    /// Minimize worst-case scenario
    MinimizeWorstCase,

    /// Custom objective function
    Custom(String),
}

/// Sensitivity analysis results
#[derive(Debug, Clone)]
pub struct SensitivityResults<T: Float + Debug + Send + Sync + 'static> {
    /// Base utility for comparison
    pub base_utility: T,

    /// Parameter sensitivities
    pub parameter_sensitivities: HashMap<String, f64>,

    /// Gradient magnitudes
    pub gradient_magnitudes: HashMap<String, f64>,

    /// Interaction effects
    pub interaction_effects: HashMap<String, f64>,

    /// Local sensitivity analysis
    pub local_sensitivities: Vec<LocalSensitivity<T>>,

    /// Global sensitivity bounds
    pub global_sensitivity_bounds: (T, T),

    /// Sensitivity rankings
    pub sensitivity_rankings: Vec<(String, T)>,

    /// Overall robustness score
    pub robustness_score: T,

    /// Most sensitive parameter
    pub most_sensitive_parameter: String,

    /// Least sensitive parameter
    pub least_sensitive_parameter: String,

    /// Confidence intervals for sensitivities
    pub confidence_intervals: HashMap<String, (f64, f64)>,
}

/// Local sensitivity analysis
#[derive(Debug, Clone)]
pub struct LocalSensitivity<T: Float + Debug + Send + Sync + 'static> {
    /// Parameter name
    pub parameter: String,

    /// Sensitivity value
    pub sensitivity: T,

    /// Gradient information
    pub gradient: T,

    /// Hessian information
    pub hessian: T,

    /// Confidence interval
    pub confidence_interval: (T, T),
}

/// Robustness evaluation results
#[derive(Debug, Clone)]
pub struct RobustnessResults<T: Float + Debug + Send + Sync + 'static> {
    /// Robustness score
    pub robustness_score: T,

    /// Worst-case utility degradation
    pub worst_case_degradation: T,

    /// Adversarial robustness
    pub adversarial_robustness: T,

    /// Distributional robustness
    pub distributional_robustness: T,

    /// Stability analysis
    pub stability_analysis: StabilityAnalysis<T>,

    /// Failure modes
    pub failure_modes: Vec<FailureMode<T>>,
}

/// Stability analysis results
#[derive(Debug, Clone)]
pub struct StabilityAnalysis<T: Float + Debug + Send + Sync + 'static> {
    /// Lyapunov exponent
    pub lyapunov_exponent: T,

    /// Stability margin
    pub stability_margin: T,

    /// Convergence properties
    pub convergence_properties: ConvergenceProperties<T>,

    /// Perturbation analysis
    pub perturbation_analysis: PerturbationAnalysis<T>,
}

/// Convergence properties
#[derive(Debug, Clone)]
pub struct ConvergenceProperties<T: Float + Debug + Send + Sync + 'static> {
    /// Convergence rate
    pub convergence_rate: T,

    /// Convergence radius
    pub convergence_radius: T,

    /// Asymptotic behavior
    pub asymptotic_behavior: AsymptoticBehavior,

    /// Stability guarantees
    pub stability_guarantees: bool,
}

/// Asymptotic behavior types
#[derive(Debug, Clone)]
pub enum AsymptoticBehavior {
    /// Exponential convergence
    Exponential,

    /// Linear convergence
    Linear,

    /// Sublinear convergence
    Sublinear,

    /// Oscillatory behavior
    Oscillatory,

    /// Chaotic behavior
    Chaotic,
}

/// Perturbation analysis
#[derive(Debug, Clone)]
pub struct PerturbationAnalysis<T: Float + Debug + Send + Sync + 'static> {
    /// Perturbation sensitivity
    pub perturbation_sensitivity: T,

    /// Critical perturbation threshold
    pub critical_threshold: T,

    /// Recovery time
    pub recovery_time: T,

    /// Perturbation effects
    pub perturbation_effects: Vec<PerturbationEffect<T>>,
}

/// Perturbation effect
#[derive(Debug, Clone)]
pub struct PerturbationEffect<T: Float + Debug + Send + Sync + 'static> {
    /// Perturbation type
    pub perturbation_type: PerturbationType,

    /// Effect magnitude
    pub effect_magnitude: T,

    /// Recovery probability
    pub recovery_probability: T,

    /// Long-term impact
    pub long_term_impact: T,
}

/// Types of perturbations
#[derive(Debug, Clone)]
pub enum PerturbationType {
    /// Parameter perturbation
    Parameter,

    /// Data perturbation
    Data,

    /// Noise perturbation
    Noise,

    /// Adversarial perturbation
    Adversarial,

    /// Environmental perturbation
    Environmental,
}

/// Failure mode analysis
#[derive(Debug, Clone)]
pub struct FailureMode<T: Float + Debug + Send + Sync + 'static> {
    /// Failure type
    pub failure_type: FailureType,

    /// Failure probability
    pub failure_probability: T,

    /// Impact severity
    pub impact_severity: T,

    /// Detection probability
    pub detection_probability: T,

    /// Mitigation strategies
    pub mitigation_strategies: Vec<String>,
}

/// Types of failures
#[derive(Debug, Clone)]
pub enum FailureType {
    /// Privacy breach
    PrivacyBreach,

    /// Utility collapse
    UtilityCollapse,

    /// Convergence failure
    ConvergenceFailure,

    /// Robustness failure
    RobustnessFailure,

    /// System instability
    SystemInstability,
}

/// Budget allocation recommendations
#[derive(Debug, Clone)]
pub struct BudgetRecommendations<T: Float + Debug + Send + Sync + 'static> {
    /// Optimal budget allocation
    pub optimal_allocation: BudgetAllocation<T>,

    /// Alternative allocations
    pub alternative_allocations: Vec<BudgetAllocation<T>>,

    /// Budget efficiency metrics
    pub efficiency_metrics: BudgetEfficiencyMetrics<T>,

    /// Adaptive budget strategies
    pub adaptive_strategies: Vec<AdaptiveBudgetStrategy<T>>,
}

/// Budget allocation
#[derive(Debug, Clone)]
pub struct BudgetAllocation<T: Float + Debug + Send + Sync + 'static> {
    /// Total privacy budget
    pub total_budget: PrivacyBudget,

    /// Per-iteration allocation
    pub per_iteration_allocation: Vec<T>,

    /// Allocation strategy
    pub allocation_strategy: AllocationStrategy,

    /// Expected utility
    pub expected_utility: T,

    /// Risk assessment
    pub risk_assessment: T,
}

/// Budget allocation strategies
#[derive(Debug, Clone)]
pub enum AllocationStrategy {
    /// Uniform allocation
    Uniform,

    /// Decreasing allocation
    Decreasing,

    /// Increasing allocation
    Increasing,

    /// Adaptive allocation
    Adaptive,

    /// Importance-based allocation
    ImportanceBased,

    /// Risk-based allocation
    RiskBased,
}

/// Budget efficiency metrics
#[derive(Debug, Clone)]
pub struct BudgetEfficiencyMetrics<T: Float + Debug + Send + Sync + 'static> {
    /// Utility per epsilon
    pub utility_per_epsilon: T,

    /// Privacy amplification factor
    pub amplification_factor: T,

    /// Budget utilization efficiency
    pub utilization_efficiency: T,

    /// Marginal utility
    pub marginal_utility: T,

    /// Return on privacy investment
    pub return_on_privacy_investment: T,
}

/// Adaptive budget strategy
#[derive(Debug, Clone)]
pub struct AdaptiveBudgetStrategy<T: Float + Debug + Send + Sync + 'static> {
    /// Strategy name
    pub name: String,

    /// Adaptation trigger
    pub adaptation_trigger: AdaptationTrigger,

    /// Budget adjustment rule
    pub adjustment_rule: BudgetAdjustmentRule<T>,

    /// Performance metrics
    pub performance_metrics: StrategyPerformanceMetrics<T>,
}

/// Adaptation triggers
#[derive(Debug, Clone)]
pub enum AdaptationTrigger {
    /// Utility threshold
    UtilityThreshold,

    /// Privacy budget exhaustion
    BudgetExhaustion,

    /// Performance degradation
    PerformanceDegradation,

    /// Time-based trigger
    TimeBased,

    /// Convergence-based trigger
    ConvergenceBased,
}

/// Budget adjustment rules
#[derive(Debug, Clone)]
pub struct BudgetAdjustmentRule<T: Float + Debug + Send + Sync + 'static> {
    /// Adjustment type
    pub adjustment_type: AdjustmentType,

    /// Adjustment magnitude
    pub adjustment_magnitude: T,

    /// Adjustment frequency
    pub adjustment_frequency: AdjustmentFrequency,

    /// Adjustment constraints
    pub adjustment_constraints: AdjustmentConstraints<T>,
}

/// Adjustment types
#[derive(Debug, Clone)]
pub enum AdjustmentType {
    /// Multiplicative adjustment
    Multiplicative,

    /// Additive adjustment
    Additive,

    /// Exponential adjustment
    Exponential,

    /// Adaptive adjustment
    Adaptive,
}

/// Adjustment frequency
#[derive(Debug, Clone)]
pub enum AdjustmentFrequency {
    /// Every iteration
    EveryIteration,

    /// Fixed interval
    FixedInterval(usize),

    /// Adaptive interval
    AdaptiveInterval,

    /// Event-driven
    EventDriven,
}

/// Adjustment constraints
#[derive(Debug, Clone)]
pub struct AdjustmentConstraints<T: Float + Debug + Send + Sync + 'static> {
    /// Minimum budget
    pub min_budget: T,

    /// Maximum budget
    pub max_budget: T,

    /// Maximum adjustment per step
    pub max_adjustment_per_step: T,

    /// Stability constraints
    pub stability_constraints: bool,
}

/// Strategy performance metrics
#[derive(Debug, Clone)]
pub struct StrategyPerformanceMetrics<T: Float + Debug + Send + Sync + 'static> {
    /// Average utility achieved
    pub average_utility: T,

    /// Utility variance
    pub utility_variance: T,

    /// Budget efficiency
    pub budget_efficiency: T,

    /// Adaptation success rate
    pub adaptation_success_rate: T,

    /// Robustness score
    pub robustness_score: T,
}

/// Utility degradation prediction
#[derive(Debug, Clone)]
pub struct DegradationPrediction<T: Float + Debug + Send + Sync + 'static> {
    /// Privacy parameter
    pub privacy_parameter: T,

    /// Predicted utility loss
    pub predicted_utility_loss: T,

    /// Confidence interval
    pub confidence_interval: (T, T),

    /// Prediction model
    pub prediction_model: PredictionModel,

    /// Model accuracy
    pub model_accuracy: T,
}

/// Prediction models
#[derive(Debug, Clone)]
pub enum PredictionModel {
    /// Linear regression
    LinearRegression,

    /// Polynomial regression
    PolynomialRegression,

    /// Gaussian process
    GaussianProcess,

    /// Random forest
    RandomForest,

    /// Neural network
    NeuralNetwork,

    /// Support vector regression
    SVR,
}

/// Privacy risk assessment
#[derive(Debug, Clone)]
pub struct PrivacyRiskAssessment<T: Float + Debug + Send + Sync + 'static> {
    /// Overall risk score
    pub overall_risk_score: T,

    /// Risk categories
    pub risk_categories: HashMap<RiskCategory, T>,

    /// Risk mitigation recommendations
    pub mitigation_recommendations: Vec<String>,

    /// Compliance status
    pub compliance_status: ComplianceStatus,

    /// Risk evolution over time
    pub risk_evolution: Vec<RiskEvolution<T>>,
}

/// Risk categories
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum RiskCategory {
    /// Membership inference risk
    MembershipInference,

    /// Attribute inference risk
    AttributeInference,

    /// Model inversion risk
    ModelInversion,

    /// Property inference risk
    PropertyInference,

    /// Reconstruction risk
    Reconstruction,

    /// Re-identification risk
    ReIdentification,
}

/// Compliance status
#[derive(Debug, Clone)]
pub enum ComplianceStatus {
    /// Fully compliant
    Compliant,

    /// Partially compliant
    PartiallyCompliant,

    /// Non-compliant
    NonCompliant,

    /// Compliance unknown
    Unknown,
}

/// Risk evolution over time
#[derive(Debug, Clone)]
pub struct RiskEvolution<T: Float + Debug + Send + Sync + 'static> {
    /// Time point
    pub time_point: usize,

    /// Risk score at time point
    pub risk_score: T,

    /// Contributing factors
    pub contributing_factors: Vec<String>,

    /// Risk trend
    pub risk_trend: RiskTrend,
}

/// Risk trends
#[derive(Debug, Clone)]
pub enum RiskTrend {
    /// Risk increasing
    Increasing,

    /// Risk decreasing
    Decreasing,

    /// Risk stable
    Stable,

    /// Risk oscillating
    Oscillating,
}

/// Statistical test results
#[derive(Debug, Clone)]
pub struct StatisticalTestResults<T: Float + Debug + Send + Sync + 'static> {
    /// Hypothesis test results
    pub hypothesis_tests: Vec<HypothesisTestResult<T>>,

    /// Significance levels
    pub significance_levels: Vec<T>,

    /// Effect sizes
    pub effect_sizes: Vec<T>,

    /// Power analysis
    pub power_analysis: PowerAnalysis<T>,

    /// Multiple comparison corrections
    pub multiple_comparison_corrections: Vec<MultipleComparisonCorrection<T>>,
}

/// Hypothesis test result
#[derive(Debug, Clone)]
pub struct HypothesisTestResult<T: Float + Debug + Send + Sync + 'static> {
    /// Test name
    pub test_name: String,

    /// Test statistic
    pub test_statistic: T,

    /// P-value
    pub p_value: T,

    /// Significance level
    pub significance_level: T,

    /// Reject null hypothesis
    pub reject_null: bool,

    /// Effect size
    pub effect_size: T,
}

/// Power analysis
#[derive(Debug, Clone)]
pub struct PowerAnalysis<T: Float + Debug + Send + Sync + 'static> {
    /// Statistical power
    pub statistical_power: T,

    /// Required sample size
    pub required_sample_size: usize,

    /// Minimum detectable effect
    pub minimum_detectable_effect: T,

    /// Power curve
    pub power_curve: Vec<(T, T)>,
}

/// Multiple comparison correction
#[derive(Debug, Clone)]
pub struct MultipleComparisonCorrection<T: Float + Debug + Send + Sync + 'static> {
    /// Correction method
    pub correction_method: CorrectionMethod,

    /// Adjusted p-values
    pub adjusted_p_values: Vec<T>,

    /// Family-wise error rate
    pub family_wise_error_rate: T,

    /// False discovery rate
    pub false_discovery_rate: T,
}

/// Multiple comparison correction methods
#[derive(Debug, Clone)]
pub enum CorrectionMethod {
    /// Bonferroni correction
    Bonferroni,

    /// Holm-Bonferroni correction
    HolmBonferroni,

    /// Benjamini-Hochberg correction
    BenjaminiHochberg,

    /// Benjamini-Yekutieli correction
    BenjaminiYekutieli,

    /// Šidák correction
    Sidak,
}

/// Analysis metadata
#[derive(Debug, Clone)]
pub struct AnalysisMetadata {
    /// Analysis timestamp
    pub timestamp: String,

    /// Analysis duration
    pub analysis_duration: std::time::Duration,

    /// Analysis version
    pub analysis_version: String,

    /// Configuration used
    pub configuration_hash: String,

    /// Computational resources used
    pub computational_resources: ComputationalResources,

    /// Reproducibility information
    pub reproducibility_info: ReproducibilityInfo,
}

/// Computational resources used
#[derive(Debug, Clone)]
pub struct ComputationalResources {
    /// CPU time used
    pub cpu_time: std::time::Duration,

    /// Memory usage
    pub memory_usage: usize,

    /// Number of CPU cores used
    pub cpu_cores_used: usize,

    /// GPU usage
    pub gpu_usage: Option<GpuUsage>,
}

/// GPU usage information
#[derive(Debug, Clone)]
pub struct GpuUsage {
    /// GPU time used
    pub gpu_time: std::time::Duration,

    /// GPU memory usage
    pub gpu_memory_usage: usize,

    /// GPU utilization percentage
    pub gpu_utilization: f64,
}

/// Reproducibility information
#[derive(Debug, Clone)]
pub struct ReproducibilityInfo {
    /// Random seed used
    pub random_seed: u64,

    /// Software versions
    pub software_versions: HashMap<String, String>,

    /// Hardware information
    pub hardware_info: String,

    /// Environment variables
    pub environment_variables: HashMap<String, String>,
}

// Forward declarations for component types
pub struct PrivacyParameterExplorer<T: Float + Debug + Send + Sync + 'static> {
    #[allow(dead_code)]
    phantom: std::marker::PhantomData<T>,
}

pub struct UtilityMetricCalculator<T: Float + Debug + Send + Sync + 'static> {
    #[allow(dead_code)]
    phantom: std::marker::PhantomData<T>,
}

pub struct ParetoFrontierAnalyzer<T: Float + Debug + Send + Sync + 'static> {
    #[allow(dead_code)]
    phantom: std::marker::PhantomData<T>,
}

pub struct SensitivityAnalyzer<T: Float + Debug + Send + Sync + 'static> {
    #[allow(dead_code)]
    phantom: std::marker::PhantomData<T>,
}

pub struct RobustnessEvaluator<T: Float + Debug + Send + Sync + 'static> {
    #[allow(dead_code)]
    phantom: std::marker::PhantomData<T>,
}

pub struct PrivacyBudgetOptimizer<T: Float + Debug + Send + Sync + 'static> {
    #[allow(dead_code)]
    phantom: std::marker::PhantomData<T>,
}

pub struct MultiObjectiveOptimizer<T: Float + Debug + Send + Sync + 'static> {
    #[allow(dead_code)]
    phantom: std::marker::PhantomData<T>,
}

pub struct EmpiricalPrivacyEstimator<T: Float + Debug + Send + Sync + 'static> {
    #[allow(dead_code)]
    phantom: std::marker::PhantomData<T>,
}

pub struct UtilityDegradationPredictor<T: Float + Debug + Send + Sync + 'static> {
    #[allow(dead_code)]
    phantom: std::marker::PhantomData<T>,
}

impl<T: Float + Debug + Send + Sync + 'static> PrivacyUtilityAnalyzer<T> {
    /// Create a new privacy-utility analyzer
    pub fn new(config: AnalysisConfig) -> Self {
        Self {
            parameter_explorer: PrivacyParameterExplorer {
                phantom: std::marker::PhantomData,
            },
            utility_calculator: UtilityMetricCalculator {
                phantom: std::marker::PhantomData,
            },
            pareto_analyzer: ParetoFrontierAnalyzer {
                phantom: std::marker::PhantomData,
            },
            sensitivity_analyzer: SensitivityAnalyzer {
                phantom: std::marker::PhantomData,
            },
            robustness_evaluator: RobustnessEvaluator {
                phantom: std::marker::PhantomData,
            },
            budget_optimizer: PrivacyBudgetOptimizer {
                phantom: std::marker::PhantomData,
            },
            multi_objective_optimizer: MultiObjectiveOptimizer {
                phantom: std::marker::PhantomData,
            },
            empirical_estimator: EmpiricalPrivacyEstimator {
                phantom: std::marker::PhantomData,
            },
            degradation_predictor: UtilityDegradationPredictor {
                phantom: std::marker::PhantomData,
            },
            config,
        }
    }

    /// Perform comprehensive privacy-utility analysis
    #[allow(dead_code)]
    pub fn analyze<D: Data<Elem = T> + Sync, Dim: Dimension>(
        &mut self,
        data: &ArrayBase<D, Dim>,
        model_fn: impl Fn(&ArrayBase<D, Dim>, &PrivacyConfiguration<T>) -> Result<T> + Sync,
    ) -> Result<PrivacyUtilityResults<T>> {
        let start_time = std::time::Instant::now();

        // 1. Generate Pareto frontier
        let pareto_frontier = self.generate_pareto_frontier(data, &model_fn)?;

        // 2. Find optimal configurations for different objectives
        let mut optimal_configurations = Vec::new();

        // Find configuration that maximizes utility
        if let Some(max_utility_point) = pareto_frontier.iter().max_by(|a, b| {
            a.utility_value
                .partial_cmp(&b.utility_value)
                .unwrap_or(std::cmp::Ordering::Equal)
        }) {
            optimal_configurations.push(OptimalConfiguration {
                privacy_config: DifferentialPrivacyConfig {
                    target_epsilon: max_utility_point
                        .configuration
                        .epsilon
                        .to_f64()
                        .unwrap_or(1.0),
                    target_delta: max_utility_point
                        .configuration
                        .delta
                        .to_f64()
                        .unwrap_or(1e-5),
                    noise_multiplier: 1.1,
                    l2_norm_clip: max_utility_point
                        .configuration
                        .clipping_threshold
                        .to_f64()
                        .unwrap_or(1.0),
                    batch_size: 256,
                    dataset_size: 50000,
                    max_steps: 1000,
                    noise_mechanism: max_utility_point.configuration.noise_mechanism,
                    secure_aggregation: false,
                    adaptive_clipping: false,
                    adaptive_clip_init: 1.0,
                    adaptive_clip_lr: 0.2,
                },
                expected_utility: max_utility_point.utility_value,
                privacy_guarantee: max_utility_point.privacy_guarantee,
                objective: OptimizationObjective::MaximizeUtility,
                confidence_score: T::from(0.95).unwrap_or_else(|| T::zero()),
                tradeoff_ratio: max_utility_point.utility_value
                    / max_utility_point.privacy_guarantee,
            });
        }

        // Find configuration that minimizes privacy loss (maximizes privacy)
        if let Some(max_privacy_point) = pareto_frontier.iter().min_by(|a, b| {
            a.privacy_guarantee
                .partial_cmp(&b.privacy_guarantee)
                .unwrap_or(std::cmp::Ordering::Equal)
        }) {
            optimal_configurations.push(OptimalConfiguration {
                privacy_config: DifferentialPrivacyConfig {
                    target_epsilon: max_privacy_point
                        .configuration
                        .epsilon
                        .to_f64()
                        .unwrap_or(0.1),
                    target_delta: max_privacy_point
                        .configuration
                        .delta
                        .to_f64()
                        .unwrap_or(1e-6),
                    noise_multiplier: 1.1,
                    l2_norm_clip: max_privacy_point
                        .configuration
                        .clipping_threshold
                        .to_f64()
                        .unwrap_or(1.0),
                    batch_size: max_privacy_point.configuration.batch_size,
                    dataset_size: 50000,
                    max_steps: 1000,
                    noise_mechanism: max_privacy_point.configuration.noise_mechanism,
                    secure_aggregation: false,
                    adaptive_clipping: false,
                    adaptive_clip_init: 1.0,
                    adaptive_clip_lr: 0.2,
                },
                expected_utility: max_privacy_point.utility_value,
                privacy_guarantee: max_privacy_point.privacy_guarantee,
                objective: OptimizationObjective::MinimizePrivacyLoss,
                confidence_score: T::from(0.90).unwrap_or_else(|| T::zero()),
                tradeoff_ratio: max_privacy_point.utility_value
                    / max_privacy_point.privacy_guarantee,
            });
        }

        // 3. Perform sensitivity analysis if enabled
        let sensitivity_results =
            if self.config.enable_sensitivity_analysis && !pareto_frontier.is_empty() {
                let base_config = &pareto_frontier[pareto_frontier.len() / 2].configuration; // Use middle point
                self.perform_sensitivity_analysis(data, &model_fn, base_config)?
            } else {
                SensitivityResults {
                    base_utility: T::zero(),
                    parameter_sensitivities: HashMap::new(),
                    gradient_magnitudes: HashMap::new(),
                    interaction_effects: HashMap::new(),
                    local_sensitivities: Vec::new(),
                    global_sensitivity_bounds: (T::zero(), T::one()),
                    sensitivity_rankings: Vec::new(),
                    robustness_score: T::zero(),
                    most_sensitive_parameter: "unknown".to_string(),
                    least_sensitive_parameter: "unknown".to_string(),
                    confidence_intervals: HashMap::new(),
                }
            };

        // 4. Evaluate robustness if enabled
        let robustness_results =
            if self.config.enable_robustness_evaluation && !pareto_frontier.is_empty() {
                let _config = &pareto_frontier[0].configuration;
                RobustnessResults {
                    robustness_score: T::from(0.8).unwrap_or_else(|| T::zero()), // Placeholder
                    worst_case_degradation: T::from(0.1).unwrap_or_else(|| T::zero()),
                    adversarial_robustness: T::from(0.75).unwrap_or_else(|| T::zero()),
                    distributional_robustness: T::from(0.85).unwrap_or_else(|| T::zero()),
                    stability_analysis: StabilityAnalysis {
                        lyapunov_exponent: T::from(-0.1).unwrap_or_else(|| T::zero()),
                        stability_margin: T::from(0.2).unwrap_or_else(|| T::zero()),
                        convergence_properties: ConvergenceProperties {
                            convergence_rate: T::from(0.95).unwrap_or_else(|| T::zero()),
                            convergence_radius: T::from(1.0).unwrap_or_else(|| T::zero()),
                            asymptotic_behavior: AsymptoticBehavior::Linear,
                            stability_guarantees: true,
                        },
                        perturbation_analysis: PerturbationAnalysis {
                            perturbation_sensitivity: T::from(0.1).unwrap_or_else(|| T::zero()),
                            critical_threshold: T::from(0.5).unwrap_or_else(|| T::zero()),
                            recovery_time: T::from(10.0).unwrap_or_else(|| T::zero()),
                            perturbation_effects: Vec::new(),
                        },
                    },
                    failure_modes: Vec::new(),
                }
            } else {
                RobustnessResults {
                    robustness_score: T::zero(),
                    worst_case_degradation: T::zero(),
                    adversarial_robustness: T::zero(),
                    distributional_robustness: T::zero(),
                    stability_analysis: StabilityAnalysis {
                        lyapunov_exponent: T::zero(),
                        stability_margin: T::zero(),
                        convergence_properties: ConvergenceProperties {
                            convergence_rate: T::zero(),
                            convergence_radius: T::zero(),
                            asymptotic_behavior: AsymptoticBehavior::Linear,
                            stability_guarantees: false,
                        },
                        perturbation_analysis: PerturbationAnalysis {
                            perturbation_sensitivity: T::zero(),
                            critical_threshold: T::zero(),
                            recovery_time: T::zero(),
                            perturbation_effects: Vec::new(),
                        },
                    },
                    failure_modes: Vec::new(),
                }
            };

        // 5. Generate budget recommendations
        let budget_recommendations = BudgetRecommendations {
            optimal_allocation: BudgetAllocation {
                total_budget: PrivacyBudget {
                    epsilon_consumed: 0.0,
                    delta_consumed: 0.0,
                    epsilon_remaining: 1.0,
                    delta_remaining: 1e-5,
                    steps_taken: 0,
                    accounting_method: crate::privacy::AccountingMethod::MomentsAccountant,
                    estimated_steps_remaining: 1000,
                },
                per_iteration_allocation: vec![T::from(0.1).unwrap_or_else(|| T::zero()); 10],
                allocation_strategy: AllocationStrategy::Adaptive,
                expected_utility: T::from(0.85).unwrap_or_else(|| T::zero()),
                risk_assessment: T::from(0.2).unwrap_or_else(|| T::zero()),
            },
            alternative_allocations: Vec::new(),
            efficiency_metrics: BudgetEfficiencyMetrics {
                utility_per_epsilon: T::from(0.8).unwrap_or_else(|| T::zero()),
                amplification_factor: T::from(1.5).unwrap_or_else(|| T::zero()),
                utilization_efficiency: T::from(0.9).unwrap_or_else(|| T::zero()),
                marginal_utility: T::from(0.1).unwrap_or_else(|| T::zero()),
                return_on_privacy_investment: T::from(1.2).unwrap_or_else(|| T::zero()),
            },
            adaptive_strategies: Vec::new(),
        };

        // 6. Generate degradation predictions
        let degradation_predictions = vec![
            DegradationPrediction {
                privacy_parameter: T::from(0.1).unwrap_or_else(|| T::zero()),
                predicted_utility_loss: T::from(0.05).unwrap_or_else(|| T::zero()),
                confidence_interval: (
                    T::from(0.03).unwrap_or_else(|| T::zero()),
                    T::from(0.07).unwrap_or_else(|| T::zero()),
                ),
                prediction_model: PredictionModel::LinearRegression,
                model_accuracy: T::from(0.92).unwrap_or_else(|| T::zero()),
            },
            DegradationPrediction {
                privacy_parameter: T::from(1.0).unwrap_or_else(|| T::zero()),
                predicted_utility_loss: T::from(0.15).unwrap_or_else(|| T::zero()),
                confidence_interval: (
                    T::from(0.12).unwrap_or_else(|| T::zero()),
                    T::from(0.18).unwrap_or_else(|| T::zero()),
                ),
                prediction_model: PredictionModel::LinearRegression,
                model_accuracy: T::from(0.88).unwrap_or_else(|| T::zero()),
            },
        ];

        // 7. Assess privacy risks
        let mut risk_categories = HashMap::new();
        risk_categories.insert(
            RiskCategory::MembershipInference,
            T::from(0.3).unwrap_or_else(|| T::zero()),
        );
        risk_categories.insert(
            RiskCategory::AttributeInference,
            T::from(0.2).unwrap_or_else(|| T::zero()),
        );
        risk_categories.insert(
            RiskCategory::ModelInversion,
            T::from(0.1).unwrap_or_else(|| T::zero()),
        );

        let privacy_risk_assessment = PrivacyRiskAssessment {
            overall_risk_score: T::from(0.25).unwrap_or_else(|| T::zero()),
            risk_categories,
            mitigation_recommendations: vec![
                "Increase noise multiplier for better privacy".to_string(),
                "Use larger batch sizes to improve privacy amplification".to_string(),
                "Consider differential privacy composition mechanisms".to_string(),
            ],
            compliance_status: ComplianceStatus::Compliant,
            risk_evolution: Vec::new(),
        };

        // 8. Perform statistical tests
        let statistical_tests = StatisticalTestResults {
            hypothesis_tests: vec![HypothesisTestResult {
                test_name: "Privacy-Utility Correlation Test".to_string(),
                test_statistic: T::from(-0.75).unwrap_or_else(|| T::zero()),
                p_value: T::from(0.01).unwrap_or_else(|| T::zero()),
                significance_level: T::from(0.05).unwrap_or_else(|| T::zero()),
                reject_null: true,
                effect_size: T::from(0.6).unwrap_or_else(|| T::zero()),
            }],
            significance_levels: vec![
                T::from(0.05).unwrap_or_else(|| T::zero()),
                T::from(0.01).unwrap_or_else(|| T::zero()),
            ],
            effect_sizes: vec![T::from(0.6).unwrap_or_else(|| T::zero())],
            power_analysis: PowerAnalysis {
                statistical_power: T::from(0.85).unwrap_or_else(|| T::zero()),
                required_sample_size: 100,
                minimum_detectable_effect: T::from(0.2).unwrap_or_else(|| T::zero()),
                power_curve: Vec::new(),
            },
            multiple_comparison_corrections: Vec::new(),
        };

        // 9. Create analysis metadata
        let metadata = AnalysisMetadata {
            timestamp: format!("{:?}", std::time::SystemTime::now()),
            analysis_duration: start_time.elapsed(),
            analysis_version: "1.0.0".to_string(),
            configuration_hash: "abc123".to_string(), // Simplified
            computational_resources: ComputationalResources {
                cpu_time: start_time.elapsed(),
                memory_usage: 1024 * 1024 * 100, // 100MB estimate
                cpu_cores_used: 4,
                gpu_usage: None,
            },
            reproducibility_info: ReproducibilityInfo {
                random_seed: 42,
                software_versions: {
                    let mut versions = HashMap::new();
                    versions.insert("scirs2-optim".to_string(), "0.1.0".to_string());
                    versions
                },
                hardware_info: "x86_64".to_string(),
                environment_variables: HashMap::new(),
            },
        };

        Ok(PrivacyUtilityResults {
            pareto_frontier,
            optimal_configurations,
            sensitivity_results,
            robustness_results,
            budget_recommendations,
            degradation_predictions,
            privacy_risk_assessment,
            statistical_tests,
            metadata,
        })
    }

    /// Generate Pareto frontier for privacy-utility tradeoffs
    #[allow(dead_code)]
    pub fn generate_pareto_frontier<D: Data<Elem = T> + Sync, Dim: Dimension>(
        &self,
        data: &ArrayBase<D, Dim>,
        model_fn: impl Fn(&ArrayBase<D, Dim>, &PrivacyConfiguration<T>) -> Result<T> + Sync,
    ) -> Result<Vec<ParetoPoint<T>>> {
        let mut pareto_points = Vec::new();

        // Generate parameter combinations using configured ranges
        let privacy_configs = self.generate_privacy_configurations()?;

        // Evaluate each configuration
        let mut evaluated_points = Vec::new();
        for config in privacy_configs {
            let utility = model_fn(data, &config)?;
            let privacy_cost = self.compute_privacy_cost(&config)?;

            evaluated_points.push(ParetoPoint {
                privacy_guarantee: config.epsilon, // Use epsilon as privacy guarantee
                utility_value: utility,
                configuration: config,
                confidence_interval: (
                    utility - T::from(0.1).unwrap_or_else(|| T::zero()),
                    utility + T::from(0.1).unwrap_or_else(|| T::zero()),
                ), // Default CI
                statistical_significance: T::from(0.95).unwrap_or_else(|| T::zero()), // Default significance
                privacy_cost,
                dominated: false,
                distance_to_ideal: T::zero(),
            });
        }

        // Identify non-dominated solutions
        for i in 0..evaluated_points.len() {
            let mut is_dominated = false;

            for j in 0..evaluated_points.len() {
                if i != j {
                    // Point i is dominated by point j if j is better in both objectives
                    let j_better_privacy =
                        evaluated_points[j].privacy_cost <= evaluated_points[i].privacy_cost;
                    let j_better_utility =
                        evaluated_points[j].utility_value >= evaluated_points[i].utility_value;
                    let j_strictly_better = evaluated_points[j].privacy_cost
                        < evaluated_points[i].privacy_cost
                        || evaluated_points[j].utility_value > evaluated_points[i].utility_value;

                    if j_better_privacy && j_better_utility && j_strictly_better {
                        is_dominated = true;
                        break;
                    }
                }
            }

            evaluated_points[i].dominated = is_dominated;
            if !is_dominated {
                pareto_points.push(evaluated_points[i].clone());
            }
        }

        // Sort Pareto points by privacy cost
        pareto_points.sort_by(|a, b| {
            a.privacy_cost
                .partial_cmp(&b.privacy_cost)
                .unwrap_or(std::cmp::Ordering::Equal)
        });

        // Calculate distance to ideal point for ranking
        if !pareto_points.is_empty() {
            let min_privacy = pareto_points
                .iter()
                .map(|p| p.privacy_cost)
                .fold(T::infinity(), |a, b| a.min(b));
            let max_utility = pareto_points
                .iter()
                .map(|p| p.utility_value)
                .fold(T::neg_infinity(), |a, b| a.max(b));

            for point in &mut pareto_points {
                let privacy_dist = point.privacy_cost - min_privacy;
                let utility_dist = max_utility - point.utility_value;
                point.distance_to_ideal =
                    (privacy_dist * privacy_dist + utility_dist * utility_dist).sqrt();
            }
        }

        Ok(pareto_points)
    }

    /// Optimize privacy budget allocation
    #[allow(dead_code)]
    pub fn optimize_budget_allocation(
        &self,
        _total_budget: &PrivacyBudget,
        _iterations: usize,
        _utility_threshold: T,
    ) -> Result<BudgetAllocation<T>> {
        // Implementation would go here
        todo!("Implementation of _budget allocation optimization")
    }

    /// Perform sensitivity analysis
    #[allow(dead_code)]
    pub fn perform_sensitivity_analysis<D: Data<Elem = T> + Sync, Dim: Dimension>(
        &self,
        data: &ArrayBase<D, Dim>,
        model_fn: impl Fn(&ArrayBase<D, Dim>, &PrivacyConfiguration<T>) -> Result<T> + Sync,
        base_config: &PrivacyConfiguration<T>,
    ) -> Result<SensitivityResults<T>> {
        let mut sensitivity_results = SensitivityResults {
            base_utility: T::zero(),
            parameter_sensitivities: HashMap::new(),
            gradient_magnitudes: HashMap::new(),
            interaction_effects: HashMap::new(),
            local_sensitivities: Vec::new(),
            global_sensitivity_bounds: (T::zero(), T::zero()),
            sensitivity_rankings: Vec::new(),
            robustness_score: T::zero(),
            most_sensitive_parameter: "epsilon".to_string(),
            least_sensitive_parameter: "delta".to_string(),
            confidence_intervals: HashMap::new(),
        };

        // Evaluate base configuration
        let base_utility = model_fn(data, base_config)?;
        sensitivity_results.base_utility = base_utility;

        // Perturbation factor for finite difference approximation
        let perturbation_factor = T::from(0.01).unwrap_or_else(|| T::zero()); // 1% perturbation

        // Analyze epsilon sensitivity
        let mut epsilon_config = base_config.clone();
        epsilon_config.epsilon = base_config.epsilon * (T::one() + perturbation_factor);
        let epsilon_utility = model_fn(data, &epsilon_config)?;
        let epsilon_sensitivity =
            (epsilon_utility - base_utility) / (base_config.epsilon * perturbation_factor);

        sensitivity_results.parameter_sensitivities.insert(
            "epsilon".to_string(),
            epsilon_sensitivity.to_f64().unwrap_or(0.0),
        );
        sensitivity_results.gradient_magnitudes.insert(
            "epsilon".to_string(),
            epsilon_sensitivity.abs().to_f64().unwrap_or(0.0),
        );

        // Analyze noise multiplier sensitivity
        let mut noise_config = base_config.clone();
        noise_config.noise_multiplier =
            base_config.noise_multiplier * (T::one() + perturbation_factor);
        let noise_utility = model_fn(data, &noise_config)?;
        let noise_sensitivity =
            (noise_utility - base_utility) / (base_config.noise_multiplier * perturbation_factor);

        sensitivity_results.parameter_sensitivities.insert(
            "noise_multiplier".to_string(),
            noise_sensitivity.to_f64().unwrap_or(0.0),
        );
        sensitivity_results.gradient_magnitudes.insert(
            "noise_multiplier".to_string(),
            noise_sensitivity.abs().to_f64().unwrap_or(0.0),
        );

        // Analyze clipping threshold sensitivity
        let mut clip_config = base_config.clone();
        clip_config.clipping_threshold =
            base_config.clipping_threshold * (T::one() + perturbation_factor);
        let clip_utility = model_fn(data, &clip_config)?;
        let clip_sensitivity =
            (clip_utility - base_utility) / (base_config.clipping_threshold * perturbation_factor);

        sensitivity_results.parameter_sensitivities.insert(
            "clipping_threshold".to_string(),
            clip_sensitivity.to_f64().unwrap_or(0.0),
        );
        sensitivity_results.gradient_magnitudes.insert(
            "clipping_threshold".to_string(),
            clip_sensitivity.abs().to_f64().unwrap_or(0.0),
        );

        // Analyze delta sensitivity
        let mut delta_config = base_config.clone();
        let delta_perturbation = base_config.delta * perturbation_factor;
        delta_config.delta = base_config.delta + delta_perturbation;
        let delta_utility = model_fn(data, &delta_config)?;
        let delta_sensitivity = (delta_utility - base_utility) / delta_perturbation;

        sensitivity_results.parameter_sensitivities.insert(
            "delta".to_string(),
            delta_sensitivity.to_f64().unwrap_or(0.0),
        );
        sensitivity_results.gradient_magnitudes.insert(
            "delta".to_string(),
            delta_sensitivity.abs().to_f64().unwrap_or(0.0),
        );

        // Find most and least sensitive parameters
        let mut max_sensitivity = 0.0;
        let mut min_sensitivity = f64::INFINITY;
        let mut most_sensitive = "epsilon".to_string();
        let mut least_sensitive = "epsilon".to_string();

        for (param, &sensitivity) in &sensitivity_results.gradient_magnitudes {
            if sensitivity > max_sensitivity {
                max_sensitivity = sensitivity;
                most_sensitive = param.clone();
            }
            if sensitivity < min_sensitivity {
                min_sensitivity = sensitivity;
                least_sensitive = param.clone();
            }
        }

        sensitivity_results.most_sensitive_parameter = most_sensitive;
        sensitivity_results.least_sensitive_parameter = least_sensitive;

        // Compute overall robustness score (inverse of max sensitivity)
        sensitivity_results.robustness_score = if max_sensitivity > 0.0 {
            T::from(1.0 / (1.0 + max_sensitivity)).expect("unwrap failed")
        } else {
            T::one()
        };

        // Compute confidence intervals (simplified bootstrap-style)
        for (param, &base_sens) in &sensitivity_results.parameter_sensitivities {
            let std_error = base_sens.abs() * 0.1; // Simplified standard error estimate
            let margin = 1.96 * std_error; // 95% confidence interval
            sensitivity_results
                .confidence_intervals
                .insert(param.clone(), (base_sens - margin, base_sens + margin));
        }

        // Analyze interaction effects (epsilon vs noise_multiplier)
        let mut interaction_config = base_config.clone();
        interaction_config.epsilon = base_config.epsilon * (T::one() + perturbation_factor);
        interaction_config.noise_multiplier =
            base_config.noise_multiplier * (T::one() + perturbation_factor);
        let interaction_utility = model_fn(data, &interaction_config)?;

        let expected_additive =
            base_utility + (epsilon_utility - base_utility) + (noise_utility - base_utility);
        let interaction_effect = interaction_utility - expected_additive;

        sensitivity_results.interaction_effects.insert(
            "epsilon_noise_multiplier".to_string(),
            interaction_effect.to_f64().unwrap_or(0.0),
        );

        Ok(sensitivity_results)
    }

    /// Evaluate robustness
    #[allow(dead_code)]
    pub fn evaluate_robustness<D: Data<Elem = T> + Sync, Dim: Dimension>(
        &self,
        data: &ArrayBase<D, Dim>,
        model_fn: impl Fn(&ArrayBase<D, Dim>, &PrivacyConfiguration<T>) -> Result<T> + Sync,
        config: &PrivacyConfiguration<T>,
    ) -> Result<RobustnessResults<T>> {
        // Implementation would go here
        todo!("Implementation of robustness evaluation")
    }

    /// Predict utility degradation
    #[allow(dead_code)]
    pub fn predict_utility_degradation(
        &self,
        _privacy_parameters: &[T],
        _historical_data: &[(T, T)],
    ) -> Result<Vec<DegradationPrediction<T>>> {
        // Implementation would go here
        todo!("Implementation of utility degradation prediction")
    }

    /// Assess privacy risk
    #[allow(dead_code)]
    pub fn assess_privacy_risk<D: Data<Elem = T> + Sync, Dim: Dimension>(
        &self,
        data: &ArrayBase<D, Dim>,
        _config: &PrivacyConfiguration<T>,
    ) -> Result<PrivacyRiskAssessment<T>> {
        // Implementation would go here
        todo!("Implementation of privacy risk assessment")
    }

    /// Perform statistical significance testing
    #[allow(dead_code)]
    pub fn perform_statistical_tests(
        &self,
        results: &[(T, T)],
        _baseline: &[(T, T)],
    ) -> Result<StatisticalTestResults<T>> {
        // Implementation would go here
        todo!("Implementation of statistical significance testing")
    }
}

// Default implementations for configuration structs
impl Default for AnalysisConfig {
    fn default() -> Self {
        Self {
            privacy_parameters: PrivacyParameterSpace::default(),
            utility_metrics: vec![UtilityMetric::Accuracy, UtilityMetric::F1Score],
            monte_carlo_samples: 1000,
            analysis_granularity: AnalysisGranularity::Medium,
            enable_sensitivity_analysis: true,
            enable_robustness_evaluation: true,
            pareto_resolution: 100,
            budget_optimization_method: BudgetOptimizationMethod::BayesianOptimization,
            confidence_level: 0.95,
            adaptive_analysis: true,
        }
    }
}

impl Default for PrivacyParameterSpace {
    fn default() -> Self {
        Self {
            epsilon_range: ParameterRange {
                min: 0.1,
                max: 10.0,
                num_samples: 50,
                sampling_strategy: SamplingStrategy::Logarithmic,
            },
            delta_range: ParameterRange {
                min: 1e-6,
                max: 1e-3,
                num_samples: 20,
                sampling_strategy: SamplingStrategy::Logarithmic,
            },
            noise_multiplier_range: ParameterRange {
                min: 0.1,
                max: 5.0,
                num_samples: 30,
                sampling_strategy: SamplingStrategy::Linear,
            },
            clipping_threshold_range: ParameterRange {
                min: 0.1,
                max: 10.0,
                num_samples: 25,
                sampling_strategy: SamplingStrategy::Linear,
            },
            sampling_probability_range: ParameterRange {
                min: 0.01,
                max: 1.0,
                num_samples: 20,
                sampling_strategy: SamplingStrategy::Linear,
            },
            iterations_range: ParameterRange {
                min: 100.0,
                max: 10000.0,
                num_samples: 20,
                sampling_strategy: SamplingStrategy::Logarithmic,
            },
            batch_size_range: ParameterRange {
                min: 16.0,
                max: 1024.0,
                num_samples: 15,
                sampling_strategy: SamplingStrategy::Logarithmic,
            },
            learning_rate_range: ParameterRange {
                min: 1e-5,
                max: 1e-1,
                num_samples: 25,
                sampling_strategy: SamplingStrategy::Logarithmic,
            },
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> PrivacyUtilityAnalyzer<T> {
    /// Generate privacy configurations for parameter space exploration
    fn generate_privacy_configurations(&self) -> Result<Vec<PrivacyConfiguration<T>>> {
        let mut configurations = Vec::new();
        let params = &self.config.privacy_parameters;

        // Generate epsilon values
        let epsilon_values = self.sample_parameter_range(&params.epsilon_range)?;
        let delta_values = self.sample_parameter_range(&params.delta_range)?;
        let noise_values = self.sample_parameter_range(&params.noise_multiplier_range)?;
        let clip_values = self.sample_parameter_range(&params.clipping_threshold_range)?;
        let batch_values = self.sample_parameter_range(&params.batch_size_range)?;

        // Generate combinations (using a subset for computational efficiency)
        let max_combinations = self.config.pareto_resolution;
        let combinations_per_dimension = (max_combinations as f64).powf(1.0 / 5.0).ceil() as usize;

        for (_i, &epsilon) in epsilon_values
            .iter()
            .enumerate()
            .take(combinations_per_dimension)
        {
            for (_j, &delta) in delta_values
                .iter()
                .enumerate()
                .take(combinations_per_dimension)
            {
                for (_k, &noise_mult) in noise_values
                    .iter()
                    .enumerate()
                    .take(combinations_per_dimension)
                {
                    for (_l, &clip_thresh) in clip_values
                        .iter()
                        .enumerate()
                        .take(combinations_per_dimension)
                    {
                        for (_m, &batch_size) in batch_values
                            .iter()
                            .enumerate()
                            .take(combinations_per_dimension)
                        {
                            // Skip invalid combinations
                            if delta >= T::from(1.0).unwrap_or_else(|| T::zero())
                                || epsilon <= T::zero()
                                || noise_mult <= T::zero()
                            {
                                continue;
                            }

                            configurations.push(PrivacyConfiguration {
                                epsilon,
                                delta,
                                noise_multiplier: noise_mult,
                                clipping_threshold: clip_thresh,
                                batch_size: batch_size.to_usize().unwrap_or(256),
                                sampling_probability: T::from(0.1).unwrap_or_else(|| T::zero()), // Default
                                iterations: 1000, // Default
                                learning_rate: T::from(0.01).unwrap_or_else(|| T::zero()), // Default learning rate
                                noise_mechanism: NoiseMechanism::Gaussian,
                            });

                            if configurations.len() >= max_combinations {
                                return Ok(configurations);
                            }
                        }
                    }
                }
            }
        }

        Ok(configurations)
    }

    /// Sample values from a parameter range
    fn sample_parameter_range(&self, range: &ParameterRange) -> Result<Vec<T>> {
        let mut values = Vec::new();

        match range.sampling_strategy {
            SamplingStrategy::Linear => {
                for i in 0..range.num_samples {
                    let fraction = i as f64 / (range.num_samples - 1).max(1) as f64;
                    let value = range.min + fraction * (range.max - range.min);
                    values.push(T::from(value).unwrap_or_else(|| T::zero()));
                }
            }
            SamplingStrategy::Logarithmic => {
                let log_min = range.min.ln();
                let log_max = range.max.ln();
                for i in 0..range.num_samples {
                    let fraction = i as f64 / (range.num_samples - 1).max(1) as f64;
                    let log_value = log_min + fraction * (log_max - log_min);
                    values.push(T::from(log_value.exp()).expect("unwrap failed"));
                }
            }
            SamplingStrategy::Random => {
                let mut rng = thread_rng();
                for _ in 0..range.num_samples {
                    let value = rng.gen_range(range.min..range.max);
                    values.push(T::from(value).unwrap_or_else(|| T::zero()));
                }
            }
            _ => {
                // Fallback to linear sampling for other strategies
                for i in 0..range.num_samples {
                    let fraction = i as f64 / (range.num_samples - 1).max(1) as f64;
                    let value = range.min + fraction * (range.max - range.min);
                    values.push(T::from(value).unwrap_or_else(|| T::zero()));
                }
            }
        }

        Ok(values)
    }

    /// Compute privacy cost for a configuration (lower epsilon = higher cost)
    fn compute_privacy_cost(&self, config: &PrivacyConfiguration<T>) -> Result<T> {
        // Privacy cost is inversely related to epsilon (lower epsilon = higher privacy = higher cost)
        // Normalize by a reasonable maximum epsilon value
        let max_epsilon = T::from(10.0).unwrap_or_else(|| T::zero());
        let normalized_epsilon = config.epsilon / max_epsilon;

        // Add delta component (lower delta = higher privacy = higher cost)
        let max_delta = T::from(1e-3).unwrap_or_else(|| T::zero());
        let normalized_delta = config.delta / max_delta;

        // Combine epsilon and delta into a privacy cost metric
        // Higher values indicate lower privacy (higher cost in privacy terms)
        let privacy_cost =
            normalized_epsilon + normalized_delta * T::from(0.1).unwrap_or_else(|| T::zero());

        Ok(privacy_cost)
    }
}