#!/usr/bin/env python3
"""
Comprehensive Compression Algorithm Benchmarking Suite
"""

import subprocess
import time
import os
import json
import statistics
from pathlib import Path
from dataclasses import dataclass
from typing import List, Dict, Tuple
import tempfile
import multiprocessing

@dataclass
class CompressionResult:
    algorithm: str
    level: int
    compress_time: float
    decompress_time: float
    original_size: int
    compressed_size: int
    compression_ratio: float
    compress_throughput: float  # MB/s
    decompress_throughput: float  # MB/s
    memory_usage: int  # Peak memory in MB
    cpu_usage: float  # Average CPU percentage

class CompressionBenchmark:
    def __init__(self, test_data_path: str, iterations: int = 3):
        self.test_data_path = Path(test_data_path)
        self.iterations = iterations
        self.algorithms = {
            'gzip': {
                'compress_cmd': 'gzip -{level} -c {input} > {output}',
                'decompress_cmd': 'gzip -d -c {input} > {output}',
                'levels': [1, 6, 9],
                'extension': '.gz'
            },
            'bzip2': {
                'compress_cmd': 'lbzip2 -{level} -c {input} > {output}',
                'decompress_cmd': 'lbzip2 -d -c {input} > {output}',
                'levels': [1, 6, 9],
                'extension': '.bz2'
            },
            'xz': {
                'compress_cmd': 'xz -{level} -T {threads} -c {input} > {output}',
                'decompress_cmd': 'xz -d -T {threads} -c {input} > {output}',
                'levels': [1, 6, 9],
                'extension': '.xz'
            },
            'lz4': {
                'compress_cmd': 'lz4 -{level} {input} {output}',
                'decompress_cmd': 'lz4 -d {input} {output}',
                'levels': [1, 6, 9],
                'extension': '.lz4'
            },
            'zstd': {
                'compress_cmd': 'zstd -{level} -T {threads} {input} -o {output}',
                'decompress_cmd': 'zstd -d -T {threads} {input} -o {output}',
                'levels': [1, 6, 9, 15, 19],
                'extension': '.zst'
            },
            'snappy': {
                'compress_cmd': 'snzip -c {input} > {output}',
                'decompress_cmd': 'snzip -d -c {input} > {output}',
                'levels': [1],  # Snappy doesn't have compression levels
                'extension': '.snz'
            },
            'brotli': {
                'compress_cmd': 'brotli -{level} -c {input} > {output}',
                'decompress_cmd': 'brotli -d -c {input} > {output}',
                'levels': [1, 6, 9, 11],
                'extension': '.br'
            }
        }
        
        self.cpu_count = multiprocessing.cpu_count()
        
    def measure_system_resources(self, pid: int) -> Tuple[float, int]:
        """Measure CPU and memory usage of a process"""
        try:
            # Use psutil if available for better accuracy
            import psutil
            process = psutil.Process(pid)
            cpu_percent = process.cpu_percent(interval=0.1)
            memory_mb = process.memory_info().rss / 1024 / 1024
            return cpu_percent, int(memory_mb)
        except ImportError:
            # Fallback to basic measurement
            return 0.0, 0
    
    def run_compression_test(self, algorithm: str, level: int, input_file: Path) -> CompressionResult:
        """Run a single compression test"""
        algo_config = self.algorithms[algorithm]
        
        with tempfile.NamedTemporaryFile(suffix=algo_config['extension']) as compressed_file, \
             tempfile.NamedTemporaryFile() as decompressed_file:
            
            # Get original file size
            original_size = input_file.stat().st_size
            
            # Prepare compression command
            compress_cmd = algo_config['compress_cmd'].format(
                level=level,
                input=str(input_file),
                output=compressed_file.name,
                threads=min(self.cpu_count, 8)
            )
            
            # Measure compression
            start_time = time.time()
            compress_process = subprocess.Popen(
                compress_cmd,
                shell=True,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE
            )
            
            # Monitor resource usage during compression
            max_memory = 0
            cpu_samples = []
            
            while compress_process.poll() is None:
                try:
                    cpu_usage, memory_usage = self.measure_system_resources(compress_process.pid)
                    max_memory = max(max_memory, memory_usage)
                    cpu_samples.append(cpu_usage)
                    time.sleep(0.1)
                except:
                    pass
            
            compress_process.wait()
            compress_time = time.time() - start_time
            
            if compress_process.returncode != 0:
                raise RuntimeError(f"Compression failed: {compress_process.stderr.read()}")
            
            # Get compressed file size
            compressed_size = Path(compressed_file.name).stat().st_size
            
            # Prepare decompression command
            decompress_cmd = algo_config['decompress_cmd'].format(
                input=compressed_file.name,
                output=decompressed_file.name,
                threads=min(self.cpu_count, 8)
            )
            
            # Measure decompression
            start_time = time.time()
            decompress_process = subprocess.run(
                decompress_cmd,
                shell=True,
                capture_output=True
            )
            decompress_time = time.time() - start_time
            
            if decompress_process.returncode != 0:
                raise RuntimeError(f"Decompression failed: {decompress_process.stderr}")
            
            # Calculate metrics
            compression_ratio = (compressed_size / original_size) * 100
            compress_throughput = (original_size / 1024 / 1024) / compress_time
            decompress_throughput = (original_size / 1024 / 1024) / decompress_time
            avg_cpu = statistics.mean(cpu_samples) if cpu_samples else 0.0
            
            return CompressionResult(
                algorithm=algorithm,
                level=level,
                compress_time=compress_time,
                decompress_time=decompress_time,
                original_size=original_size,
                compressed_size=compressed_size,
                compression_ratio=compression_ratio,
                compress_throughput=compress_throughput,
                decompress_throughput=decompress_throughput,
                memory_usage=max_memory,
                cpu_usage=avg_cpu
            )
    
    def run_full_benchmark(self) -> List[CompressionResult]:
        """Run comprehensive benchmark across all algorithms and levels"""
        results = []
        
        print(f"Starting compression benchmark with {self.iterations} iterations")
        print(f"Test file: {self.test_data_path} ({self.test_data_path.stat().st_size / 1024 / 1024:.1f} MB)")
        
        for algorithm, config in self.algorithms.items():
            print(f"\nTesting {algorithm}...")
            
            for level in config['levels']:
                print(f"  Level {level}...", end=' ')
                
                iteration_results = []
                
                for iteration in range(self.iterations):
                    try:
                        result = self.run_compression_test(algorithm, level, self.test_data_path)
                        iteration_results.append(result)
                    except Exception as e:
                        print(f"Error: {e}")
                        continue
                
                if iteration_results:
                    # Average results across iterations
                    avg_result = self.average_results(iteration_results)
                    results.append(avg_result)
                    print(f"Ratio: {avg_result.compression_ratio:.1f}%, "
                          f"Compress: {avg_result.compress_throughput:.1f} MB/s, "
                          f"Decompress: {avg_result.decompress_throughput:.1f} MB/s")
        
        return results
    
    def average_results(self, results: List[CompressionResult]) -> CompressionResult:
        """Average multiple test results"""
        if len(results) == 1:
            return results[0]
        
        return CompressionResult(
            algorithm=results[0].algorithm,
            level=results[0].level,
            compress_time=statistics.mean([r.compress_time for r in results]),
            decompress_time=statistics.mean([r.decompress_time for r in results]),
            original_size=results[0].original_size,
            compressed_size=int(statistics.mean([r.compressed_size for r in results])),
            compression_ratio=statistics.mean([r.compression_ratio for r in results]),
            compress_throughput=statistics.mean([r.compress_throughput for r in results]),
            decompress_throughput=statistics.mean([r.decompress_throughput for r in results]),
            memory_usage=int(statistics.mean([r.memory_usage for r in results])),
            cpu_usage=statistics.mean([r.cpu_usage for r in results])
        )
    
    def generate_report(self, results: List[CompressionResult]) -> Dict:
        """Generate comprehensive benchmark report"""
        report = {
            'benchmark_info': {
                'test_file': str(self.test_data_path),
                'file_size_mb': self.test_data_path.stat().st_size / 1024 / 1024,
                'iterations': self.iterations,
                'cpu_count': self.cpu_count,
                'timestamp': time.strftime('%Y-%m-%d %H:%M:%S')
            },
            'results': [],
            'analysis': {
                'fastest_compression': None,
                'fastest_decompression': None,
                'best_ratio': None,
                'most_efficient': None
            }
        }
        
        # Convert results to dictionaries
        for result in results:
            report['results'].append({
                'algorithm': result.algorithm,
                'level': result.level,
                'compress_time': round(result.compress_time, 3),
                'decompress_time': round(result.decompress_time, 3),
                'original_size_mb': round(result.original_size / 1024 / 1024, 1),
                'compressed_size_mb': round(result.compressed_size / 1024 / 1024, 1),
                'compression_ratio': round(result.compression_ratio, 1),
                'compress_throughput': round(result.compress_throughput, 1),
                'decompress_throughput': round(result.decompress_throughput, 1),
                'memory_usage_mb': result.memory_usage,
                'cpu_usage_percent': round(result.cpu_usage, 1),
                'efficiency_score': self.calculate_efficiency_score(result)
            })
        
        # Find best performers
        if results:
            report['analysis']['fastest_compression'] = max(results, key=lambda x: x.compress_throughput).algorithm
            report['analysis']['fastest_decompression'] = max(results, key=lambda x: x.decompress_throughput).algorithm
            report['analysis']['best_ratio'] = min(results, key=lambda x: x.compression_ratio).algorithm
            report['analysis']['most_efficient'] = max(results, key=lambda x: self.calculate_efficiency_score(x)).algorithm
        
        return report
    
    def calculate_efficiency_score(self, result: CompressionResult) -> float:
        """Calculate overall efficiency score balancing speed and ratio"""
        # Normalize metrics (lower compression ratio is better, higher throughput is better)
        ratio_score = 100 - result.compression_ratio  # Invert so higher is better
        speed_score = (result.compress_throughput + result.decompress_throughput) / 2
        
        # Weighted combination (can be adjusted based on priorities)
        efficiency_score = (ratio_score * 0.4) + (speed_score * 0.6)
        return efficiency_score

# Advanced Benchmarking with Different Data Types
class DataTypeBenchmark:
    def __init__(self):
        self.data_generators = {
            'text': self.generate_text_data,
            'binary': self.generate_binary_data,
            'mixed': self.generate_mixed_data,
            'random': self.generate_random_data,
            'repetitive': self.generate_repetitive_data
        }
    
    def generate_text_data(self, size_mb: int) -> Path:
        """Generate text-heavy test data"""
        output_file = Path(f'/tmp/text_data_{size_mb}mb.txt')
        
        with open(output_file, 'w') as f:
            # Generate lorem ipsum style text
            words = ['lorem', 'ipsum', 'dolor', 'sit', 'amet', 'consectetur', 
                    'adipiscing', 'elit', 'sed', 'do', 'eiusmod', 'tempor']
            
            target_size = size_mb * 1024 * 1024
            current_size = 0
            
            while current_size < target_size:
                line = ' '.join(words[:8]) + '\n'
                f.write(line)
                current_size += len(line.encode())
                words = words[1:] + [words[0]]  # Rotate words
        
        return output_file
    
    def generate_binary_data(self, size_mb: int) -> Path:
        """Generate binary test data"""
        output_file = Path(f'/tmp/binary_data_{size_mb}mb.bin')
        
        with open(output_file, 'wb') as f:
            # Generate pseudo-random binary data
            target_size = size_mb * 1024 * 1024
            chunk_size = 8192
            
            for i in range(0, target_size, chunk_size):
                remaining = min(chunk_size, target_size - i)
                chunk = bytes([(i + j) % 256 for j in range(remaining)])
                f.write(chunk)
        
        return output_file
    
    def generate_mixed_data(self, size_mb: int) -> Path:
        """Generate mixed data simulating real-world files"""
        output_file = Path(f'/tmp/mixed_data_{size_mb}mb.tar')
        
        # Create a tar file with mixed content
        with tempfile.TemporaryDirectory() as temp_dir:
            temp_path = Path(temp_dir)
            
            # Create text files
            for i in range(10):
                text_file = temp_path / f'document_{i}.txt'
                with open(text_file, 'w') as f:
                    f.write('Sample document content\n' * 1000)
            
            # Create binary files
            for i in range(5):
                bin_file = temp_path / f'binary_{i}.dat'
                with open(bin_file, 'wb') as f:
                    f.write(os.urandom(100000))
            
            # Create tar archive
            subprocess.run(['tar', '-cf', str(output_file), '-C', temp_dir, '.'], check=True)
        
        return output_file
    
    def generate_random_data(self, size_mb: int) -> Path:
        """Generate random data (worst case for compression)"""
        output_file = Path(f'/tmp/random_data_{size_mb}mb.bin')
        
        with open(output_file, 'wb') as f:
            target_size = size_mb * 1024 * 1024
            chunk_size = 1024 * 1024  # 1MB chunks
            
            for i in range(0, target_size, chunk_size):
                remaining = min(chunk_size, target_size - i)
                f.write(os.urandom(remaining))
        
        return output_file
    
    def generate_repetitive_data(self, size_mb: int) -> Path:
        """Generate highly repetitive data (best case for compression)"""
        output_file = Path(f'/tmp/repetitive_data_{size_mb}mb.txt')
        
        with open(output_file, 'w') as f:
            pattern = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' * 40 + '\n'
            target_size = size_mb * 1024 * 1024
            
            while f.tell() < target_size:
                f.write(pattern)
        
        return output_file

# Usage example and main execution
if __name__ == "__main__":
    import argparse
    
    parser = argparse.ArgumentParser(description='Comprehensive compression benchmarking')
    parser.add_argument('--data-type', choices=['text', 'binary', 'mixed', 'random', 'repetitive'],
                       default='mixed', help='Type of test data to generate')
    parser.add_argument('--size', type=int, default=100, help='Test data size in MB')
    parser.add_argument('--iterations', type=int, default=3, help='Number of test iterations')
    parser.add_argument('--output', default='benchmark_results.json', help='Output file for results')
    
    args = parser.parse_args()
    
    # Generate test data
    data_gen = DataTypeBenchmark()
    test_file = data_gen.data_generators[args.data_type](args.size)
    
    try:
        # Run benchmark
        benchmark = CompressionBenchmark(test_file, args.iterations)
        results = benchmark.run_full_benchmark()
        
        # Generate and save report
        report = benchmark.generate_report(results)
        
        with open(args.output, 'w') as f:
            json.dump(report, f, indent=2)
        
        print(f"\nBenchmark completed. Results saved to {args.output}")
        
        # Print summary
        print("\n=== SUMMARY ===")
        print(f"Fastest Compression: {report['analysis']['fastest_compression']}")
        print(f"Fastest Decompression: {report['analysis']['fastest_decompression']}")
        print(f"Best Compression Ratio: {report['analysis']['best_ratio']}")
        print(f"Most Efficient Overall: {report['analysis']['most_efficient']}")
        
    finally:
        # Cleanup test file
        if test_file.exists():
            test_file.unlink()

#!/usr/bin/env python3
"""
Enterprise Backup Compression Strategy Optimizer
"""

import json
from dataclasses import dataclass
from typing import List, Dict
from enum import Enum

class BackupType(Enum):
    FULL = "full"
    INCREMENTAL = "incremental"
    DIFFERENTIAL = "differential"

class DataType(Enum):
    DATABASE = "database"
    LOGS = "logs"
    DOCUMENTS = "documents"
    VIRTUAL_MACHINES = "virtual_machines"
    SOURCE_CODE = "source_code"
    MEDIA = "media"

@dataclass
class BackupRequirements:
    data_type: DataType
    backup_type: BackupType
    size_gb: float
    frequency: str  # daily, weekly, monthly
    retention_days: int
    rto_minutes: int  # Recovery Time Objective
    network_bandwidth_mbps: int
    storage_cost_per_gb: float
    
class CompressionSelector:
    def __init__(self):
        # Algorithm characteristics based on extensive testing
        self.algorithm_profiles = {
            'lz4': {
                'compress_speed': 400,  # MB/s
                'decompress_speed': 800,
                'ratio_text': 3.2,
                'ratio_binary': 1.8,
                'ratio_mixed': 2.5,
                'cpu_efficiency': 9,
                'memory_usage': 1,
                'enterprise_support': 8
            },
            'zstd': {
                'compress_speed': 150,
                'decompress_speed': 600,
                'ratio_text': 4.5,
                'ratio_binary': 2.8,
                'ratio_mixed': 3.6,
                'cpu_efficiency': 8,
                'memory_usage': 3,
                'enterprise_support': 9
            },
            'gzip': {
                'compress_speed': 80,
                'decompress_speed': 250,
                'ratio_text': 4.0,
                'ratio_binary': 2.2,
                'ratio_mixed': 3.1,
                'cpu_efficiency': 7,
                'memory_usage': 2,
                'enterprise_support': 10
            },
            'bzip2': {
                'compress_speed': 25,
                'decompress_speed': 40,
                'ratio_text': 5.2,
                'ratio_binary': 3.5,
                'ratio_mixed': 4.3,
                'cpu_efficiency': 5,
                'memory_usage': 4,
                'enterprise_support': 8
            },
            'xz': {
                'compress_speed': 15,
                'decompress_speed': 45,
                'ratio_text': 6.1,
                'ratio_binary': 4.2,
                'ratio_mixed': 5.1,
                'cpu_efficiency': 4,
                'memory_usage': 6,
                'enterprise_support': 7
            }
        }
        
        # Data type characteristics
        self.data_characteristics = {
            DataType.DATABASE: {'compressibility': 'medium', 'priority': 'ratio'},
            DataType.LOGS: {'compressibility': 'high', 'priority': 'speed'},
            DataType.DOCUMENTS: {'compressibility': 'high', 'priority': 'ratio'},
            DataType.VIRTUAL_MACHINES: {'compressibility': 'medium', 'priority': 'balanced'},
            DataType.SOURCE_CODE: {'compressibility': 'high', 'priority': 'ratio'},
            DataType.MEDIA: {'compressibility': 'low', 'priority': 'speed'}
        }
    
    def calculate_backup_metrics(self, requirements: BackupRequirements, algorithm: str) -> Dict:
        """Calculate comprehensive metrics for backup strategy"""
        profile = self.algorithm_profiles[algorithm]
        data_char = self.data_characteristics[requirements.data_type]
        
        # Estimate compression ratio based on data type
        if data_char['compressibility'] == 'high':
            ratio = profile['ratio_text']
        elif data_char['compressibility'] == 'medium':
            ratio = profile['ratio_mixed']
        else:
            ratio = profile['ratio_binary']
        
        # Calculate storage and time metrics
        compressed_size_gb = requirements.size_gb / ratio
        compression_time_minutes = (requirements.size_gb * 1024) / profile['compress_speed'] / 60
        decompression_time_minutes = (requirements.size_gb * 1024) / profile['decompress_speed'] / 60
        
        # Calculate costs
        storage_cost_per_backup = compressed_size_gb * requirements.storage_cost_per_gb
        annual_storage_cost = storage_cost_per_backup * (365 / self.frequency_to_days(requirements.frequency))
        
        # Network transfer time
        transfer_time_minutes = (compressed_size_gb * 1024 * 8) / requirements.network_bandwidth_mbps / 60
        
        # Total backup time
        total_backup_time = compression_time_minutes + transfer_time_minutes
        
        # RTO compliance
        rto_compliant = decompression_time_minutes <= requirements.rto_minutes
        
        return {
            'algorithm': algorithm,
            'compressed_size_gb': round(compressed_size_gb, 2),
            'compression_ratio': round(ratio, 1),
            'compression_time_minutes': round(compression_time_minutes, 1),
            'decompression_time_minutes': round(decompression_time_minutes, 1),
            'transfer_time_minutes': round(transfer_time_minutes, 1),
            'total_backup_time_minutes': round(total_backup_time, 1),
            'storage_cost_per_backup': round(storage_cost_per_backup, 2),
            'annual_storage_cost': round(annual_storage_cost, 2),
            'rto_compliant': rto_compliant,
            'efficiency_score': self.calculate_backup_efficiency_score(
                ratio, total_backup_time, decompression_time_minutes, 
                storage_cost_per_backup, rto_compliant
            )
        }
    
    def frequency_to_days(self, frequency: str) -> int:
        """Convert frequency string to days"""
        frequency_map = {
            'daily': 1,
            'weekly': 7,
            'monthly': 30
        }
        return frequency_map.get(frequency, 1)
    
    def calculate_backup_efficiency_score(self, ratio: float, backup_time: float, 
                                        restore_time: float, cost: float, 
                                        rto_compliant: bool) -> float:
        """Calculate overall efficiency score for backup strategy"""
        # Normalize metrics (higher is better)
        ratio_score = min(ratio * 10, 100)  # Cap at 100
        time_score = max(0, 100 - backup_time)  # Penalize long backup times
        restore_score = max(0, 100 - restore_time * 2)  # Heavily penalize slow restore
        cost_score = max(0, 100 - cost * 10)  # Penalize high costs
        rto_score = 100 if rto_compliant else 0
        
        # Weighted combination
        efficiency = (ratio_score * 0.25 + time_score * 0.20 + 
                     restore_score * 0.30 + cost_score * 0.15 + rto_score * 0.10)
        
        return round(efficiency, 1)
    
    def recommend_algorithm(self, requirements: BackupRequirements) -> Dict:
        """Recommend optimal compression algorithm for backup requirements"""
        recommendations = []
        
        for algorithm in self.algorithm_profiles.keys():
            metrics = self.calculate_backup_metrics(requirements, algorithm)
            recommendations.append(metrics)
        
        # Sort by efficiency score
        recommendations.sort(key=lambda x: x['efficiency_score'], reverse=True)
        
        return {
            'recommended_algorithm': recommendations[0]['algorithm'],
            'all_options': recommendations,
            'requirements': {
                'data_type': requirements.data_type.value,
                'backup_type': requirements.backup_type.value,
                'size_gb': requirements.size_gb,
                'rto_minutes': requirements.rto_minutes,
                'frequency': requirements.frequency
            }
        }

# Example usage for different enterprise scenarios
if __name__ == "__main__":
    selector = CompressionSelector()
    
    # Scenario 1: Database backup
    db_backup = BackupRequirements(
        data_type=DataType.DATABASE,
        backup_type=BackupType.FULL,
        size_gb=500,
        frequency='daily',
        retention_days=30,
        rto_minutes=60,
        network_bandwidth_mbps=1000,
        storage_cost_per_gb=0.02
    )
    
    db_recommendation = selector.recommend_algorithm(db_backup)
    print("Database Backup Recommendation:")
    print(f"Algorithm: {db_recommendation['recommended_algorithm']}")
    print(f"Efficiency Score: {db_recommendation['all_options'][0]['efficiency_score']}")
    
    # Scenario 2: Log archival
    log_backup = BackupRequirements(
        data_type=DataType.LOGS,
        backup_type=BackupType.INCREMENTAL,
        size_gb=50,
        frequency='daily',
        retention_days=365,
        rto_minutes=15,
        network_bandwidth_mbps=100,
        storage_cost_per_gb=0.01
    )
    
    log_recommendation = selector.recommend_algorithm(log_backup)
    print("\nLog Backup Recommendation:")
    print(f"Algorithm: {log_recommendation['recommended_algorithm']}")
    print(f"Efficiency Score: {log_recommendation['all_options'][0]['efficiency_score']}")

#!/bin/bash
# Enterprise compression pipeline optimization script

set -euo pipefail

# System optimization for compression workloads
optimize_system_for_compression() {
    echo "Optimizing system for compression workloads..."
    
    # CPU governor optimization
    echo "performance" | tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
    
    # Memory optimization
    sysctl -w vm.swappiness=1
    sysctl -w vm.dirty_ratio=15
    sysctl -w vm.dirty_background_ratio=5
    
    # I/O scheduler optimization
    for disk in /sys/block/sd*; do
        if [[ -f "$disk/queue/scheduler" ]]; then
            echo "mq-deadline" > "$disk/queue/scheduler"
        fi
    done
    
    # Increase open file limits
    echo "* soft nofile 65536" >> /etc/security/limits.conf
    echo "* hard nofile 65536" >> /etc/security/limits.conf
    
    # Optimize for SSD if available
    for disk in /sys/block/nvme*; do
        if [[ -d "$disk" ]]; then
            echo "none" > "$disk/queue/scheduler"
        fi
    done
    
    echo "System optimization completed"
}

# Parallel compression implementation
parallel_compress() {
    local input_dir="$1"
    local output_dir="$2"
    local algorithm="${3:-zstd}"
    local compression_level="${4:-6}"
    local num_threads="${5:-$(nproc)}"
    
    echo "Starting parallel compression:"
    echo "  Input: $input_dir"
    echo "  Output: $output_dir"
    echo "  Algorithm: $algorithm"
    echo "  Level: $compression_level"
    echo "  Threads: $num_threads"
    
    mkdir -p "$output_dir"
    
    case "$algorithm" in
        "zstd")
            find "$input_dir" -type f -print0 | \
            xargs -0 -n 1 -P "$num_threads" -I {} \
            zstd -"$compression_level" -T1 "{}" -o "$output_dir/{}.zst"
            ;;
        "lz4")
            find "$input_dir" -type f -print0 | \
            xargs -0 -n 1 -P "$num_threads" -I {} \
            lz4 -"$compression_level" "{}" "$output_dir/{}.lz4"
            ;;
        "gzip")
            find "$input_dir" -type f -print0 | \
            xargs -0 -n 1 -P "$num_threads" -I {} \
            gzip -"$compression_level" -c "{}" > "$output_dir/{}.gz"
            ;;
        "xz")
            find "$input_dir" -type f -print0 | \
            xargs -0 -n 1 -P "$num_threads" -I {} \
            xz -"$compression_level" -T1 -c "{}" > "$output_dir/{}.xz"
            ;;
        *)
            echo "Unsupported algorithm: $algorithm"
            return 1
            ;;
    esac
    
    echo "Parallel compression completed"
}

# Intelligent compression selection
intelligent_compress() {
    local input_file="$1"
    local output_dir="$2"
    
    echo "Analyzing file for optimal compression: $input_file"
    
    # Get file size and type
    local file_size=$(stat -c%s "$input_file")
    local file_type=$(file -b --mime-type "$input_file")
    local filename=$(basename "$input_file")
    
    # Size-based selection
    if [[ $file_size -lt $((10 * 1024 * 1024)) ]]; then
        # Small files: prioritize speed
        algorithm="lz4"
        level="1"
    elif [[ $file_size -gt $((1024 * 1024 * 1024)) ]]; then
        # Large files: prioritize ratio for storage savings
        algorithm="zstd"
        level="9"
    else
        # Medium files: balanced approach
        algorithm="zstd"
        level="6"
    fi
    
    # Type-based adjustments
    case "$file_type" in
        "text/"*)
            # Text compresses well, use higher compression
            algorithm="zstd"
            level="9"
            ;;
        "video/"*|"audio/"*|"image/jpeg"|"image/png")
            # Already compressed media, use fast algorithm
            algorithm="lz4"
            level="1"
            ;;
        "application/x-executable"|"application/octet-stream")
            # Binary data, balanced approach
            algorithm="zstd"
            level="6"
            ;;
    esac
    
    echo "Selected algorithm: $algorithm, level: $level"
    echo "File type: $file_type, size: $(numfmt --to=iec $file_size)"
    
    # Perform compression
    case "$algorithm" in
        "lz4")
            lz4 -"$level" "$input_file" "$output_dir/$filename.lz4"
            ;;
        "zstd")
            zstd -"$level" "$input_file" -o "$output_dir/$filename.zst"
            ;;
        "gzip")
            gzip -"$level" -c "$input_file" > "$output_dir/$filename.gz"
            ;;
    esac
    
    # Report results
    local compressed_size=$(stat -c%s "$output_dir/$filename."*)
    local ratio=$(echo "scale=1; $file_size / $compressed_size" | bc -l)
    
    echo "Compression completed:"
    echo "  Original size: $(numfmt --to=iec $file_size)"
    echo "  Compressed size: $(numfmt --to=iec $compressed_size)"
    echo "  Compression ratio: ${ratio}:1"
}

# Performance monitoring during compression
monitor_compression_performance() {
    local pid="$1"
    local log_file="${2:-/tmp/compression_performance.log}"
    
    echo "Monitoring compression performance for PID $pid"
    echo "timestamp,cpu_percent,memory_mb,io_read_mb,io_write_mb" > "$log_file"
    
    while kill -0 "$pid" 2>/dev/null; do
        local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
        
        # Get CPU usage
        local cpu_percent=$(ps -p "$pid" -o %cpu --no-headers | tr -d ' ')
        
        # Get memory usage
        local memory_kb=$(ps -p "$pid" -o rss --no-headers | tr -d ' ')
        local memory_mb=$((memory_kb / 1024))
        
        # Get I/O stats if available
        local io_read_mb=0
        local io_write_mb=0
        
        if [[ -f "/proc/$pid/io" ]]; then
            local read_bytes=$(grep "read_bytes" "/proc/$pid/io" | awk '{print $2}')
            local write_bytes=$(grep "write_bytes" "/proc/$pid/io" | awk '{print $2}')
            io_read_mb=$((read_bytes / 1024 / 1024))
            io_write_mb=$((write_bytes / 1024 / 1024))
        fi
        
        echo "$timestamp,$cpu_percent,$memory_mb,$io_read_mb,$io_write_mb" >> "$log_file"
        sleep 1
    done
    
    echo "Performance monitoring completed. Log saved to $log_file"
}

# Main execution
case "${1:-help}" in
    "optimize")
        optimize_system_for_compression
        ;;
    "parallel")
        parallel_compress "$2" "$3" "${4:-zstd}" "${5:-6}" "${6:-$(nproc)}"
        ;;
    "intelligent")
        intelligent_compress "$2" "$3"
        ;;
    "monitor")
        monitor_compression_performance "$2" "$3"
        ;;
    "help"|*)
        echo "Usage: $0 {optimize|parallel|intelligent|monitor|help}"
        echo ""
        echo "Commands:"
        echo "  optimize                              - Optimize system for compression"
        echo "  parallel <input_dir> <output_dir>    - Parallel compression"
        echo "  intelligent <input_file> <output_dir> - Intelligent algorithm selection"
        echo "  monitor <pid> [log_file]             - Monitor compression performance"
        ;;
esac

# Multi-stage compression optimization for containers
FROM ubuntu:20.04 as compression-tools

# Install all compression tools
RUN apt-get update && apt-get install -y \
    zstd \
    lz4 \
    xz-utils \
    gzip \
    bzip2 \
    lbzip2 \
    brotli \
    snzip \
    && rm -rf /var/lib/apt/lists/*

# Create compression benchmark utility
COPY compression-benchmark.py /usr/local/bin/
RUN chmod +x /usr/local/bin/compression-benchmark.py

# Optimize container layers
FROM compression-tools as optimized

# Use ZSTD for package compression
ENV DEBIAN_FRONTEND=noninteractive
RUN echo 'APT::Acquire::CompressionTypes::Order:: "zstd";' > /etc/apt/apt.conf.d/99compression

# Application layer with optimized compression
FROM optimized as application

WORKDIR /app

# Copy application files
COPY --from=compression-tools /usr/local/bin/compression-benchmark.py .
COPY requirements.txt .

# Install dependencies with compression
RUN pip install --no-cache-dir -r requirements.txt

# Compress application assets
RUN find /app -name "*.js" -exec zstd -19 {} \; && \
    find /app -name "*.css" -exec zstd -19 {} \; && \
    find /app -name "*.json" -exec zstd -19 {} \;

CMD ["python", "compression-benchmark.py"]

# ConfigMap for compression optimization
apiVersion: v1
kind: ConfigMap
metadata:
  name: compression-config
data:
  compression.conf: |
    # Algorithm selection based on workload
    [database]
    algorithm=zstd
    level=6
    parallel=true
    
    [logs]
    algorithm=lz4
    level=1
    parallel=true
    
    [backups]
    algorithm=xz
    level=9
    parallel=true
    
    [realtime]
    algorithm=lz4
    level=1
    parallel=false

---
# Deployment with compression optimization
apiVersion: apps/v1
kind: Deployment
metadata:
  name: compression-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: compression-service
  template:
    metadata:
      labels:
        app: compression-service
    spec:
      containers:
      - name: compression-worker
        image: compression-service:latest
        resources:
          requests:
            memory: "2Gi"
            cpu: "1000m"
          limits:
            memory: "4Gi"
            cpu: "2000m"
        env:
        - name: COMPRESSION_CONFIG
          value: "/etc/compression/compression.conf"
        - name: COMPRESSION_THREADS
          value: "4"
        - name: COMPRESSION_MEMORY_LIMIT
          value: "2048"
        volumeMounts:
        - name: compression-config
          mountPath: /etc/compression
        - name: temp-storage
          mountPath: /tmp/compression
      volumes:
      - name: compression-config
        configMap:
          name: compression-config
      - name: temp-storage
        emptyDir:
          sizeLimit: 10Gi
          medium: Memory  # Use tmpfs for temporary compression work
      nodeSelector:
        compression-optimized: "true"
      tolerations:
      - key: "compression-workload"
        operator: "Equal"
        value: "true"
        effect: "NoSchedule"