voirs-sdk 0.1.0-rc.1

//! Unified streaming interface for all VoiRS advanced features.
//!
//! This module provides a unified streaming interface that can handle multiple
//! advanced features (emotion, cloning, conversion, singing, spatial audio) in
//! a coordinated streaming pipeline.

use crate::types::{AdvancedFeature, LanguageCode, SynthesisConfig};
use crate::{AudioBuffer, VoirsError, VoirsResult};
use async_trait::async_trait;
use futures::Stream;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::pin::Pin;

/// Unified streaming synthesis request that can handle multiple features
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UnifiedStreamingRequest {
    /// The text to synthesize
    pub text: String,
    /// Language for synthesis
    pub language: LanguageCode,
    /// Base synthesis configuration
    pub synthesis_config: SynthesisConfig,
    /// Enabled advanced features and their configurations
    pub feature_configs: HashMap<AdvancedFeature, FeatureStreamingConfig>,
    /// Streaming parameters
    pub streaming_params: StreamingParameters,
}

/// Streaming parameters for unified synthesis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StreamingParameters {
    /// Chunk size in milliseconds
    pub chunk_size_ms: u32,
    /// Overlap between chunks in milliseconds
    pub overlap_ms: u32,
    /// Maximum latency tolerance in milliseconds
    pub max_latency_ms: u32,
    /// Quality vs speed preference (0.0 = speed, 1.0 = quality)
    pub quality_preference: f32,
    /// Enable predictive processing
    pub predictive_processing: bool,
}

/// Feature-specific streaming configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum FeatureStreamingConfig {
    /// Emotion control streaming configuration
    Emotion {
        /// Emotion type (e.g., "happy", "sad")
        emotion_type: String,
        /// Emotion intensity (0.0-1.0)
        intensity: f32,
        /// Enable emotion transitions
        enable_transitions: bool,
        /// Transition duration in milliseconds
        transition_duration_ms: u32,
    },
    /// Voice cloning streaming configuration
    Cloning {
        /// Speaker profile ID
        speaker_id: String,
        /// Adaptation strength (0.0-1.0)
        adaptation_strength: f32,
        /// Enable real-time fine-tuning
        realtime_adaptation: bool,
    },
    /// Voice conversion streaming configuration
    Conversion {
        /// Target voice characteristics
        target_age: Option<u8>,
        target_gender: Option<String>,
        /// Conversion strength (0.0-1.0)
        conversion_strength: f32,
        /// Preserve original prosody
        preserve_prosody: bool,
    },
    /// Singing synthesis streaming configuration
    Singing {
        /// Musical score (simplified format)
        score: Vec<MusicalNote>,
        /// Singing technique
        technique: String,
        /// Vibrato settings
        vibrato_rate: f32,
        vibrato_depth: f32,
    },
    /// Spatial audio streaming configuration
    SpatialAudio {
        /// 3D position (x, y, z)
        position: [f32; 3],
        /// Listener position (x, y, z)
        listener_position: [f32; 3],
        /// Room acoustics model
        room_model: String,
        /// Enable head tracking
        head_tracking: bool,
    },
}

/// Musical note for singing synthesis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MusicalNote {
    /// Note pitch (e.g., "C4", "A#3")
    pub pitch: String,
    /// Duration in beats
    pub duration: f32,
    /// Start time in beats
    pub start_time: f32,
    /// Lyrics for this note
    pub lyrics: String,
}

/// Streaming synthesis result with feature processing
#[derive(Debug, Clone)]
pub struct UnifiedStreamingResult {
    /// Synthesized audio chunk
    pub audio: AudioBuffer,
    /// Processing metadata
    pub metadata: StreamingMetadata,
    /// Feature-specific results
    pub feature_results: HashMap<AdvancedFeature, FeatureStreamingResult>,
}

/// Metadata for streaming synthesis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StreamingMetadata {
    /// Chunk sequence number
    pub chunk_id: u32,
    /// Timestamp in milliseconds
    pub timestamp_ms: u64,
    /// Processing latency for this chunk
    pub latency_ms: u32,
    /// Quality metrics
    pub quality_metrics: QualityMetrics,
    /// Performance metrics
    pub performance_metrics: PerformanceMetrics,
}

/// Quality metrics for streaming
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QualityMetrics {
    /// Signal-to-noise ratio
    pub snr_db: f32,
    /// Total harmonic distortion
    pub thd_percent: f32,
    /// Spectral centroid
    pub spectral_centroid: f32,
    /// Confidence score (0.0-1.0)
    pub confidence_score: f32,
}

/// Performance metrics for streaming
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceMetrics {
    /// Processing time for this chunk in milliseconds
    pub processing_time_ms: u32,
    /// Memory usage in MB
    pub memory_usage_mb: u32,
    /// CPU utilization (0.0-1.0)
    pub cpu_utilization: f32,
    /// GPU utilization (0.0-1.0), if applicable
    pub gpu_utilization: Option<f32>,
}

/// Feature-specific streaming result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum FeatureStreamingResult {
    /// Emotion processing result
    Emotion {
        /// Applied emotion intensity
        applied_intensity: f32,
        /// Detected emotion transitions
        transitions: Vec<EmotionTransition>,
    },
    /// Voice cloning result
    Cloning {
        /// Similarity score to target speaker
        similarity_score: f32,
        /// Adaptation quality
        adaptation_quality: f32,
    },
    /// Voice conversion result
    Conversion {
        /// Conversion success rate
        success_rate: f32,
        /// Detected voice characteristics
        detected_characteristics: HashMap<String, f32>,
    },
    /// Singing synthesis result
    Singing {
        /// Pitch accuracy
        pitch_accuracy: f32,
        /// Rhythm accuracy
        rhythm_accuracy: f32,
        /// Musical expression score
        expression_score: f32,
    },
    /// Spatial audio result
    SpatialAudio {
        /// 3D audio positioning accuracy
        positioning_accuracy: f32,
        /// Room acoustics quality
        acoustics_quality: f32,
        /// Binaural rendering quality
        binaural_quality: f32,
    },
}

/// Emotion transition event
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmotionTransition {
    /// Transition start time in milliseconds
    pub start_time_ms: u32,
    /// Transition duration in milliseconds
    pub duration_ms: u32,
    /// Source emotion
    pub from_emotion: String,
    /// Target emotion
    pub to_emotion: String,
    /// Transition curve type
    pub curve_type: String,
}

/// Unified streaming interface trait
#[async_trait]
pub trait UnifiedStreamingSynthesis: Send + Sync {
    /// Start streaming synthesis with unified feature support
    async fn start_unified_streaming(
        &self,
        request: UnifiedStreamingRequest,
    ) -> VoirsResult<Pin<Box<dyn Stream<Item = VoirsResult<UnifiedStreamingResult>> + Send>>>;

    /// Update streaming parameters during synthesis
    async fn update_streaming_parameters(&self, params: StreamingParameters) -> VoirsResult<()>;

    /// Update feature configuration during streaming
    async fn update_feature_config(
        &self,
        feature: AdvancedFeature,
        config: FeatureStreamingConfig,
    ) -> VoirsResult<()>;

    /// Stop streaming synthesis
    async fn stop_streaming(&self) -> VoirsResult<()>;

    /// Get current streaming status
    async fn get_streaming_status(&self) -> VoirsResult<StreamingStatus>;
}

/// Current streaming status
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StreamingStatus {
    /// Whether streaming is active
    pub is_active: bool,
    /// Current chunk being processed
    pub current_chunk: u32,
    /// Total chunks processed
    pub total_chunks_processed: u32,
    /// Average processing latency
    pub avg_latency_ms: f32,
    /// Active features
    pub active_features: Vec<AdvancedFeature>,
    /// Resource utilization
    pub resource_utilization: ResourceUtilization,
}

/// Resource utilization metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResourceUtilization {
    /// CPU usage percentage (0-100)
    pub cpu_percent: f32,
    /// Memory usage in MB
    pub memory_mb: u32,
    /// GPU usage percentage (0-100), if applicable
    pub gpu_percent: Option<f32>,
    /// Network bandwidth usage in Mbps
    pub network_mbps: f32,
}

/// Unified streaming pipeline implementation
pub struct UnifiedStreamingPipeline {
    /// Feature processors
    feature_processors: HashMap<AdvancedFeature, Box<dyn FeatureStreamingProcessor>>,
    /// Current streaming state
    streaming_state: Option<StreamingState>,
    /// Performance monitor
    performance_monitor: Box<dyn StreamingPerformanceMonitor>,
}

/// Internal streaming state
#[derive(Debug)]
struct StreamingState {
    /// Current request configuration
    request: UnifiedStreamingRequest,
    /// Chunk counter
    chunk_counter: u32,
    /// Start time
    start_time: std::time::Instant,
    /// Performance metrics history
    metrics_history: Vec<PerformanceMetrics>,
}

/// Feature-specific streaming processor trait
#[async_trait]
pub trait FeatureStreamingProcessor: Send + Sync {
    /// Process audio chunk with feature-specific logic
    async fn process_chunk(
        &self,
        audio: &AudioBuffer,
        config: &FeatureStreamingConfig,
        metadata: &StreamingMetadata,
    ) -> VoirsResult<(AudioBuffer, FeatureStreamingResult)>;

    /// Update configuration during streaming
    async fn update_config(&self, config: &FeatureStreamingConfig) -> VoirsResult<()>;

    /// Get processing capabilities
    fn get_capabilities(&self) -> FeatureCapabilities;
}

/// Feature processing capabilities
#[derive(Debug, Clone)]
pub struct FeatureCapabilities {
    /// Supports real-time processing
    pub realtime_capable: bool,
    /// Minimum chunk size in milliseconds
    pub min_chunk_size_ms: u32,
    /// Maximum chunk size in milliseconds
    pub max_chunk_size_ms: u32,
    /// Required overlap in milliseconds
    pub required_overlap_ms: u32,
    /// Latency contribution in milliseconds
    pub latency_contribution_ms: u32,
}

/// Streaming performance monitor trait
#[async_trait]
pub trait StreamingPerformanceMonitor: Send + Sync {
    /// Record performance metrics for a chunk
    async fn record_chunk_metrics(&self, metrics: &PerformanceMetrics);

    /// Get average performance over time window
    async fn get_average_performance(&self, window_seconds: u32)
        -> VoirsResult<PerformanceMetrics>;

    /// Check if performance is within acceptable limits
    async fn check_performance_limits(&self, limits: &PerformanceLimits) -> VoirsResult<bool>;

    /// Get performance recommendations
    async fn get_performance_recommendations(&self) -> Vec<PerformanceRecommendation>;
}

/// Performance limits for monitoring
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceLimits {
    /// Maximum acceptable latency in milliseconds
    pub max_latency_ms: u32,
    /// Maximum CPU utilization (0.0-1.0)
    pub max_cpu_utilization: f32,
    /// Maximum memory usage in MB
    pub max_memory_mb: u32,
    /// Minimum quality threshold (0.0-1.0)
    pub min_quality_threshold: f32,
}

/// Performance optimization recommendation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceRecommendation {
    /// Recommendation type
    pub recommendation_type: RecommendationType,
    /// Description of the recommendation
    pub description: String,
    /// Expected performance impact
    pub expected_impact: String,
    /// Priority level
    pub priority: RecommendationPriority,
}

/// Types of performance recommendations
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum RecommendationType {
    /// Reduce chunk size
    ReduceChunkSize,
    /// Disable non-essential features
    DisableFeatures,
    /// Switch to GPU processing
    UseGpuAcceleration,
    /// Reduce quality settings
    ReduceQuality,
    /// Increase buffer size
    IncreaseBufferSize,
    /// Optimize thread allocation
    OptimizeThreads,
}

/// Priority level for recommendations
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
pub enum RecommendationPriority {
    /// Low priority - minor optimization
    Low,
    /// Medium priority - noticeable improvement
    Medium,
    /// High priority - significant performance issue
    High,
    /// Critical priority - system may fail
    Critical,
}

impl Default for StreamingParameters {
    fn default() -> Self {
        Self {
            chunk_size_ms: 100,
            overlap_ms: 10,
            max_latency_ms: 500,
            quality_preference: 0.7,
            predictive_processing: true,
        }
    }
}

impl Default for QualityMetrics {
    fn default() -> Self {
        Self {
            snr_db: 0.0,
            thd_percent: 0.0,
            spectral_centroid: 0.0,
            confidence_score: 1.0,
        }
    }
}

impl Default for PerformanceMetrics {
    fn default() -> Self {
        Self {
            processing_time_ms: 0,
            memory_usage_mb: 0,
            cpu_utilization: 0.0,
            gpu_utilization: None,
        }
    }
}

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

impl UnifiedStreamingPipeline {
    /// Create a new unified streaming pipeline
    pub fn new() -> Self {
        Self {
            feature_processors: HashMap::new(),
            streaming_state: None,
            performance_monitor: Box::new(DefaultStreamingPerformanceMonitor::new()),
        }
    }

    /// Add a feature processor to the pipeline
    pub fn add_feature_processor(
        &mut self,
        feature: AdvancedFeature,
        processor: Box<dyn FeatureStreamingProcessor>,
    ) {
        self.feature_processors.insert(feature, processor);
    }

    /// Remove a feature processor from the pipeline
    pub fn remove_feature_processor(&mut self, feature: &AdvancedFeature) {
        self.feature_processors.remove(feature);
    }

    /// Get supported features
    pub fn supported_features(&self) -> Vec<AdvancedFeature> {
        self.feature_processors.keys().cloned().collect()
    }
}

#[async_trait]
impl UnifiedStreamingSynthesis for UnifiedStreamingPipeline {
    async fn start_unified_streaming(
        &self,
        request: UnifiedStreamingRequest,
    ) -> VoirsResult<Pin<Box<dyn Stream<Item = VoirsResult<UnifiedStreamingResult>> + Send>>> {
        // Validate request
        self.validate_request(&request)?;

        // Initialize streaming state
        let streaming_state = StreamingState {
            request: request.clone(),
            chunk_counter: 0,
            start_time: std::time::Instant::now(),
            metrics_history: Vec::new(),
        };

        // Create the streaming implementation
        let stream = UnifiedStreamingImpl::new(request).await?;

        Ok(Box::pin(stream))
    }

    async fn update_streaming_parameters(&self, _params: StreamingParameters) -> VoirsResult<()> {
        // Implementation would update streaming parameters
        Ok(())
    }

    async fn update_feature_config(
        &self,
        feature: AdvancedFeature,
        config: FeatureStreamingConfig,
    ) -> VoirsResult<()> {
        if let Some(processor) = self.feature_processors.get(&feature) {
            processor.update_config(&config).await?;
        }
        Ok(())
    }

    async fn stop_streaming(&self) -> VoirsResult<()> {
        // Implementation would stop streaming
        Ok(())
    }

    async fn get_streaming_status(&self) -> VoirsResult<StreamingStatus> {
        // Return current streaming status
        Ok(StreamingStatus {
            is_active: self.streaming_state.is_some(),
            current_chunk: 0,
            total_chunks_processed: 0,
            avg_latency_ms: 0.0,
            active_features: self.supported_features(),
            resource_utilization: ResourceUtilization {
                cpu_percent: 0.0,
                memory_mb: 0,
                gpu_percent: None,
                network_mbps: 0.0,
            },
        })
    }
}

impl UnifiedStreamingPipeline {
    /// Validate streaming request
    fn validate_request(&self, request: &UnifiedStreamingRequest) -> VoirsResult<()> {
        // Check if requested features are supported
        for feature in request.feature_configs.keys() {
            if !self.feature_processors.contains_key(feature) {
                return Err(VoirsError::FeatureUnavailable {
                    feature: format!("{:?}", feature),
                    reason: "Feature processor not available".to_string(),
                });
            }
        }

        // Validate streaming parameters
        if request.streaming_params.chunk_size_ms == 0 {
            return Err(VoirsError::InvalidConfiguration {
                field: "chunk_size_ms".to_string(),
                value: "0".to_string(),
                reason: "Chunk size must be greater than zero".to_string(),
                valid_values: Some(vec!["1".to_string(), "100".to_string(), "1000".to_string()]),
            });
        }

        Ok(())
    }
}

/// Streaming implementation
struct UnifiedStreamingImpl {
    // Implementation details would go here
}

impl UnifiedStreamingImpl {
    async fn new(_request: UnifiedStreamingRequest) -> VoirsResult<Self> {
        Ok(Self {})
    }
}

impl Stream for UnifiedStreamingImpl {
    type Item = VoirsResult<UnifiedStreamingResult>;

    fn poll_next(
        self: Pin<&mut Self>,
        _cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        // Implementation would handle actual streaming
        std::task::Poll::Ready(None)
    }
}

/// Default performance monitor implementation
struct DefaultStreamingPerformanceMonitor {
    metrics_history: std::sync::Arc<std::sync::Mutex<Vec<PerformanceMetrics>>>,
}

impl DefaultStreamingPerformanceMonitor {
    fn new() -> Self {
        Self {
            metrics_history: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
        }
    }
}

#[async_trait]
impl StreamingPerformanceMonitor for DefaultStreamingPerformanceMonitor {
    async fn record_chunk_metrics(&self, metrics: &PerformanceMetrics) {
        if let Ok(mut history) = self.metrics_history.lock() {
            history.push(metrics.clone());
            // Keep only last 1000 metrics
            if history.len() > 1000 {
                history.remove(0);
            }
        }
    }

    async fn get_average_performance(
        &self,
        _window_seconds: u32,
    ) -> VoirsResult<PerformanceMetrics> {
        // Calculate average from history
        Ok(PerformanceMetrics::default())
    }

    async fn check_performance_limits(&self, _limits: &PerformanceLimits) -> VoirsResult<bool> {
        // Check if current performance is within limits
        Ok(true)
    }

    async fn get_performance_recommendations(&self) -> Vec<PerformanceRecommendation> {
        // Generate performance recommendations
        vec![]
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_unified_streaming_request_creation() {
        let request = UnifiedStreamingRequest {
            text: "Hello, world!".to_string(),
            language: LanguageCode::EnUs,
            synthesis_config: SynthesisConfig::default(),
            feature_configs: HashMap::new(),
            streaming_params: StreamingParameters::default(),
        };

        assert_eq!(request.text, "Hello, world!");
        assert_eq!(request.language, LanguageCode::EnUs);
    }

    #[test]
    fn test_streaming_parameters_default() {
        let params = StreamingParameters::default();
        assert_eq!(params.chunk_size_ms, 100);
        assert_eq!(params.overlap_ms, 10);
        assert_eq!(params.max_latency_ms, 500);
        assert_eq!(params.quality_preference, 0.7);
        assert!(params.predictive_processing);
    }

    #[test]
    fn test_feature_streaming_config_emotion() {
        let config = FeatureStreamingConfig::Emotion {
            emotion_type: "happy".to_string(),
            intensity: 0.8,
            enable_transitions: true,
            transition_duration_ms: 200,
        };

        match config {
            FeatureStreamingConfig::Emotion {
                emotion_type,
                intensity,
                ..
            } => {
                assert_eq!(emotion_type, "happy");
                assert_eq!(intensity, 0.8);
            }
            _ => panic!("Expected emotion config"),
        }
    }

    #[test]
    fn test_unified_streaming_pipeline_creation() {
        let pipeline = UnifiedStreamingPipeline::new();
        assert!(pipeline.supported_features().is_empty());
    }
}