quantrs2-device 0.1.3

//! Platform types and compilation targets

use std::collections::{HashMap, HashSet};
use std::time::{Duration, SystemTime};

use super::config::HardwareConstraints;
use crate::backend_traits::BackendCapabilities;

/// Multi-platform compilation target specifications
#[derive(Debug, Clone, PartialEq)]
pub enum CompilationTarget {
    /// IBM Quantum platform with specific backend
    IBMQuantum {
        backend_name: String,
        coupling_map: Vec<(usize, usize)>,
        native_gates: HashSet<String>,
        basis_gates: Vec<String>,
        max_shots: usize,
        simulator: bool,
    },
    /// AWS Braket platform
    AWSBraket {
        device_arn: String,
        provider: BraketProvider,
        supported_gates: HashSet<String>,
        max_shots: usize,
        cost_per_shot: f64,
    },
    /// Azure Quantum platform
    AzureQuantum {
        workspace: String,
        target: String,
        provider: AzureProvider,
        supported_operations: HashSet<String>,
        resource_estimation: bool,
    },
    /// IonQ platform
    IonQ {
        backend: String,
        all_to_all: bool,
        native_gates: HashSet<String>,
        noise_model: Option<String>,
    },
    /// Google Quantum AI
    GoogleQuantumAI {
        processor_id: String,
        gate_set: GoogleGateSet,
        topology: GridTopology,
    },
    /// Rigetti QCS
    Rigetti {
        qpu_id: String,
        lattice: RigettiLattice,
        supported_gates: HashSet<String>,
    },
    /// Custom hardware platform
    Custom {
        name: String,
        capabilities: BackendCapabilities,
        constraints: HardwareConstraints,
    },
}

/// AWS Braket provider types
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum BraketProvider {
    IonQ,
    Rigetti,
    OQC,
    QuEra,
    Simulator,
}

/// Azure Quantum provider types
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AzureProvider {
    IonQ,
    Quantinuum,
    Pasqal,
    Rigetti,
    Microsoft,
}

/// Google Quantum AI gate sets
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum GoogleGateSet {
    Sycamore,
    SqrtISwap,
    SYC,
}

/// Grid topology for Google devices
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct GridTopology {
    pub rows: usize,
    pub cols: usize,
    pub connectivity: ConnectivityPattern,
}

/// Connectivity patterns
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ConnectivityPattern {
    NearestNeighbor,
    Square,
    Hexagonal,
    Custom(Vec<(usize, usize)>),
}

/// Rigetti lattice types
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RigettiLattice {
    Aspen,
    Ankaa,
    Custom(Vec<(usize, usize)>),
}

/// Pass information with timing and metrics
#[derive(Debug, Clone)]
pub struct PassInfo {
    /// Pass name
    pub name: String,
    /// Execution time
    pub execution_time: Duration,
    /// Number of gates modified
    pub gates_modified: usize,
    /// Improvement metric
    pub improvement: f64,
    /// Pass-specific metrics
    pub metrics: HashMap<String, f64>,
    /// Success status
    pub success: bool,
    /// Error message if failed
    pub error_message: Option<String>,
}

/// Hardware allocation information
#[derive(Debug, Clone)]
pub struct HardwareAllocation {
    /// Qubit mapping from logical to physical
    pub qubit_mapping: HashMap<usize, usize>,
    /// Allocated qubits
    pub allocated_qubits: Vec<usize>,
    /// Resource utilization
    pub resource_utilization: f64,
    /// Allocation strategy used
    pub strategy: AllocationStrategy,
    /// Allocation quality score
    pub quality_score: f64,
}

/// Allocation strategies
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AllocationStrategy {
    GreedyMapping,
    OptimalMapping,
    HeuristicMapping,
    GraphBased,
    Custom(String),
}

/// Performance prediction with confidence intervals
#[derive(Debug, Clone)]
pub struct PerformancePrediction {
    /// Predicted execution time
    pub execution_time: Duration,
    /// Predicted fidelity
    pub fidelity: f64,
    /// Predicted error rate
    pub error_rate: f64,
    /// Success probability
    pub success_probability: f64,
    /// Confidence interval
    pub confidence_interval: (f64, f64),
    /// Prediction model used
    pub model: String,
}

/// Advanced metrics for compilation analysis
#[derive(Debug, Clone)]
pub struct AdvancedMetrics {
    /// Quantum volume
    pub quantum_volume: usize,
    /// Expressivity measure
    pub expressivity: f64,
    /// Entanglement entropy
    pub entanglement_entropy: f64,
    /// Circuit complexity
    pub complexity_score: f64,
    /// Resource efficiency
    pub resource_efficiency: f64,
    /// Error resilience
    pub error_resilience: f64,
    /// Platform compatibility score
    pub compatibility_score: f64,
}

/// Optimization iteration information
#[derive(Debug, Clone)]
pub struct OptimizationIteration {
    /// Iteration number
    pub iteration: usize,
    /// Objective function values
    pub objective_values: Vec<f64>,
    /// Applied transformations
    pub transformations: Vec<String>,
    /// Intermediate metrics
    pub intermediate_metrics: HashMap<String, f64>,
    /// Timestamp
    pub timestamp: Duration,
}

/// Platform-specific optimization results
#[derive(Debug, Clone)]
pub struct PlatformSpecificResults {
    /// Platform name
    pub platform: String,
    /// Platform-specific metrics
    pub metrics: HashMap<String, f64>,
    /// Applied transformations
    pub transformations: Vec<String>,
}

/// Platform-specific constraints
#[derive(Debug, Clone)]
pub struct PlatformConstraints {
    /// Maximum circuit depth
    pub max_depth: Option<usize>,
    /// Supported gate set
    pub supported_gates: HashSet<String>,
    /// Connectivity restrictions
    pub connectivity: Vec<(usize, usize)>,
    /// Timing constraints
    pub timing_constraints: HashMap<String, f64>,
}

/// Verification and validation results
#[derive(Debug, Clone)]
pub struct VerificationResults {
    /// Circuit equivalence verified
    pub equivalence_verified: bool,
    /// Constraint satisfaction verified
    pub constraints_satisfied: bool,
    /// Semantic correctness verified
    pub semantic_correctness: bool,
    /// Verification time
    pub verification_time: Duration,
    /// Detailed verification report
    pub verification_report: String,
}

/// Constraint verification result
#[derive(Debug, Clone)]
pub struct ConstraintVerificationResult {
    /// Whether constraints are satisfied
    pub is_valid: bool,
}

/// Semantic verification result
#[derive(Debug, Clone)]
pub struct SemanticVerificationResult {
    /// Whether semantics are correct
    pub is_valid: bool,
}

/// Complexity metrics for circuit analysis
#[derive(Debug, Clone)]
pub struct ComplexityMetrics {
    /// Circuit depth distribution
    pub depth_distribution: Vec<usize>,
    /// Gate type distribution
    pub gate_distribution: HashMap<String, usize>,
    /// Entanglement entropy
    pub entanglement_entropy: f64,
    /// Expressivity measure
    pub expressivity_measure: f64,
    /// Quantum volume
    pub quantum_volume: usize,
}

/// Compilation result with comprehensive analysis
#[derive(Debug, Clone)]
pub struct CompilationResult {
    /// Original circuit
    pub original_circuit: String,
    /// Optimized circuit
    pub optimized_circuit: String,
    /// Optimization statistics
    pub optimization_stats: OptimizationStats,
    /// Applied passes with detailed information
    pub applied_passes: Vec<PassInfo>,
    /// Hardware allocation and scheduling
    pub hardware_allocation: HardwareAllocation,
    /// Predicted performance with confidence intervals
    pub predicted_performance: PerformancePrediction,
    /// Compilation timing breakdown
    pub compilation_time: Duration,
    /// Advanced metrics and analysis
    pub advanced_metrics: AdvancedMetrics,
    /// Multi-pass optimization history
    pub optimization_history: Vec<OptimizationIteration>,
    /// Platform-specific results
    pub platform_specific: PlatformSpecificResults,
    /// Verification and validation results
    pub verification_results: VerificationResults,
}

/// Optimization statistics
#[derive(Debug, Clone)]
pub struct OptimizationStats {
    /// Original gate count
    pub original_gate_count: usize,
    /// Optimized gate count
    pub optimized_gate_count: usize,
    /// Original circuit depth
    pub original_depth: usize,
    /// Optimized circuit depth
    pub optimized_depth: usize,
    /// Predicted error rate improvement
    pub error_improvement: f64,
    /// Fidelity improvement
    pub fidelity_improvement: f64,
    /// Resource efficiency gain
    pub efficiency_gain: f64,
    /// Overall improvement score
    pub overall_improvement: f64,
}

/// Performance anomaly detection
#[derive(Debug, Clone)]
pub struct PerformanceAnomaly {
    /// Anomaly description
    pub description: String,
    /// Severity level
    pub severity: AnomalySeverity,
    /// Confidence score
    pub confidence: f64,
    /// Affected metrics
    pub affected_metrics: Vec<String>,
    /// Anomaly type
    pub anomaly_type: String,
    /// Recommended action
    pub recommended_action: String,
}

/// Anomaly severity levels
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AnomalySeverity {
    Low,
    Medium,
    High,
    Critical,
}

/// Advanced optimization results
#[derive(Debug, Clone)]
pub struct AdvancedOptimizationResult {
    /// Optimization method used
    pub method: String,
    /// Convergence achieved
    pub converged: bool,
    /// Final objective value
    pub objective_value: f64,
    /// Number of iterations
    pub iterations: usize,
    /// Parameter evolution
    pub parameter_evolution: Vec<scirs2_core::ndarray::Array1<f64>>,
    /// Whether optimization was successful
    pub success: bool,
    /// Optimized parameters
    pub x: scirs2_core::ndarray::Array1<f64>,
    /// Improvement achieved
    pub improvement: f64,
}

/// Linear algebra optimization results
#[derive(Debug, Clone)]
pub struct LinalgOptimizationResult {
    /// Matrix decomposition improvements
    pub decomposition_improvements: HashMap<String, f64>,
    /// Numerical stability metrics
    pub stability_metrics: NumericalStabilityMetrics,
    /// Eigenvalue analysis
    pub eigenvalue_analysis: EigenvalueAnalysis,
}

/// Numerical stability metrics
#[derive(Debug, Clone)]
pub struct NumericalStabilityMetrics {
    /// Condition number
    pub condition_number: f64,
    /// Numerical rank
    pub numerical_rank: usize,
    /// Spectral radius
    pub spectral_radius: f64,
}

/// Eigenvalue analysis
#[derive(Debug, Clone)]
pub struct EigenvalueAnalysis {
    /// Eigenvalue distribution
    pub eigenvalue_distribution: Vec<scirs2_core::Complex64>,
    /// Spectral gap
    pub spectral_gap: f64,
    /// Entanglement spectrum
    pub entanglement_spectrum: Vec<f64>,
}