dexther_lib 0.0.261

use base64::{engine::general_purpose, Engine as _};
use flate2::read::GzDecoder;
use flate2::write::GzEncoder;
use flate2::Compression;
use std::io::Read;
use std::io::Write;

pub fn compress_message(input: &str) -> Vec<u8> {
    let mut output = Vec::new();
    let mut encoder = GzEncoder::new(&mut output, Compression::default());
    encoder.write_all(input.as_bytes()).unwrap();
    encoder.finish().unwrap();
    output
}

pub fn decompress_message(compressed: &[u8]) -> String {
    let mut decoder = GzDecoder::new(compressed);
    let mut output = String::new();
    decoder.read_to_string(&mut output).unwrap();
    output
}

pub fn compress_message_base64(input: &str) -> String {
    let compressed = compress_message(input);
    general_purpose::STANDARD.encode(&compressed)
}

pub fn decompress_message_base64(compressed: &str) -> String {
    let compressed = general_purpose::STANDARD.decode(compressed).unwrap();
    decompress_message(&compressed)
}

#[cfg(test)]
mod compression_tests {
    use crate::compression::{
        compress_message, compress_message_base64, decompress_message, decompress_message_base64,
    };

    #[test]
    fn test_compression_decompression() {
        let message = "This is a test message";
        let compressed_message = compress_message(message);
        let decompressed_message = decompress_message(&compressed_message);

        assert_eq!(message, decompressed_message);
    }

    #[test]
    fn test_compression_ratio() {
        let message = "This is a test message. This is a test message. This is a test message. This is a test message.";
        let compressed_message = compress_message(message);

        let original_size = message.len();
        let compressed_size = compressed_message.len();

        println!("Original size: {} bytes", original_size);
        println!("Compressed size: {} bytes", compressed_size);

        assert!(compressed_size < original_size);
    }

    #[test]
    fn test_large_message_compression() {
        let message = "a".repeat(1000); // Large repetitive message
        let compressed_message = compress_message(&message);

        let original_size = message.len();
        let compressed_size = compressed_message.len();

        println!("Original size: {} bytes", original_size);
        println!("Compressed size: {} bytes", compressed_size);

        assert!(compressed_size < original_size);
    }

    #[test]
    fn test_base64_messasge_compression() {
        let message = "a".repeat(1000); // Large repetitive message
        let compressed_message = compress_message_base64(&message);
        let decompressed_message = decompress_message_base64(&compressed_message);
        let original_size = message.len();
        let compressed_size = compressed_message.len();

        println!("Original size: {} bytes", original_size);
        println!("Compressed size: {} bytes", compressed_size);

        assert!(compressed_size < original_size);
        assert!(message == decompressed_message);
    }
}