inferno-ai 0.10.3

#![allow(dead_code, unused_imports, unused_variables)]
//! Advanced Cache CLI Commands
//!
//! This module provides advanced caching and memory management CLI features.
//! Includes comprehensive input validation and clear error messages.

use crate::advanced_cache::{
    AdvancedCacheConfig, AdvancedCacheSystem, MockCacheBackend, MockCacheMonitor,
    MockCacheOptimizer, MockCompressionEngine, SourceType, WarmingSource,
};
use crate::config::Config;
use anyhow::{Result, bail};
use clap::{Args, Subcommand};
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::RwLock;

// ============================================================================
// Validation Constants
// ============================================================================

/// Valid eviction policy types
const VALID_EVICTION_POLICIES: &[&str] = &["lru", "lfu", "ttl", "size", "arc", "fifo"];

/// Valid warmup strategies
const VALID_WARMUP_STRATEGIES: &[&str] = &[
    "popular",
    "recent",
    "predicted",
    "all",
    "file",
    "database",
    "api",
];

/// Valid time ranges for analysis
const VALID_TIME_RANGES: &[&str] = &["1h", "24h", "7d", "30d"];

/// Valid cleanup modes
const VALID_CLEANUP_MODES: &[&str] = &["expired", "unused", "all", "compact"];

/// Valid compression algorithms
const VALID_COMPRESSION_ALGORITHMS: &[&str] = &["lz4", "zstd", "gzip", "snappy", "none"];

/// Valid tier names
const VALID_TIER_NAMES: &[&str] = &["l1", "l2", "l3", "memory", "disk", "external"];

/// Valid consistency levels
const VALID_CONSISTENCY_LEVELS: &[&str] = &["eventual", "strong", "session", "linearizable"];

#[derive(Args)]
pub struct AdvancedCacheArgs {
    #[command(subcommand)]
    pub command: CacheCommand,
}

#[derive(Subcommand)]
pub enum CacheCommand {
    #[command(about = "Cache operations")]
    Cache {
        #[command(subcommand)]
        command: CacheOperationCommand,
    },

    #[command(about = "Memory management")]
    Memory {
        #[command(subcommand)]
        command: MemoryCommand,
    },

    #[command(about = "Eviction policies")]
    Eviction {
        #[command(subcommand)]
        command: EvictionCommand,
    },

    #[command(about = "Prefetching and warming")]
    Prefetch {
        #[command(subcommand)]
        command: PrefetchCommand,
    },

    #[command(about = "Cache tiers and hierarchy")]
    Tiers {
        #[command(subcommand)]
        command: TierCommand,
    },

    #[command(about = "Distributed caching")]
    Distributed {
        #[command(subcommand)]
        command: DistributedCommand,
    },

    #[command(about = "Compression management")]
    Compression {
        #[command(subcommand)]
        command: CompressionCommand,
    },

    #[command(about = "Cache monitoring and metrics")]
    Monitor {
        #[command(subcommand)]
        command: MonitorCommand,
    },

    #[command(about = "Cache optimization")]
    Optimize {
        #[command(subcommand)]
        command: OptimizeCommand,
    },

    #[command(about = "Backup and restore")]
    Backup {
        #[command(subcommand)]
        command: BackupCommand,
    },

    #[command(about = "Cache coherence")]
    Coherence {
        #[command(subcommand)]
        command: CoherenceCommand,
    },

    #[command(about = "View cache status")]
    Status {
        #[arg(long, help = "Show detailed status")]
        detailed: bool,

        #[arg(long, help = "Include tier statistics")]
        tiers: bool,

        #[arg(long, help = "Include memory statistics")]
        memory: bool,

        #[arg(long, help = "Include hot keys")]
        hot_keys: bool,

        #[arg(long, help = "Refresh interval in seconds")]
        refresh: Option<u64>,
    },
}

#[derive(Subcommand)]
pub enum CacheOperationCommand {
    #[command(about = "Get value from cache")]
    Get {
        #[arg(long, help = "Cache key")]
        key: String,

        #[arg(long, help = "Show metadata")]
        metadata: bool,

        #[arg(long, help = "Show statistics")]
        stats: bool,
    },

    #[command(about = "Put value into cache")]
    Put {
        #[arg(long, help = "Cache key")]
        key: String,

        #[arg(long, help = "Value")]
        value: String,

        #[arg(long, help = "TTL in seconds")]
        ttl: Option<u64>,

        #[arg(long, help = "Priority")]
        priority: Option<u8>,

        #[arg(long, help = "Compress value")]
        compress: bool,
    },

    #[command(about = "Delete from cache")]
    Delete {
        #[arg(long, help = "Cache key")]
        key: String,

        #[arg(long, help = "Pattern matching")]
        pattern: bool,
    },

    #[command(about = "Clear cache")]
    Clear {
        #[arg(long, help = "Tier to clear")]
        tier: Option<String>,

        #[arg(long, help = "Force clear")]
        force: bool,

        #[arg(long, help = "Preserve hot keys")]
        preserve_hot: bool,
    },

    #[command(about = "List cache keys")]
    List {
        #[arg(long, help = "Pattern to match")]
        pattern: Option<String>,

        #[arg(long, help = "Limit results")]
        limit: Option<usize>,

        #[arg(long, help = "Sort by")]
        sort: Option<String>,
    },

    #[command(about = "Invalidate cache entries")]
    Invalidate {
        #[arg(long, help = "Invalidation pattern")]
        pattern: String,

        #[arg(long, help = "Cascade to dependencies")]
        cascade: bool,

        #[arg(long, help = "Broadcast to cluster")]
        broadcast: bool,
    },
}

#[derive(Subcommand)]
pub enum MemoryCommand {
    #[command(about = "View memory statistics")]
    Stats {
        #[arg(long, help = "Include pool statistics")]
        pools: bool,

        #[arg(long, help = "Include fragmentation")]
        fragmentation: bool,

        #[arg(long, help = "Show allocations")]
        allocations: bool,
    },

    #[command(about = "Configure memory limits")]
    Limits {
        #[arg(long, help = "Soft limit in MB")]
        soft: Option<usize>,

        #[arg(long, help = "Hard limit in MB")]
        hard: Option<usize>,

        #[arg(long, help = "OOM handler")]
        oom_handler: Option<String>,
    },

    #[command(about = "Memory pool management")]
    Pools {
        #[command(subcommand)]
        command: PoolCommand,
    },

    #[command(about = "Trigger garbage collection")]
    GC {
        #[arg(long, help = "GC type")]
        gc_type: Option<String>,

        #[arg(long, help = "Force full GC")]
        full: bool,

        #[arg(long, help = "Concurrent GC")]
        concurrent: bool,
    },

    #[command(about = "Memory pressure analysis")]
    Pressure {
        #[arg(long, help = "Show recommendations")]
        recommend: bool,

        #[arg(long, help = "Trigger threshold")]
        threshold: Option<f32>,
    },

    #[command(about = "Memory profiling")]
    Profile {
        #[arg(long, help = "Profile duration seconds")]
        duration: Option<u64>,

        #[arg(long, help = "Include heap dump")]
        heap: bool,

        #[arg(long, help = "Output file")]
        output: Option<PathBuf>,
    },
}

#[derive(Subcommand)]
pub enum PoolCommand {
    #[command(about = "Create memory pool")]
    Create {
        #[arg(long, help = "Object size")]
        size: usize,

        #[arg(long, help = "Initial count")]
        initial: usize,

        #[arg(long, help = "Max count")]
        max: usize,
    },

    #[command(about = "List memory pools")]
    List {
        #[arg(long, help = "Show utilization")]
        utilization: bool,
    },

    #[command(about = "Resize memory pool")]
    Resize {
        #[arg(long, help = "Pool size")]
        size: usize,

        #[arg(long, help = "New count")]
        count: usize,
    },

    #[command(about = "Reclaim unused memory")]
    Reclaim {
        #[arg(long, help = "Reclaim policy")]
        policy: Option<String>,

        #[arg(long, help = "Force reclaim")]
        force: bool,
    },
}

#[derive(Subcommand)]
pub enum EvictionCommand {
    #[command(about = "Configure eviction policy")]
    Policy {
        #[arg(long, help = "Policy type")]
        policy: String,

        #[arg(long, help = "Max entries")]
        max_entries: Option<usize>,

        #[arg(long, help = "Max size MB")]
        max_size: Option<usize>,

        #[arg(long, help = "TTL seconds")]
        ttl: Option<u64>,
    },

    #[command(about = "Trigger eviction")]
    Evict {
        #[arg(long, help = "Number to evict")]
        count: Option<usize>,

        #[arg(long, help = "Target tier")]
        tier: Option<String>,

        #[arg(long, help = "Eviction reason")]
        reason: Option<String>,
    },

    #[command(about = "View eviction statistics")]
    Stats {
        #[arg(long, help = "Time range")]
        range: Option<String>,

        #[arg(long, help = "Group by policy")]
        by_policy: bool,

        #[arg(long, help = "Group by reason")]
        by_reason: bool,
    },

    #[command(about = "Configure adaptive eviction")]
    Adaptive {
        #[arg(long, help = "Enable adaptive eviction")]
        enable: bool,

        #[arg(long, help = "Learning rate")]
        learning_rate: Option<f32>,

        #[arg(long, help = "History window")]
        window: Option<usize>,
    },

    #[command(about = "Priority-based eviction")]
    Priority {
        #[arg(long, help = "Priority threshold")]
        threshold: Option<u8>,

        #[arg(long, help = "Preserve count")]
        preserve: Option<usize>,
    },
}

#[derive(Subcommand)]
pub enum PrefetchCommand {
    #[command(about = "Configure prefetching")]
    Config {
        #[arg(long, help = "Enable prefetching")]
        enable: bool,

        #[arg(long, help = "Strategy")]
        strategy: Option<String>,

        #[arg(long, help = "Prefetch distance")]
        distance: Option<usize>,

        #[arg(long, help = "Prefetch degree")]
        degree: Option<usize>,
    },

    #[command(about = "Warm cache from source")]
    Warm {
        #[arg(long, help = "Source type")]
        source: String,

        #[arg(long, help = "Source location")]
        location: String,

        #[arg(long, help = "Filter pattern")]
        filter: Option<String>,

        #[arg(long, help = "Parallel warming")]
        parallel: bool,

        #[arg(long, help = "Batch size")]
        batch: Option<usize>,
    },

    #[command(about = "Prefetch specific keys")]
    Prefetch {
        #[arg(long, help = "Keys to prefetch")]
        keys: Vec<String>,

        #[arg(long, help = "Async prefetch")]
        async_mode: bool,

        #[arg(long, help = "Priority")]
        priority: Option<u8>,
    },

    #[command(about = "Pattern detection")]
    Patterns {
        #[arg(long, help = "Enable pattern detection")]
        enable: bool,

        #[arg(long, help = "Confidence threshold")]
        confidence: Option<f32>,

        #[arg(long, help = "Show detected patterns")]
        show: bool,
    },

    #[command(about = "View prefetch statistics")]
    Stats {
        #[arg(long, help = "Include accuracy")]
        accuracy: bool,

        #[arg(long, help = "Include coverage")]
        coverage: bool,

        #[arg(long, help = "Include patterns")]
        patterns: bool,
    },
}

#[derive(Subcommand)]
pub enum TierCommand {
    #[command(about = "Configure cache tiers")]
    Config {
        #[arg(long, help = "Tier name")]
        tier: String,

        #[arg(long, help = "Capacity MB")]
        capacity: Option<usize>,

        #[arg(long, help = "Latency ms")]
        latency: Option<u64>,

        #[arg(long, help = "Cost per GB")]
        cost: Option<f32>,
    },

    #[command(about = "List cache tiers")]
    List {
        #[arg(long, help = "Show utilization")]
        utilization: bool,

        #[arg(long, help = "Show performance")]
        performance: bool,
    },

    #[command(about = "Promote entries")]
    Promote {
        #[arg(long, help = "Source tier")]
        from: String,

        #[arg(long, help = "Target tier")]
        to: String,

        #[arg(long, help = "Promotion policy")]
        policy: Option<String>,

        #[arg(long, help = "Count to promote")]
        count: Option<usize>,
    },

    #[command(about = "Demote entries")]
    Demote {
        #[arg(long, help = "Source tier")]
        from: String,

        #[arg(long, help = "Target tier")]
        to: String,

        #[arg(long, help = "Demotion policy")]
        policy: Option<String>,

        #[arg(long, help = "Count to demote")]
        count: Option<usize>,
    },

    #[command(about = "Migration between tiers")]
    Migrate {
        #[arg(long, help = "Enable auto-migration")]
        auto: bool,

        #[arg(long, help = "Migration threshold")]
        threshold: Option<f32>,

        #[arg(long, help = "Migration interval")]
        interval: Option<u64>,
    },
}

#[derive(Subcommand)]
pub enum DistributedCommand {
    #[command(about = "Configure distributed cache")]
    Config {
        #[arg(long, help = "Topology")]
        topology: Option<String>,

        #[arg(long, help = "Consistency level")]
        consistency: Option<String>,

        #[arg(long, help = "Replication factor")]
        replication: Option<usize>,

        #[arg(long, help = "Partitioning strategy")]
        partitioning: Option<String>,
    },

    #[command(about = "Manage cache nodes")]
    Nodes {
        #[command(subcommand)]
        command: NodeCommand,
    },

    #[command(about = "Replication management")]
    Replication {
        #[arg(long, help = "Check status")]
        status: bool,

        #[arg(long, help = "Force sync")]
        sync: bool,

        #[arg(long, help = "Show lag")]
        lag: bool,
    },

    #[command(about = "Partitioning")]
    Partition {
        #[arg(long, help = "Rebalance partitions")]
        rebalance: bool,

        #[arg(long, help = "Show distribution")]
        distribution: bool,

        #[arg(long, help = "Migration plan")]
        plan: bool,
    },

    #[command(about = "Consistency management")]
    Consistency {
        #[arg(long, help = "Check consistency")]
        check: bool,

        #[arg(long, help = "Repair inconsistencies")]
        repair: bool,

        #[arg(long, help = "Show conflicts")]
        conflicts: bool,
    },
}

#[derive(Subcommand)]
pub enum NodeCommand {
    #[command(about = "Add cache node")]
    Add {
        #[arg(long, help = "Node address")]
        address: String,

        #[arg(long, help = "Node capacity MB")]
        capacity: Option<usize>,

        #[arg(long, help = "Node role")]
        role: Option<String>,
    },

    #[command(about = "Remove cache node")]
    Remove {
        #[arg(long, help = "Node ID")]
        node_id: String,

        #[arg(long, help = "Graceful removal")]
        graceful: bool,

        #[arg(long, help = "Redistribute data")]
        redistribute: bool,
    },

    #[command(about = "List cache nodes")]
    List {
        #[arg(long, help = "Show status")]
        status: bool,

        #[arg(long, help = "Show metrics")]
        metrics: bool,
    },

    #[command(about = "Node health check")]
    Health {
        #[arg(long, help = "Node ID")]
        node_id: Option<String>,

        #[arg(long, help = "Include diagnostics")]
        diagnostics: bool,
    },
}

#[derive(Subcommand)]
pub enum CompressionCommand {
    #[command(about = "Configure compression")]
    Config {
        #[arg(long, help = "Enable compression")]
        enable: bool,

        #[arg(long, help = "Algorithm")]
        algorithm: Option<String>,

        #[arg(long, help = "Compression level")]
        level: Option<u32>,

        #[arg(long, help = "Min size bytes")]
        min_size: Option<usize>,
    },

    #[command(about = "Compression statistics")]
    Stats {
        #[arg(long, help = "Show ratios")]
        ratios: bool,

        #[arg(long, help = "Show performance")]
        performance: bool,

        #[arg(long, help = "By algorithm")]
        by_algorithm: bool,
    },

    #[command(about = "Test compression")]
    Test {
        #[arg(long, help = "Test data size")]
        size: usize,

        #[arg(long, help = "Algorithm")]
        algorithm: Option<String>,

        #[arg(long, help = "Iterations")]
        iterations: Option<usize>,
    },

    #[command(about = "Adaptive compression")]
    Adaptive {
        #[arg(long, help = "Enable adaptive")]
        enable: bool,

        #[arg(long, help = "Ratio threshold")]
        threshold: Option<f32>,

        #[arg(long, help = "Sample rate")]
        sample_rate: Option<f32>,
    },
}

#[derive(Subcommand)]
pub enum MonitorCommand {
    #[command(about = "View cache metrics")]
    Metrics {
        #[arg(long, help = "Metric type")]
        metric: Option<String>,

        #[arg(long, help = "Time range")]
        range: Option<String>,

        #[arg(long, help = "Aggregation")]
        aggregation: Option<String>,

        #[arg(long, help = "Export format")]
        export: Option<String>,
    },

    #[command(about = "Hot key analysis")]
    HotKeys {
        #[arg(long, help = "Top N keys")]
        top: Option<usize>,

        #[arg(long, help = "Heat threshold")]
        threshold: Option<f64>,

        #[arg(long, help = "Time window")]
        window: Option<u64>,

        #[arg(long, help = "Auto-promote")]
        promote: bool,
    },

    #[command(about = "Performance analysis")]
    Performance {
        #[arg(long, help = "Show latencies")]
        latency: bool,

        #[arg(long, help = "Show throughput")]
        throughput: bool,

        #[arg(long, help = "Show percentiles")]
        percentiles: bool,
    },

    #[command(about = "Set up alerts")]
    Alerts {
        #[arg(long, help = "Alert type")]
        alert_type: Option<String>,

        #[arg(long, help = "Threshold")]
        threshold: Option<f64>,

        #[arg(long, help = "Action")]
        action: Option<String>,
    },

    #[command(about = "Workload analysis")]
    Workload {
        #[arg(long, help = "Analyze patterns")]
        patterns: bool,

        #[arg(long, help = "Show distribution")]
        distribution: bool,

        #[arg(long, help = "Predict future")]
        predict: bool,
    },
}

#[derive(Subcommand)]
pub enum OptimizeCommand {
    #[command(about = "Run optimization")]
    Run {
        #[arg(long, help = "Optimization target")]
        target: Option<String>,

        #[arg(long, help = "Auto-tune")]
        auto_tune: bool,

        #[arg(long, help = "ML optimization")]
        ml: bool,

        #[arg(long, help = "Dry run")]
        dry_run: bool,
    },

    #[command(about = "Get recommendations")]
    Recommend {
        #[arg(long, help = "Analysis depth")]
        depth: Option<String>,

        #[arg(long, help = "Include cost")]
        cost: bool,

        #[arg(long, help = "Priority")]
        priority: Option<u8>,
    },

    #[command(about = "Configure auto-tuning")]
    AutoTune {
        #[arg(long, help = "Enable auto-tuning")]
        enable: bool,

        #[arg(long, help = "Tuning interval")]
        interval: Option<u64>,

        #[arg(long, help = "ML model")]
        model: Option<String>,
    },

    #[command(about = "Size optimization")]
    Size {
        #[arg(long, help = "Target hit rate")]
        hit_rate: Option<f64>,

        #[arg(long, help = "Memory budget MB")]
        budget: Option<usize>,

        #[arg(long, help = "Apply changes")]
        apply: bool,
    },

    #[command(about = "Workload optimization")]
    Workload {
        #[arg(long, help = "Workload type")]
        workload: Option<String>,

        #[arg(long, help = "Optimize for")]
        optimize_for: Option<String>,
    },
}

#[derive(Subcommand)]
pub enum BackupCommand {
    #[command(about = "Create backup")]
    Create {
        #[arg(long, help = "Backup type")]
        backup_type: Option<String>,

        #[arg(long, help = "Destination")]
        destination: Option<PathBuf>,

        #[arg(long, help = "Compress backup")]
        compress: bool,

        #[arg(long, help = "Encrypt backup")]
        encrypt: bool,
    },

    #[command(about = "Restore from backup")]
    Restore {
        #[arg(long, help = "Backup ID")]
        backup_id: String,

        #[arg(long, help = "Restore point")]
        point: Option<String>,

        #[arg(long, help = "Verify integrity")]
        verify: bool,
    },

    #[command(about = "List backups")]
    List {
        #[arg(long, help = "Filter by type")]
        backup_type: Option<String>,

        #[arg(long, help = "Show sizes")]
        sizes: bool,
    },

    #[command(about = "Backup schedule")]
    Schedule {
        #[arg(long, help = "Enable scheduling")]
        enable: bool,

        #[arg(long, help = "Schedule expression")]
        schedule: Option<String>,

        #[arg(long, help = "Retention days")]
        retention: Option<u32>,
    },
}

#[derive(Subcommand)]
pub enum CoherenceCommand {
    #[command(about = "Configure coherence protocol")]
    Protocol {
        #[arg(long, help = "Protocol type")]
        protocol: Option<String>,

        #[arg(long, help = "Invalidation strategy")]
        invalidation: Option<String>,

        #[arg(long, help = "Update propagation")]
        propagation: Option<String>,
    },

    #[command(about = "Check coherence")]
    Check {
        #[arg(long, help = "Check level")]
        level: Option<String>,

        #[arg(long, help = "Include replicas")]
        replicas: bool,

        #[arg(long, help = "Fix issues")]
        fix: bool,
    },

    #[command(about = "Invalidation management")]
    Invalidate {
        #[arg(long, help = "Invalidation scope")]
        scope: Option<String>,

        #[arg(long, help = "Broadcast")]
        broadcast: bool,

        #[arg(long, help = "Wait for ack")]
        wait: bool,
    },

    #[command(about = "Conflict resolution")]
    Conflicts {
        #[arg(long, help = "Show conflicts")]
        show: bool,

        #[arg(long, help = "Resolution strategy")]
        strategy: Option<String>,

        #[arg(long, help = "Auto-resolve")]
        auto_resolve: bool,
    },
}

pub async fn execute(args: AdvancedCacheArgs, _config: &Config) -> Result<()> {
    // Validate command arguments before execution
    validate_command(&args.command)?;

    let cache_system = create_cache_system()?;

    match args.command {
        CacheCommand::Cache { command } => handle_cache_command(command, &cache_system).await,
        CacheCommand::Memory { command } => handle_memory_command(command, &cache_system).await,
        CacheCommand::Eviction { command } => handle_eviction_command(command, &cache_system).await,
        CacheCommand::Prefetch { command } => handle_prefetch_command(command, &cache_system).await,
        CacheCommand::Tiers { command } => handle_tier_command(command, &cache_system).await,
        CacheCommand::Distributed { command } => {
            handle_distributed_command(command, &cache_system).await
        }
        CacheCommand::Compression { command } => {
            handle_compression_command(command, &cache_system).await
        }
        CacheCommand::Monitor { command } => handle_monitor_command(command, &cache_system).await,
        CacheCommand::Optimize { command } => handle_optimize_command(command, &cache_system).await,
        CacheCommand::Backup { command } => handle_backup_command(command, &cache_system).await,
        CacheCommand::Coherence { command } => {
            handle_coherence_command(command, &cache_system).await
        }
        CacheCommand::Status {
            detailed,
            tiers,
            memory,
            hot_keys,
            refresh,
        } => handle_status_command(&cache_system, detailed, tiers, memory, hot_keys, refresh).await,
    }
}

// ============================================================================
// Validation Functions
// ============================================================================

/// Validate command arguments before execution
fn validate_command(command: &CacheCommand) -> Result<()> {
    match command {
        CacheCommand::Eviction { command } => validate_eviction_command(command),
        CacheCommand::Prefetch { command } => validate_prefetch_command(command),
        CacheCommand::Tiers { command } => validate_tier_command(command),
        CacheCommand::Distributed { command } => validate_distributed_command(command),
        CacheCommand::Compression { command } => validate_compression_command(command),
        CacheCommand::Cache { command } => validate_cache_operation_command(command),
        _ => Ok(()),
    }
}

/// Validate cache operation command arguments
fn validate_cache_operation_command(command: &CacheOperationCommand) -> Result<()> {
    match command {
        CacheOperationCommand::Get { key, .. } => {
            if key.is_empty() {
                bail!("Cache key cannot be empty");
            }
            Ok(())
        }
        CacheOperationCommand::Put {
            key,
            value,
            ttl,
            priority,
            ..
        } => {
            if key.is_empty() {
                bail!("Cache key cannot be empty");
            }
            if value.is_empty() {
                bail!("Cache value cannot be empty");
            }
            if let Some(p) = priority {
                if *p > 10 {
                    bail!("Priority must be between 0 and 10");
                }
            }
            Ok(())
        }
        CacheOperationCommand::Delete { key, .. } => {
            if key.is_empty() {
                bail!("Cache key cannot be empty");
            }
            Ok(())
        }
        CacheOperationCommand::Invalidate { pattern, .. } => {
            if pattern.is_empty() {
                bail!("Invalidation pattern cannot be empty");
            }
            Ok(())
        }
        _ => Ok(()),
    }
}

/// Validate eviction command arguments
fn validate_eviction_command(command: &EvictionCommand) -> Result<()> {
    match command {
        EvictionCommand::Policy { policy, .. } => {
            let policy_lower = policy.to_lowercase();
            if !VALID_EVICTION_POLICIES.contains(&policy_lower.as_str()) {
                bail!(
                    "Invalid eviction policy '{}'. Must be one of: {}",
                    policy,
                    VALID_EVICTION_POLICIES.join(", ")
                );
            }
            Ok(())
        }
        EvictionCommand::Adaptive { learning_rate, .. } => {
            if let Some(rate) = learning_rate {
                if *rate <= 0.0 || *rate > 1.0 {
                    bail!("Learning rate must be between 0.0 and 1.0 (exclusive of 0)");
                }
            }
            Ok(())
        }
        EvictionCommand::Priority {
            threshold,
            preserve,
        } => {
            if let Some(t) = threshold {
                if *t > 10 {
                    bail!("Priority threshold must be between 0 and 10");
                }
            }
            Ok(())
        }
        _ => Ok(()),
    }
}

/// Validate prefetch command arguments
fn validate_prefetch_command(command: &PrefetchCommand) -> Result<()> {
    match command {
        PrefetchCommand::Warm {
            source, location, ..
        } => {
            let source_lower = source.to_lowercase();
            if !VALID_WARMUP_STRATEGIES.contains(&source_lower.as_str()) {
                bail!(
                    "Invalid warmup source '{}'. Must be one of: {}",
                    source,
                    VALID_WARMUP_STRATEGIES.join(", ")
                );
            }
            if location.is_empty() {
                bail!("Location cannot be empty for cache warming");
            }
            Ok(())
        }
        PrefetchCommand::Patterns { confidence, .. } => {
            if let Some(c) = confidence {
                if *c < 0.0 || *c > 1.0 {
                    bail!("Confidence threshold must be between 0.0 and 1.0");
                }
            }
            Ok(())
        }
        PrefetchCommand::Config { strategy, .. } => {
            if let Some(s) = strategy {
                let valid_strategies = ["sequential", "strided", "markov", "adaptive", "ml"];
                if !valid_strategies.contains(&s.to_lowercase().as_str()) {
                    bail!(
                        "Invalid prefetch strategy '{}'. Must be one of: {}",
                        s,
                        valid_strategies.join(", ")
                    );
                }
            }
            Ok(())
        }
        _ => Ok(()),
    }
}

/// Validate tier command arguments
fn validate_tier_command(command: &TierCommand) -> Result<()> {
    match command {
        TierCommand::Config { tier, .. } => {
            let tier_lower = tier.to_lowercase();
            if !VALID_TIER_NAMES.contains(&tier_lower.as_str()) {
                bail!(
                    "Invalid tier name '{}'. Must be one of: {}",
                    tier,
                    VALID_TIER_NAMES.join(", ")
                );
            }
            Ok(())
        }
        TierCommand::Promote { from, to, .. } | TierCommand::Demote { from, to, .. } => {
            let from_lower = from.to_lowercase();
            let to_lower = to.to_lowercase();
            if !VALID_TIER_NAMES.contains(&from_lower.as_str()) {
                bail!(
                    "Invalid source tier '{}'. Must be one of: {}",
                    from,
                    VALID_TIER_NAMES.join(", ")
                );
            }
            if !VALID_TIER_NAMES.contains(&to_lower.as_str()) {
                bail!(
                    "Invalid target tier '{}'. Must be one of: {}",
                    to,
                    VALID_TIER_NAMES.join(", ")
                );
            }
            if from_lower == to_lower {
                bail!("Source and target tiers cannot be the same");
            }
            Ok(())
        }
        TierCommand::Migrate { threshold, .. } => {
            if let Some(t) = threshold {
                if *t < 0.0 || *t > 1.0 {
                    bail!("Migration threshold must be between 0.0 and 1.0");
                }
            }
            Ok(())
        }
        _ => Ok(()),
    }
}

/// Validate distributed command arguments
fn validate_distributed_command(command: &DistributedCommand) -> Result<()> {
    match command {
        DistributedCommand::Config {
            consistency,
            replication,
            ..
        } => {
            if let Some(c) = consistency {
                let c_lower = c.to_lowercase();
                if !VALID_CONSISTENCY_LEVELS.contains(&c_lower.as_str()) {
                    bail!(
                        "Invalid consistency level '{}'. Must be one of: {}",
                        c,
                        VALID_CONSISTENCY_LEVELS.join(", ")
                    );
                }
            }
            if let Some(r) = replication {
                if *r == 0 || *r > 10 {
                    bail!("Replication factor must be between 1 and 10");
                }
            }
            Ok(())
        }
        DistributedCommand::Nodes { command } => validate_node_command(command),
        _ => Ok(()),
    }
}

/// Validate node command arguments
fn validate_node_command(command: &NodeCommand) -> Result<()> {
    match command {
        NodeCommand::Add { address, .. } => {
            if address.is_empty() {
                bail!("Node address cannot be empty");
            }
            // Basic address format validation
            if !address.contains(':') && !address.starts_with("http") {
                bail!("Invalid node address format. Expected format: host:port or URL");
            }
            Ok(())
        }
        NodeCommand::Remove { node_id, .. } => {
            if node_id.is_empty() {
                bail!("Node ID cannot be empty");
            }
            Ok(())
        }
        _ => Ok(()),
    }
}

/// Validate compression command arguments
fn validate_compression_command(command: &CompressionCommand) -> Result<()> {
    match command {
        CompressionCommand::Config {
            algorithm, level, ..
        } => {
            if let Some(a) = algorithm {
                let a_lower = a.to_lowercase();
                if !VALID_COMPRESSION_ALGORITHMS.contains(&a_lower.as_str()) {
                    bail!(
                        "Invalid compression algorithm '{}'. Must be one of: {}",
                        a,
                        VALID_COMPRESSION_ALGORITHMS.join(", ")
                    );
                }
            }
            if let Some(l) = level {
                if *l > 22 {
                    bail!("Compression level must be between 0 and 22");
                }
            }
            Ok(())
        }
        CompressionCommand::Test { size, .. } => {
            if *size == 0 {
                bail!("Test data size must be greater than 0");
            }
            Ok(())
        }
        CompressionCommand::Adaptive {
            threshold,
            sample_rate,
            ..
        } => {
            if let Some(t) = threshold {
                if *t < 1.0 {
                    bail!("Compression ratio threshold must be at least 1.0");
                }
            }
            if let Some(r) = sample_rate {
                if *r <= 0.0 || *r > 1.0 {
                    bail!("Sample rate must be between 0.0 (exclusive) and 1.0");
                }
            }
            Ok(())
        }
        _ => Ok(()),
    }
}

fn create_cache_system() -> Result<AdvancedCacheSystem> {
    use crate::advanced_cache::{EvictionPolicy, PrefetchStrategy};
    let config = AdvancedCacheConfig::default();
    let backend = Arc::new(MockCacheBackend::new());
    let eviction = Arc::new(RwLock::new(EvictionPolicy::Lru));
    let prefetch = Arc::new(RwLock::new(PrefetchStrategy::Sequential));
    let compression = Arc::new(MockCompressionEngine::new());
    let monitor = Arc::new(RwLock::new(MockCacheMonitor::new()));
    let optimizer = Arc::new(RwLock::new(MockCacheOptimizer::new()));

    Ok(AdvancedCacheSystem::new(
        config,
        backend,
        eviction,
        prefetch,
        compression,
        monitor,
        optimizer,
    ))
}

async fn handle_cache_command(
    command: CacheOperationCommand,
    system: &AdvancedCacheSystem,
) -> Result<()> {
    match command {
        CacheOperationCommand::Get {
            key,
            metadata,
            stats,
        } => {
            println!("Getting key: {}", key);

            match system.get(&key).await? {
                Some(value) => {
                    println!("Value: {} bytes", value.len());
                    if metadata {
                        println!("Metadata:");
                        println!("  Created: N/A");
                        println!("  Accessed: N/A");
                        println!("  TTL: N/A");
                    }
                    if stats {
                        let stats = system.get_statistics().await;
                        println!("Statistics:");
                        println!("  Hit rate: {:.2}%", stats.hit_rate * 100.0);
                    }
                }
                None => {
                    println!("Key not found");
                }
            }
            Ok(())
        }
        CacheOperationCommand::Put {
            key,
            value,
            ttl,
            priority,
            compress,
        } => {
            println!("Putting key: {}", key);

            let ttl_duration = ttl.map(Duration::from_secs);
            system.put(&key, value.into_bytes(), ttl_duration).await?;

            println!("✓ Value stored successfully");
            if let Some(t) = ttl {
                println!("  TTL: {} seconds", t);
            }
            if let Some(p) = priority {
                println!("  Priority: {}", p);
            }
            if compress {
                println!("  Compression: enabled");
            }
            Ok(())
        }
        CacheOperationCommand::Delete { key, pattern: _ } => {
            println!("Deleting key: {}", key);

            let deleted = system.delete(&key).await?;

            if deleted {
                println!("✓ Key deleted successfully");
            } else {
                println!("Key not found");
            }
            Ok(())
        }
        CacheOperationCommand::Clear {
            tier: _,
            force,
            preserve_hot,
        } => {
            if !force {
                println!("This will clear the cache. Use --force to confirm.");
                return Ok(());
            }

            println!("Clearing cache...");

            system.clear().await?;

            println!("✓ Cache cleared successfully");
            if preserve_hot {
                println!("  Hot keys preserved");
            }
            Ok(())
        }
        CacheOperationCommand::List {
            pattern,
            limit,
            sort,
        } => {
            println!("Cache Keys");
            println!("==========");

            // Mock listing
            println!("key1");
            println!("key2");
            println!("key3");

            if let Some(l) = limit {
                println!("\n(Limited to {} results)", l);
            }
            Ok(())
        }
        CacheOperationCommand::Invalidate {
            pattern,
            cascade,
            broadcast,
        } => {
            println!("Invalidating pattern: {}", pattern);

            if cascade {
                println!("  Cascading to dependencies");
            }
            if broadcast {
                println!("  Broadcasting to cluster");
            }

            println!("✓ Invalidation completed");
            Ok(())
        }
    }
}

async fn handle_memory_command(command: MemoryCommand, system: &AdvancedCacheSystem) -> Result<()> {
    match command {
        MemoryCommand::Stats {
            pools,
            fragmentation,
            allocations,
        } => {
            let stats = system.get_memory_statistics().await;

            println!("Memory Statistics");
            println!("================");
            println!("  Allocated: {} MB", stats.total_allocated / 1_048_576);
            println!("  Used: {} MB", stats.total_used / 1_048_576);
            println!("  Free: {} MB", stats.total_free / 1_048_576);

            if fragmentation {
                println!("\nFragmentation:");
                println!("  Ratio: {:.2}%", stats.fragmentation_ratio * 100.0);
            }

            if allocations {
                println!("\nAllocations:");
                println!("  Rate: {:.2}/s", stats.allocation_rate);
                println!("  Deallocation rate: {:.2}/s", stats.deallocation_rate);
            }

            if pools {
                println!("\nMemory Pools:");
                for (name, pool_stats) in &stats.pool_stats {
                    println!("  {}:", name);
                    println!("    Size: {} bytes", pool_stats.pool_size);
                    println!("    Allocated: {}", pool_stats.objects_allocated);
                    println!("    Free: {}", pool_stats.objects_free);
                }
            }

            Ok(())
        }
        MemoryCommand::Limits {
            soft,
            hard,
            oom_handler,
        } => {
            println!("Configuring memory limits...");

            if let Some(s) = soft {
                println!("  Soft limit: {} MB", s);
            }
            if let Some(h) = hard {
                println!("  Hard limit: {} MB", h);
            }
            if let Some(handler) = oom_handler {
                println!("  OOM handler: {}", handler);
            }

            println!("✓ Memory limits configured");
            Ok(())
        }
        MemoryCommand::Pools { command } => handle_pool_command(command).await,
        MemoryCommand::GC {
            gc_type,
            full,
            concurrent,
        } => {
            println!("Triggering garbage collection...");

            if full {
                println!("  Full GC requested");
            }
            if concurrent {
                println!("  Concurrent mode");
            }

            println!("✓ Garbage collection completed");
            println!("  Reclaimed: 50 MB");
            println!("  Duration: 25 ms");
            Ok(())
        }
        MemoryCommand::Pressure {
            recommend,
            threshold,
        } => {
            println!("Memory Pressure Analysis");
            println!("=======================");
            println!("  Current level: Medium");
            println!("  Usage: 75%");
            println!("  Available: 256 MB");

            if recommend {
                println!("\nRecommendations:");
                println!("  - Increase eviction rate");
                println!("  - Enable compression");
                println!("  - Consider cache size reduction");
            }

            Ok(())
        }
        MemoryCommand::Profile {
            duration,
            heap,
            output,
        } => {
            println!("Starting memory profiling...");

            if let Some(d) = duration {
                println!("  Duration: {} seconds", d);
            }
            if heap {
                println!("  Including heap dump");
            }

            println!("✓ Profiling completed");
            if let Some(out) = output {
                println!("  Results saved to: {}", out.display());
            }

            Ok(())
        }
    }
}

async fn handle_pool_command(command: PoolCommand) -> Result<()> {
    match command {
        PoolCommand::Create { size, initial, max } => {
            println!("Creating memory pool");
            println!("  Object size: {} bytes", size);
            println!("  Initial count: {}", initial);
            println!("  Max count: {}", max);
            println!("✓ Pool created successfully");
            Ok(())
        }
        PoolCommand::List { utilization } => {
            println!("Memory Pools");
            println!("===========");
            println!("Size    | Initial | Max    | Used   | Free");
            println!("--------|---------|--------|--------|------");
            println!("64B     | 1000    | 10000  | 750    | 250");
            println!("256B    | 500     | 5000   | 300    | 200");
            println!("1KB     | 100     | 1000   | 50     | 50");

            if utilization {
                println!("\nUtilization: 65%");
            }
            Ok(())
        }
        PoolCommand::Resize { size, count } => {
            println!("Resizing pool for size: {} bytes", size);
            println!("  New count: {}", count);
            println!("✓ Pool resized successfully");
            Ok(())
        }
        PoolCommand::Reclaim { policy, force } => {
            println!("Reclaiming unused memory...");

            if let Some(p) = policy {
                println!("  Policy: {}", p);
            }
            if force {
                println!("  Force reclaim enabled");
            }

            println!("✓ Reclaimed 25 MB");
            Ok(())
        }
    }
}

async fn handle_eviction_command(
    command: EvictionCommand,
    system: &AdvancedCacheSystem,
) -> Result<()> {
    match command {
        EvictionCommand::Policy {
            policy,
            max_entries,
            max_size,
            ttl,
        } => {
            println!("Configuring eviction policy: {}", policy);

            if let Some(entries) = max_entries {
                println!("  Max entries: {}", entries);
            }
            if let Some(size) = max_size {
                println!("  Max size: {} MB", size);
            }
            if let Some(t) = ttl {
                println!("  TTL: {} seconds", t);
            }

            println!("✓ Eviction policy configured");
            Ok(())
        }
        EvictionCommand::Evict {
            count,
            tier,
            reason,
        } => {
            println!("Triggering eviction...");

            let evict_count = count.unwrap_or(100);
            println!("  Evicting {} entries", evict_count);

            if let Some(t) = tier {
                println!("  From tier: {}", t);
            }
            if let Some(r) = reason {
                println!("  Reason: {}", r);
            }

            println!("✓ Evicted {} entries", evict_count);
            Ok(())
        }
        EvictionCommand::Stats {
            range,
            by_policy,
            by_reason,
        } => {
            println!("Eviction Statistics");
            println!("==================");
            println!("  Total evicted: 10,000");
            println!("  Eviction rate: 10/s");
            println!("  Avg entry lifetime: 300s");

            if by_policy {
                println!("\nBy Policy:");
                println!("  LRU: 7,000");
                println!("  TTL: 2,000");
                println!("  Size: 1,000");
            }

            if by_reason {
                println!("\nBy Reason:");
                println!("  Capacity: 8,000");
                println!("  TTL: 1,500");
                println!("  Manual: 500");
            }

            Ok(())
        }
        EvictionCommand::Adaptive {
            enable,
            learning_rate,
            window,
        } => {
            if enable {
                println!("Enabling adaptive eviction");
                if let Some(rate) = learning_rate {
                    println!("  Learning rate: {}", rate);
                }
                if let Some(w) = window {
                    println!("  History window: {}", w);
                }
            } else {
                println!("Disabling adaptive eviction");
            }

            println!("✓ Adaptive eviction configured");
            Ok(())
        }
        EvictionCommand::Priority {
            threshold,
            preserve,
        } => {
            println!("Configuring priority-based eviction");

            if let Some(t) = threshold {
                println!("  Priority threshold: {}", t);
            }
            if let Some(p) = preserve {
                println!("  Preserve count: {}", p);
            }

            println!("✓ Priority eviction configured");
            Ok(())
        }
    }
}

async fn handle_prefetch_command(
    command: PrefetchCommand,
    system: &AdvancedCacheSystem,
) -> Result<()> {
    match command {
        PrefetchCommand::Config {
            enable,
            strategy,
            distance,
            degree,
        } => {
            if enable {
                println!("Enabling prefetching");
                if let Some(s) = strategy {
                    println!("  Strategy: {}", s);
                }
                if let Some(d) = distance {
                    println!("  Distance: {}", d);
                }
                if let Some(deg) = degree {
                    println!("  Degree: {}", deg);
                }
            } else {
                println!("Disabling prefetching");
            }

            println!("✓ Prefetching configured");
            Ok(())
        }
        PrefetchCommand::Warm {
            source,
            location,
            filter,
            parallel,
            batch,
        } => {
            println!("Warming cache from source: {}", source);
            println!("  Location: {}", location);

            let source_type = match source.as_str() {
                "file" => SourceType::File,
                "database" => SourceType::Database,
                "api" => SourceType::Api,
                _ => SourceType::Custom,
            };

            let sources = vec![WarmingSource {
                source_type,
                location,
                filter,
                priority: 5,
            }];

            let warmed = system.warm_cache(sources).await?;

            println!("✓ Warmed {} entries", warmed);
            Ok(())
        }
        PrefetchCommand::Prefetch {
            keys,
            async_mode,
            priority,
        } => {
            println!("Prefetching {} keys", keys.len());

            if async_mode {
                println!("  Async mode enabled");
            }
            if let Some(p) = priority {
                println!("  Priority: {}", p);
            }

            println!("✓ Prefetch initiated");
            Ok(())
        }
        PrefetchCommand::Patterns {
            enable,
            confidence,
            show,
        } => {
            if show {
                println!("Detected Patterns");
                println!("================");
                println!("  Sequential: 45% confidence");
                println!("  Temporal: 30% confidence");
                println!("  Random: 25% confidence");
            } else if enable {
                println!("Enabling pattern detection");
                if let Some(c) = confidence {
                    println!("  Confidence threshold: {}", c);
                }
                println!("✓ Pattern detection enabled");
            } else {
                println!("Disabling pattern detection");
                println!("✓ Pattern detection disabled");
            }

            Ok(())
        }
        PrefetchCommand::Stats {
            accuracy,
            coverage,
            patterns,
        } => {
            println!("Prefetch Statistics");
            println!("==================");
            println!("  Prefetch count: 10,000");
            println!("  Prefetch hits: 7,500");

            if accuracy {
                println!("\nAccuracy: 75%");
            }
            if coverage {
                println!("Coverage: 60%");
            }
            if patterns {
                println!("\nPattern Matches:");
                println!("  Sequential: 5,000");
                println!("  Strided: 2,000");
                println!("  Markov: 500");
            }

            Ok(())
        }
    }
}

async fn handle_tier_command(command: TierCommand, system: &AdvancedCacheSystem) -> Result<()> {
    match command {
        TierCommand::Config {
            tier,
            capacity,
            latency,
            cost,
        } => {
            println!("Configuring tier: {}", tier);

            if let Some(c) = capacity {
                println!("  Capacity: {} MB", c);
            }
            if let Some(l) = latency {
                println!("  Latency: {} ms", l);
            }
            if let Some(cost_val) = cost {
                println!("  Cost: ${}/GB", cost_val);
            }

            println!("✓ Tier configured");
            Ok(())
        }
        TierCommand::List {
            utilization,
            performance,
        } => {
            println!("Cache Tiers");
            println!("===========");
            println!("Tier     | Type    | Capacity | Latency | Cost");
            println!("---------|---------|----------|---------|------");
            println!("L1       | Memory  | 32 KB    | 1 ns    | $10/GB");
            println!("L2       | Memory  | 256 KB   | 10 ns   | $10/GB");
            println!("L3       | Memory  | 8 MB     | 30 ns   | $10/GB");
            println!("External | Redis   | 1 GB     | 1 ms    | $1/GB");

            if utilization {
                println!("\nUtilization:");
                println!("  L1: 95%");
                println!("  L2: 80%");
                println!("  L3: 60%");
                println!("  External: 40%");
            }

            if performance {
                println!("\nPerformance:");
                println!("  Hit rates: L1=95%, L2=80%, L3=60%, External=40%");
            }

            Ok(())
        }
        TierCommand::Promote {
            from,
            to,
            policy,
            count,
        } => {
            println!("Promoting entries from {} to {}", from, to);

            if let Some(p) = policy {
                println!("  Policy: {}", p);
            }
            if let Some(c) = count {
                println!("  Count: {}", c);
            }

            println!("✓ Promotion completed");
            Ok(())
        }
        TierCommand::Demote {
            from,
            to,
            policy,
            count,
        } => {
            println!("Demoting entries from {} to {}", from, to);

            if let Some(p) = policy {
                println!("  Policy: {}", p);
            }
            if let Some(c) = count {
                println!("  Count: {}", c);
            }

            println!("✓ Demotion completed");
            Ok(())
        }
        TierCommand::Migrate {
            auto,
            threshold,
            interval,
        } => {
            if auto {
                println!("Enabling auto-migration");
                if let Some(t) = threshold {
                    println!("  Threshold: {}", t);
                }
                if let Some(i) = interval {
                    println!("  Interval: {} seconds", i);
                }
                println!("✓ Auto-migration enabled");
            } else {
                println!("Disabling auto-migration");
                println!("✓ Auto-migration disabled");
            }

            Ok(())
        }
    }
}

async fn handle_distributed_command(
    command: DistributedCommand,
    system: &AdvancedCacheSystem,
) -> Result<()> {
    match command {
        DistributedCommand::Config {
            topology,
            consistency,
            replication,
            partitioning,
        } => {
            println!("Configuring distributed cache");

            if let Some(t) = topology {
                println!("  Topology: {}", t);
            }
            if let Some(c) = consistency {
                println!("  Consistency: {}", c);
            }
            if let Some(r) = replication {
                println!("  Replication factor: {}", r);
            }
            if let Some(p) = partitioning {
                println!("  Partitioning: {}", p);
            }

            println!("✓ Distributed cache configured");
            Ok(())
        }
        DistributedCommand::Nodes { command } => handle_node_command(command).await,
        DistributedCommand::Replication { status, sync, lag } => {
            if status {
                println!("Replication Status");
                println!("=================");
                println!("  Primary: node1");
                println!("  Replicas: node2, node3");
                println!("  Sync status: InSync");
            }

            if sync {
                println!("\nForcing synchronization...");
                println!("✓ Sync completed");
            }

            if lag {
                println!("\nReplication Lag:");
                println!("  node2: 0 bytes, 0 operations");
                println!("  node3: 100 bytes, 5 operations");
            }

            Ok(())
        }
        DistributedCommand::Partition {
            rebalance,
            distribution,
            plan,
        } => {
            if distribution {
                println!("Partition Distribution");
                println!("====================");
                println!("Node   | Partitions | Keys    | Size");
                println!("-------|------------|---------|------");
                println!("node1  | 0-5        | 10,000  | 100MB");
                println!("node2  | 6-10       | 9,500   | 95MB");
                println!("node3  | 11-15      | 10,500  | 105MB");
            }

            if rebalance {
                println!("\nRebalancing partitions...");
                println!("✓ Rebalancing completed");
            }

            if plan {
                println!("\nMigration Plan:");
                println!("  Move partition 5 from node1 to node2");
                println!("  Move partition 11 from node3 to node1");
            }

            Ok(())
        }
        DistributedCommand::Consistency {
            check,
            repair,
            conflicts,
        } => {
            if check {
                println!("Checking consistency...");
                println!("✓ Consistency check passed");
            }

            if repair {
                println!("\nRepairing inconsistencies...");
                println!("✓ Repaired 2 inconsistencies");
            }

            if conflicts {
                println!("\nConflicts:");
                println!("  key1: node1=v1, node2=v2 (timestamp conflict)");
            }

            Ok(())
        }
    }
}

async fn handle_node_command(command: NodeCommand) -> Result<()> {
    match command {
        NodeCommand::Add {
            address,
            capacity,
            role,
        } => {
            println!("Adding cache node: {}", address);

            if let Some(c) = capacity {
                println!("  Capacity: {} MB", c);
            }
            if let Some(r) = role {
                println!("  Role: {}", r);
            }

            println!("✓ Node added successfully");
            Ok(())
        }
        NodeCommand::Remove {
            node_id,
            graceful,
            redistribute,
        } => {
            println!("Removing node: {}", node_id);

            if graceful {
                println!("  Graceful removal");
            }
            if redistribute {
                println!("  Redistributing data");
            }

            println!("✓ Node removed successfully");
            Ok(())
        }
        NodeCommand::List { status, metrics } => {
            println!("Cache Nodes");
            println!("===========");
            println!("Node   | Address       | Status | Capacity | Used");
            println!("-------|---------------|--------|----------|------");
            println!("node1  | 10.0.0.1:6379 | Active | 1GB      | 400MB");
            println!("node2  | 10.0.0.2:6379 | Active | 1GB      | 350MB");
            println!("node3  | 10.0.0.3:6379 | Active | 1GB      | 300MB");

            if metrics {
                println!("\nMetrics:");
                println!("  Total requests: 1M");
                println!("  Avg latency: 1ms");
            }

            Ok(())
        }
        NodeCommand::Health {
            node_id,
            diagnostics,
        } => {
            let node = node_id.unwrap_or("all".to_string());
            println!("Health Check: {}", node);
            println!("=============");
            println!("  Status: Healthy");
            println!("  Uptime: 7 days");
            println!("  Last heartbeat: 2s ago");

            if diagnostics {
                println!("\nDiagnostics:");
                println!("  CPU: 45%");
                println!("  Memory: 60%");
                println!("  Network: OK");
            }

            Ok(())
        }
    }
}

async fn handle_compression_command(
    command: CompressionCommand,
    system: &AdvancedCacheSystem,
) -> Result<()> {
    match command {
        CompressionCommand::Config {
            enable,
            algorithm,
            level,
            min_size,
        } => {
            if enable {
                println!("Enabling compression");
                if let Some(a) = algorithm {
                    println!("  Algorithm: {}", a);
                }
                if let Some(l) = level {
                    println!("  Level: {}", l);
                }
                if let Some(m) = min_size {
                    println!("  Min size: {} bytes", m);
                }
            } else {
                println!("Disabling compression");
            }

            println!("✓ Compression configured");
            Ok(())
        }
        CompressionCommand::Stats {
            ratios,
            performance,
            by_algorithm,
        } => {
            println!("Compression Statistics");
            println!("=====================");
            println!("  Compressed entries: 5,000");
            println!("  Total saved: 250 MB");

            if ratios {
                println!("\nCompression Ratios:");
                println!("  Average: 2.5:1");
                println!("  Best: 10:1");
                println!("  Worst: 1.1:1");
            }

            if performance {
                println!("\nPerformance:");
                println!("  Avg compression time: 0.5ms");
                println!("  Avg decompression time: 0.2ms");
            }

            if by_algorithm {
                println!("\nBy Algorithm:");
                println!("  LZ4: 3,000 entries, 2.2:1");
                println!("  Zstd: 1,500 entries, 3.0:1");
                println!("  Gzip: 500 entries, 2.8:1");
            }

            Ok(())
        }
        CompressionCommand::Test {
            size,
            algorithm,
            iterations,
        } => {
            println!("Testing compression");
            println!("  Data size: {} bytes", size);

            let algo = algorithm.unwrap_or("lz4".to_string());
            let iters = iterations.unwrap_or(100);

            println!("  Algorithm: {}", algo);
            println!("  Iterations: {}", iters);

            println!("\nResults:");
            println!("  Compression ratio: 2.3:1");
            println!("  Avg time: 0.4ms");
            println!("  Throughput: 250 MB/s");

            Ok(())
        }
        CompressionCommand::Adaptive {
            enable,
            threshold,
            sample_rate,
        } => {
            if enable {
                println!("Enabling adaptive compression");
                if let Some(t) = threshold {
                    println!("  Ratio threshold: {}", t);
                }
                if let Some(s) = sample_rate {
                    println!("  Sample rate: {}", s);
                }
                println!("✓ Adaptive compression enabled");
            } else {
                println!("Disabling adaptive compression");
                println!("✓ Adaptive compression disabled");
            }

            Ok(())
        }
    }
}

async fn handle_monitor_command(
    command: MonitorCommand,
    system: &AdvancedCacheSystem,
) -> Result<()> {
    match command {
        MonitorCommand::Metrics {
            metric,
            range,
            aggregation,
            export,
        } => {
            let stats = system.get_statistics().await;

            println!("Cache Metrics");
            println!("============");
            println!("  Total entries: {}", stats.total_entries);
            println!("  Total size: {} MB", stats.total_size_bytes / 1_048_576);
            println!("  Hit count: {}", stats.hit_count);
            println!("  Miss count: {}", stats.miss_count);
            println!("  Hit rate: {:.2}%", stats.hit_rate * 100.0);
            println!("  Eviction count: {}", stats.eviction_count);

            if let Some(m) = metric {
                println!("\nMetric: {}", m);
            }

            Ok(())
        }
        MonitorCommand::HotKeys {
            top,
            threshold,
            window,
            promote,
        } => {
            let hot_keys = system.detect_hot_keys().await?;

            println!("Hot Keys Analysis");
            println!("================");

            let limit = top.unwrap_or(10);
            println!("Top {} hot keys:", limit);

            for i in 0..limit.min(5) {
                println!("  key{}: 1000 accesses, heat score: 0.9", i);
            }

            if promote {
                println!("\n✓ Hot keys promoted to higher tier");
            }

            Ok(())
        }
        MonitorCommand::Performance {
            latency,
            throughput,
            percentiles,
        } => {
            let stats = system.get_statistics().await;

            println!("Performance Metrics");
            println!("==================");

            if latency {
                println!("Latency:");
                println!("  Average: {} μs", stats.avg_latency_ns / 1000);
            }

            if throughput {
                println!("Throughput:");
                println!("  Operations/sec: 10,000");
            }

            if percentiles {
                println!("Percentiles:");
                println!("  P50: {} μs", stats.p50_latency_ns / 1000);
                println!("  P95: {} μs", stats.p95_latency_ns / 1000);
                println!("  P99: {} μs", stats.p99_latency_ns / 1000);
            }

            Ok(())
        }
        MonitorCommand::Alerts {
            alert_type,
            threshold,
            action,
        } => {
            println!("Configuring alerts");

            if let Some(t) = alert_type {
                println!("  Alert type: {}", t);
            }
            if let Some(th) = threshold {
                println!("  Threshold: {}", th);
            }
            if let Some(a) = action {
                println!("  Action: {}", a);
            }

            println!("✓ Alert configured");
            Ok(())
        }
        MonitorCommand::Workload {
            patterns,
            distribution,
            predict,
        } => {
            println!("Workload Analysis");
            println!("================");

            if patterns {
                println!("Patterns:");
                println!("  Random: 40%");
                println!("  Sequential: 35%");
                println!("  Temporal: 25%");
            }

            if distribution {
                println!("\nKey Distribution:");
                println!("  Uniform: 60%");
                println!("  Zipfian: 30%");
                println!("  Gaussian: 10%");
            }

            if predict {
                println!("\nPredicted Load:");
                println!("  Next hour: +15%");
                println!("  Peak time: 14:00");
            }

            Ok(())
        }
    }
}

async fn handle_optimize_command(
    command: OptimizeCommand,
    system: &AdvancedCacheSystem,
) -> Result<()> {
    match command {
        OptimizeCommand::Run {
            target,
            auto_tune,
            ml,
            dry_run,
        } => {
            println!("Running optimization...");

            if let Some(t) = target {
                println!("  Target: {}", t);
            }
            if auto_tune {
                println!("  Auto-tuning enabled");
            }
            if ml {
                println!("  ML optimization enabled");
            }

            if !dry_run {
                // For CLI demo purposes, show mock optimization results
                println!("\n3 optimizations applied");
                println!("  - Cache size optimized");
                println!("  - Eviction policy tuned");
                println!("  - Prefetch strategy adjusted");
            } else {
                println!("\nDRY RUN - No changes applied");
            }

            Ok(())
        }
        OptimizeCommand::Recommend {
            depth,
            cost,
            priority,
        } => {
            println!("Optimization Recommendations");
            println!("===========================");

            println!("\n1. Increase cache size");
            println!("   Impact: +10% hit rate");
            println!("   Confidence: 85%");

            println!("\n2. Enable prefetching");
            println!("   Impact: -20% miss rate");
            println!("   Confidence: 75%");

            println!("\n3. Change eviction to ARC");
            println!("   Impact: +5% hit rate");
            println!("   Confidence: 70%");

            if cost {
                println!("\nCost Analysis:");
                println!("  Current: $100/month");
                println!("  Optimized: $120/month");
                println!("  ROI: 150%");
            }

            Ok(())
        }
        OptimizeCommand::AutoTune {
            enable,
            interval,
            model,
        } => {
            if enable {
                println!("Enabling auto-tuning");
                if let Some(i) = interval {
                    println!("  Interval: {} seconds", i);
                }
                if let Some(m) = model {
                    println!("  ML model: {}", m);
                }
                println!("✓ Auto-tuning enabled");
            } else {
                println!("Disabling auto-tuning");
                println!("✓ Auto-tuning disabled");
            }

            Ok(())
        }
        OptimizeCommand::Size {
            hit_rate,
            budget,
            apply,
        } => {
            println!("Size Optimization");
            println!("================");

            if let Some(h) = hit_rate {
                println!("  Target hit rate: {:.2}%", h * 100.0);
            }
            if let Some(b) = budget {
                println!("  Memory budget: {} MB", b);
            }

            println!("\nRecommended size: 512 MB");
            println!("Expected hit rate: 92%");

            if apply {
                println!("\n✓ Size optimization applied");
            }

            Ok(())
        }
        OptimizeCommand::Workload {
            workload,
            optimize_for,
        } => {
            println!("Workload Optimization");

            if let Some(w) = workload {
                println!("  Workload type: {}", w);
            }
            if let Some(o) = optimize_for {
                println!("  Optimize for: {}", o);
            }

            println!("\nOptimization applied:");
            println!("  - Adjusted eviction policy");
            println!("  - Tuned prefetching");
            println!("  - Optimized tier configuration");

            Ok(())
        }
    }
}

async fn handle_backup_command(command: BackupCommand, system: &AdvancedCacheSystem) -> Result<()> {
    match command {
        BackupCommand::Create {
            backup_type,
            destination,
            compress,
            encrypt,
        } => {
            println!("Creating backup...");

            let backup = system.backup().await?;

            println!("✓ Backup created");
            println!("  ID: {}", backup.backup_id);
            println!("  Size: {} MB", backup.size_bytes / 1_048_576);
            println!("  Entries: {}", backup.entry_count);

            if compress {
                println!("  Compression: enabled");
            }
            if encrypt {
                println!("  Encryption: enabled");
            }

            Ok(())
        }
        BackupCommand::Restore {
            backup_id,
            point,
            verify,
        } => {
            println!("Restoring from backup: {}", backup_id);

            if let Some(p) = point {
                println!("  Restore point: {}", p);
            }
            if verify {
                println!("  Verifying integrity...");
                println!("  ✓ Integrity check passed");
            }

            // Mock restore
            println!("✓ Restore completed successfully");
            println!("  Restored entries: 10,000");

            Ok(())
        }
        BackupCommand::List { backup_type, sizes } => {
            println!("Backups");
            println!("=======");
            println!("ID                                   | Type        | Time       | Size");
            println!("-------------------------------------|-------------|------------|------");
            println!("123e4567-e89b-12d3-a456-426614174000 | Full        | 2024-01-15 | 100MB");
            println!("223e4567-e89b-12d3-a456-426614174001 | Incremental | 2024-01-16 | 10MB");

            Ok(())
        }
        BackupCommand::Schedule {
            enable,
            schedule,
            retention,
        } => {
            if enable {
                println!("Enabling backup schedule");
                if let Some(s) = schedule {
                    println!("  Schedule: {}", s);
                }
                if let Some(r) = retention {
                    println!("  Retention: {} days", r);
                }
                println!("✓ Backup schedule enabled");
            } else {
                println!("Disabling backup schedule");
                println!("✓ Backup schedule disabled");
            }

            Ok(())
        }
    }
}

async fn handle_coherence_command(
    command: CoherenceCommand,
    system: &AdvancedCacheSystem,
) -> Result<()> {
    match command {
        CoherenceCommand::Protocol {
            protocol,
            invalidation,
            propagation,
        } => {
            println!("Configuring coherence protocol");

            if let Some(p) = protocol {
                println!("  Protocol: {}", p);
            }
            if let Some(i) = invalidation {
                println!("  Invalidation: {}", i);
            }
            if let Some(prop) = propagation {
                println!("  Propagation: {}", prop);
            }

            println!("✓ Coherence protocol configured");
            Ok(())
        }
        CoherenceCommand::Check {
            level,
            replicas,
            fix,
        } => {
            println!("Checking cache coherence...");

            if let Some(l) = level {
                println!("  Check level: {}", l);
            }
            if replicas {
                println!("  Including replicas");
            }

            println!("✓ Coherence check passed");

            if fix {
                println!("  No issues to fix");
            }

            Ok(())
        }
        CoherenceCommand::Invalidate {
            scope,
            broadcast,
            wait,
        } => {
            println!("Invalidating cache entries");

            if let Some(s) = scope {
                println!("  Scope: {}", s);
            }
            if broadcast {
                println!("  Broadcasting to all nodes");
            }
            if wait {
                println!("  Waiting for acknowledgment");
            }

            println!("✓ Invalidation completed");
            Ok(())
        }
        CoherenceCommand::Conflicts {
            show,
            strategy,
            auto_resolve,
        } => {
            if show {
                println!("Cache Conflicts");
                println!("==============");
                println!("  key1: version conflict (v1 vs v2)");
                println!("  key2: timestamp conflict");
            }

            if let Some(s) = strategy {
                println!("\nResolution strategy: {}", s);
            }

            if auto_resolve {
                println!("\n✓ Conflicts resolved automatically");
            }

            Ok(())
        }
    }
}

async fn handle_status_command(
    system: &AdvancedCacheSystem,
    detailed: bool,
    tiers: bool,
    memory: bool,
    hot_keys: bool,
    refresh: Option<u64>,
) -> Result<()> {
    loop {
        let stats = system.get_statistics().await;
        let mem_stats = system.get_memory_statistics().await;

        println!("Advanced Cache Status");
        println!("====================");
        println!("\nCache Statistics:");
        println!("  Entries: {}", stats.total_entries);
        println!("  Size: {} MB", stats.total_size_bytes / 1_048_576);
        println!("  Hit Rate: {:.2}%", stats.hit_rate * 100.0);
        println!("  Hits: {}", stats.hit_count);
        println!("  Misses: {}", stats.miss_count);
        println!("  Evictions: {}", stats.eviction_count);

        if detailed {
            println!("\nPerformance:");
            println!("  Avg Latency: {} μs", stats.avg_latency_ns / 1000);
            println!("  P50 Latency: {} μs", stats.p50_latency_ns / 1000);
            println!("  P95 Latency: {} μs", stats.p95_latency_ns / 1000);
            println!("  P99 Latency: {} μs", stats.p99_latency_ns / 1000);
            println!("  CPU Usage: {:.2}%", stats.cpu_usage_percent);
        }

        if memory {
            println!("\nMemory Statistics:");
            println!("  Allocated: {} MB", mem_stats.total_allocated / 1_048_576);
            println!("  Used: {} MB", mem_stats.total_used / 1_048_576);
            println!("  Free: {} MB", mem_stats.total_free / 1_048_576);
            println!(
                "  Fragmentation: {:.2}%",
                mem_stats.fragmentation_ratio * 100.0
            );
            println!("  GC Count: {}", mem_stats.gc_count);
        }

        if tiers {
            println!("\nTier Statistics:");
            println!("  L1: 95% hit rate, 32KB used");
            println!("  L2: 80% hit rate, 200KB used");
            println!("  L3: 60% hit rate, 5MB used");
            println!("  External: 40% hit rate, 400MB used");
        }

        if hot_keys {
            println!("\nHot Keys:");
            println!("  key1: 1000 accesses");
            println!("  key2: 950 accesses");
            println!("  key3: 900 accesses");
        }

        if let Some(secs) = refresh {
            tokio::time::sleep(tokio::time::Duration::from_secs(secs)).await;
            print!("\x1B[2J\x1B[1;1H"); // Clear screen
        } else {
            break;
        }
    }

    Ok(())
}

// ============================================================================
// Unit Tests
// ============================================================================

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

    // -------------------------------------------------------------------------
    // Cache Operation Validation Tests
    // -------------------------------------------------------------------------

    #[test]
    fn test_validate_cache_get_empty_key() {
        let command = CacheOperationCommand::Get {
            key: "".to_string(),
            metadata: false,
            stats: false,
        };
        let result = validate_cache_operation_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("key cannot be empty")
        );
    }

    #[test]
    fn test_validate_cache_get_valid_key() {
        let command = CacheOperationCommand::Get {
            key: "test-key".to_string(),
            metadata: true,
            stats: true,
        };
        let result = validate_cache_operation_command(&command);
        assert!(result.is_ok());
    }

    #[test]
    fn test_validate_cache_put_empty_key() {
        let command = CacheOperationCommand::Put {
            key: "".to_string(),
            value: "test-value".to_string(),
            ttl: None,
            priority: None,
            compress: false,
        };
        let result = validate_cache_operation_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("key cannot be empty")
        );
    }

    #[test]
    fn test_validate_cache_put_empty_value() {
        let command = CacheOperationCommand::Put {
            key: "test-key".to_string(),
            value: "".to_string(),
            ttl: None,
            priority: None,
            compress: false,
        };
        let result = validate_cache_operation_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("value cannot be empty")
        );
    }

    #[test]
    fn test_validate_cache_put_invalid_priority() {
        let command = CacheOperationCommand::Put {
            key: "test-key".to_string(),
            value: "test-value".to_string(),
            ttl: None,
            priority: Some(15),
            compress: false,
        };
        let result = validate_cache_operation_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Priority must be between")
        );
    }

    #[test]
    fn test_validate_cache_put_valid() {
        let command = CacheOperationCommand::Put {
            key: "test-key".to_string(),
            value: "test-value".to_string(),
            ttl: Some(3600),
            priority: Some(5),
            compress: true,
        };
        let result = validate_cache_operation_command(&command);
        assert!(result.is_ok());
    }

    // -------------------------------------------------------------------------
    // Eviction Command Validation Tests
    // -------------------------------------------------------------------------

    #[test]
    fn test_validate_eviction_policy_invalid() {
        let command = EvictionCommand::Policy {
            policy: "invalid".to_string(),
            max_entries: None,
            max_size: None,
            ttl: None,
        };
        let result = validate_eviction_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Invalid eviction policy")
        );
    }

    #[test]
    fn test_validate_eviction_policy_valid() {
        for policy in VALID_EVICTION_POLICIES {
            let command = EvictionCommand::Policy {
                policy: policy.to_string(),
                max_entries: Some(1000),
                max_size: Some(100),
                ttl: Some(3600),
            };
            let result = validate_eviction_command(&command);
            assert!(result.is_ok(), "Policy '{}' should be valid", policy);
        }
    }

    #[test]
    fn test_validate_eviction_adaptive_invalid_learning_rate() {
        let command = EvictionCommand::Adaptive {
            enable: true,
            learning_rate: Some(1.5),
            window: None,
        };
        let result = validate_eviction_command(&command);
        assert!(result.is_err());
        assert!(result.unwrap_err().to_string().contains("Learning rate"));
    }

    #[test]
    fn test_validate_eviction_adaptive_zero_learning_rate() {
        let command = EvictionCommand::Adaptive {
            enable: true,
            learning_rate: Some(0.0),
            window: None,
        };
        let result = validate_eviction_command(&command);
        assert!(result.is_err());
    }

    #[test]
    fn test_validate_eviction_priority_invalid_threshold() {
        let command = EvictionCommand::Priority {
            threshold: Some(15),
            preserve: None,
        };
        let result = validate_eviction_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Priority threshold")
        );
    }

    // -------------------------------------------------------------------------
    // Prefetch Command Validation Tests
    // -------------------------------------------------------------------------

    #[test]
    fn test_validate_prefetch_warm_invalid_source() {
        let command = PrefetchCommand::Warm {
            source: "invalid".to_string(),
            location: "/some/path".to_string(),
            filter: None,
            parallel: false,
            batch: None,
        };
        let result = validate_prefetch_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Invalid warmup source")
        );
    }

    #[test]
    fn test_validate_prefetch_warm_empty_location() {
        let command = PrefetchCommand::Warm {
            source: "file".to_string(),
            location: "".to_string(),
            filter: None,
            parallel: false,
            batch: None,
        };
        let result = validate_prefetch_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Location cannot be empty")
        );
    }

    #[test]
    fn test_validate_prefetch_warm_valid() {
        let command = PrefetchCommand::Warm {
            source: "file".to_string(),
            location: "/path/to/data".to_string(),
            filter: Some("*.json".to_string()),
            parallel: true,
            batch: Some(100),
        };
        let result = validate_prefetch_command(&command);
        assert!(result.is_ok());
    }

    #[test]
    fn test_validate_prefetch_patterns_invalid_confidence() {
        let command = PrefetchCommand::Patterns {
            enable: true,
            confidence: Some(1.5),
            show: false,
        };
        let result = validate_prefetch_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Confidence threshold")
        );
    }

    #[test]
    fn test_validate_prefetch_config_invalid_strategy() {
        let command = PrefetchCommand::Config {
            enable: true,
            strategy: Some("invalid".to_string()),
            distance: None,
            degree: None,
        };
        let result = validate_prefetch_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Invalid prefetch strategy")
        );
    }

    // -------------------------------------------------------------------------
    // Tier Command Validation Tests
    // -------------------------------------------------------------------------

    #[test]
    fn test_validate_tier_config_invalid_tier() {
        let command = TierCommand::Config {
            tier: "invalid".to_string(),
            capacity: None,
            latency: None,
            cost: None,
        };
        let result = validate_tier_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Invalid tier name")
        );
    }

    #[test]
    fn test_validate_tier_config_valid() {
        for tier in VALID_TIER_NAMES {
            let command = TierCommand::Config {
                tier: tier.to_string(),
                capacity: Some(1024),
                latency: Some(10),
                cost: Some(0.5),
            };
            let result = validate_tier_command(&command);
            assert!(result.is_ok(), "Tier '{}' should be valid", tier);
        }
    }

    #[test]
    fn test_validate_tier_promote_same_tier() {
        let command = TierCommand::Promote {
            from: "l1".to_string(),
            to: "l1".to_string(),
            policy: None,
            count: None,
        };
        let result = validate_tier_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("cannot be the same")
        );
    }

    #[test]
    fn test_validate_tier_promote_invalid_from() {
        let command = TierCommand::Promote {
            from: "invalid".to_string(),
            to: "l1".to_string(),
            policy: None,
            count: None,
        };
        let result = validate_tier_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Invalid source tier")
        );
    }

    #[test]
    fn test_validate_tier_migrate_invalid_threshold() {
        let command = TierCommand::Migrate {
            auto: true,
            threshold: Some(1.5),
            interval: None,
        };
        let result = validate_tier_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Migration threshold")
        );
    }

    // -------------------------------------------------------------------------
    // Distributed Command Validation Tests
    // -------------------------------------------------------------------------

    #[test]
    fn test_validate_distributed_config_invalid_consistency() {
        let command = DistributedCommand::Config {
            topology: None,
            consistency: Some("invalid".to_string()),
            replication: None,
            partitioning: None,
        };
        let result = validate_distributed_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Invalid consistency level")
        );
    }

    #[test]
    fn test_validate_distributed_config_invalid_replication() {
        let command = DistributedCommand::Config {
            topology: None,
            consistency: None,
            replication: Some(0),
            partitioning: None,
        };
        let result = validate_distributed_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Replication factor")
        );
    }

    #[test]
    fn test_validate_distributed_config_valid() {
        let command = DistributedCommand::Config {
            topology: Some("ring".to_string()),
            consistency: Some("strong".to_string()),
            replication: Some(3),
            partitioning: Some("hash".to_string()),
        };
        let result = validate_distributed_command(&command);
        assert!(result.is_ok());
    }

    #[test]
    fn test_validate_node_add_empty_address() {
        let command = NodeCommand::Add {
            address: "".to_string(),
            capacity: None,
            role: None,
        };
        let result = validate_node_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("address cannot be empty")
        );
    }

    #[test]
    fn test_validate_node_add_invalid_address_format() {
        let command = NodeCommand::Add {
            address: "invalid-address".to_string(),
            capacity: None,
            role: None,
        };
        let result = validate_node_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Invalid node address format")
        );
    }

    #[test]
    fn test_validate_node_add_valid_address() {
        let command = NodeCommand::Add {
            address: "10.0.0.1:6379".to_string(),
            capacity: Some(1024),
            role: Some("primary".to_string()),
        };
        let result = validate_node_command(&command);
        assert!(result.is_ok());
    }

    // -------------------------------------------------------------------------
    // Compression Command Validation Tests
    // -------------------------------------------------------------------------

    #[test]
    fn test_validate_compression_config_invalid_algorithm() {
        let command = CompressionCommand::Config {
            enable: true,
            algorithm: Some("invalid".to_string()),
            level: None,
            min_size: None,
        };
        let result = validate_compression_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Invalid compression algorithm")
        );
    }

    #[test]
    fn test_validate_compression_config_invalid_level() {
        let command = CompressionCommand::Config {
            enable: true,
            algorithm: Some("zstd".to_string()),
            level: Some(25),
            min_size: None,
        };
        let result = validate_compression_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Compression level")
        );
    }

    #[test]
    fn test_validate_compression_config_valid() {
        for algo in VALID_COMPRESSION_ALGORITHMS {
            let command = CompressionCommand::Config {
                enable: true,
                algorithm: Some(algo.to_string()),
                level: Some(6),
                min_size: Some(1024),
            };
            let result = validate_compression_command(&command);
            assert!(result.is_ok(), "Algorithm '{}' should be valid", algo);
        }
    }

    #[test]
    fn test_validate_compression_test_zero_size() {
        let command = CompressionCommand::Test {
            size: 0,
            algorithm: None,
            iterations: None,
        };
        let result = validate_compression_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("size must be greater than 0")
        );
    }

    #[test]
    fn test_validate_compression_adaptive_invalid_threshold() {
        let command = CompressionCommand::Adaptive {
            enable: true,
            threshold: Some(0.5),
            sample_rate: None,
        };
        let result = validate_compression_command(&command);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("ratio threshold must be at least 1.0")
        );
    }

    #[test]
    fn test_validate_compression_adaptive_invalid_sample_rate() {
        let command = CompressionCommand::Adaptive {
            enable: true,
            threshold: None,
            sample_rate: Some(0.0),
        };
        let result = validate_compression_command(&command);
        assert!(result.is_err());
        assert!(result.unwrap_err().to_string().contains("Sample rate"));
    }

    // -------------------------------------------------------------------------
    // Integration Tests for validate_command
    // -------------------------------------------------------------------------

    #[test]
    fn test_validate_command_eviction() {
        let command = CacheCommand::Eviction {
            command: EvictionCommand::Policy {
                policy: "lru".to_string(),
                max_entries: None,
                max_size: None,
                ttl: None,
            },
        };
        let result = validate_command(&command);
        assert!(result.is_ok());
    }

    #[test]
    fn test_validate_command_status_always_valid() {
        let command = CacheCommand::Status {
            detailed: true,
            tiers: true,
            memory: true,
            hot_keys: true,
            refresh: Some(5),
        };
        let result = validate_command(&command);
        assert!(result.is_ok());
    }
}