saorsa_core/messaging/

media.rs

// Media processing for rich messaging
// Handles images, videos, voice messages, and file attachments

use super::types::*;
use anyhow::Result;
use blake3::Hasher;
use serde::{Deserialize, Serialize};

/// Media processor for handling attachments
pub struct MediaProcessor {
    /// Maximum file size in bytes (100MB)
    max_file_size: u64,
    /// Supported image formats
    _image_formats: Vec<String>,
    /// Supported video formats
    _video_formats: Vec<String>,
    /// Supported audio formats
    _audio_formats: Vec<String>,
}

impl MediaProcessor {
    /// Create a new media processor
    pub fn new() -> Result<Self> {
        Ok(Self {
            max_file_size: 100 * 1024 * 1024, // 100MB
            _image_formats: ["jpg", "jpeg", "png", "gif", "webp", "avif", "svg"]
                .iter()
                .map(|s| s.to_string())
                .collect(),
            _video_formats: ["mp4", "webm", "mov", "avi", "mkv"]
                .iter()
                .map(|s| s.to_string())
                .collect(),
            _audio_formats: ["mp3", "m4a", "ogg", "wav", "aac", "opus"]
                .iter()
                .map(|s| s.to_string())
                .collect(),
        })
    }

    /// Process a raw attachment
    pub async fn process_attachment(&self, data: Vec<u8>) -> Result<Attachment> {
        // Check size
        if data.len() as u64 > self.max_file_size {
            return Err(anyhow::anyhow!("File too large: {} bytes", data.len()));
        }

        // Detect MIME type
        let mime_type = self.detect_mime_type(&data);

        // Generate hash for DHT storage
        let dht_hash = self.generate_hash(&data);

        // Generate thumbnail if image/video
        let thumbnail = if self.is_image(&mime_type) || self.is_video(&mime_type) {
            Some(self.generate_thumbnail(&data, &mime_type).await?)
        } else {
            None
        };

        // Create attachment
        Ok(Attachment {
            id: uuid::Uuid::new_v4().to_string(),
            filename: format!("attachment_{}", chrono::Utc::now().timestamp()),
            mime_type,
            size_bytes: data.len() as u64,
            thumbnail,
            dht_hash,
            encryption_key: None, // Will be set by encryption service
            metadata: std::collections::HashMap::new(),
        })
    }

    /// Process an image
    pub async fn process_image(&self, data: Vec<u8>) -> Result<ProcessedImage> {
        let mime_type = self.detect_mime_type(&data);

        if !self.is_image(&mime_type) {
            return Err(anyhow::anyhow!("Not an image file"));
        }

        // Generate multiple sizes for responsive display
        let thumbnail = self.resize_image(&data, 150, 150).await?;
        let preview = self.resize_image(&data, 500, 500).await?;
        let blurhash = self.generate_blurhash(&data).await?;

        Ok(ProcessedImage {
            original: data.clone(),
            thumbnail,
            preview,
            blurhash,
            width: 0, // Would be extracted from image metadata
            height: 0,
            mime_type,
        })
    }

    /// Process a video
    pub async fn process_video(&self, data: Vec<u8>) -> Result<ProcessedVideo> {
        let mime_type = self.detect_mime_type(&data);

        if !self.is_video(&mime_type) {
            return Err(anyhow::anyhow!("Not a video file"));
        }

        // Extract video metadata
        let duration = self.get_video_duration(&data).await?;
        let thumbnail = self.extract_video_frame(&data, 0.0).await?;

        Ok(ProcessedVideo {
            data,
            thumbnail,
            duration_seconds: duration,
            width: 0, // Would be extracted from video metadata
            height: 0,
            mime_type,
            streaming_url: None,
        })
    }

    /// Process a voice message
    pub async fn process_voice_message(&self, data: Vec<u8>) -> Result<VoiceMessage> {
        // Generate waveform for visualization
        let waveform = self.generate_waveform(&data).await?;

        // Optionally transcribe using speech-to-text
        let transcription = self.transcribe_audio(&data).await.ok();

        Ok(VoiceMessage {
            duration_seconds: self.get_audio_duration(&data).await?,
            waveform,
            transcription,
            mime_type: "audio/opus".to_string(),
            data,
        })
    }

    /// Compress media if needed
    pub async fn compress_if_needed(&self, data: Vec<u8>, mime_type: &str) -> Result<Vec<u8>> {
        let size = data.len() as u64;

        // Compress large images
        if self.is_image(mime_type) && size > 5 * 1024 * 1024 {
            return self.compress_image(data, 85).await;
        }

        // Compress large videos
        if self.is_video(mime_type) && size > 20 * 1024 * 1024 {
            return self.compress_video(data).await;
        }

        Ok(data)
    }

    /// Stream large files in chunks
    pub async fn create_stream(&self, data: Vec<u8>) -> MediaStream {
        let chunk_size = 1024 * 1024; // 1MB chunks
        let chunks = data
            .chunks(chunk_size)
            .map(|chunk| chunk.to_vec())
            .collect();

        MediaStream {
            chunks,
            total_size: data.len() as u64,
            chunk_size: chunk_size as u32,
            mime_type: self.detect_mime_type(&data),
        }
    }

    /// Validate media file
    pub fn validate_media(&self, data: &[u8], expected_type: &MediaType) -> Result<()> {
        let mime_type = self.detect_mime_type(data);

        match expected_type {
            MediaType::Image if !self.is_image(&mime_type) => {
                Err(anyhow::anyhow!("Expected image, got {}", mime_type))
            }
            MediaType::Video if !self.is_video(&mime_type) => {
                Err(anyhow::anyhow!("Expected video, got {}", mime_type))
            }
            MediaType::Audio if !self.is_audio(&mime_type) => {
                Err(anyhow::anyhow!("Expected audio, got {}", mime_type))
            }
            _ => Ok(()),
        }
    }

    // Helper methods

    fn detect_mime_type(&self, data: &[u8]) -> String {
        // Simple magic byte detection
        if data.starts_with(b"\xFF\xD8\xFF") {
            "image/jpeg".to_string()
        } else if data.starts_with(b"\x89PNG") {
            "image/png".to_string()
        } else if data.starts_with(b"GIF8") {
            "image/gif".to_string()
        } else if data.starts_with(b"RIFF") && data[8..12] == *b"WEBP" {
            "image/webp".to_string()
        } else if data.len() > 12 && &data[4..12] == b"ftypavif" {
            "image/avif".to_string()
        } else if data.len() > 8 && &data[4..8] == b"ftyp" {
            "video/mp4".to_string()
        } else {
            "application/octet-stream".to_string()
        }
    }

    fn is_image(&self, mime_type: &str) -> bool {
        mime_type.starts_with("image/")
    }

    fn is_video(&self, mime_type: &str) -> bool {
        mime_type.starts_with("video/")
    }

    fn is_audio(&self, mime_type: &str) -> bool {
        mime_type.starts_with("audio/")
    }

    fn generate_hash(&self, data: &[u8]) -> String {
        let mut hasher = Hasher::new();
        hasher.update(data);
        hasher.finalize().to_hex().to_string()
    }

    async fn generate_thumbnail(&self, _data: &[u8], _mime_type: &str) -> Result<Vec<u8>> {
        // In production, use image processing library
        // For now, return a placeholder
        Ok(vec![0; 100])
    }

    async fn resize_image(&self, data: &[u8], _width: u32, _height: u32) -> Result<Vec<u8>> {
        // In production, use image crate for resizing
        Ok(data.to_vec())
    }

    async fn generate_blurhash(&self, _data: &[u8]) -> Result<String> {
        // In production, use blurhash crate
        Ok("LEHV6nWB2yk8pyo0adR*.7kCMdnj".to_string())
    }

    async fn get_video_duration(&self, _data: &[u8]) -> Result<u32> {
        // In production, use ffmpeg or similar
        Ok(60) // Mock 60 seconds
    }

    async fn extract_video_frame(&self, _data: &[u8], _timestamp: f32) -> Result<Vec<u8>> {
        // In production, use ffmpeg to extract frame
        Ok(vec![0; 1000])
    }

    async fn generate_waveform(&self, _data: &[u8]) -> Result<Vec<u8>> {
        // In production, analyze audio and generate waveform
        Ok(vec![50; 100]) // Mock waveform data
    }

    async fn transcribe_audio(&self, _data: &[u8]) -> Result<String> {
        // In production, use speech-to-text service
        Ok("Mock transcription".to_string())
    }

    async fn get_audio_duration(&self, _data: &[u8]) -> Result<u32> {
        // In production, parse audio metadata
        Ok(30) // Mock 30 seconds
    }

    async fn compress_image(&self, data: Vec<u8>, _quality: u8) -> Result<Vec<u8>> {
        // In production, use image compression
        Ok(data)
    }

    async fn compress_video(&self, data: Vec<u8>) -> Result<Vec<u8>> {
        // In production, use video compression
        Ok(data)
    }
}

/// Processed image with multiple sizes
#[derive(Debug, Clone)]
pub struct ProcessedImage {
    pub original: Vec<u8>,
    pub thumbnail: Vec<u8>,
    pub preview: Vec<u8>,
    pub blurhash: String,
    pub width: u32,
    pub height: u32,
    pub mime_type: String,
}

/// Processed video
#[derive(Debug, Clone)]
pub struct ProcessedVideo {
    pub data: Vec<u8>,
    pub thumbnail: Vec<u8>,
    pub duration_seconds: u32,
    pub width: u32,
    pub height: u32,
    pub mime_type: String,
    pub streaming_url: Option<String>,
}

/// Media stream for large files
#[derive(Debug, Clone)]
pub struct MediaStream {
    pub chunks: Vec<Vec<u8>>,
    pub total_size: u64,
    pub chunk_size: u32,
    pub mime_type: String,
}

/// Media type enum
#[derive(Debug, Clone, PartialEq)]
pub enum MediaType {
    Image,
    Video,
    Audio,
    Document,
    Other,
}

/// Media upload progress
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UploadProgress {
    pub bytes_uploaded: u64,
    pub total_bytes: u64,
    pub percentage: f32,
    pub estimated_time_remaining: Option<u32>,
}

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

    #[tokio::test]
    async fn test_media_processor_creation() {
        let processor = MediaProcessor::new().unwrap();
        assert_eq!(processor.max_file_size, 100 * 1024 * 1024);
    }

    #[tokio::test]
    async fn test_mime_type_detection() {
        let processor = MediaProcessor::new().unwrap();

        // JPEG magic bytes
        let jpeg_data = vec![0xFF, 0xD8, 0xFF, 0xE0];
        assert_eq!(processor.detect_mime_type(&jpeg_data), "image/jpeg");

        // PNG magic bytes
        let png_data = vec![0x89, 0x50, 0x4E, 0x47];
        assert_eq!(processor.detect_mime_type(&png_data), "image/png");

        // GIF magic bytes
        let gif_data = b"GIF89a".to_vec();
        assert_eq!(processor.detect_mime_type(&gif_data), "image/gif");
    }

    #[tokio::test]
    async fn test_file_size_validation() {
        let processor = MediaProcessor::new().unwrap();

        // File too large
        let large_data = vec![0; 101 * 1024 * 1024];
        let result = processor.process_attachment(large_data).await;
        assert!(result.is_err());

        // File within limit
        let normal_data = vec![0; 1024];
        let result = processor.process_attachment(normal_data).await;
        assert!(result.is_ok());
    }

    #[tokio::test]
    async fn test_hash_generation() {
        let processor = MediaProcessor::new().unwrap();

        let data = b"test data".to_vec();
        let hash = processor.generate_hash(&data);

        // Blake3 hash should be deterministic
        assert_eq!(hash.len(), 64); // 32 bytes as hex
    }
}