quantrs2_circuit/

simulator_interface.rs

//! Efficient circuit-to-simulator interfaces
//!
//! This module provides optimized interfaces for converting quantum circuits
//! to various simulator formats, with support for batching, compilation,
//! and execution across different quantum simulation backends.

use crate::builder::Circuit;
use quantrs2_core::{
    error::{QuantRS2Error, QuantRS2Result},
    gate::GateOp,
    qubit::QubitId,
};
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet, VecDeque};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};

/// Simulator backend types
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum SimulatorBackend {
    /// State vector simulator
    StateVector {
        /// Maximum number of qubits
        max_qubits: usize,
        /// Use GPU acceleration
        use_gpu: bool,
        /// Memory optimization level
        memory_optimization: MemoryOptimization,
    },
    /// Stabilizer tableau simulator
    Stabilizer {
        /// Support for magic states
        support_magic: bool,
        /// Tableau compression
        use_compression: bool,
    },
    /// Matrix Product State simulator
    MatrixProductState {
        /// Maximum bond dimension
        max_bond_dim: usize,
        /// Compression threshold
        compression_threshold: f64,
        /// Use CUDA for GPU acceleration
        use_cuda: bool,
    },
    /// Density matrix simulator
    DensityMatrix {
        /// Noise model support
        noise_support: bool,
        /// Maximum density matrix size
        max_size: usize,
    },
    /// Tensor network simulator
    TensorNetwork {
        /// Contraction strategy
        contraction_strategy: ContractionStrategy,
        /// Memory limit in GB
        memory_limit: f64,
    },
    /// External simulator (via API)
    External {
        /// Simulator name/identifier
        name: String,
        /// API endpoint
        endpoint: Option<String>,
        /// Authentication token
        auth_token: Option<String>,
    },
}

/// Memory optimization strategies
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum MemoryOptimization {
    None,
    Basic,
    Aggressive,
    CustomThreshold(f64),
}

/// Tensor contraction strategies
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum ContractionStrategy {
    Greedy,
    DynamicProgramming,
    SimulatedAnnealing,
    Kahypar,
    Custom(String),
}

/// Compilation target for circuits
#[derive(Debug, Clone)]
pub struct CompilationTarget {
    /// Target backend
    pub backend: SimulatorBackend,
    /// Optimization level
    pub optimization_level: OptimizationLevel,
    /// Target instruction set
    pub instruction_set: InstructionSet,
    /// Enable parallel execution
    pub parallel_execution: bool,
    /// Batch size for gate operations
    pub batch_size: Option<usize>,
}

/// Circuit optimization levels for compilation
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum OptimizationLevel {
    /// No optimization
    None,
    /// Basic gate fusion and cancellation
    Basic,
    /// Advanced optimization with reordering
    Advanced,
    /// Aggressive optimization with synthesis
    Aggressive,
}

/// Supported instruction sets
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum InstructionSet {
    /// Universal gate set
    Universal,
    /// Clifford gates only
    Clifford,
    /// Native gate set for specific hardware
    Native { gates: Vec<String> },
    /// Custom instruction set
    Custom {
        single_qubit: Vec<String>,
        two_qubit: Vec<String>,
        multi_qubit: Vec<String>,
    },
}

/// Compiled circuit representation
#[derive(Debug, Clone)]
pub struct CompiledCircuit {
    /// Original circuit metadata
    pub metadata: CircuitMetadata,
    /// Compiled instructions
    pub instructions: Vec<CompiledInstruction>,
    /// Resource requirements
    pub resources: ResourceRequirements,
    /// Compilation statistics
    pub stats: CompilationStats,
    /// Backend-specific data
    pub backend_data: BackendData,
}

/// Circuit metadata
#[derive(Debug, Clone)]
pub struct CircuitMetadata {
    /// Number of qubits
    pub num_qubits: usize,
    /// Circuit depth
    pub depth: usize,
    /// Gate count by type
    pub gate_counts: HashMap<String, usize>,
    /// Creation timestamp
    pub created_at: std::time::SystemTime,
    /// Compilation target
    pub target: CompilationTarget,
}

/// Compiled instruction
#[derive(Debug, Clone)]
pub enum CompiledInstruction {
    /// Single gate operation
    Gate {
        name: String,
        qubits: Vec<usize>,
        parameters: Vec<f64>,
        /// Instruction ID for debugging
        id: usize,
    },
    /// Batched operations
    Batch {
        instructions: Vec<Self>,
        parallel: bool,
    },
    /// Measurement
    Measure { qubit: usize, classical_bit: usize },
    /// Conditional operation
    Conditional {
        condition: ClassicalCondition,
        instruction: Box<Self>,
    },
    /// Barrier/synchronization
    Barrier { qubits: Vec<usize> },
    /// Backend-specific instruction
    Native { opcode: String, operands: Vec<u8> },
}

/// Classical condition for conditional operations
#[derive(Debug, Clone)]
pub struct ClassicalCondition {
    pub register: String,
    pub value: u64,
    pub comparison: ComparisonOp,
}

/// Comparison operators for classical conditions
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ComparisonOp {
    Equal,
    NotEqual,
    Greater,
    Less,
    GreaterEqual,
    LessEqual,
}

/// Resource requirements for execution
#[derive(Debug, Clone)]
pub struct ResourceRequirements {
    /// Memory requirement in bytes
    pub memory_bytes: usize,
    /// Estimated execution time
    pub estimated_time: Duration,
    /// GPU memory requirement
    pub gpu_memory_bytes: Option<usize>,
    /// CPU cores recommended
    pub cpu_cores: usize,
    /// Disk space for intermediate results
    pub disk_space_bytes: Option<usize>,
}

/// Compilation statistics
#[derive(Debug, Clone)]
pub struct CompilationStats {
    /// Time taken to compile
    pub compilation_time: Duration,
    /// Original gate count
    pub original_gates: usize,
    /// Compiled gate count
    pub compiled_gates: usize,
    /// Optimization passes applied
    pub optimization_passes: Vec<String>,
    /// Warnings encountered
    pub warnings: Vec<String>,
}

/// Backend-specific data
#[derive(Debug, Clone)]
pub enum BackendData {
    StateVector {
        /// Initial state preparation
        initial_state: Option<Vec<f64>>,
        /// Measurement strategy
        measurement_strategy: MeasurementStrategy,
    },
    Stabilizer {
        /// Initial tableau
        initial_tableau: Option<Vec<u8>>,
    },
    MatrixProductState {
        /// MPS representation
        tensors: Vec<Vec<f64>>,
        /// Bond dimensions
        bond_dims: Vec<usize>,
    },
    TensorNetwork {
        /// Network topology
        network_topology: String,
        /// Contraction order
        contraction_order: Vec<usize>,
    },
    External {
        /// Serialized circuit format
        serialized_circuit: String,
        /// Format specification
        format: String,
    },
}

/// Measurement strategies
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MeasurementStrategy {
    /// Measure all qubits at the end
    EndMeasurement,
    /// Support mid-circuit measurements
    MidCircuitMeasurement,
    /// Deferred measurement
    DeferredMeasurement,
}

/// Circuit compiler for different backends
pub struct CircuitCompiler {
    /// Compilation targets by priority
    targets: Vec<CompilationTarget>,
    /// Optimization passes
    optimization_passes: Vec<Box<dyn OptimizationPass>>,
    /// Compilation cache
    cache: Arc<Mutex<HashMap<String, CompiledCircuit>>>,
    /// Statistics collector
    stats_collector: Arc<Mutex<GlobalCompilationStats>>,
}

/// Global compilation statistics
#[derive(Debug, Default)]
pub struct GlobalCompilationStats {
    pub total_compilations: usize,
    pub cache_hits: usize,
    pub average_compilation_time: Duration,
    pub backend_usage: HashMap<String, usize>,
}

/// Optimization pass trait
pub trait OptimizationPass: Send + Sync {
    /// Apply optimization to compiled circuit
    fn apply(&self, circuit: &mut CompiledCircuit) -> QuantRS2Result<()>;

    /// Pass name
    fn name(&self) -> &str;

    /// Whether this pass modifies the circuit structure
    fn modifies_structure(&self) -> bool;
}

/// Gate fusion optimization pass
pub struct GateFusionPass {
    /// Maximum gates to fuse
    pub max_fusion_size: usize,
    /// Supported gate types for fusion
    pub fusable_gates: HashSet<String>,
}

impl OptimizationPass for GateFusionPass {
    fn apply(&self, circuit: &mut CompiledCircuit) -> QuantRS2Result<()> {
        let mut optimized_instructions = Vec::new();
        let mut current_batch = Vec::new();

        for instruction in &circuit.instructions {
            match instruction {
                CompiledInstruction::Gate { name, qubits, .. }
                    if self.fusable_gates.contains(name) && qubits.len() == 1 =>
                {
                    current_batch.push(instruction.clone());

                    if current_batch.len() >= self.max_fusion_size {
                        if current_batch.len() > 1 {
                            optimized_instructions.push(CompiledInstruction::Batch {
                                instructions: current_batch,
                                parallel: false,
                            });
                        } else {
                            optimized_instructions.extend(current_batch);
                        }
                        current_batch = Vec::new();
                    }
                }
                _ => {
                    // Flush current batch
                    if !current_batch.is_empty() {
                        if current_batch.len() > 1 {
                            optimized_instructions.push(CompiledInstruction::Batch {
                                instructions: current_batch,
                                parallel: false,
                            });
                        } else {
                            optimized_instructions.extend(current_batch);
                        }
                        current_batch = Vec::new();
                    }
                    optimized_instructions.push(instruction.clone());
                }
            }
        }

        // Flush remaining batch
        if !current_batch.is_empty() {
            if current_batch.len() > 1 {
                optimized_instructions.push(CompiledInstruction::Batch {
                    instructions: current_batch,
                    parallel: false,
                });
            } else {
                optimized_instructions.extend(current_batch);
            }
        }

        circuit.instructions = optimized_instructions;
        Ok(())
    }

    fn name(&self) -> &'static str {
        "GateFusion"
    }

    fn modifies_structure(&self) -> bool {
        true
    }
}

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

impl CircuitCompiler {
    /// Create a new circuit compiler
    #[must_use]
    pub fn new() -> Self {
        Self {
            targets: Vec::new(),
            optimization_passes: Vec::new(),
            cache: Arc::new(Mutex::new(HashMap::new())),
            stats_collector: Arc::new(Mutex::new(GlobalCompilationStats::default())),
        }
    }

    /// Add a compilation target
    pub fn add_target(&mut self, target: CompilationTarget) {
        self.targets.push(target);
    }

    /// Add an optimization pass
    pub fn add_optimization_pass(&mut self, pass: Box<dyn OptimizationPass>) {
        self.optimization_passes.push(pass);
    }

    /// Compile circuit for the best available target
    pub fn compile<const N: usize>(&self, circuit: &Circuit<N>) -> QuantRS2Result<CompiledCircuit> {
        let start_time = Instant::now();

        // Generate cache key
        let cache_key = self.generate_cache_key(circuit);

        // Check cache
        if let Ok(cache) = self.cache.lock() {
            if let Some(cached) = cache.get(&cache_key) {
                self.update_stats(true, start_time.elapsed());
                return Ok(cached.clone());
            }
        }

        // Select best target
        let target = self.select_target(circuit)?;

        // Compile circuit
        let mut compiled = self.compile_for_target(circuit, &target)?;

        // Apply optimization passes
        for pass in &self.optimization_passes {
            if target.optimization_level != OptimizationLevel::None {
                pass.apply(&mut compiled)?;
            }
        }

        // Update statistics
        compiled.stats.compilation_time = start_time.elapsed();

        // Cache result
        if let Ok(mut cache) = self.cache.lock() {
            cache.insert(cache_key, compiled.clone());
        }

        self.update_stats(false, start_time.elapsed());
        Ok(compiled)
    }

    /// Compile circuit for specific target
    pub fn compile_for_target<const N: usize>(
        &self,
        circuit: &Circuit<N>,
        target: &CompilationTarget,
    ) -> QuantRS2Result<CompiledCircuit> {
        let metadata = self.generate_metadata(circuit, target);
        let instructions = self.compile_instructions(circuit, target)?;
        let resources = self.estimate_resources(&instructions, target);
        let backend_data = self.generate_backend_data(circuit, target)?;

        let stats = CompilationStats {
            compilation_time: Duration::from_millis(0), // Will be updated later
            original_gates: circuit.gates().len(),
            compiled_gates: instructions.len(),
            optimization_passes: Vec::new(),
            warnings: Vec::new(),
        };

        Ok(CompiledCircuit {
            metadata,
            instructions,
            resources,
            stats,
            backend_data,
        })
    }

    /// Select a compilation target for a circuit.
    ///
    /// This deliberately uses a simple, deterministic policy: it selects the
    /// first configured target. This is a real (if non-optimal) choice, not a
    /// fabricated decision. Cost-based selection that inspects the circuit
    /// (gate set coverage, qubit count, connectivity) to pick the most suitable
    /// target is future work.
    fn select_target<const N: usize>(
        &self,
        _circuit: &Circuit<N>,
    ) -> QuantRS2Result<CompilationTarget> {
        self.targets.first().cloned().ok_or_else(|| {
            QuantRS2Error::InvalidInput("No compilation targets available".to_string())
        })
    }

    /// Compile circuit instructions
    fn compile_instructions<const N: usize>(
        &self,
        circuit: &Circuit<N>,
        target: &CompilationTarget,
    ) -> QuantRS2Result<Vec<CompiledInstruction>> {
        let mut instructions = Vec::new();
        let mut instruction_id = 0;

        for gate in circuit.gates() {
            let compiled_gate = self.compile_gate(gate.as_ref(), target, instruction_id)?;
            instructions.push(compiled_gate);
            instruction_id += 1;
        }

        // Apply batching if enabled
        if let Some(batch_size) = target.batch_size {
            instructions = self.apply_batching(instructions, batch_size);
        }

        Ok(instructions)
    }

    /// Compile a single gate
    fn compile_gate(
        &self,
        gate: &dyn GateOp,
        target: &CompilationTarget,
        id: usize,
    ) -> QuantRS2Result<CompiledInstruction> {
        let name = gate.name().to_string();
        let qubits: Vec<usize> = gate.qubits().iter().map(|q| q.id() as usize).collect();
        let parameters = self.extract_gate_parameters(gate);

        // Check if gate is supported by instruction set
        if !self.is_gate_supported(&name, &target.instruction_set) {
            return Err(QuantRS2Error::InvalidInput(format!(
                "Gate {name} not supported by instruction set"
            )));
        }

        Ok(CompiledInstruction::Gate {
            name,
            qubits,
            parameters,
            id,
        })
    }

    /// Extract the continuous parameters (rotation angles, phases) carried by a
    /// gate so they survive compilation into [`CompiledInstruction`]s.
    ///
    /// `GateOp` exposes no generic parameter accessor, so we downcast to every
    /// known parameterized core gate type and read its field(s). Gates that are
    /// genuinely non-parameterized (Pauli, Hadamard, CNOT, SWAP, ...) correctly
    /// yield an empty vector. Parameter ordering for multi-parameter gates
    /// follows the gate's struct field order.
    fn extract_gate_parameters(&self, gate: &dyn GateOp) -> Vec<f64> {
        use quantrs2_core::gate::{global, multi, single};

        // Fast path: non-parameterized gates never carry angles.
        if !gate.is_parameterized() {
            return Vec::new();
        }

        let any = gate.as_any();

        // Single-qubit single-angle rotations.
        if let Some(g) = any.downcast_ref::<single::RotationX>() {
            return vec![g.theta];
        }
        if let Some(g) = any.downcast_ref::<single::RotationY>() {
            return vec![g.theta];
        }
        if let Some(g) = any.downcast_ref::<single::RotationZ>() {
            return vec![g.theta];
        }

        // Two-qubit single-angle rotations.
        if let Some(g) = any.downcast_ref::<multi::CRX>() {
            return vec![g.theta];
        }
        if let Some(g) = any.downcast_ref::<multi::CRY>() {
            return vec![g.theta];
        }
        if let Some(g) = any.downcast_ref::<multi::CRZ>() {
            return vec![g.theta];
        }
        if let Some(g) = any.downcast_ref::<multi::RXX>() {
            return vec![g.theta];
        }
        if let Some(g) = any.downcast_ref::<multi::RYY>() {
            return vec![g.theta];
        }
        if let Some(g) = any.downcast_ref::<multi::RZZ>() {
            return vec![g.theta];
        }
        if let Some(g) = any.downcast_ref::<multi::RZX>() {
            return vec![g.theta];
        }

        // Multi-parameter gates (field order: theta, then the second angle).
        if let Some(g) = any.downcast_ref::<multi::XXPlusYY>() {
            return vec![g.theta, g.beta];
        }
        if let Some(g) = any.downcast_ref::<multi::XXMinusYY>() {
            return vec![g.theta, g.beta];
        }
        if let Some(g) = any.downcast_ref::<global::RGate>() {
            return vec![g.theta, g.phi];
        }

        // Global phase carries a single phase angle.
        if let Some(g) = any.downcast_ref::<global::GlobalPhase>() {
            return vec![g.phase];
        }

        // Parameterized gate type we do not yet special-case: return empty
        // rather than fabricate values. (This is an honest gap, not fake data.)
        Vec::new()
    }

    /// Check if gate is supported by instruction set
    fn is_gate_supported(&self, gate_name: &str, instruction_set: &InstructionSet) -> bool {
        match instruction_set {
            InstructionSet::Universal => true,
            InstructionSet::Clifford => {
                matches!(gate_name, "H" | "S" | "CNOT" | "X" | "Y" | "Z")
            }
            InstructionSet::Native { gates } => gates.contains(&gate_name.to_string()),
            InstructionSet::Custom {
                single_qubit,
                two_qubit,
                multi_qubit,
            } => {
                single_qubit.contains(&gate_name.to_string())
                    || two_qubit.contains(&gate_name.to_string())
                    || multi_qubit.contains(&gate_name.to_string())
            }
        }
    }

    /// Apply batching to instructions
    fn apply_batching(
        &self,
        instructions: Vec<CompiledInstruction>,
        batch_size: usize,
    ) -> Vec<CompiledInstruction> {
        let mut batched = Vec::new();
        let mut current_batch = Vec::new();

        for instruction in instructions {
            current_batch.push(instruction);

            if current_batch.len() >= batch_size {
                batched.push(CompiledInstruction::Batch {
                    instructions: current_batch,
                    parallel: true,
                });
                current_batch = Vec::new();
            }
        }

        // Add remaining instructions
        if !current_batch.is_empty() {
            if current_batch.len() == 1 {
                batched.extend(current_batch);
            } else {
                batched.push(CompiledInstruction::Batch {
                    instructions: current_batch,
                    parallel: true,
                });
            }
        }

        batched
    }

    /// Generate circuit metadata
    fn generate_metadata<const N: usize>(
        &self,
        circuit: &Circuit<N>,
        target: &CompilationTarget,
    ) -> CircuitMetadata {
        let mut gate_counts = HashMap::new();
        for gate in circuit.gates() {
            *gate_counts.entry(gate.name().to_string()).or_insert(0) += 1;
        }

        CircuitMetadata {
            num_qubits: N,
            depth: circuit.gates().len(), // Simplified depth calculation
            gate_counts,
            created_at: std::time::SystemTime::now(),
            target: target.clone(),
        }
    }

    /// Estimate resource requirements
    fn estimate_resources(
        &self,
        instructions: &[CompiledInstruction],
        target: &CompilationTarget,
    ) -> ResourceRequirements {
        let instruction_count = instructions.len();

        // Simple estimation based on backend type
        let (memory_bytes, estimated_time, gpu_memory) = match &target.backend {
            SimulatorBackend::StateVector {
                max_qubits,
                use_gpu,
                ..
            } => {
                let memory = if *max_qubits <= 30 {
                    (1usize << max_qubits) * 16 // 16 bytes per complex number
                } else {
                    usize::MAX // Too large
                };
                let time = Duration::from_millis(instruction_count as u64);
                let gpu_mem = if *use_gpu { Some(memory) } else { None };
                (memory, time, gpu_mem)
            }
            SimulatorBackend::Stabilizer { .. } => {
                // Stabilizer tableau grows quadratically
                let memory = instruction_count * instruction_count * 8;
                let time = Duration::from_millis(instruction_count as u64 / 10);
                (memory, time, None)
            }
            SimulatorBackend::MatrixProductState { max_bond_dim, .. } => {
                let memory = instruction_count * max_bond_dim * max_bond_dim * 16;
                let time = Duration::from_millis(instruction_count as u64 * 2);
                (memory, time, None)
            }
            _ => {
                // Default estimates
                let memory = instruction_count * 1024;
                let time = Duration::from_millis(instruction_count as u64);
                (memory, time, None)
            }
        };

        ResourceRequirements {
            memory_bytes,
            estimated_time,
            gpu_memory_bytes: gpu_memory,
            cpu_cores: 1,
            disk_space_bytes: None,
        }
    }

    /// Generate backend-specific data
    fn generate_backend_data<const N: usize>(
        &self,
        circuit: &Circuit<N>,
        target: &CompilationTarget,
    ) -> QuantRS2Result<BackendData> {
        match &target.backend {
            SimulatorBackend::StateVector { .. } => Ok(BackendData::StateVector {
                initial_state: None,
                measurement_strategy: MeasurementStrategy::EndMeasurement,
            }),
            SimulatorBackend::Stabilizer { .. } => Ok(BackendData::Stabilizer {
                initial_tableau: None,
            }),
            SimulatorBackend::MatrixProductState { max_bond_dim, .. } => {
                Ok(BackendData::MatrixProductState {
                    tensors: Vec::new(),
                    bond_dims: vec![1; N + 1],
                })
            }
            SimulatorBackend::TensorNetwork { .. } => Ok(BackendData::TensorNetwork {
                network_topology: "linear".to_string(),
                contraction_order: (0..N).collect(),
            }),
            SimulatorBackend::External { name, .. } => Ok(BackendData::External {
                serialized_circuit: format!("circuit_for_{name}"),
                format: "qasm".to_string(),
            }),
            SimulatorBackend::DensityMatrix { .. } => Ok(BackendData::StateVector {
                initial_state: None,
                measurement_strategy: MeasurementStrategy::EndMeasurement,
            }),
        }
    }

    /// Generate cache key for circuit
    fn generate_cache_key<const N: usize>(&self, circuit: &Circuit<N>) -> String {
        use std::collections::hash_map::DefaultHasher;
        use std::hash::{Hash, Hasher};

        let mut hasher = DefaultHasher::new();

        // Hash circuit structure
        N.hash(&mut hasher);
        circuit.gates().len().hash(&mut hasher);

        // Hash gate sequence (simplified)
        for gate in circuit.gates() {
            gate.name().hash(&mut hasher);
            for qubit in gate.qubits() {
                qubit.id().hash(&mut hasher);
            }
        }

        format!("{:x}", hasher.finish())
    }

    /// Update compilation statistics
    fn update_stats(&self, cache_hit: bool, compilation_time: Duration) {
        if let Ok(mut stats) = self.stats_collector.lock() {
            stats.total_compilations += 1;
            if cache_hit {
                stats.cache_hits += 1;
            }

            // Update average compilation time (simple moving average)
            let total_time =
                stats.average_compilation_time.as_nanos() * (stats.total_compilations - 1) as u128;
            let new_total = total_time + compilation_time.as_nanos();
            stats.average_compilation_time =
                Duration::from_nanos((new_total / stats.total_compilations as u128) as u64);
        }
    }

    /// Get compilation statistics
    #[must_use]
    pub fn get_stats(&self) -> GlobalCompilationStats {
        self.stats_collector
            .lock()
            .map(|stats| GlobalCompilationStats {
                total_compilations: stats.total_compilations,
                cache_hits: stats.cache_hits,
                average_compilation_time: stats.average_compilation_time,
                backend_usage: stats.backend_usage.clone(),
            })
            .unwrap_or_default()
    }

    /// Clear compilation cache
    pub fn clear_cache(&self) {
        if let Ok(mut cache) = self.cache.lock() {
            cache.clear();
        }
    }
}

/// Execution interface for compiled circuits
pub struct CircuitExecutor {
    /// Active backends
    backends: HashMap<String, Box<dyn SimulatorExecutor>>,
}

/// Simulator executor trait
pub trait SimulatorExecutor: Send + Sync {
    /// Execute compiled circuit
    fn execute(&self, circuit: &CompiledCircuit) -> QuantRS2Result<ExecutionResult>;

    /// Backend name
    fn name(&self) -> &str;

    /// Check if circuit is compatible
    fn is_compatible(&self, circuit: &CompiledCircuit) -> bool;
}

/// Execution result
#[derive(Debug, Clone)]
pub struct ExecutionResult {
    /// Measurement outcomes
    pub measurements: HashMap<usize, Vec<u8>>,
    /// Final state (if available)
    pub final_state: Option<Vec<f64>>,
    /// Execution statistics
    pub execution_stats: ExecutionStats,
    /// Backend-specific results
    pub backend_results: HashMap<String, String>,
}

/// Execution statistics
#[derive(Debug, Clone)]
pub struct ExecutionStats {
    /// Execution time
    pub execution_time: Duration,
    /// Memory used
    pub memory_used: usize,
    /// Number of shots
    pub shots: usize,
    /// Success rate
    pub success_rate: f64,
}

#[cfg(test)]
mod tests {
    use super::*;
    use quantrs2_core::gate::multi::CNOT;
    use quantrs2_core::gate::single::Hadamard;

    #[test]
    fn test_compiler_creation() {
        let compiler = CircuitCompiler::new();
        assert_eq!(compiler.targets.len(), 0);
    }

    #[test]
    fn test_compilation_target() {
        let target = CompilationTarget {
            backend: SimulatorBackend::StateVector {
                max_qubits: 20,
                use_gpu: false,
                memory_optimization: MemoryOptimization::Basic,
            },
            optimization_level: OptimizationLevel::Basic,
            instruction_set: InstructionSet::Universal,
            parallel_execution: true,
            batch_size: Some(10),
        };

        assert!(matches!(
            target.backend,
            SimulatorBackend::StateVector { .. }
        ));
    }

    #[test]
    fn test_gate_support_checking() {
        let compiler = CircuitCompiler::new();

        // Universal instruction set should support all gates
        assert!(compiler.is_gate_supported("H", &InstructionSet::Universal));
        assert!(compiler.is_gate_supported("CNOT", &InstructionSet::Universal));

        // Clifford set should only support Clifford gates
        assert!(compiler.is_gate_supported("H", &InstructionSet::Clifford));
        assert!(!compiler.is_gate_supported("T", &InstructionSet::Clifford));
    }

    #[test]
    fn test_extract_gate_parameters() {
        use quantrs2_core::gate::single::RotationX;

        let compiler = CircuitCompiler::new();

        // A rotation gate must expose its angle, not drop it.
        let rx = RotationX {
            target: QubitId(0),
            theta: 0.75,
        };
        let params = compiler.extract_gate_parameters(&rx);
        assert_eq!(params.len(), 1);
        assert!((params[0] - 0.75).abs() < 1e-12);

        // Non-parameterized gates correctly yield no parameters.
        let h = Hadamard { target: QubitId(0) };
        assert!(compiler.extract_gate_parameters(&h).is_empty());
    }

    #[test]
    fn test_resource_estimation() {
        let compiler = CircuitCompiler::new();
        let instructions = vec![
            CompiledInstruction::Gate {
                name: "H".to_string(),
                qubits: vec![0],
                parameters: vec![],
                id: 0,
            },
            CompiledInstruction::Gate {
                name: "CNOT".to_string(),
                qubits: vec![0, 1],
                parameters: vec![],
                id: 1,
            },
        ];

        let target = CompilationTarget {
            backend: SimulatorBackend::StateVector {
                max_qubits: 10,
                use_gpu: false,
                memory_optimization: MemoryOptimization::None,
            },
            optimization_level: OptimizationLevel::None,
            instruction_set: InstructionSet::Universal,
            parallel_execution: false,
            batch_size: None,
        };

        let resources = compiler.estimate_resources(&instructions, &target);
        assert!(resources.memory_bytes > 0);
        assert!(resources.estimated_time > Duration::from_millis(0));
    }

    #[test]
    fn test_cache_key_generation() {
        let compiler = CircuitCompiler::new();

        let mut circuit1 = Circuit::<2>::new();
        circuit1
            .add_gate(Hadamard { target: QubitId(0) })
            .expect("add H gate to circuit1");

        let mut circuit2 = Circuit::<2>::new();
        circuit2
            .add_gate(Hadamard { target: QubitId(0) })
            .expect("add H gate to circuit2");

        let key1 = compiler.generate_cache_key(&circuit1);
        let key2 = compiler.generate_cache_key(&circuit2);

        assert_eq!(key1, key2); // Same circuits should have same keys
    }

    #[test]
    fn test_gate_fusion_pass() {
        let mut fusable_gates = HashSet::new();
        fusable_gates.insert("H".to_string());
        fusable_gates.insert("X".to_string());

        let pass = GateFusionPass {
            max_fusion_size: 3,
            fusable_gates,
        };

        assert_eq!(pass.name(), "GateFusion");
        assert!(pass.modifies_structure());
    }
}