quantrs2-anneal 0.1.3

//! Execution result types.
//!
//! This module contains types for representing execution results,
//! predictions, and metadata.

use std::collections::HashMap;
use std::time::{Duration, Instant};

use super::compilation::CompilationResult;
use super::config::{OptimizationLevel, ResourceAllocationStrategy, SchedulingPriority};
use super::platform::QuantumPlatform;

/// Universal execution result
#[derive(Debug, Clone)]
pub struct UniversalExecutionResult {
    /// Problem identifier
    pub problem_id: String,
    /// Selected optimal platform
    pub optimal_platform: QuantumPlatform,
    /// Compilation results for all platforms
    pub compilation_results: HashMap<QuantumPlatform, CompilationResult>,
    /// Performance predictions
    pub performance_predictions: HashMap<QuantumPlatform, PlatformPerformancePrediction>,
    /// Execution result
    pub execution_result: PlatformExecutionResult,
    /// Total execution time
    pub total_time: Duration,
    /// Execution metadata
    pub metadata: UniversalExecutionMetadata,
}

/// Platform performance prediction
#[derive(Debug, Clone)]
pub struct PlatformPerformancePrediction {
    /// Target platform
    pub platform: QuantumPlatform,
    /// Predicted performance
    pub predicted_performance: PredictedPerformance,
    /// Confidence in prediction
    pub confidence_score: f64,
    /// Prediction metadata
    pub prediction_metadata: PredictionMetadata,
}

/// Predicted performance
#[derive(Debug, Clone)]
pub struct PredictedPerformance {
    /// Execution time
    pub execution_time: Duration,
    /// Solution quality
    pub solution_quality: f64,
    /// Success probability
    pub success_probability: f64,
    /// Cost
    pub cost: f64,
    /// Reliability score
    pub reliability_score: f64,
}

/// Prediction metadata
#[derive(Debug, Clone)]
pub struct PredictionMetadata {
    /// Model version
    pub model_version: String,
    /// Prediction timestamp
    pub prediction_timestamp: Instant,
    /// Features used
    pub features_used: Vec<String>,
    /// Model accuracy
    pub model_accuracy: f64,
}

/// Optimal platform selection
#[derive(Debug, Clone)]
pub struct OptimalPlatformSelection {
    /// Selected platform
    pub platform: QuantumPlatform,
    /// Selection score
    pub selection_score: f64,
    /// Selection rationale
    pub selection_rationale: String,
    /// Alternative platforms
    pub alternatives: Vec<QuantumPlatform>,
    /// Selection metadata
    pub selection_metadata: SelectionMetadata,
}

/// Selection metadata
#[derive(Debug, Clone)]
pub struct SelectionMetadata {
    /// Selection timestamp
    pub selection_timestamp: Instant,
    /// Strategy used
    pub strategy_used: ResourceAllocationStrategy,
    /// Confidence
    pub confidence: f64,
}

/// Execution plan
#[derive(Debug, Clone)]
pub struct ExecutionPlan {
    /// Target platform
    pub platform: QuantumPlatform,
    /// Scheduled start time
    pub scheduled_start_time: Instant,
    /// Estimated duration
    pub estimated_duration: Duration,
    /// Resource allocation
    pub resource_allocation: PlatformResourceAllocation,
    /// Execution parameters
    pub execution_parameters: ExecutionParameters,
}

/// Platform resource allocation
#[derive(Debug, Clone)]
pub struct PlatformResourceAllocation {
    /// Allocated qubits
    pub qubits: Vec<usize>,
    /// Execution priority
    pub execution_priority: SchedulingPriority,
    /// Resource reservation
    pub resource_reservation: ResourceReservationInfo,
}

/// Resource reservation information
#[derive(Debug, Clone)]
pub struct ResourceReservationInfo {
    /// Reservation identifier
    pub reservation_id: String,
    /// Reserved until
    pub reserved_until: Instant,
}

/// Execution parameters
#[derive(Debug, Clone)]
pub struct ExecutionParameters {
    /// Number of shots
    pub shots: usize,
    /// Optimization level
    pub optimization_level: OptimizationLevel,
    /// Error mitigation enabled
    pub error_mitigation: bool,
}

/// Platform execution result
#[derive(Debug, Clone)]
pub struct PlatformExecutionResult {
    /// Platform used
    pub platform: QuantumPlatform,
    /// Execution identifier
    pub execution_id: String,
    /// Solution found
    pub solution: Vec<i32>,
    /// Objective value
    pub objective_value: f64,
    /// Execution time
    pub execution_time: Duration,
    /// Success indicator
    pub success: bool,
    /// Quality metrics
    pub quality_metrics: ExecutionQualityMetrics,
    /// Resource usage
    pub resource_usage: ExecutionResourceUsage,
    /// Execution metadata
    pub metadata: ExecutionMetadata,
}

/// Execution quality metrics
#[derive(Debug, Clone)]
pub struct ExecutionQualityMetrics {
    /// Solution quality
    pub solution_quality: f64,
    /// Fidelity
    pub fidelity: f64,
    /// Success probability
    pub success_probability: f64,
}

/// Execution resource usage
#[derive(Debug, Clone)]
pub struct ExecutionResourceUsage {
    /// Qubits used
    pub qubits_used: usize,
    /// Shots executed
    pub shots_executed: usize,
    /// Classical compute time
    pub classical_compute_time: Duration,
    /// Cost incurred
    pub cost_incurred: f64,
}

/// Execution metadata
#[derive(Debug, Clone)]
pub struct ExecutionMetadata {
    /// Execution timestamp
    pub execution_timestamp: Instant,
    /// Platform version
    pub platform_version: String,
    /// Execution environment
    pub execution_environment: String,
}

/// Universal execution metadata
#[derive(Debug, Clone)]
pub struct UniversalExecutionMetadata {
    /// Compiler version
    pub compiler_version: String,
    /// Platforms considered
    pub platforms_considered: usize,
    /// Optimization level used
    pub optimization_level: OptimizationLevel,
    /// Cost savings achieved
    pub cost_savings: f64,
    /// Performance improvement
    pub performance_improvement: f64,
}

/// Performance predictor placeholder
#[derive(Debug)]
pub struct PerformancePredictor {}

impl PerformancePredictor {
    /// Create a new performance predictor
    pub fn new() -> Self {
        Self {}
    }
}

impl Default for PerformancePredictor {
    fn default() -> Self {
        Self::new()
    }
}

/// Cost optimizer placeholder
#[derive(Debug)]
pub struct CostOptimizer {}

impl CostOptimizer {
    /// Create a new cost optimizer
    pub fn new() -> Self {
        Self {}
    }
}

impl Default for CostOptimizer {
    fn default() -> Self {
        Self::new()
    }
}