voirs_conversion/

fallback.rs

//! Graceful degradation and fallback strategies for voice conversion
//!
//! This module provides robust error recovery mechanisms and quality-based fallback
//! strategies to ensure the system continues to function even when optimal conversion
//! fails or produces poor quality results.

use crate::{
    config::ConversionConfig,
    quality::ArtifactDetector,
    transforms::{PitchTransform, SpeedTransform, Transform},
    types::{
        ConversionRequest, ConversionResult, ConversionTarget, ConversionType, DetectedArtifacts,
        ObjectiveQualityMetrics, VoiceCharacteristics,
    },
    Error, Result,
};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::{Duration, Instant, SystemTime};
use tracing::{debug, error, info, warn};

/// Graceful degradation controller
#[derive(Debug)]
pub struct GracefulDegradationController {
    /// Configuration for degradation strategies
    config: DegradationConfig,
    /// Quality thresholds for different fallback levels
    quality_thresholds: QualityThresholds,
    /// Fallback strategy executor
    strategy_executor: FallbackStrategyExecutor,
    /// Performance metrics tracker
    performance_tracker: PerformanceTracker,
    /// Failure history for learning
    failure_history: FailureHistory,
}

/// Configuration for graceful degradation
#[derive(Debug, Clone)]
pub struct DegradationConfig {
    /// Enable graceful degradation
    pub enable_degradation: bool,
    /// Enable quality-based fallbacks
    pub enable_quality_fallbacks: bool,
    /// Enable error recovery attempts
    pub enable_error_recovery: bool,
    /// Maximum number of retry attempts
    pub max_retry_attempts: u32,
    /// Maximum time to spend on recovery attempts
    pub max_recovery_time_ms: u64,
    /// Enable fallback learning
    pub enable_learning: bool,
    /// Enable performance monitoring
    pub enable_performance_monitoring: bool,
}

impl Default for DegradationConfig {
    fn default() -> Self {
        Self {
            enable_degradation: true,
            enable_quality_fallbacks: true,
            enable_error_recovery: true,
            max_retry_attempts: 3,
            max_recovery_time_ms: 5000,
            enable_learning: true,
            enable_performance_monitoring: true,
        }
    }
}

/// Quality thresholds for triggering different fallback strategies
#[derive(Debug, Clone)]
pub struct QualityThresholds {
    /// Minimum acceptable quality score (0.0 to 1.0)
    pub min_acceptable_quality: f32,
    /// Quality threshold for reducing conversion complexity
    pub complexity_reduction_threshold: f32,
    /// Quality threshold for switching to simpler algorithms
    pub simple_algorithm_threshold: f32,
    /// Quality threshold for passthrough fallback
    pub passthrough_threshold: f32,
    /// Maximum acceptable artifact score
    pub max_artifact_score: f32,
}

impl Default for QualityThresholds {
    fn default() -> Self {
        Self {
            min_acceptable_quality: 0.3,
            complexity_reduction_threshold: 0.5,
            simple_algorithm_threshold: 0.4,
            passthrough_threshold: 0.2,
            max_artifact_score: 0.7,
        }
    }
}

/// Fallback strategy executor
#[derive(Debug)]
pub struct FallbackStrategyExecutor {
    /// Available fallback strategies
    strategies: Vec<Box<dyn FallbackStrategy>>,
    /// Strategy performance history
    strategy_performance: HashMap<String, StrategyPerformance>,
}

/// Fallback strategy trait  
pub trait FallbackStrategy: Send + Sync + std::fmt::Debug {
    /// Name of the strategy
    fn name(&self) -> &str;

    /// Check if this strategy can handle the given failure
    fn can_handle(&self, failure_type: &FailureType, conversion_type: &ConversionType) -> bool;

    /// Estimate the success probability for this strategy
    fn success_probability(&self, context: &FallbackContext) -> f32;

    /// Apply the fallback strategy
    fn apply(
        &self,
        request: &ConversionRequest,
        context: &FallbackContext,
        config: &ConversionConfig,
    ) -> Result<ConversionResult>;

    /// Get strategy priority (higher = more preferred)
    fn priority(&self) -> i32;
}

/// Context for fallback decisions
#[derive(Debug, Clone)]
pub struct FallbackContext {
    /// Original error that triggered fallback
    pub original_error: Option<String>,
    /// Current quality metrics
    pub current_quality: Option<f32>,
    /// Detected artifacts
    pub artifacts: Option<DetectedArtifacts>,
    /// Previous attempt results
    pub previous_attempts: Vec<FallbackAttempt>,
    /// Available processing resources
    pub available_resources: ResourceContext,
    /// Time constraints
    pub time_constraints: TimeConstraints,
}

/// Previous fallback attempt
#[derive(Debug, Clone)]
pub struct FallbackAttempt {
    /// Name of the fallback strategy that was attempted
    pub strategy_name: String,
    /// Whether the fallback attempt was successful
    pub success: bool,
    /// Quality score achieved by this fallback attempt if successful
    pub quality_achieved: Option<f32>,
    /// Time taken to execute this fallback attempt
    pub processing_time: Duration,
    /// Error message if the fallback attempt failed
    pub error: Option<String>,
}

/// Available processing resources
#[derive(Debug, Clone)]
pub struct ResourceContext {
    /// Current CPU utilization as a percentage (0.0 to 100.0)
    pub cpu_usage_percent: f32,
    /// Available system memory in megabytes
    pub memory_available_mb: f64,
    /// Whether GPU acceleration is available for processing
    pub gpu_available: bool,
    /// Overall processing capacity normalized to 0.0 to 1.0 scale
    pub processing_capacity: f32, // 0.0 to 1.0
}

/// Time constraints for fallback processing
#[derive(Debug, Clone)]
pub struct TimeConstraints {
    /// Maximum allowed time for fallback processing to complete
    pub max_processing_time: Duration,
    /// Optional absolute deadline for fallback completion
    pub deadline: Option<Instant>,
    /// Whether real-time processing constraints must be met
    pub real_time_requirement: bool,
}

/// Types of failures that can trigger fallbacks
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum FailureType {
    /// Processing error
    ProcessingError,
    /// Quality below threshold
    QualityFailure,
    /// High artifact levels
    ArtifactFailure,
    /// Timeout or performance issue
    PerformanceFailure,
    /// Resource exhaustion
    ResourceFailure,
    /// Model loading failure
    ModelFailure,
    /// Memory allocation failure
    MemoryFailure,
    /// Unknown error
    Unknown,
}

/// Strategy performance tracking
#[derive(Debug, Clone, Default)]
pub struct StrategyPerformance {
    /// Total number of times this strategy was attempted
    pub total_attempts: u32,
    /// Number of successful fallback attempts using this strategy
    pub successful_attempts: u32,
    /// Average quality score achieved by this strategy
    pub average_quality: f32,
    /// Average time taken by this strategy to execute
    pub average_processing_time: Duration,
    /// Recent success rate calculated from latest attempts
    pub recent_success_rate: f32,
    /// Overall effectiveness score combining success rate and quality
    pub effectiveness_score: f32,
}

/// Performance tracking for the degradation controller
#[derive(Debug, Default, Clone)]
pub struct PerformanceTracker {
    /// Total number of degradation attempts across all strategies
    pub total_degradations: u64,
    /// Number of degradation attempts that successfully recovered
    pub successful_degradations: u64,
    /// Average time spent executing fallback strategies
    pub average_fallback_time: Duration,
    /// Count of how many times each strategy has been used
    pub strategy_usage: HashMap<String, u64>,
    /// History of quality improvements achieved through fallbacks
    pub quality_improvements: Vec<QualityImprovement>,
}

/// Quality improvement tracking
#[derive(Debug, Clone)]
pub struct QualityImprovement {
    /// Quality score before applying the fallback strategy
    pub original_quality: f32,
    /// Quality score after applying the fallback strategy
    pub final_quality: f32,
    /// Name of the strategy that achieved the improvement
    pub strategy_used: String,
    /// Time taken to achieve the quality improvement
    pub processing_time: Duration,
    /// When this quality improvement was recorded
    pub timestamp: Instant,
}

/// Failure history for learning and adaptation
#[derive(Debug)]
pub struct FailureHistory {
    /// Recent failures by type
    pub failures_by_type: HashMap<FailureType, Vec<FailureRecord>>,
    /// Success patterns
    pub success_patterns: Vec<SuccessPattern>,
    /// Maximum history length
    max_history_length: usize,
}

/// Individual failure record
#[derive(Debug, Clone)]
pub struct FailureRecord {
    /// When this failure occurred
    pub timestamp: Instant,
    /// Type of failure that was encountered
    pub failure_type: FailureType,
    /// Type of conversion that was being attempted
    pub conversion_type: ConversionType,
    /// Additional context about the failure conditions
    pub context: String,
    /// Description of the resolution strategy if attempted
    pub resolution: Option<String>,
    /// Whether the resolution attempt was successful
    pub resolution_success: bool,
}

/// Pattern of successful fallback resolution
#[derive(Debug, Clone)]
pub struct SuccessPattern {
    /// Type of failure this pattern successfully handles
    pub failure_type: FailureType,
    /// Type of conversion this pattern applies to
    pub conversion_type: ConversionType,
    /// Name of the strategy that successfully resolved this pattern
    pub successful_strategy: String,
    /// Confidence score in this pattern's reliability (0.0 to 1.0)
    pub confidence: f32,
    /// Number of times this pattern has been successfully applied
    pub usage_count: u32,
}

// Concrete fallback strategy implementations

/// Passthrough fallback strategy - returns original audio
#[derive(Debug)]
pub struct PassthroughStrategy;

impl FallbackStrategy for PassthroughStrategy {
    fn name(&self) -> &str {
        "passthrough"
    }

    fn can_handle(&self, _failure_type: &FailureType, _conversion_type: &ConversionType) -> bool {
        true // Can always handle by doing nothing
    }

    fn success_probability(&self, _context: &FallbackContext) -> f32 {
        1.0 // Always succeeds
    }

    fn apply(
        &self,
        request: &ConversionRequest,
        _context: &FallbackContext,
        _config: &ConversionConfig,
    ) -> Result<ConversionResult> {
        warn!("Applying passthrough fallback for request: {}", request.id);

        // Return original audio unchanged
        let processing_time = Duration::from_millis(1);
        let mut result = ConversionResult::success(
            request.id.clone(),
            request.source_audio.clone(),
            request.source_sample_rate,
            processing_time,
            request.conversion_type.clone(),
        );

        // Set quality metrics to indicate this is a fallback
        result
            .quality_metrics
            .insert("overall_quality".to_string(), 0.5);
        result
            .quality_metrics
            .insert("fallback_applied".to_string(), 1.0);
        result
            .quality_metrics
            .insert("passthrough_strategy".to_string(), 1.0);

        Ok(result)
    }

    fn priority(&self) -> i32 {
        -100 // Lowest priority - last resort
    }
}

/// Simplified processing strategy - uses basic algorithms
#[derive(Debug)]
pub struct SimplifiedProcessingStrategy;

impl FallbackStrategy for SimplifiedProcessingStrategy {
    fn name(&self) -> &str {
        "simplified_processing"
    }

    fn can_handle(&self, failure_type: &FailureType, conversion_type: &ConversionType) -> bool {
        match failure_type {
            FailureType::QualityFailure
            | FailureType::ProcessingError
            | FailureType::PerformanceFailure => {
                matches!(
                    conversion_type,
                    ConversionType::PitchShift | ConversionType::SpeedTransformation
                )
            }
            _ => false,
        }
    }

    fn success_probability(&self, context: &FallbackContext) -> f32 {
        if context.available_resources.processing_capacity > 0.3 {
            0.8
        } else {
            0.6
        }
    }

    fn apply(
        &self,
        request: &ConversionRequest,
        _context: &FallbackContext,
        config: &ConversionConfig,
    ) -> Result<ConversionResult> {
        info!(
            "Applying simplified processing fallback for request: {}",
            request.id
        );

        let start_time = Instant::now();

        // Use simple, robust algorithms
        let converted_audio = match request.conversion_type {
            ConversionType::PitchShift => {
                let pitch_factor = 1.2; // Simple 20% pitch increase as fallback
                let transform = PitchTransform::new(pitch_factor);
                transform.apply(&request.source_audio)?
            }
            ConversionType::SpeedTransformation => {
                let speed_factor = 1.1; // Simple 10% speed increase as fallback
                let transform = SpeedTransform::new(speed_factor);
                transform.apply(&request.source_audio)?
            }
            _ => request.source_audio.clone(), // Fallback to passthrough for unsupported types
        };

        let processing_time = start_time.elapsed();

        let mut result = ConversionResult::success(
            request.id.clone(),
            converted_audio,
            config.output_sample_rate,
            processing_time,
            request.conversion_type.clone(),
        );

        // Set quality metrics
        result
            .quality_metrics
            .insert("overall_quality".to_string(), 0.6);
        result
            .quality_metrics
            .insert("fallback_applied".to_string(), 1.0);
        result
            .quality_metrics
            .insert("simplified_processing".to_string(), 1.0);

        Ok(result)
    }

    fn priority(&self) -> i32 {
        0 // Medium priority
    }
}

// Implementation of GracefulDegradationController
impl GracefulDegradationController {
    /// Create new graceful degradation controller
    pub fn new() -> Self {
        Self::with_config(DegradationConfig::default())
    }

    /// Create with custom configuration
    pub fn with_config(config: DegradationConfig) -> Self {
        let quality_thresholds = QualityThresholds::default();
        let strategy_executor = FallbackStrategyExecutor::new();
        let performance_tracker = PerformanceTracker::default();
        let failure_history = FailureHistory::new(1000);

        Self {
            config,
            quality_thresholds,
            strategy_executor,
            performance_tracker,
            failure_history,
        }
    }

    /// Handle conversion failure with graceful degradation
    pub async fn handle_failure(
        &mut self,
        request: &ConversionRequest,
        original_error: Error,
        config: &ConversionConfig,
    ) -> Result<ConversionResult> {
        let failure_type = self.classify_failure(&original_error);
        let context = self
            .build_fallback_context(&original_error, &failure_type, request)
            .await;

        info!(
            "Handling failure type {:?} for request {}",
            failure_type, request.id
        );

        // Record the failure for learning
        self.record_failure(&failure_type, request, &original_error)
            .await;

        // Check if degradation is enabled
        if !self.config.enable_degradation {
            return Err(original_error);
        }

        // Attempt graceful degradation
        self.attempt_graceful_degradation(request, &context, config)
            .await
    }

    /// Handle quality-based degradation
    pub async fn handle_quality_degradation(
        &mut self,
        request: &ConversionRequest,
        result: &ConversionResult,
        config: &ConversionConfig,
    ) -> Result<Option<ConversionResult>> {
        if !self.config.enable_quality_fallbacks {
            return Ok(None);
        }

        // Check if quality is below acceptable thresholds
        let overall_quality = result
            .quality_metrics
            .get("overall_quality")
            .copied()
            .unwrap_or(1.0);
        let artifact_score = result
            .artifacts
            .as_ref()
            .map(|a| a.overall_score)
            .unwrap_or(0.0);

        let needs_degradation = overall_quality < self.quality_thresholds.min_acceptable_quality
            || artifact_score > self.quality_thresholds.max_artifact_score;

        if !needs_degradation {
            return Ok(None);
        }

        warn!(
            "Quality degradation triggered: quality={:.3}, artifacts={:.3}",
            overall_quality, artifact_score
        );

        let failure_type = if artifact_score > self.quality_thresholds.max_artifact_score {
            FailureType::ArtifactFailure
        } else {
            FailureType::QualityFailure
        };

        let context = self
            .build_quality_fallback_context(result, &failure_type)
            .await;

        match self
            .attempt_graceful_degradation(request, &context, config)
            .await
        {
            Ok(fallback_result) => Ok(Some(fallback_result)),
            Err(_) => Ok(None), // Don't propagate fallback errors
        }
    }

    /// Classify the type of failure
    fn classify_failure(&self, error: &Error) -> FailureType {
        match error {
            Error::Processing { .. } => FailureType::ProcessingError,
            Error::Model { .. } => FailureType::ModelFailure,
            Error::Audio { .. } => FailureType::ProcessingError,
            Error::Realtime { .. } => FailureType::PerformanceFailure,
            Error::Streaming { .. } => FailureType::PerformanceFailure,
            Error::Buffer { .. } => FailureType::MemoryFailure,
            Error::Transform { .. } => FailureType::ProcessingError,
            Error::Validation { .. } => FailureType::ProcessingError,
            Error::Runtime { .. } => FailureType::Unknown,
            Error::Io(_) => FailureType::ResourceFailure,
            Error::Candle(_) => FailureType::ModelFailure,
            _ => FailureType::Unknown,
        }
    }

    /// Build fallback context from error and request
    async fn build_fallback_context(
        &self,
        error: &Error,
        failure_type: &FailureType,
        request: &ConversionRequest,
    ) -> FallbackContext {
        let resource_context = self.assess_current_resources().await;
        let time_constraints = self.build_time_constraints(request).await;

        FallbackContext {
            original_error: Some(error.to_string()),
            current_quality: None,
            artifacts: None,
            previous_attempts: Vec::new(),
            available_resources: resource_context,
            time_constraints,
        }
    }

    /// Build context for quality-based fallback
    async fn build_quality_fallback_context(
        &self,
        result: &ConversionResult,
        failure_type: &FailureType,
    ) -> FallbackContext {
        let resource_context = self.assess_current_resources().await;
        let overall_quality = result.quality_metrics.get("overall_quality").copied();

        FallbackContext {
            original_error: Some(format!("Quality below threshold: {overall_quality:?}")),
            current_quality: overall_quality,
            artifacts: result.artifacts.clone(),
            previous_attempts: Vec::new(),
            available_resources: resource_context,
            time_constraints: TimeConstraints {
                max_processing_time: Duration::from_millis(self.config.max_recovery_time_ms),
                deadline: None,
                real_time_requirement: false,
            },
        }
    }

    /// Attempt graceful degradation using available strategies
    async fn attempt_graceful_degradation(
        &mut self,
        request: &ConversionRequest,
        context: &FallbackContext,
        config: &ConversionConfig,
    ) -> Result<ConversionResult> {
        let start_time = Instant::now();
        let mut current_context = context.clone();
        let mut attempt_count = 0;

        while attempt_count < self.config.max_retry_attempts {
            if start_time.elapsed() > Duration::from_millis(self.config.max_recovery_time_ms) {
                warn!("Fallback timeout exceeded, using final strategy");
                break;
            }

            // Find best strategy for current situation
            if let Some(strategy) = self
                .strategy_executor
                .select_best_strategy(&current_context, &request.conversion_type)
            {
                let attempt_start = Instant::now();
                let strategy_name = strategy.name().to_string(); // Clone the name to avoid borrowing issues

                info!(
                    "Attempting fallback strategy '{}' (attempt {}/{})",
                    strategy_name,
                    attempt_count + 1,
                    self.config.max_retry_attempts
                );

                match strategy.apply(request, &current_context, config) {
                    Ok(result) => {
                        let processing_time = attempt_start.elapsed();

                        // Record successful attempt
                        self.record_successful_fallback(&strategy_name, &result, processing_time)
                            .await;

                        // Validate result quality
                        if self.validate_fallback_result(&result) {
                            info!("Fallback strategy '{}' succeeded", strategy_name);
                            self.performance_tracker.successful_degradations += 1;
                            return Ok(result);
                        } else {
                            warn!(
                                "Fallback strategy '{}' produced poor quality",
                                strategy_name
                            );
                        }
                    }
                    Err(e) => {
                        warn!("Fallback strategy '{}' failed: {}", strategy_name, e);

                        // Record failed attempt
                        let failed_attempt = FallbackAttempt {
                            strategy_name: strategy_name.clone(),
                            success: false,
                            quality_achieved: None,
                            processing_time: attempt_start.elapsed(),
                            error: Some(e.to_string()),
                        };
                        current_context.previous_attempts.push(failed_attempt);
                    }
                }
            }

            attempt_count += 1;
        }

        // Final fallback - use passthrough strategy
        warn!("All fallback strategies failed, applying final passthrough");
        let passthrough = PassthroughStrategy;
        passthrough.apply(request, &current_context, config)
    }

    /// Validate fallback result quality
    fn validate_fallback_result(&self, result: &ConversionResult) -> bool {
        // Basic validation - result should be successful and have audio
        if !result.success || result.converted_audio.is_empty() {
            return false;
        }

        // Check for reasonable quality metrics
        if let Some(quality) = result.quality_metrics.get("overall_quality") {
            if *quality < 0.1 {
                return false;
            }
        }

        true
    }

    /// Assess current system resources
    async fn assess_current_resources(&self) -> ResourceContext {
        // In a real implementation, this would query actual system resources
        // For now, provide reasonable defaults
        ResourceContext {
            cpu_usage_percent: 50.0,
            memory_available_mb: 1024.0,
            gpu_available: true,
            processing_capacity: 0.7,
        }
    }

    /// Build time constraints for processing
    async fn build_time_constraints(&self, request: &ConversionRequest) -> TimeConstraints {
        let is_realtime = request.realtime;
        let max_time = if is_realtime {
            Duration::from_millis(100) // Strict for real-time
        } else {
            Duration::from_millis(self.config.max_recovery_time_ms)
        };

        TimeConstraints {
            max_processing_time: max_time,
            deadline: None,
            real_time_requirement: is_realtime,
        }
    }

    /// Record failure for learning and analysis
    async fn record_failure(
        &mut self,
        failure_type: &FailureType,
        request: &ConversionRequest,
        error: &Error,
    ) {
        let failure_record = FailureRecord {
            timestamp: Instant::now(),
            failure_type: failure_type.clone(),
            conversion_type: request.conversion_type.clone(),
            context: format!("Request: {}, Error: {}", request.id, error),
            resolution: None,
            resolution_success: false,
        };

        self.failure_history.record_failure(failure_record);
        self.performance_tracker.total_degradations += 1;
    }

    /// Record successful fallback attempt
    async fn record_successful_fallback(
        &mut self,
        strategy_name: &str,
        result: &ConversionResult,
        processing_time: Duration,
    ) {
        // Update strategy performance
        self.strategy_executor
            .record_success(strategy_name, result, processing_time);

        // Update overall performance tracking
        if let Some(quality) = result.quality_metrics.get("overall_quality") {
            let improvement = QualityImprovement {
                original_quality: 0.0, // Would track from original failure
                final_quality: *quality,
                strategy_used: strategy_name.to_string(),
                processing_time,
                timestamp: Instant::now(),
            };
            self.performance_tracker
                .quality_improvements
                .push(improvement);
        }

        // Update strategy usage count
        *self
            .performance_tracker
            .strategy_usage
            .entry(strategy_name.to_string())
            .or_insert(0) += 1;
    }

    /// Get performance statistics
    pub fn get_performance_stats(&self) -> &PerformanceTracker {
        &self.performance_tracker
    }

    /// Update quality thresholds
    pub fn update_quality_thresholds(&mut self, thresholds: QualityThresholds) {
        self.quality_thresholds = thresholds;
    }

    /// Get current quality thresholds
    pub fn get_quality_thresholds(&self) -> &QualityThresholds {
        &self.quality_thresholds
    }

    /// Enable or disable specific degradation features
    pub fn configure(&mut self, config: DegradationConfig) {
        self.config = config;
    }
}

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

// Implementation of FallbackStrategyExecutor
impl FallbackStrategyExecutor {
    /// Create new strategy executor with default strategies
    pub fn new() -> Self {
        let strategies: Vec<Box<dyn FallbackStrategy>> = vec![
            Box::new(SimplifiedProcessingStrategy),
            Box::new(PassthroughStrategy),
            Box::new(QualityAdjustmentStrategy),
            Box::new(ResourceOptimizationStrategy),
            Box::new(AlternativeAlgorithmStrategy),
        ];

        Self {
            strategies,
            strategy_performance: HashMap::new(),
        }
    }

    /// Select the best strategy for the given context
    pub fn select_best_strategy(
        &self,
        context: &FallbackContext,
        conversion_type: &ConversionType,
    ) -> Option<&dyn FallbackStrategy> {
        let failure_type = if let Some(ref error) = context.original_error {
            if error.contains("quality") {
                FailureType::QualityFailure
            } else if error.contains("timeout") {
                FailureType::PerformanceFailure
            } else if error.contains("memory") {
                FailureType::MemoryFailure
            } else {
                FailureType::ProcessingError
            }
        } else {
            FailureType::Unknown
        };

        // Filter strategies that can handle this failure type
        let mut candidates: Vec<&dyn FallbackStrategy> = self
            .strategies
            .iter()
            .map(|s| s.as_ref())
            .filter(|s| s.can_handle(&failure_type, conversion_type))
            .collect();

        if candidates.is_empty() {
            return None;
        }

        // Sort by effectiveness (combination of priority and success probability)
        candidates.sort_by(|a, b| {
            let score_a = (a.priority() as f32) + a.success_probability(context);
            let score_b = (b.priority() as f32) + b.success_probability(context);
            score_b
                .partial_cmp(&score_a)
                .unwrap_or(std::cmp::Ordering::Equal)
        });

        candidates.into_iter().next()
    }

    /// Record successful strategy execution
    pub fn record_success(
        &mut self,
        strategy_name: &str,
        result: &ConversionResult,
        processing_time: Duration,
    ) {
        let perf = self
            .strategy_performance
            .entry(strategy_name.to_string())
            .or_default();

        perf.total_attempts += 1;
        perf.successful_attempts += 1;

        if let Some(quality) = result.quality_metrics.get("overall_quality") {
            perf.average_quality = (perf.average_quality * (perf.successful_attempts - 1) as f32
                + quality)
                / perf.successful_attempts as f32;
        }

        perf.average_processing_time = Duration::from_nanos(
            ((perf.average_processing_time.as_nanos() * (perf.successful_attempts - 1) as u128
                + processing_time.as_nanos())
                / perf.successful_attempts as u128) as u64,
        );

        // Update recent success rate (simplified)
        perf.recent_success_rate = perf.successful_attempts as f32 / perf.total_attempts as f32;
        perf.effectiveness_score = perf.recent_success_rate * perf.average_quality;
    }

    /// Add custom fallback strategy
    pub fn add_strategy(&mut self, strategy: Box<dyn FallbackStrategy>) {
        self.strategies.push(strategy);
    }

    /// Get strategy performance statistics
    pub fn get_strategy_stats(&self) -> &HashMap<String, StrategyPerformance> {
        &self.strategy_performance
    }
}

// Implementation of FailureHistory
impl FailureHistory {
    /// Create new failure history tracker
    pub fn new(max_history_length: usize) -> Self {
        Self {
            failures_by_type: HashMap::new(),
            success_patterns: Vec::new(),
            max_history_length,
        }
    }

    /// Record a failure
    pub fn record_failure(&mut self, failure: FailureRecord) {
        let failures = self
            .failures_by_type
            .entry(failure.failure_type.clone())
            .or_default();

        failures.push(failure);

        // Limit history size
        if failures.len() > self.max_history_length {
            failures.remove(0);
        }
    }

    /// Update success pattern
    pub fn record_success_pattern(
        &mut self,
        failure_type: FailureType,
        conversion_type: ConversionType,
        successful_strategy: String,
    ) {
        // Look for existing pattern
        if let Some(pattern) = self.success_patterns.iter_mut().find(|p| {
            p.failure_type == failure_type
                && p.conversion_type == conversion_type
                && p.successful_strategy == successful_strategy
        }) {
            pattern.usage_count += 1;
            pattern.confidence = (pattern.confidence * 0.9 + 0.1).min(1.0);
        } else {
            // Add new pattern
            self.success_patterns.push(SuccessPattern {
                failure_type,
                conversion_type,
                successful_strategy,
                confidence: 0.5,
                usage_count: 1,
            });
        }

        // Limit pattern history
        if self.success_patterns.len() > self.max_history_length / 2 {
            self.success_patterns
                .sort_by(|a, b| a.usage_count.cmp(&b.usage_count));
            self.success_patterns.remove(0);
        }
    }

    /// Get failure statistics
    pub fn get_failure_stats(&self) -> HashMap<FailureType, usize> {
        self.failures_by_type
            .iter()
            .map(|(k, v)| (k.clone(), v.len()))
            .collect()
    }

    /// Get most successful strategy for a failure type
    pub fn get_best_strategy(
        &self,
        failure_type: &FailureType,
        conversion_type: &ConversionType,
    ) -> Option<String> {
        self.success_patterns
            .iter()
            .filter(|p| &p.failure_type == failure_type && &p.conversion_type == conversion_type)
            .max_by(|a, b| {
                let score_a = a.confidence * a.usage_count as f32;
                let score_b = b.confidence * b.usage_count as f32;
                score_a
                    .partial_cmp(&score_b)
                    .unwrap_or(std::cmp::Ordering::Equal)
            })
            .map(|p| p.successful_strategy.clone())
    }
}

/// Quality Adjustment Strategy - Adjusts quality parameters to improve results
#[derive(Debug)]
pub struct QualityAdjustmentStrategy;

impl FallbackStrategy for QualityAdjustmentStrategy {
    fn name(&self) -> &str {
        "quality_adjustment"
    }

    fn can_handle(&self, failure_type: &FailureType, conversion_type: &ConversionType) -> bool {
        match failure_type {
            FailureType::QualityFailure | FailureType::ArtifactFailure => {
                matches!(
                    conversion_type,
                    ConversionType::SpeakerConversion
                        | ConversionType::PitchShift
                        | ConversionType::SpeedTransformation
                        | ConversionType::EmotionalTransformation
                )
            }
            _ => false,
        }
    }

    fn success_probability(&self, context: &FallbackContext) -> f32 {
        // Higher probability if we have quality metrics and moderate artifact levels
        let quality_factor = context.current_quality.unwrap_or(0.5);
        let artifact_factor = context
            .artifacts
            .as_ref()
            .map(|a| 1.0 - a.overall_score)
            .unwrap_or(0.5);

        // Base probability adjusted by quality and artifact metrics
        let base_probability = 0.7;
        base_probability * quality_factor * artifact_factor
    }

    fn apply(
        &self,
        request: &ConversionRequest,
        context: &FallbackContext,
        config: &ConversionConfig,
    ) -> Result<ConversionResult> {
        debug!("Applying quality adjustment strategy");

        // Create adjusted configuration with more conservative settings
        let mut adjusted_config = config.clone();

        // Reduce quality level to be more conservative
        adjusted_config.quality_level = (adjusted_config.quality_level * 0.8).max(0.1);

        // Apply more conservative processing parameters
        let input_audio = &request.source_audio;
        let mut output_audio = input_audio.clone();

        // Apply gentle processing based on conversion type
        match &request.conversion_type {
            ConversionType::PitchShift => {
                // Apply conservative pitch shifting (1.1x factor)
                let pitch_transform = PitchTransform::new(1.1);
                output_audio = pitch_transform.apply(&output_audio)?;
            }
            ConversionType::SpeedTransformation => {
                // Apply conservative speed transformation (0.95x factor)
                let speed_transform = SpeedTransform::new(0.95);
                output_audio = speed_transform.apply(&output_audio)?;
            }
            _ => {
                // For other types, apply minimal processing
                output_audio = input_audio.clone();
            }
        }

        Ok(ConversionResult {
            request_id: request.id.clone(),
            converted_audio: output_audio,
            output_sample_rate: request.source_sample_rate,
            quality_metrics: HashMap::new(),
            artifacts: None,
            objective_quality: Some(ObjectiveQualityMetrics {
                overall_score: 0.7,
                spectral_similarity: 0.7,
                temporal_consistency: 0.8,
                prosodic_preservation: 0.7,
                naturalness: 0.7,
                perceptual_quality: 0.7,
                snr_estimate: 20.0,
                segmental_snr: 18.0,
            }),
            processing_time: context
                .time_constraints
                .max_processing_time
                .min(Duration::from_millis(100)),
            conversion_type: request.conversion_type.clone(),
            success: true,
            error_message: None,
            timestamp: SystemTime::now(),
        })
    }

    fn priority(&self) -> i32 {
        75 // High priority for quality issues
    }
}

/// Resource Optimization Strategy - Optimizes resource usage when resources are constrained
#[derive(Debug)]
pub struct ResourceOptimizationStrategy;

impl FallbackStrategy for ResourceOptimizationStrategy {
    fn name(&self) -> &str {
        "resource_optimization"
    }

    fn can_handle(&self, failure_type: &FailureType, _conversion_type: &ConversionType) -> bool {
        matches!(
            failure_type,
            FailureType::ResourceFailure
                | FailureType::MemoryFailure
                | FailureType::PerformanceFailure
        )
    }

    fn success_probability(&self, context: &FallbackContext) -> f32 {
        // Higher probability if we have resource constraints
        let cpu_factor = 1.0 - (context.available_resources.cpu_usage_percent / 100.0);
        let memory_factor = if context.available_resources.memory_available_mb > 1000.0 {
            0.8
        } else {
            0.3
        };

        // Base probability adjusted by available resources
        let base_probability = 0.8_f32;
        base_probability * ((cpu_factor + memory_factor) / 2.0).max(0.2)
    }

    fn apply(
        &self,
        request: &ConversionRequest,
        context: &FallbackContext,
        config: &ConversionConfig,
    ) -> Result<ConversionResult> {
        debug!("Applying resource optimization strategy");

        // Create optimized configuration for low resource usage
        let mut optimized_config = config.clone();

        // Reduce buffer sizes and processing complexity
        optimized_config.buffer_size = optimized_config.buffer_size.min(1024);
        // Note: enable_gpu_acceleration not available in this config, using CPU-optimized settings

        // Reduce processing quality for speed
        optimized_config.quality_level = optimized_config.quality_level.min(0.5);

        let input_audio = &request.source_audio;
        let mut output_audio = input_audio.clone();

        // Apply minimal processing to conserve resources
        match &request.conversion_type {
            ConversionType::PitchShift => {
                // Use simple pitch shifting for minimal resource usage
                let pitch_transform = PitchTransform::new(1.05);
                output_audio = pitch_transform.apply(&output_audio)?;
            }
            ConversionType::SpeedTransformation => {
                let speed_transform = SpeedTransform::new(0.98);
                output_audio = speed_transform.apply(&output_audio)?;
            }
            _ => {
                // For complex conversions, use simplified processing
                output_audio = input_audio.clone();
            }
        }

        Ok(ConversionResult {
            request_id: request.id.clone(),
            converted_audio: output_audio,
            output_sample_rate: request.source_sample_rate,
            quality_metrics: HashMap::new(),
            artifacts: None,
            objective_quality: Some(ObjectiveQualityMetrics {
                overall_score: 0.6,
                spectral_similarity: 0.6,
                temporal_consistency: 0.7,
                prosodic_preservation: 0.6,
                naturalness: 0.6,
                perceptual_quality: 0.6,
                snr_estimate: 18.0,
                segmental_snr: 16.0,
            }),
            processing_time: Duration::from_millis(50),
            conversion_type: request.conversion_type.clone(),
            success: true,
            error_message: None,
            timestamp: SystemTime::now(),
        })
    }

    fn priority(&self) -> i32 {
        60 // Medium-high priority for resource issues
    }
}

/// Alternative Algorithm Strategy - Uses alternative algorithms when primary ones fail
#[derive(Debug)]
pub struct AlternativeAlgorithmStrategy;

impl FallbackStrategy for AlternativeAlgorithmStrategy {
    fn name(&self) -> &str {
        "alternative_algorithm"
    }

    fn can_handle(&self, failure_type: &FailureType, conversion_type: &ConversionType) -> bool {
        match failure_type {
            FailureType::ProcessingError | FailureType::ModelFailure => {
                matches!(
                    conversion_type,
                    ConversionType::SpeakerConversion
                        | ConversionType::PitchShift
                        | ConversionType::SpeedTransformation
                        | ConversionType::AgeTransformation
                        | ConversionType::GenderTransformation
                )
            }
            _ => false,
        }
    }

    fn success_probability(&self, context: &FallbackContext) -> f32 {
        // Higher probability if previous attempts have failed
        let attempt_factor = if context.previous_attempts.len() > 1 {
            0.8
        } else {
            0.6
        };

        // Consider available processing time
        let time_factor = if context.time_constraints.max_processing_time.as_millis() > 1000 {
            1.0
        } else {
            0.7
        };

        attempt_factor * time_factor
    }

    fn apply(
        &self,
        request: &ConversionRequest,
        context: &FallbackContext,
        _config: &ConversionConfig,
    ) -> Result<ConversionResult> {
        debug!("Applying alternative algorithm strategy");

        let input_audio = &request.source_audio;
        let mut output_audio = input_audio.clone();

        // Use alternative, more robust algorithms
        match &request.conversion_type {
            ConversionType::PitchShift => {
                // Use basic time-domain pitch shifting instead of complex frequency-domain methods
                let factor = 1.2; // Fixed factor for alternative approach
                let samples_per_frame = 512;

                for chunk in output_audio.chunks_mut(samples_per_frame) {
                    if chunk.len() == samples_per_frame {
                        // Simple pitch shifting by resampling
                        let mut resampled = Vec::with_capacity(chunk.len());
                        for i in 0..chunk.len() {
                            let src_idx = ((i as f32) / factor) as usize;
                            if src_idx < chunk.len() {
                                resampled.push(chunk[src_idx]);
                            } else {
                                resampled.push(0.0);
                            }
                        }
                        chunk.copy_from_slice(&resampled);
                    }
                }
            }
            ConversionType::SpeedTransformation => {
                // Use simple time-stretching without pitch preservation
                let speed_factor = 0.9; // Fixed factor for alternative approach
                let target_len = ((input_audio.len() as f32) / speed_factor) as usize;
                let mut stretched = Vec::with_capacity(target_len);

                for i in 0..target_len {
                    let src_idx = ((i as f32) * speed_factor) as usize;
                    if src_idx < input_audio.len() {
                        stretched.push(input_audio[src_idx]);
                    } else {
                        stretched.push(0.0);
                    }
                }
                output_audio = stretched;
            }
            ConversionType::AgeTransformation => {
                // Use simple formant shifting approximation
                for sample in output_audio.iter_mut() {
                    *sample *= 0.9; // Simple age simulation through amplitude reduction
                }
            }
            ConversionType::GenderTransformation => {
                // Use basic spectral modification
                for (i, sample) in output_audio.iter_mut().enumerate() {
                    if i % 2 == 0 {
                        *sample *= 1.1; // Simple formant approximation
                    }
                }
            }
            _ => {
                // For other types, apply passthrough with minimal processing
                output_audio = input_audio.clone();
            }
        }

        Ok(ConversionResult {
            request_id: request.id.clone(),
            converted_audio: output_audio,
            output_sample_rate: request.source_sample_rate,
            quality_metrics: HashMap::new(),
            artifacts: None,
            objective_quality: Some(ObjectiveQualityMetrics {
                overall_score: 0.65,
                spectral_similarity: 0.65,
                temporal_consistency: 0.7,
                prosodic_preservation: 0.6,
                naturalness: 0.65,
                perceptual_quality: 0.65,
                snr_estimate: 19.0,
                segmental_snr: 17.0,
            }),
            processing_time: context
                .time_constraints
                .max_processing_time
                .min(Duration::from_millis(200)),
            conversion_type: request.conversion_type.clone(),
            success: true,
            error_message: None,
            timestamp: SystemTime::now(),
        })
    }

    fn priority(&self) -> i32 {
        50 // Medium priority - try after quality adjustment but before passthrough
    }
}

/// Default implementation
impl Default for GracefulDegradationController {
    fn default() -> Self {
        Self::new()
    }
}