voirs_conversion/

communication.rs

//! Communication app integration for voice conversion
//!
//! This module provides comprehensive integration with VoIP and communication applications,
//! enabling real-time voice conversion for calls, conferences, and messaging platforms.
//!
//! ## Supported Applications
//!
//! - **Zoom**: Video conferencing with real-time voice conversion
//! - **Microsoft Teams**: Enterprise communication with voice transformation
//! - **Skype**: VoIP calls with voice effects and conversion
//! - **Discord**: Gaming and community voice chat integration
//! - **Slack**: Team communication with voice message conversion
//! - **WhatsApp**: Messaging with voice note transformation
//! - **Telegram**: Secure messaging with voice conversion
//! - **Signal**: Privacy-focused messaging with voice effects
//! - **WebRTC**: Generic web-based communication support
//!
//! ## Features
//!
//! - **Real-time Voice Conversion**: Ultra-low latency for live communication
//! - **Call Quality Optimization**: Adaptive quality based on network conditions
//! - **Privacy Protection**: Voice masking and anonymization features
//! - **Multi-party Calls**: Voice conversion in group conversations
//! - **Recording Integration**: Voice conversion for call recordings
//! - **Accessibility Features**: Voice enhancement for hearing impaired users
//!
//! ## Usage
//!
//! ```rust
//! # use voirs_conversion::communication::{CommunicationApp, VoipProcessor, VoipConfig};
//! # #[tokio::main]
//! # async fn main() -> Result<(), Box<dyn std::error::Error>> {
//! // Create processor for Zoom
//! let config = VoipConfig::zoom_optimized();
//! let mut processor = VoipProcessor::new(CommunicationApp::Zoom, config)?;
//!
//! // Process call audio in real-time
//! let input_audio = vec![0.0f32; 1024]; // Sample audio data
//! let converted_audio = processor.process_call_audio(&input_audio, "professional_voice").await?;
//! # Ok(())
//! # }
//! ```

use crate::{
    config::ConversionConfig,
    core::VoiceConverter,
    realtime::{RealtimeConfig, RealtimeConverter},
    types::{ConversionRequest, ConversionTarget, ConversionType, VoiceCharacteristics},
    Error, Result,
};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;
use tracing::{debug, info, warn};

/// Supported communication applications
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum CommunicationApp {
    /// Zoom video conferencing
    Zoom,
    /// Microsoft Teams
    MicrosoftTeams,
    /// Skype
    Skype,
    /// Discord
    Discord,
    /// Slack
    Slack,
    /// WhatsApp
    WhatsApp,
    /// Telegram
    Telegram,
    /// Signal
    Signal,
    /// Generic WebRTC
    WebRTC,
    /// Google Meet
    GoogleMeet,
    /// Cisco Webex
    CiscoWebex,
}

impl CommunicationApp {
    /// Get app-specific communication constraints
    pub fn communication_constraints(&self) -> CommunicationConstraints {
        match self {
            CommunicationApp::Zoom => CommunicationConstraints {
                max_latency_ms: 150.0, // Zoom buffer tolerance
                max_jitter_ms: 30.0,
                sample_rate: 48000,
                channels: 2,
                recommended_bitrate_kbps: 128,
                echo_cancellation: true,
                noise_suppression: true,
                automatic_gain_control: true,
                quality_adaptation: true,
                privacy_features: false,
            },
            CommunicationApp::MicrosoftTeams => CommunicationConstraints {
                max_latency_ms: 120.0,
                max_jitter_ms: 25.0,
                sample_rate: 48000,
                channels: 2,
                recommended_bitrate_kbps: 128,
                echo_cancellation: true,
                noise_suppression: true,
                automatic_gain_control: true,
                quality_adaptation: true,
                privacy_features: true, // Enterprise features
            },
            CommunicationApp::Skype => CommunicationConstraints {
                max_latency_ms: 200.0, // Skype has higher tolerance
                max_jitter_ms: 40.0,
                sample_rate: 48000,
                channels: 2,
                recommended_bitrate_kbps: 64,
                echo_cancellation: true,
                noise_suppression: true,
                automatic_gain_control: true,
                quality_adaptation: true,
                privacy_features: false,
            },
            CommunicationApp::Discord => CommunicationConstraints {
                max_latency_ms: 40.0, // Gaming requires very low latency
                max_jitter_ms: 10.0,
                sample_rate: 48000,
                channels: 2,
                recommended_bitrate_kbps: 320, // Discord voice quality
                echo_cancellation: false,      // Discord handles this
                noise_suppression: false,      // Discord handles this
                automatic_gain_control: false, // Discord handles this
                quality_adaptation: false,
                privacy_features: true, // Voice masking for privacy
            },
            CommunicationApp::Slack => CommunicationConstraints {
                max_latency_ms: 300.0, // Slack calls can tolerate higher latency
                max_jitter_ms: 50.0,
                sample_rate: 44100,
                channels: 2,
                recommended_bitrate_kbps: 64,
                echo_cancellation: true,
                noise_suppression: true,
                automatic_gain_control: true,
                quality_adaptation: true,
                privacy_features: true,
            },
            CommunicationApp::WhatsApp => CommunicationConstraints {
                max_latency_ms: 250.0, // Mobile tolerance
                max_jitter_ms: 60.0,
                sample_rate: 44100,
                channels: 1, // Mono for mobile efficiency
                recommended_bitrate_kbps: 32,
                echo_cancellation: true,
                noise_suppression: true,
                automatic_gain_control: true,
                quality_adaptation: true,
                privacy_features: true, // End-to-end encryption
            },
            CommunicationApp::Telegram => CommunicationConstraints {
                max_latency_ms: 200.0,
                max_jitter_ms: 40.0,
                sample_rate: 48000,
                channels: 2,
                recommended_bitrate_kbps: 64,
                echo_cancellation: true,
                noise_suppression: true,
                automatic_gain_control: true,
                quality_adaptation: true,
                privacy_features: true, // Secret chats
            },
            CommunicationApp::Signal => CommunicationConstraints {
                max_latency_ms: 180.0,
                max_jitter_ms: 35.0,
                sample_rate: 48000,
                channels: 2,
                recommended_bitrate_kbps: 64,
                echo_cancellation: true,
                noise_suppression: true,
                automatic_gain_control: true,
                quality_adaptation: true,
                privacy_features: true, // Privacy by design
            },
            CommunicationApp::WebRTC => CommunicationConstraints {
                max_latency_ms: 100.0, // WebRTC standard
                max_jitter_ms: 20.0,
                sample_rate: 48000,
                channels: 2,
                recommended_bitrate_kbps: 128,
                echo_cancellation: true,
                noise_suppression: true,
                automatic_gain_control: true,
                quality_adaptation: true,
                privacy_features: false,
            },
            CommunicationApp::GoogleMeet => CommunicationConstraints {
                max_latency_ms: 120.0,
                max_jitter_ms: 25.0,
                sample_rate: 48000,
                channels: 2,
                recommended_bitrate_kbps: 128,
                echo_cancellation: true,
                noise_suppression: true,
                automatic_gain_control: true,
                quality_adaptation: true,
                privacy_features: false,
            },
            CommunicationApp::CiscoWebex => CommunicationConstraints {
                max_latency_ms: 100.0, // Enterprise quality
                max_jitter_ms: 20.0,
                sample_rate: 48000,
                channels: 2,
                recommended_bitrate_kbps: 256,
                echo_cancellation: true,
                noise_suppression: true,
                automatic_gain_control: true,
                quality_adaptation: true,
                privacy_features: true, // Enterprise security
            },
        }
    }

    /// Get app name as string
    pub fn as_str(&self) -> &'static str {
        match self {
            CommunicationApp::Zoom => "Zoom",
            CommunicationApp::MicrosoftTeams => "Microsoft Teams",
            CommunicationApp::Skype => "Skype",
            CommunicationApp::Discord => "Discord",
            CommunicationApp::Slack => "Slack",
            CommunicationApp::WhatsApp => "WhatsApp",
            CommunicationApp::Telegram => "Telegram",
            CommunicationApp::Signal => "Signal",
            CommunicationApp::WebRTC => "WebRTC",
            CommunicationApp::GoogleMeet => "Google Meet",
            CommunicationApp::CiscoWebex => "Cisco Webex",
        }
    }
}

/// Communication app constraints
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CommunicationConstraints {
    /// Maximum acceptable latency in milliseconds
    pub max_latency_ms: f32,
    /// Maximum acceptable jitter in milliseconds
    pub max_jitter_ms: f32,
    /// Audio sample rate
    pub sample_rate: u32,
    /// Number of audio channels
    pub channels: u32,
    /// Recommended bitrate in kbps
    pub recommended_bitrate_kbps: u32,
    /// Enable echo cancellation
    pub echo_cancellation: bool,
    /// Enable noise suppression
    pub noise_suppression: bool,
    /// Enable automatic gain control
    pub automatic_gain_control: bool,
    /// Enable quality adaptation
    pub quality_adaptation: bool,
    /// Enable privacy features
    pub privacy_features: bool,
}

/// VoIP-specific audio configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VoipConfig {
    /// Target communication app
    pub app: CommunicationApp,
    /// Audio buffer size for processing
    pub buffer_size: usize,
    /// Sample rate
    pub sample_rate: u32,
    /// Number of audio channels
    pub channels: u32,
    /// Enable real-time processing
    pub realtime_processing: bool,
    /// Enable call quality monitoring
    pub quality_monitoring: bool,
    /// Enable privacy protection
    pub privacy_protection: bool,
    /// Enable echo cancellation
    pub echo_cancellation: bool,
    /// Enable noise suppression
    pub noise_suppression: bool,
    /// Enable automatic gain control
    pub automatic_gain_control: bool,
    /// App-specific optimizations
    pub app_optimizations: HashMap<String, f32>,
}

impl VoipConfig {
    /// Create Zoom-optimized configuration
    pub fn zoom_optimized() -> Self {
        let mut app_optimizations = HashMap::new();
        app_optimizations.insert("zoom_api_integration".to_string(), 1.0);
        app_optimizations.insert("zoom_recording_support".to_string(), 0.9);
        app_optimizations.insert("zoom_meeting_rooms".to_string(), 0.8);

        Self {
            app: CommunicationApp::Zoom,
            buffer_size: 1024,
            sample_rate: 48000,
            channels: 2,
            realtime_processing: true,
            quality_monitoring: true,
            privacy_protection: false,
            echo_cancellation: true,
            noise_suppression: true,
            automatic_gain_control: true,
            app_optimizations,
        }
    }

    /// Create Microsoft Teams-optimized configuration
    pub fn teams_optimized() -> Self {
        let mut app_optimizations = HashMap::new();
        app_optimizations.insert("teams_enterprise_integration".to_string(), 1.0);
        app_optimizations.insert("teams_tenant_security".to_string(), 1.0);
        app_optimizations.insert("teams_office365_sync".to_string(), 0.9);

        Self {
            app: CommunicationApp::MicrosoftTeams,
            buffer_size: 1024,
            sample_rate: 48000,
            channels: 2,
            realtime_processing: true,
            quality_monitoring: true,
            privacy_protection: true,
            echo_cancellation: true,
            noise_suppression: true,
            automatic_gain_control: true,
            app_optimizations,
        }
    }

    /// Create Discord-optimized configuration
    pub fn discord_optimized() -> Self {
        let mut app_optimizations = HashMap::new();
        app_optimizations.insert("discord_gaming_optimization".to_string(), 1.0);
        app_optimizations.insert("discord_low_latency".to_string(), 1.0);
        app_optimizations.insert("discord_voice_activity".to_string(), 0.9);

        Self {
            app: CommunicationApp::Discord,
            buffer_size: 256, // Very small buffer for gaming
            sample_rate: 48000,
            channels: 2,
            realtime_processing: true,
            quality_monitoring: true,
            privacy_protection: true,
            echo_cancellation: false,      // Discord handles this
            noise_suppression: false,      // Discord handles this
            automatic_gain_control: false, // Discord handles this
            app_optimizations,
        }
    }

    /// Create WhatsApp-optimized configuration
    pub fn whatsapp_optimized() -> Self {
        let mut app_optimizations = HashMap::new();
        app_optimizations.insert("whatsapp_mobile_optimization".to_string(), 1.0);
        app_optimizations.insert("whatsapp_bandwidth_efficiency".to_string(), 1.0);
        app_optimizations.insert("whatsapp_e2e_encryption".to_string(), 0.9);

        Self {
            app: CommunicationApp::WhatsApp,
            buffer_size: 512,
            sample_rate: 44100,
            channels: 1, // Mono for efficiency
            realtime_processing: true,
            quality_monitoring: false, // Mobile battery optimization
            privacy_protection: true,
            echo_cancellation: true,
            noise_suppression: true,
            automatic_gain_control: true,
            app_optimizations,
        }
    }

    /// Create Slack-optimized configuration
    pub fn slack_optimized() -> Self {
        let mut app_optimizations = HashMap::new();
        app_optimizations.insert("slack_workspace_integration".to_string(), 1.0);
        app_optimizations.insert("slack_channel_optimization".to_string(), 0.9);
        app_optimizations.insert("slack_threading_support".to_string(), 0.8);

        Self {
            app: CommunicationApp::Slack,
            buffer_size: 512,
            sample_rate: 48000,
            channels: 2,
            realtime_processing: true,
            quality_monitoring: true,
            privacy_protection: true, // Business privacy
            echo_cancellation: true,
            noise_suppression: true,
            automatic_gain_control: true,
            app_optimizations,
        }
    }
}

/// Communication voice processing modes
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum CommunicationMode {
    /// Professional business call
    BusinessCall,
    /// Casual personal call
    PersonalCall,
    /// Conference/meeting call
    ConferenceCall,
    /// Gaming voice chat
    GamingChat,
    /// Anonymous/privacy call
    AnonymousCall,
    /// Accessibility enhanced call
    AccessibilityCall,
}

/// VoIP processor for real-time voice conversion in communication apps
#[derive(Debug)]
pub struct VoipProcessor {
    /// Target communication application being processed
    app: CommunicationApp,
    /// VoIP-specific configuration settings
    config: VoipConfig,
    /// Real-time voice converter engine
    realtime_converter: RealtimeConverter,
    /// Voice converter for complex transformations and effects
    voice_converter: Arc<VoiceConverter>,
    /// Application-specific communication constraints
    constraints: CommunicationConstraints,
    /// Voice profiles mapped by name for different communication modes
    voice_profiles: Arc<RwLock<HashMap<String, VoiceCharacteristics>>>,
    /// Active call sessions tracked by call ID
    active_calls: Arc<RwLock<HashMap<String, CallSession>>>,
    /// Performance monitor for tracking call quality metrics
    performance_monitor: CallPerformanceMonitor,
    /// Network adaptation state for quality adjustments
    network_adaptation: NetworkAdaptationState,
}

impl VoipProcessor {
    /// Create new VoIP processor
    pub fn new(app: CommunicationApp, config: VoipConfig) -> Result<Self> {
        let constraints = app.communication_constraints();

        // Create real-time converter with VoIP-optimized settings
        let realtime_config = RealtimeConfig {
            buffer_size: config.buffer_size,
            sample_rate: config.sample_rate,
            target_latency_ms: constraints.max_latency_ms * 0.8, // 80% of max for safety
            overlap_factor: 0.25,
            adaptive_buffering: constraints.quality_adaptation,
            max_threads: 2,
            enable_lookahead: false, // Disable for real-time communication
            lookahead_size: 0,
        };

        let realtime_converter = RealtimeConverter::new(realtime_config)?;
        let voice_converter = Arc::new(VoiceConverter::new()?);

        Ok(Self {
            app,
            config,
            realtime_converter,
            voice_converter,
            constraints,
            voice_profiles: Arc::new(RwLock::new(HashMap::new())),
            active_calls: Arc::new(RwLock::new(HashMap::new())),
            performance_monitor: CallPerformanceMonitor::new(),
            network_adaptation: NetworkAdaptationState::new(),
        })
    }

    /// Process call audio in real-time
    pub async fn process_call_audio(
        &mut self,
        input_audio: &[f32],
        voice_profile: &str,
    ) -> Result<Vec<f32>> {
        let start_time = std::time::Instant::now();

        // Check network adaptation
        if self.constraints.quality_adaptation {
            self.update_network_adaptation().await?;
        }

        // Get voice characteristics
        let voice_characteristics = {
            let profiles = self.voice_profiles.read().await;
            profiles.get(voice_profile).cloned().unwrap_or_default()
        };

        // Set conversion target
        let target = ConversionTarget::new(voice_characteristics);
        self.realtime_converter.set_conversion_target(target);

        // Process with real-time converter
        let mut result = self.realtime_converter.process_chunk(input_audio).await?;

        // Apply communication-specific processing
        if self.config.echo_cancellation && self.constraints.echo_cancellation {
            result = self.apply_echo_cancellation(&result)?;
        }

        if self.config.noise_suppression && self.constraints.noise_suppression {
            result = self.apply_communication_noise_suppression(&result)?;
        }

        if self.config.automatic_gain_control && self.constraints.automatic_gain_control {
            result = self.apply_communication_agc(&result)?;
        }

        // Update performance metrics
        let processing_time = start_time.elapsed();
        self.performance_monitor.record_processing(
            processing_time,
            input_audio.len(),
            &self.constraints,
        );

        debug!(
            "Call audio processed: {} samples in {:.2}ms for {}",
            input_audio.len(),
            processing_time.as_secs_f32() * 1000.0,
            self.app.as_str()
        );

        Ok(result)
    }

    /// Process call audio with specific communication mode
    pub async fn process_call_with_mode(
        &mut self,
        input_audio: &[f32],
        voice_profile: &str,
        mode: CommunicationMode,
    ) -> Result<Vec<f32>> {
        // Apply mode-specific processing
        let processed_audio = match mode {
            CommunicationMode::BusinessCall => {
                self.apply_business_processing(input_audio, voice_profile)
                    .await?
            }
            CommunicationMode::PersonalCall => {
                self.apply_personal_processing(input_audio, voice_profile)
                    .await?
            }
            CommunicationMode::ConferenceCall => {
                self.apply_conference_processing(input_audio, voice_profile)
                    .await?
            }
            CommunicationMode::GamingChat => {
                self.apply_gaming_processing(input_audio, voice_profile)
                    .await?
            }
            CommunicationMode::AnonymousCall => {
                self.apply_anonymous_processing(input_audio, voice_profile)
                    .await?
            }
            CommunicationMode::AccessibilityCall => {
                self.apply_accessibility_processing(input_audio, voice_profile)
                    .await?
            }
        };

        Ok(processed_audio)
    }

    /// Register voice profile for communication
    pub async fn register_voice_profile(
        &self,
        profile_name: String,
        characteristics: VoiceCharacteristics,
    ) {
        let mut profiles = self.voice_profiles.write().await;
        profiles.insert(profile_name.clone(), characteristics);
        info!("Registered voice profile: {}", profile_name);
    }

    /// Start call session
    pub async fn start_call_session(
        &self,
        call_id: String,
        participants: Vec<String>,
        mode: CommunicationMode,
    ) -> Result<()> {
        let session = CallSession {
            call_id: call_id.clone(),
            participants,
            mode,
            start_time: std::time::Instant::now(),
            app: self.app,
            processed_packets: 0,
            total_latency_ms: 0.0,
            quality_issues: 0,
        };

        let mut calls = self.active_calls.write().await;
        calls.insert(call_id.clone(), session);

        info!("Started call session: {} on {}", call_id, self.app.as_str());
        Ok(())
    }

    /// End call session
    pub async fn end_call_session(&self, call_id: &str) -> Result<CallSession> {
        let mut calls = self.active_calls.write().await;
        calls
            .remove(call_id)
            .ok_or_else(|| Error::processing(format!("Call session not found: {call_id}")))
    }

    /// Get current call performance metrics
    pub fn get_call_metrics(&self) -> CallPerformanceMetrics {
        self.performance_monitor.get_current_metrics()
    }

    /// Check if call quality is acceptable
    pub fn is_call_quality_acceptable(&self) -> bool {
        self.performance_monitor
            .check_call_quality(&self.constraints)
    }

    /// Get app integration information
    pub fn get_app_integration(&self) -> AppIntegration {
        match self.app {
            CommunicationApp::Zoom => AppIntegration::Zoom(ZoomIntegration {
                sdk_version: "5.15.0".to_string(),
                meeting_integration: true,
                recording_support: true,
                breakout_rooms: true,
                webhook_support: true,
            }),
            CommunicationApp::MicrosoftTeams => AppIntegration::Teams(TeamsIntegration {
                graph_api_version: "v1.0".to_string(),
                tenant_integration: true,
                bot_framework_support: true,
                meeting_apps: true,
                compliance_recording: true,
            }),
            CommunicationApp::Skype => AppIntegration::Skype(SkypeIntegration {
                api_version: "v3".to_string(),
                bot_integration: true,
                calling_support: true,
                messaging_extension: true,
            }),
            CommunicationApp::Discord => AppIntegration::Discord(DiscordIntegration {
                api_version: "v10".to_string(),
                voice_channel_integration: true,
                bot_integration: true,
                stage_channel_support: true,
                permission_system: true,
            }),
            CommunicationApp::Slack => AppIntegration::Slack(SlackIntegration {
                api_version: "v1".to_string(),
                workspace_integration: true,
                app_home: true,
                slash_commands: true,
                interactive_components: true,
            }),
            CommunicationApp::WhatsApp => AppIntegration::WhatsApp(WhatsAppIntegration {
                business_api_version: "v16.0".to_string(),
                webhook_support: true,
                template_messages: true,
                media_support: true,
            }),
            CommunicationApp::Telegram => AppIntegration::Telegram(TelegramIntegration {
                bot_api_version: "6.7".to_string(),
                bot_integration: true,
                inline_queries: true,
                webhook_support: true,
                payments_support: false,
            }),
            CommunicationApp::Signal => AppIntegration::Signal(SignalIntegration {
                protocol_version: "v1".to_string(),
                privacy_focused: true,
                end_to_end_encryption: true,
                disappearing_messages: true,
            }),
            CommunicationApp::WebRTC => AppIntegration::WebRTC(WebRTCIntegration {
                specification_version: "1.0".to_string(),
                peer_connection_support: true,
                data_channel_support: true,
                media_stream_support: true,
            }),
            CommunicationApp::GoogleMeet => AppIntegration::GoogleMeet(GoogleMeetIntegration {
                api_version: "v2".to_string(),
                calendar_integration: true,
                workspace_integration: true,
                recording_support: true,
            }),
            CommunicationApp::CiscoWebex => AppIntegration::CiscoWebex(WebexIntegration {
                api_version: "v1".to_string(),
                enterprise_integration: true,
                meeting_controls: true,
                recording_support: true,
                compliance_features: true,
            }),
        }
    }

    // Private helper methods

    async fn update_network_adaptation(&mut self) -> Result<()> {
        // Simple network adaptation based on performance
        let metrics = self.performance_monitor.get_current_metrics();

        if metrics.average_latency_ms > self.constraints.max_latency_ms * 1.1 {
            self.network_adaptation.decrease_quality();
        } else if metrics.average_latency_ms < self.constraints.max_latency_ms * 0.7 {
            self.network_adaptation.increase_quality();
        }

        Ok(())
    }

    async fn apply_business_processing(
        &mut self,
        input_audio: &[f32],
        voice_profile: &str,
    ) -> Result<Vec<f32>> {
        // Professional voice enhancement
        let mut result = self.process_call_audio(input_audio, voice_profile).await?;

        // Apply business-specific enhancements (clarity, authority)
        for sample in result.iter_mut() {
            *sample = (*sample * 1.05).clamp(-1.0, 1.0);
        }

        Ok(result)
    }

    async fn apply_personal_processing(
        &mut self,
        input_audio: &[f32],
        voice_profile: &str,
    ) -> Result<Vec<f32>> {
        // Casual conversation processing
        self.process_call_audio(input_audio, voice_profile).await
    }

    async fn apply_conference_processing(
        &mut self,
        input_audio: &[f32],
        voice_profile: &str,
    ) -> Result<Vec<f32>> {
        // Conference-specific processing (clarity, presence)
        let mut result = self.process_call_audio(input_audio, voice_profile).await?;

        // Enhance presence in conference setting
        for sample in result.iter_mut() {
            *sample = (*sample * 1.1).clamp(-1.0, 1.0);
        }

        Ok(result)
    }

    async fn apply_gaming_processing(
        &mut self,
        input_audio: &[f32],
        voice_profile: &str,
    ) -> Result<Vec<f32>> {
        // Gaming-optimized processing (low latency, clear communication)
        self.process_call_audio(input_audio, voice_profile).await
    }

    async fn apply_anonymous_processing(
        &mut self,
        input_audio: &[f32],
        _voice_profile: &str,
    ) -> Result<Vec<f32>> {
        // Privacy-focused voice masking
        let mut result = input_audio.to_vec();

        // Apply simple voice masking (pitch shift)
        for (i, sample) in result.iter_mut().enumerate() {
            let phase_shift = (i as f32 * 0.1).sin() * 0.2;
            *sample = (*sample * (1.0 + phase_shift)).clamp(-1.0, 1.0);
        }

        Ok(result)
    }

    async fn apply_accessibility_processing(
        &mut self,
        input_audio: &[f32],
        voice_profile: &str,
    ) -> Result<Vec<f32>> {
        // Accessibility-enhanced processing (clarity, loudness)
        let mut result = self.process_call_audio(input_audio, voice_profile).await?;

        // Enhance for accessibility (clearer, louder)
        for sample in result.iter_mut() {
            *sample = (*sample * 1.3).clamp(-1.0, 1.0);
        }

        Ok(result)
    }

    /// Advanced Acoustic Echo Cancellation (AEC) using NLMS adaptive filtering
    /// Implements Normalized Least Mean Squares algorithm for echo removal
    fn apply_echo_cancellation(&self, audio: &[f32]) -> Result<Vec<f32>> {
        // NLMS (Normalized Least Mean Squares) Adaptive Filter for AEC
        // This removes acoustic echo from microphone input caused by speaker output

        // For very short signals, use simplified high-pass filter
        if audio.len() < 16 {
            return self.apply_simple_echo_reduction(audio);
        }

        const FILTER_LENGTH: usize = 512; // 512 taps for ~10-32ms echo path at 48kHz
        const MU: f32 = 0.5; // Learning rate (step size)
        const REGULARIZATION: f32 = 0.01; // Prevents division by zero

        let audio_len = audio.len();
        let mut output = vec![0.0; audio_len];

        // Adaptive filter coefficients (simulates echo path estimation)
        let mut weights = vec![0.0; FILTER_LENGTH];

        // Reference signal buffer (loudspeaker output - simulated here)
        // In real AEC, this would be the far-end signal (what's being played)
        let mut reference_buffer = vec![0.0; FILTER_LENGTH];

        for n in 0..audio_len {
            // Update reference buffer (circular buffer)
            reference_buffer.rotate_right(1);
            reference_buffer[0] = if n > 10 { audio[n - 10] } else { 0.0 }; // Delayed signal as ref

            // Estimate echo using current filter weights
            let mut echo_estimate = 0.0;
            for k in 0..FILTER_LENGTH {
                echo_estimate += weights[k] * reference_buffer[k];
            }

            // Error signal (desired signal - echo estimate)
            let error = audio[n] - echo_estimate;
            output[n] = error;

            // Compute power of reference signal for normalization
            let reference_power: f32 = reference_buffer.iter().map(|x| x * x).sum();
            let normalization = reference_power + REGULARIZATION;

            // Update filter weights using NLMS algorithm
            // w[n+1] = w[n] + μ * e[n] * x[n] / (x[n]^T * x[n] + δ)
            let step_size = MU * error / normalization;
            for k in 0..FILTER_LENGTH {
                weights[k] += step_size * reference_buffer[k];
            }

            // Apply soft clipping to prevent artifacts
            output[n] = output[n].clamp(-1.0, 1.0);
        }

        // Post-processing: Apply residual echo suppression
        // Uses spectral subtraction-like approach for remaining echo
        self.apply_residual_echo_suppression(&mut output)?;

        Ok(output)
    }

    /// Simple echo reduction for very short audio buffers
    /// Uses high-pass filtering to remove low-frequency echo components
    fn apply_simple_echo_reduction(&self, audio: &[f32]) -> Result<Vec<f32>> {
        let mut processed = audio.to_vec();

        // Apply simple first-order high-pass filter: y[n] = x[n] - 0.95*x[n-1]
        // This removes DC and low-frequency echo components
        for i in 1..processed.len() {
            processed[i] -= 0.95 * processed[i - 1];
        }

        // Apply soft clipping
        for sample in processed.iter_mut() {
            *sample = sample.clamp(-1.0, 1.0);
        }

        Ok(processed)
    }

    /// Residual Echo Suppression (RES) - removes remaining echo after AEC
    /// Uses envelope detection and soft suppression
    fn apply_residual_echo_suppression(&self, audio: &mut [f32]) -> Result<()> {
        const ATTACK_COEFF: f32 = 0.1; // Fast attack for echo detection
        const RELEASE_COEFF: f32 = 0.001; // Slow release to avoid choppy audio
        const SUPPRESSION_THRESHOLD: f32 = 0.05; // Threshold for residual echo
        const SUPPRESSION_FACTOR: f32 = 0.3; // How much to suppress

        let mut envelope = 0.0;

        for sample in audio.iter_mut() {
            let abs_sample = sample.abs();

            // Envelope follower (peak detector)
            if abs_sample > envelope {
                envelope = envelope * (1.0 - ATTACK_COEFF) + abs_sample * ATTACK_COEFF;
            } else {
                envelope = envelope * (1.0 - RELEASE_COEFF) + abs_sample * RELEASE_COEFF;
            }

            // Suppress signal when envelope indicates possible residual echo
            if envelope < SUPPRESSION_THRESHOLD {
                *sample *= SUPPRESSION_FACTOR;
            }
        }

        Ok(())
    }

    /// Double-talk detection - detects when both near and far-end are talking
    /// Returns confidence (0.0 = single talk, 1.0 = double talk)
    #[allow(dead_code)]
    fn detect_double_talk(&self, near_end: &[f32], far_end: &[f32]) -> f32 {
        if near_end.len() != far_end.len() {
            return 0.0;
        }

        // Compute energy of near-end and far-end signals
        let near_energy: f32 = near_end.iter().map(|x| x * x).sum();
        let far_energy: f32 = far_end.iter().map(|x| x * x).sum();

        // Compute cross-correlation
        let cross_corr: f32 = near_end
            .iter()
            .zip(far_end.iter())
            .map(|(n, f)| n * f)
            .sum();

        // Normalize correlation
        let norm_corr = if near_energy > 0.0 && far_energy > 0.0 {
            cross_corr / (near_energy.sqrt() * far_energy.sqrt())
        } else {
            0.0
        };

        // Double-talk indicator: low correlation and high near-end energy
        let double_talk_confidence = if near_energy > far_energy * 0.5 {
            (1.0 - norm_corr.abs()).max(0.0)
        } else {
            0.0
        };

        double_talk_confidence.clamp(0.0, 1.0)
    }

    fn apply_communication_noise_suppression(&self, audio: &[f32]) -> Result<Vec<f32>> {
        // Communication-optimized noise suppression
        let threshold = 0.015; // Balanced threshold for voice calls
        let mut processed = audio.to_vec();

        for sample in processed.iter_mut() {
            if sample.abs() < threshold {
                *sample *= 0.2; // Moderate suppression to preserve voice quality
            }
        }

        Ok(processed)
    }

    fn apply_communication_agc(&self, audio: &[f32]) -> Result<Vec<f32>> {
        // Communication-optimized automatic gain control
        let target_level = 0.6; // Conservative target for voice calls
        let current_level = audio.iter().map(|&x| x.abs()).sum::<f32>() / audio.len() as f32;

        if current_level > 0.0 {
            let gain = target_level / current_level;
            let clamped_gain = gain.clamp(0.5, 2.5); // Conservative range

            Ok(audio
                .iter()
                .map(|&x| (x * clamped_gain).clamp(-1.0, 1.0))
                .collect())
        } else {
            Ok(audio.to_vec())
        }
    }
}

/// Call session for tracking communication state
#[derive(Debug, Clone)]
pub struct CallSession {
    /// Unique identifier for this call session
    pub call_id: String,
    /// List of participant identifiers in the call
    pub participants: Vec<String>,
    /// Communication mode being used for this call
    pub mode: CommunicationMode,
    /// Timestamp when the call session started
    pub start_time: std::time::Instant,
    /// Communication application used for this call
    pub app: CommunicationApp,
    /// Number of audio packets processed in this session
    pub processed_packets: u64,
    /// Total accumulated latency in milliseconds
    pub total_latency_ms: f32,
    /// Number of quality issues detected during the call
    pub quality_issues: u32,
}

/// Network adaptation state for VoIP quality management
#[derive(Debug, Clone)]
pub struct NetworkAdaptationState {
    /// Current bitrate in kbps for audio transmission
    pub current_bitrate: u32,
    /// Target latency in milliseconds for optimal performance
    pub target_latency_ms: f32,
    /// History of network adaptation events
    pub adaptation_history: Vec<NetworkAdaptationEvent>,
}

impl NetworkAdaptationState {
    fn new() -> Self {
        Self {
            current_bitrate: 128,
            target_latency_ms: 100.0,
            adaptation_history: Vec::new(),
        }
    }

    fn decrease_quality(&mut self) {
        self.current_bitrate = (self.current_bitrate as f32 * 0.8) as u32;
        self.current_bitrate = self.current_bitrate.max(32); // Minimum bitrate

        self.adaptation_history.push(NetworkAdaptationEvent {
            timestamp: std::time::Instant::now(),
            direction: NetworkAdaptationDirection::Decrease,
            new_bitrate: self.current_bitrate,
        });
    }

    fn increase_quality(&mut self) {
        self.current_bitrate = (self.current_bitrate as f32 * 1.25) as u32;
        self.current_bitrate = self.current_bitrate.min(320); // Maximum bitrate

        self.adaptation_history.push(NetworkAdaptationEvent {
            timestamp: std::time::Instant::now(),
            direction: NetworkAdaptationDirection::Increase,
            new_bitrate: self.current_bitrate,
        });
    }
}

/// Event triggered when network adaptation occurs
#[derive(Debug, Clone)]
pub struct NetworkAdaptationEvent {
    /// Timestamp when the adaptation event occurred
    pub timestamp: std::time::Instant,
    /// Direction of quality adaptation (increase or decrease)
    pub direction: NetworkAdaptationDirection,
    /// New bitrate after adaptation in kbps
    pub new_bitrate: u32,
}

/// Direction of network quality adaptation
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum NetworkAdaptationDirection {
    /// Increase quality/bitrate due to improved network conditions
    Increase,
    /// Decrease quality/bitrate due to degraded network conditions
    Decrease,
}

/// Call performance monitor
#[derive(Debug)]
pub struct CallPerformanceMonitor {
    processing_times: Vec<std::time::Duration>,
    jitter_samples: Vec<f32>,
    packet_loss_samples: Vec<f32>,
    quality_issues: u32,
    last_check: std::time::Instant,
}

impl CallPerformanceMonitor {
    fn new() -> Self {
        Self {
            processing_times: Vec::new(),
            jitter_samples: Vec::new(),
            packet_loss_samples: Vec::new(),
            quality_issues: 0,
            last_check: std::time::Instant::now(),
        }
    }

    fn record_processing(
        &mut self,
        processing_time: std::time::Duration,
        _sample_count: usize,
        constraints: &CommunicationConstraints,
    ) {
        self.processing_times.push(processing_time);

        // Keep only recent samples
        if self.processing_times.len() > 100 {
            self.processing_times.drain(0..50);
        }

        // Check for quality issues
        let latency_ms = processing_time.as_secs_f32() * 1000.0;
        if latency_ms > constraints.max_latency_ms {
            self.quality_issues += 1;
        }
    }

    fn check_call_quality(&self, constraints: &CommunicationConstraints) -> bool {
        if self.processing_times.is_empty() {
            return true;
        }

        let avg_latency_ms = self
            .processing_times
            .iter()
            .map(|d| d.as_secs_f32() * 1000.0)
            .sum::<f32>()
            / self.processing_times.len() as f32;

        avg_latency_ms <= constraints.max_latency_ms
    }

    fn get_current_metrics(&self) -> CallPerformanceMetrics {
        let avg_latency_ms = if self.processing_times.is_empty() {
            0.0
        } else {
            self.processing_times
                .iter()
                .map(|d| d.as_secs_f32() * 1000.0)
                .sum::<f32>()
                / self.processing_times.len() as f32
        };

        CallPerformanceMetrics {
            average_latency_ms: avg_latency_ms,
            jitter_ms: self.jitter_samples.last().copied().unwrap_or(0.0),
            packet_loss_percent: self.packet_loss_samples.last().copied().unwrap_or(0.0),
            quality_issues: self.quality_issues,
            call_duration_seconds: self.last_check.elapsed().as_secs(),
        }
    }
}

/// Call performance metrics for quality monitoring
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CallPerformanceMetrics {
    /// Average processing latency in milliseconds
    pub average_latency_ms: f32,
    /// Network jitter measurement in milliseconds
    pub jitter_ms: f32,
    /// Packet loss percentage (0-100)
    pub packet_loss_percent: f32,
    /// Total number of quality issues encountered
    pub quality_issues: u32,
    /// Duration of the call in seconds
    pub call_duration_seconds: u64,
}

/// App-specific integration information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AppIntegration {
    /// Zoom video conferencing integration details
    Zoom(ZoomIntegration),
    /// Microsoft Teams integration details
    Teams(TeamsIntegration),
    /// Skype integration details
    Skype(SkypeIntegration),
    /// Discord voice chat integration details
    Discord(DiscordIntegration),
    /// Slack workspace integration details
    Slack(SlackIntegration),
    /// WhatsApp messaging integration details
    WhatsApp(WhatsAppIntegration),
    /// Telegram bot integration details
    Telegram(TelegramIntegration),
    /// Signal privacy-focused integration details
    Signal(SignalIntegration),
    /// Generic WebRTC integration details
    WebRTC(WebRTCIntegration),
    /// Google Meet integration details
    GoogleMeet(GoogleMeetIntegration),
    /// Cisco Webex enterprise integration details
    CiscoWebex(WebexIntegration),
}

/// Zoom video conferencing integration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ZoomIntegration {
    /// Version of Zoom SDK used for integration
    pub sdk_version: String,
    /// Whether meeting integration is enabled
    pub meeting_integration: bool,
    /// Whether recording features are supported
    pub recording_support: bool,
    /// Whether breakout room features are enabled
    pub breakout_rooms: bool,
    /// Whether webhook notifications are supported
    pub webhook_support: bool,
}

/// Microsoft Teams integration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TeamsIntegration {
    /// Version of Microsoft Graph API used
    pub graph_api_version: String,
    /// Whether tenant-level integration is enabled
    pub tenant_integration: bool,
    /// Whether Bot Framework is supported
    pub bot_framework_support: bool,
    /// Whether meeting apps are supported
    pub meeting_apps: bool,
    /// Whether compliance recording features are enabled
    pub compliance_recording: bool,
}

/// Skype voice and video calling integration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SkypeIntegration {
    /// Version of Skype API used
    pub api_version: String,
    /// Whether bot integration is enabled
    pub bot_integration: bool,
    /// Whether calling features are supported
    pub calling_support: bool,
    /// Whether messaging extensions are enabled
    pub messaging_extension: bool,
}

/// Discord voice chat and gaming integration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DiscordIntegration {
    /// Version of Discord API used
    pub api_version: String,
    /// Whether voice channel integration is enabled
    pub voice_channel_integration: bool,
    /// Whether bot integration is supported
    pub bot_integration: bool,
    /// Whether stage channel features are supported
    pub stage_channel_support: bool,
    /// Whether permission system integration is enabled
    pub permission_system: bool,
}

/// Slack team communication integration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SlackIntegration {
    /// Version of Slack API used
    pub api_version: String,
    /// Whether workspace-level integration is enabled
    pub workspace_integration: bool,
    /// Whether App Home features are supported
    pub app_home: bool,
    /// Whether slash commands are enabled
    pub slash_commands: bool,
    /// Whether interactive components are supported
    pub interactive_components: bool,
}

/// WhatsApp Business messaging integration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WhatsAppIntegration {
    /// Version of WhatsApp Business API used
    pub business_api_version: String,
    /// Whether webhook notifications are supported
    pub webhook_support: bool,
    /// Whether template messages are enabled
    pub template_messages: bool,
    /// Whether media file support is enabled
    pub media_support: bool,
}

/// Telegram bot and messaging integration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TelegramIntegration {
    /// Version of Telegram Bot API used
    pub bot_api_version: String,
    /// Whether bot integration is enabled
    pub bot_integration: bool,
    /// Whether inline queries are supported
    pub inline_queries: bool,
    /// Whether webhook notifications are enabled
    pub webhook_support: bool,
    /// Whether payment features are supported
    pub payments_support: bool,
}

/// Signal privacy-focused messaging integration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SignalIntegration {
    /// Version of Signal protocol used
    pub protocol_version: String,
    /// Whether privacy-focused features are enabled
    pub privacy_focused: bool,
    /// Whether end-to-end encryption is supported
    pub end_to_end_encryption: bool,
    /// Whether disappearing messages are supported
    pub disappearing_messages: bool,
}

/// Generic WebRTC real-time communication integration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebRTCIntegration {
    /// Version of WebRTC specification used
    pub specification_version: String,
    /// Whether peer connection API is supported
    pub peer_connection_support: bool,
    /// Whether data channel features are supported
    pub data_channel_support: bool,
    /// Whether media stream capture is supported
    pub media_stream_support: bool,
}

/// Google Meet video conferencing integration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GoogleMeetIntegration {
    /// Version of Google Meet API used
    pub api_version: String,
    /// Whether Google Calendar integration is enabled
    pub calendar_integration: bool,
    /// Whether Google Workspace integration is enabled
    pub workspace_integration: bool,
    /// Whether recording features are supported
    pub recording_support: bool,
}

/// Cisco Webex enterprise communication integration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebexIntegration {
    /// Version of Webex API used
    pub api_version: String,
    /// Whether enterprise-level integration is enabled
    pub enterprise_integration: bool,
    /// Whether meeting control features are supported
    pub meeting_controls: bool,
    /// Whether recording capabilities are supported
    pub recording_support: bool,
    /// Whether compliance and security features are enabled
    pub compliance_features: bool,
}

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

    #[test]
    fn test_communication_app_constraints() {
        let zoom_constraints = CommunicationApp::Zoom.communication_constraints();
        assert!(zoom_constraints.max_latency_ms <= 150.0);
        assert!(zoom_constraints.echo_cancellation);

        let discord_constraints = CommunicationApp::Discord.communication_constraints();
        assert!(discord_constraints.max_latency_ms <= 40.0);
        assert!(!discord_constraints.echo_cancellation); // Discord handles this
    }

    #[test]
    fn test_voip_config_creation() {
        let zoom_config = VoipConfig::zoom_optimized();
        assert_eq!(zoom_config.app, CommunicationApp::Zoom);
        assert!(zoom_config.realtime_processing);

        let discord_config = VoipConfig::discord_optimized();
        assert_eq!(discord_config.app, CommunicationApp::Discord);
        assert_eq!(discord_config.buffer_size, 256);
        assert!(!discord_config.echo_cancellation);
    }

    #[tokio::test]
    async fn test_voip_processor_creation() {
        let config = VoipConfig::zoom_optimized();
        let processor = VoipProcessor::new(CommunicationApp::Zoom, config);
        assert!(processor.is_ok());

        let processor = processor.unwrap();
        assert_eq!(processor.app, CommunicationApp::Zoom);
    }

    #[tokio::test]
    async fn test_voice_profile_registration() {
        let config = VoipConfig::teams_optimized();
        let processor = VoipProcessor::new(CommunicationApp::MicrosoftTeams, config).unwrap();

        let characteristics = VoiceCharacteristics::default();
        processor
            .register_voice_profile("professional".to_string(), characteristics)
            .await;

        let profiles = processor.voice_profiles.read().await;
        assert!(profiles.contains_key("professional"));
    }

    #[tokio::test]
    async fn test_call_session_management() {
        let config = VoipConfig::zoom_optimized();
        let processor = VoipProcessor::new(CommunicationApp::Zoom, config).unwrap();

        // Start session
        let result = processor
            .start_call_session(
                "call123".to_string(),
                vec!["user1".to_string(), "user2".to_string()],
                CommunicationMode::BusinessCall,
            )
            .await;
        assert!(result.is_ok());

        // Check session exists
        let calls = processor.active_calls.read().await;
        assert!(calls.contains_key("call123"));
    }

    #[test]
    fn test_network_adaptation() {
        let mut adaptation = NetworkAdaptationState::new();

        let initial_bitrate = adaptation.current_bitrate;
        adaptation.decrease_quality();
        assert!(adaptation.current_bitrate < initial_bitrate);

        adaptation.increase_quality();
        // Should be higher than decreased but may not equal initial due to rounding
        assert!(adaptation.current_bitrate as f64 > initial_bitrate as f64 * 0.8);
    }

    #[test]
    fn test_communication_modes() {
        let modes = [
            CommunicationMode::BusinessCall,
            CommunicationMode::PersonalCall,
            CommunicationMode::ConferenceCall,
            CommunicationMode::GamingChat,
            CommunicationMode::AnonymousCall,
            CommunicationMode::AccessibilityCall,
        ];

        for mode in &modes {
            // Test serialization
            let serialized = serde_json::to_string(mode).unwrap();
            let deserialized: CommunicationMode = serde_json::from_str(&serialized).unwrap();
            assert_eq!(*mode, deserialized);
        }
    }

    #[test]
    fn test_performance_monitor() {
        let mut monitor = CallPerformanceMonitor::new();
        let constraints = CommunicationApp::Zoom.communication_constraints();

        // Record some processing times
        monitor.record_processing(std::time::Duration::from_millis(80), 1024, &constraints);

        let metrics = monitor.get_current_metrics();
        assert!(metrics.average_latency_ms > 0.0);
        assert!(monitor.check_call_quality(&constraints));
    }

    #[test]
    fn test_app_integration_info() {
        let config = VoipConfig::discord_optimized();
        let processor = VoipProcessor::new(CommunicationApp::Discord, config).unwrap();

        let integration = processor.get_app_integration();
        match integration {
            AppIntegration::Discord(discord) => {
                assert!(discord.voice_channel_integration);
                assert!(discord.bot_integration);
            }
            _ => panic!("Expected Discord integration"),
        }
    }

    #[tokio::test]
    async fn test_communication_audio_processing() {
        let config = VoipConfig::whatsapp_optimized();
        let mut processor = VoipProcessor::new(CommunicationApp::WhatsApp, config).unwrap();

        // Register a voice profile
        let characteristics = VoiceCharacteristics::default();
        processor
            .register_voice_profile("mobile_voice".to_string(), characteristics)
            .await;

        // Process some audio
        let test_audio = vec![0.1, -0.2, 0.3, -0.4, 0.5];
        let result = processor
            .process_call_audio(&test_audio, "mobile_voice")
            .await;

        assert!(result.is_ok());
        let processed = result.unwrap();
        assert!(!processed.is_empty());
    }

    #[tokio::test]
    async fn test_echo_cancellation() {
        let config = VoipConfig::zoom_optimized();
        let processor = VoipProcessor::new(CommunicationApp::Zoom, config).unwrap();

        let audio_with_echo = vec![0.5, 0.4, 0.3, 0.2, 0.1];
        let processed = processor.apply_echo_cancellation(&audio_with_echo).unwrap();

        // Check that processing was applied
        assert_eq!(processed.len(), audio_with_echo.len());
        assert_ne!(processed, audio_with_echo);
    }

    #[tokio::test]
    async fn test_communication_noise_suppression() {
        let config = VoipConfig::teams_optimized();
        let processor = VoipProcessor::new(CommunicationApp::MicrosoftTeams, config).unwrap();

        let noisy_audio = vec![0.01, 0.5, 0.012, -0.7]; // Mix of noise and signal
        let processed = processor
            .apply_communication_noise_suppression(&noisy_audio)
            .unwrap();

        // Check that small signals are suppressed but voice quality is preserved
        assert!(processed[0].abs() < noisy_audio[0].abs());
        assert!(processed[2].abs() < noisy_audio[2].abs());

        // Large signals should be mostly preserved
        assert!((processed[1] - noisy_audio[1]).abs() < 0.1);
        assert!((processed[3] - noisy_audio[3]).abs() < 0.1);
    }

    #[tokio::test]
    async fn test_communication_agc() {
        let config = VoipConfig::slack_optimized();
        let processor = VoipProcessor::new(CommunicationApp::Slack, config).unwrap();

        let quiet_audio = vec![0.1, -0.1, 0.05, -0.05];
        let processed = processor.apply_communication_agc(&quiet_audio).unwrap();

        // Check that conservative AGC was applied
        let original_level =
            quiet_audio.iter().map(|&x| x.abs()).sum::<f32>() / quiet_audio.len() as f32;
        let processed_level =
            processed.iter().map(|&x| x.abs()).sum::<f32>() / processed.len() as f32;
        assert!(processed_level > original_level);
        assert!(processed_level < original_level * 3.0); // Conservative gain
    }
}