mullama 0.3.0

//! Format conversion utilities for audio and image processing
//!
//! This module provides comprehensive format conversion capabilities for both audio
//! and image data, enabling seamless interoperability between different formats
//! and codecs.
//!
//! ## Features
//!
//! - **Audio Format Conversion**: Support for WAV, MP3, FLAC, AAC, OGG, and more
//! - **Image Format Conversion**: Support for JPEG, PNG, WebP, TIFF, BMP, and more
//! - **Real-time Conversion**: Streaming format conversion for live data
//! - **Quality Control**: Configurable quality settings and compression
//! - **Metadata Preservation**: Maintain metadata during conversion
//! - **Batch Processing**: Convert multiple files efficiently
//! - **FFmpeg Integration**: Leverage FFmpeg for advanced conversions
//!
//! ## Example
//!
//! ```rust,no_run
//! use mullama::format_conversion::{AudioConverter, ImageConverter, ConversionConfig};
//!
//! #[tokio::main]
//! async fn main() -> Result<(), mullama::MullamaError> {
//!     // Audio conversion
//!     let audio_converter = AudioConverter::new();
//!     let wav_data = audio_converter.mp3_to_wav("input.mp3", ConversionConfig::default()).await?;
//!
//!     // Image conversion
//!     let image_converter = ImageConverter::new();
//!     let png_data = image_converter.jpeg_to_png("input.jpg", ConversionConfig::default()).await?;
//!
//!     Ok(())
//! }
//! ```

mod audio;
mod image;

use std::{collections::HashMap, time::Duration};

use serde::{Deserialize, Serialize};

use crate::MullamaError;

// Re-export audio types
pub use audio::{AudioConverter, AudioConverterConfig};

// Re-export image types
pub use self::image::{ImageConverter, ImageConverterConfig};

/// Conversion configuration for specific operations
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConversionConfig {
    /// Output quality/compression
    pub quality: Option<f32>,
    /// Target sample rate for audio
    pub sample_rate: Option<u32>,
    /// Target number of channels for audio
    pub channels: Option<u16>,
    /// Target dimensions for images
    pub dimensions: Option<(u32, u32)>,
    /// Preserve metadata
    pub preserve_metadata: bool,
    /// Additional format-specific options
    pub options: HashMap<String, String>,
}

/// Supported audio formats
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum AudioFormatType {
    Wav,
    Mp3,
    Flac,
    Aac,
    Ogg,
    M4a,
    Wma,
    Pcm,
}

/// Supported image formats
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ImageFormatType {
    Jpeg,
    Png,
    WebP,
    Tiff,
    Bmp,
    Gif,
    Ico,
    Avif,
}

/// Audio conversion result
#[derive(Debug, Clone)]
pub struct AudioConversionResult {
    pub data: Vec<u8>,
    pub format: AudioFormatType,
    pub sample_rate: u32,
    pub channels: u16,
    pub duration: Duration,
    pub metadata: HashMap<String, String>,
}

/// Image conversion result
#[derive(Debug, Clone)]
pub struct ImageConversionResult {
    pub data: Vec<u8>,
    pub format: ImageFormatType,
    pub width: u32,
    pub height: u32,
    pub metadata: HashMap<String, String>,
}

/// Real-time format converter for streaming data
#[cfg(feature = "format-conversion")]
pub struct StreamingConverter {
    #[allow(dead_code)]
    audio_converter: AudioConverter,
    #[allow(dead_code)]
    image_converter: ImageConverter,
    buffer_size: usize,
}

impl Default for ConversionConfig {
    fn default() -> Self {
        Self {
            quality: None,
            sample_rate: None,
            channels: None,
            dimensions: None,
            preserve_metadata: true,
            options: HashMap::new(),
        }
    }
}

/// Streaming converter implementation
#[cfg(feature = "format-conversion")]
impl StreamingConverter {
    pub fn new(buffer_size: usize) -> Self {
        Self {
            audio_converter: AudioConverter::new(),
            image_converter: ImageConverter::new(),
            buffer_size,
        }
    }

    /// Convert audio stream in real-time
    pub async fn convert_audio_stream<S>(
        &self,
        mut input_stream: S,
        input_format: AudioFormatType,
        output_format: AudioFormatType,
        config: ConversionConfig,
    ) -> Result<Vec<u8>, MullamaError>
    where
        S: futures::Stream<Item = Vec<u8>> + Unpin,
    {
        use futures::StreamExt;

        let mut output_buffer = Vec::new();
        let mut chunk_buffer = Vec::new();

        while let Some(chunk) = input_stream.next().await {
            chunk_buffer.extend_from_slice(&chunk);

            // Process complete frames based on buffer size
            if chunk_buffer.len() >= self.buffer_size {
                let mut frame_data = chunk_buffer.split_off(self.buffer_size);
                std::mem::swap(&mut chunk_buffer, &mut frame_data);

                // Convert this frame
                let converted_frame = self
                    .convert_audio_frame(&frame_data, input_format, output_format, &config)
                    .await?;
                output_buffer.extend_from_slice(&converted_frame);

                chunk_buffer.clear();
            }
        }

        // Process remaining data
        if !chunk_buffer.is_empty() {
            let converted_frame = self
                .convert_audio_frame(&chunk_buffer, input_format, output_format, &config)
                .await?;
            output_buffer.extend_from_slice(&converted_frame);
        }

        Ok(output_buffer)
    }

    /// Convert a single audio frame
    async fn convert_audio_frame(
        &self,
        frame_data: &[u8],
        input_format: AudioFormatType,
        output_format: AudioFormatType,
        _config: &ConversionConfig,
    ) -> Result<Vec<u8>, MullamaError> {
        // For this demo, we'll simulate format conversion
        // In a real implementation, this would use appropriate codecs
        match (input_format, output_format) {
            (AudioFormatType::Wav, AudioFormatType::Mp3) => {
                // Simulate WAV to MP3 conversion with compression
                Ok(frame_data
                    .iter()
                    .take(frame_data.len() / 2)
                    .cloned()
                    .collect())
            }
            (AudioFormatType::Mp3, AudioFormatType::Wav) => {
                // Simulate MP3 to WAV decompression
                let mut expanded = Vec::with_capacity(frame_data.len() * 2);
                for &byte in frame_data {
                    expanded.push(byte);
                    expanded.push(0); // Add padding for demonstration
                }
                Ok(expanded)
            }
            (AudioFormatType::Flac, AudioFormatType::Wav) => {
                // Simulate FLAC decompression
                Ok(frame_data.to_vec())
            }
            _ => {
                // For other conversions, return as-is for demo
                Ok(frame_data.to_vec())
            }
        }
    }
}

#[cfg(not(feature = "format-conversion"))]
compile_error!("Format conversion requires the 'format-conversion' feature to be enabled");