voirs-sdk 0.1.0-rc.1

//! Format plugins for audio encoding, streaming, and protocol support
//!
//! This module provides various format plugins for handling different audio
//! formats, codec integration, streaming protocols, and network formats.

use crate::{audio::AudioBuffer, error::Result, plugins::VoirsPlugin, VoirsError};
use async_trait::async_trait;
use parking_lot::RwLock;
use std::collections::HashMap;

/// Trait for format plugins that handle audio encoding/decoding
#[async_trait]
pub trait FormatPlugin: VoirsPlugin {
    /// Encode audio buffer to format-specific data
    async fn encode(&self, audio: &AudioBuffer) -> Result<Vec<u8>>;

    /// Decode format-specific data to audio buffer
    async fn decode(&self, data: &[u8]) -> Result<AudioBuffer>;

    /// Get format-specific metadata
    fn get_metadata(&self) -> HashMap<String, String>;

    /// Validate format-specific data
    fn validate_data(&self, data: &[u8]) -> bool;
}

/// Custom VoiRS audio format plugin
pub struct VoirsFormat {
    /// Compression level (0-9)
    pub compression_level: RwLock<u32>,

    /// Include metadata in format
    pub include_metadata: RwLock<bool>,

    /// Error correction level
    pub error_correction: RwLock<f32>,

    /// Format version
    pub format_version: RwLock<u32>,
}

impl VoirsFormat {
    pub fn new() -> Self {
        Self {
            compression_level: RwLock::new(5),
            include_metadata: RwLock::new(true),
            error_correction: RwLock::new(0.1),
            format_version: RwLock::new(1),
        }
    }

    /// Simple custom format: [header][metadata][compressed_audio]
    fn create_voirs_format(&self, audio: &AudioBuffer) -> Vec<u8> {
        let mut data = Vec::new();

        // Header: "VOIRS" + version + sample_rate + channels + length
        data.extend_from_slice(b"VOIRS");
        data.extend_from_slice(&(*self.format_version.read()).to_le_bytes());
        data.extend_from_slice(&audio.sample_rate().to_le_bytes());
        data.extend_from_slice(&audio.channels().to_le_bytes());
        data.extend_from_slice(&(audio.samples().len() as u32).to_le_bytes());

        // Metadata section
        if *self.include_metadata.read() {
            let metadata = format!("VoiRS Audio Format v{}", *self.format_version.read());
            let metadata_bytes = metadata.as_bytes();
            data.extend_from_slice(&(metadata_bytes.len() as u32).to_le_bytes());
            data.extend_from_slice(metadata_bytes);
        } else {
            data.extend_from_slice(&0u32.to_le_bytes()); // No metadata
        }

        // Simple compression: quantize based on compression level
        let compression = *self.compression_level.read() as f32 / 9.0;
        let quantization_factor = 1.0 + compression * 15.0; // 1x to 16x quantization

        for &sample in audio.samples() {
            let quantized = (sample * quantization_factor).round() / quantization_factor;
            let quantized_bytes = quantized.to_le_bytes();
            data.extend_from_slice(&quantized_bytes);
        }

        data
    }

    /// Parse VoiRS format data
    fn parse_voirs_format(&self, data: &[u8]) -> Result<AudioBuffer> {
        if data.len() < 25 {
            // Minimum header size
            return Err(VoirsError::internal(
                "format",
                "Invalid VoiRS format: too small",
            ));
        }

        let mut offset = 0;

        // Check header
        if &data[0..5] != b"VOIRS" {
            return Err(VoirsError::internal(
                "format",
                "Invalid VoiRS format: bad header",
            ));
        }
        offset += 5;

        // Read format info
        let _version = u32::from_le_bytes([
            data[offset],
            data[offset + 1],
            data[offset + 2],
            data[offset + 3],
        ]);
        offset += 4;
        let sample_rate = u32::from_le_bytes([
            data[offset],
            data[offset + 1],
            data[offset + 2],
            data[offset + 3],
        ]);
        offset += 4;
        let channels = u32::from_le_bytes([
            data[offset],
            data[offset + 1],
            data[offset + 2],
            data[offset + 3],
        ]);
        offset += 4;
        let sample_count = u32::from_le_bytes([
            data[offset],
            data[offset + 1],
            data[offset + 2],
            data[offset + 3],
        ]);
        offset += 4;

        // Skip metadata
        let metadata_len = u32::from_le_bytes([
            data[offset],
            data[offset + 1],
            data[offset + 2],
            data[offset + 3],
        ]);
        offset += 4 + metadata_len as usize;

        // Read samples
        let mut samples = Vec::with_capacity(sample_count as usize);
        for _ in 0..sample_count {
            if offset + 4 > data.len() {
                return Err(VoirsError::internal(
                    "format",
                    "Invalid VoiRS format: truncated",
                ));
            }
            let sample = f32::from_le_bytes([
                data[offset],
                data[offset + 1],
                data[offset + 2],
                data[offset + 3],
            ]);
            samples.push(sample);
            offset += 4;
        }

        Ok(AudioBuffer::new(samples, sample_rate, channels))
    }
}

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

impl VoirsPlugin for VoirsFormat {
    fn name(&self) -> &str {
        "VoiRS Format"
    }

    fn version(&self) -> &str {
        "1.0.0"
    }

    fn description(&self) -> &str {
        "Custom VoiRS audio format with compression and metadata"
    }

    fn author(&self) -> &str {
        "VoiRS Team"
    }

    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
}

#[async_trait]
impl FormatPlugin for VoirsFormat {
    async fn encode(&self, audio: &AudioBuffer) -> Result<Vec<u8>> {
        Ok(self.create_voirs_format(audio))
    }

    async fn decode(&self, data: &[u8]) -> Result<AudioBuffer> {
        self.parse_voirs_format(data)
    }

    fn get_metadata(&self) -> HashMap<String, String> {
        let mut metadata = HashMap::new();
        metadata.insert("format".to_string(), "VoiRS".to_string());
        metadata.insert(
            "version".to_string(),
            self.format_version.read().to_string(),
        );
        metadata.insert(
            "compression".to_string(),
            self.compression_level.read().to_string(),
        );
        metadata
    }

    fn validate_data(&self, data: &[u8]) -> bool {
        data.len() >= 25 && &data[0..5] == b"VOIRS"
    }
}

/// Codec integration plugin for standard formats
pub struct CodecIntegration {
    /// Target codec type
    pub codec_type: RwLock<String>,

    /// Bitrate for lossy codecs (kbps)
    pub bitrate: RwLock<u32>,

    /// Quality setting (0.0 - 1.0)
    pub quality: RwLock<f32>,

    /// Variable bitrate mode
    pub variable_bitrate: RwLock<bool>,
}

impl CodecIntegration {
    pub fn new() -> Self {
        Self {
            codec_type: RwLock::new("PCM".to_string()),
            bitrate: RwLock::new(128),
            quality: RwLock::new(0.8),
            variable_bitrate: RwLock::new(false),
        }
    }

    /// Simulate codec encoding
    fn encode_with_codec(&self, audio: &AudioBuffer) -> Vec<u8> {
        let codec = self.codec_type.read().clone();
        let quality = *self.quality.read();

        match codec.as_str() {
            "PCM" => {
                // Uncompressed PCM
                let mut data = Vec::new();
                for &sample in audio.samples() {
                    data.extend_from_slice(&sample.to_le_bytes());
                }
                data
            }
            "MP3" => {
                // Simulate MP3 compression
                let compression_ratio = 1.0 - quality * 0.8; // Higher quality = less compression
                let mut data = Vec::new();
                data.extend_from_slice(b"MP3_SIM");
                for &sample in audio.samples() {
                    let compressed = sample * compression_ratio;
                    data.extend_from_slice(&compressed.to_le_bytes());
                }
                data
            }
            "OGG" => {
                // Simulate OGG Vorbis compression
                let compression_ratio = 1.0 - quality * 0.7;
                let mut data = Vec::new();
                data.extend_from_slice(b"OGG_SIM");
                for &sample in audio.samples() {
                    let compressed = sample * compression_ratio;
                    data.extend_from_slice(&compressed.to_le_bytes());
                }
                data
            }
            _ => {
                // Default to PCM
                let mut data = Vec::new();
                for &sample in audio.samples() {
                    data.extend_from_slice(&sample.to_le_bytes());
                }
                data
            }
        }
    }

    /// Simulate codec decoding
    fn decode_with_codec(&self, data: &[u8]) -> Result<AudioBuffer> {
        // Detect format
        if data.len() < 8 {
            return Err(VoirsError::internal("codec", "Invalid codec data"));
        }

        let (_header, audio_data) = if data.starts_with(b"MP3_SIM") || data.starts_with(b"OGG_SIM")
        {
            (7, &data[7..])
        } else {
            (0, data) // PCM
        };

        // Decode samples
        let mut samples = Vec::new();
        for chunk in audio_data.chunks_exact(4) {
            let sample = f32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]);
            samples.push(sample);
        }

        Ok(AudioBuffer::new(samples, 44100, 1)) // Default format
    }
}

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

impl VoirsPlugin for CodecIntegration {
    fn name(&self) -> &str {
        "Codec Integration"
    }

    fn version(&self) -> &str {
        "1.0.0"
    }

    fn description(&self) -> &str {
        "Integration with standard audio codecs (MP3, OGG, FLAC, etc.)"
    }

    fn author(&self) -> &str {
        "VoiRS Team"
    }

    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
}

#[async_trait]
impl FormatPlugin for CodecIntegration {
    async fn encode(&self, audio: &AudioBuffer) -> Result<Vec<u8>> {
        Ok(self.encode_with_codec(audio))
    }

    async fn decode(&self, data: &[u8]) -> Result<AudioBuffer> {
        self.decode_with_codec(data)
    }

    fn get_metadata(&self) -> HashMap<String, String> {
        let mut metadata = HashMap::new();
        metadata.insert("codec".to_string(), self.codec_type.read().clone());
        metadata.insert("bitrate".to_string(), self.bitrate.read().to_string());
        metadata.insert("quality".to_string(), self.quality.read().to_string());
        metadata
    }

    fn validate_data(&self, data: &[u8]) -> bool {
        data.len() >= 4
            && (data.len().is_multiple_of(4)
                || data.starts_with(b"MP3_SIM")
                || data.starts_with(b"OGG_SIM"))
    }
}

/// Streaming protocol plugin for real-time audio streaming
pub struct StreamingProtocol {
    /// Protocol type (RTP, WebRTC, etc.)
    pub protocol_type: RwLock<String>,

    /// Buffer size for streaming
    pub buffer_size: RwLock<u32>,

    /// Latency target in milliseconds
    pub target_latency: RwLock<u32>,

    /// Adaptive bitrate enabled
    pub adaptive_bitrate: RwLock<bool>,

    /// Packet loss compensation
    pub loss_compensation: RwLock<f32>,
}

impl StreamingProtocol {
    pub fn new() -> Self {
        Self {
            protocol_type: RwLock::new("RTP".to_string()),
            buffer_size: RwLock::new(1024),
            target_latency: RwLock::new(50),
            adaptive_bitrate: RwLock::new(true),
            loss_compensation: RwLock::new(0.1),
        }
    }

    /// Create streaming packets
    #[allow(dead_code)]
    fn create_stream_packets(&self, audio: &AudioBuffer) -> Vec<Vec<u8>> {
        let buffer_size = *self.buffer_size.read() as usize;
        let protocol = self.protocol_type.read().clone();
        let mut packets = Vec::new();

        for chunk in audio.samples().chunks(buffer_size) {
            let mut packet = Vec::new();

            // Add protocol header
            match protocol.as_str() {
                "RTP" => {
                    packet.extend_from_slice(b"RTP");
                    packet.extend_from_slice(&(chunk.len() as u32).to_le_bytes());
                }
                "WebRTC" => {
                    packet.extend_from_slice(b"WEBRTC");
                    packet.extend_from_slice(&(chunk.len() as u32).to_le_bytes());
                }
                _ => {
                    packet.extend_from_slice(b"STREAM");
                    packet.extend_from_slice(&(chunk.len() as u32).to_le_bytes());
                }
            }

            // Add audio data
            for &sample in chunk {
                packet.extend_from_slice(&sample.to_le_bytes());
            }

            packets.push(packet);
        }

        packets
    }

    /// Reconstruct audio from stream packets
    #[allow(dead_code)]
    fn reconstruct_from_packets(&self, packets: &[Vec<u8>]) -> Result<AudioBuffer> {
        let mut samples = Vec::new();

        for packet in packets {
            if packet.len() < 7 {
                continue; // Skip invalid packets
            }

            let (header_size, data_start) = if packet.starts_with(b"RTP") {
                (7, 7)
            } else if packet.starts_with(b"WEBRTC") || packet.starts_with(b"STREAM") {
                (10, 10)
            } else {
                continue; // Unknown packet format
            };

            let sample_count = u32::from_le_bytes([
                packet[header_size - 4],
                packet[header_size - 3],
                packet[header_size - 2],
                packet[header_size - 1],
            ]) as usize;

            for i in 0..sample_count {
                let offset = data_start + i * 4;
                if offset + 4 <= packet.len() {
                    let sample = f32::from_le_bytes([
                        packet[offset],
                        packet[offset + 1],
                        packet[offset + 2],
                        packet[offset + 3],
                    ]);
                    samples.push(sample);
                }
            }
        }

        Ok(AudioBuffer::new(samples, 44100, 1))
    }
}

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

impl VoirsPlugin for StreamingProtocol {
    fn name(&self) -> &str {
        "Streaming Protocol"
    }

    fn version(&self) -> &str {
        "1.0.0"
    }

    fn description(&self) -> &str {
        "Real-time audio streaming with RTP, WebRTC, and custom protocols"
    }

    fn author(&self) -> &str {
        "VoiRS Team"
    }

    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
}

/// Network format plugin for distributed audio processing
pub struct NetworkFormat {
    /// Network compression enabled
    pub compression_enabled: RwLock<bool>,

    /// Encryption level (0-3)
    pub encryption_level: RwLock<u32>,

    /// Checksum verification
    pub checksum_enabled: RwLock<bool>,

    /// Fragment size for large transfers
    pub fragment_size: RwLock<u32>,
}

impl NetworkFormat {
    pub fn new() -> Self {
        Self {
            compression_enabled: RwLock::new(true),
            encryption_level: RwLock::new(1),
            checksum_enabled: RwLock::new(true),
            fragment_size: RwLock::new(8192),
        }
    }

    /// Create network-optimized format
    fn create_network_format(&self, audio: &AudioBuffer) -> Vec<u8> {
        let mut data = Vec::new();

        // Network header
        data.extend_from_slice(b"VOINET");
        data.extend_from_slice(&audio.sample_rate().to_le_bytes());
        data.extend_from_slice(&audio.channels().to_le_bytes());

        // Flags
        let mut flags = 0u8;
        if *self.compression_enabled.read() {
            flags |= 0x01;
        }
        if *self.checksum_enabled.read() {
            flags |= 0x02;
        }
        flags |= (*self.encryption_level.read() as u8) << 2;
        data.push(flags);

        // Audio data with optional compression
        let audio_data: Vec<u8> = if *self.compression_enabled.read() {
            // Simple compression: delta encoding
            let mut compressed = Vec::new();
            let mut prev_sample = 0.0f32;
            for &sample in audio.samples() {
                let delta = sample - prev_sample;
                compressed.extend_from_slice(&delta.to_le_bytes());
                prev_sample = sample;
            }
            compressed
        } else {
            // Uncompressed
            let mut uncompressed = Vec::new();
            for &sample in audio.samples() {
                uncompressed.extend_from_slice(&sample.to_le_bytes());
            }
            uncompressed
        };

        // Add data size
        data.extend_from_slice(&(audio_data.len() as u32).to_le_bytes());

        // Add audio data
        data.extend_from_slice(&audio_data);

        // Add checksum if enabled
        if *self.checksum_enabled.read() {
            let checksum = audio_data
                .iter()
                .fold(0u32, |acc, &b| acc.wrapping_add(b as u32));
            data.extend_from_slice(&checksum.to_le_bytes());
        }

        data
    }

    /// Parse network format
    fn parse_network_format(&self, data: &[u8]) -> Result<AudioBuffer> {
        if data.len() < 15 {
            return Err(VoirsError::internal("network", "Invalid network format"));
        }

        if &data[0..6] != b"VOINET" {
            return Err(VoirsError::internal(
                "network",
                "Invalid network format header",
            ));
        }

        let mut offset = 6;
        let sample_rate = u32::from_le_bytes([
            data[offset],
            data[offset + 1],
            data[offset + 2],
            data[offset + 3],
        ]);
        offset += 4;
        let channels = u32::from_le_bytes([
            data[offset],
            data[offset + 1],
            data[offset + 2],
            data[offset + 3],
        ]);
        offset += 4;

        let flags = data[offset];
        offset += 1;
        let compression_enabled = (flags & 0x01) != 0;
        let checksum_enabled = (flags & 0x02) != 0;

        let data_size = u32::from_le_bytes([
            data[offset],
            data[offset + 1],
            data[offset + 2],
            data[offset + 3],
        ]);
        offset += 4;

        if offset + data_size as usize > data.len() {
            return Err(VoirsError::internal("network", "Truncated network format"));
        }

        let audio_data = &data[offset..offset + data_size as usize];
        offset += data_size as usize;

        // Verify checksum if enabled
        if checksum_enabled {
            if offset + 4 > data.len() {
                return Err(VoirsError::internal("network", "Missing checksum"));
            }
            let expected_checksum = u32::from_le_bytes([
                data[offset],
                data[offset + 1],
                data[offset + 2],
                data[offset + 3],
            ]);
            let actual_checksum = audio_data
                .iter()
                .fold(0u32, |acc, &b| acc.wrapping_add(b as u32));
            if expected_checksum != actual_checksum {
                return Err(VoirsError::internal("network", "Checksum mismatch"));
            }
        }

        // Decode audio data
        let samples = if compression_enabled {
            // Delta decoding
            let mut samples = Vec::new();
            let mut current_sample = 0.0f32;
            for chunk in audio_data.chunks_exact(4) {
                let delta = f32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]);
                current_sample += delta;
                samples.push(current_sample);
            }
            samples
        } else {
            // Direct decoding
            let mut samples = Vec::new();
            for chunk in audio_data.chunks_exact(4) {
                let sample = f32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]);
                samples.push(sample);
            }
            samples
        };

        Ok(AudioBuffer::new(samples, sample_rate, channels))
    }
}

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

impl VoirsPlugin for NetworkFormat {
    fn name(&self) -> &str {
        "Network Format"
    }

    fn version(&self) -> &str {
        "1.0.0"
    }

    fn description(&self) -> &str {
        "Network-optimized format with compression and error checking"
    }

    fn author(&self) -> &str {
        "VoiRS Team"
    }

    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
}

#[async_trait]
impl FormatPlugin for NetworkFormat {
    async fn encode(&self, audio: &AudioBuffer) -> Result<Vec<u8>> {
        Ok(self.create_network_format(audio))
    }

    async fn decode(&self, data: &[u8]) -> Result<AudioBuffer> {
        self.parse_network_format(data)
    }

    fn get_metadata(&self) -> HashMap<String, String> {
        let mut metadata = HashMap::new();
        metadata.insert(
            "compression".to_string(),
            self.compression_enabled.read().to_string(),
        );
        metadata.insert(
            "encryption".to_string(),
            self.encryption_level.read().to_string(),
        );
        metadata.insert(
            "checksum".to_string(),
            self.checksum_enabled.read().to_string(),
        );
        metadata
    }

    fn validate_data(&self, data: &[u8]) -> bool {
        data.len() >= 15 && &data[0..6] == b"VOINET"
    }
}

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

    #[tokio::test]
    async fn test_voirs_format() {
        let format = VoirsFormat::new();
        let audio = crate::AudioBuffer::sine_wave(440.0, 0.5, 44100, 0.5);

        // Test encoding
        let encoded = format.encode(&audio).await.unwrap();
        assert!(!encoded.is_empty());
        assert!(format.validate_data(&encoded));

        // Test decoding
        let decoded = format.decode(&encoded).await.unwrap();
        assert_eq!(decoded.sample_rate(), audio.sample_rate());
        assert_eq!(decoded.channels(), audio.channels());
    }

    #[tokio::test]
    async fn test_codec_integration() {
        let codec = CodecIntegration::new();
        let audio = crate::AudioBuffer::sine_wave(1000.0, 0.3, 22050, 0.7);

        // Test PCM encoding/decoding
        let encoded = codec.encode(&audio).await.unwrap();
        let decoded = codec.decode(&encoded).await.unwrap();
        assert_eq!(decoded.len(), audio.len());

        // Test metadata
        let metadata = codec.get_metadata();
        assert!(metadata.contains_key("codec"));
    }

    #[tokio::test]
    async fn test_streaming_protocol() {
        let stream = StreamingProtocol::new();
        let audio = crate::AudioBuffer::sine_wave(440.0, 0.1, 44100, 0.5);

        // Test packet creation
        let packets = stream.create_stream_packets(&audio);
        assert!(!packets.is_empty());

        // Test reconstruction
        let reconstructed = stream.reconstruct_from_packets(&packets).unwrap();
        assert!(!reconstructed.is_empty());
    }

    #[tokio::test]
    async fn test_network_format() {
        let network = NetworkFormat::new();
        let audio = crate::AudioBuffer::sine_wave(440.0, 0.2, 48000, 0.8);

        // Test encoding
        let encoded = network.encode(&audio).await.unwrap();
        assert!(!encoded.is_empty());
        assert!(network.validate_data(&encoded));

        // Test decoding
        let decoded = network.decode(&encoded).await.unwrap();
        assert_eq!(decoded.sample_rate(), audio.sample_rate());
        assert_eq!(decoded.channels(), audio.channels());

        // Test metadata
        let metadata = network.get_metadata();
        assert!(metadata.contains_key("compression"));
        assert!(metadata.contains_key("checksum"));
    }

    #[test]
    fn test_format_plugin_metadata() {
        let voirs_format = VoirsFormat::new();
        assert_eq!(voirs_format.name(), "VoiRS Format");
        assert_eq!(voirs_format.version(), "1.0.0");
        assert_eq!(voirs_format.author(), "VoiRS Team");

        let codec = CodecIntegration::new();
        assert_eq!(codec.name(), "Codec Integration");

        let network = NetworkFormat::new();
        assert_eq!(network.name(), "Network Format");
    }
}