laurus 0.4.0

//! Vector index optimization utilities.

use crate::error::{LaurusError, Result};
use crate::vector::writer::VectorIndexWriter;

/// Optimizer for vector indexes after construction.
pub struct VectorIndexOptimizer {
    optimization_level: OptimizationLevel,
    memory_target: Option<usize>,
    performance_target: Option<OptimizationConfig>,
}

/// Level of optimization to apply.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OptimizationLevel {
    /// Minimal optimization, fastest to apply.
    Fast,
    /// Balanced optimization between speed and quality.
    Balanced,
    /// Aggressive optimization for best results.
    Aggressive,
}

/// Performance optimization targets.
#[derive(Debug, Clone)]
pub struct OptimizationConfig {
    /// Target search time in milliseconds.
    pub target_search_time_ms: f64,
    /// Target memory usage in bytes.
    pub target_memory_bytes: usize,
    /// Target recall (accuracy) level.
    pub target_recall: f32,
}

impl VectorIndexOptimizer {
    /// Create a new index optimizer.
    pub fn new(optimization_level: OptimizationLevel) -> Self {
        Self {
            optimization_level,
            memory_target: None,
            performance_target: None,
        }
    }

    /// Set memory usage target.
    pub fn with_memory_target(mut self, target_bytes: usize) -> Self {
        self.memory_target = Some(target_bytes);
        self
    }

    /// Set performance targets.
    pub fn with_performance_target(mut self, target: OptimizationConfig) -> Self {
        self.performance_target = Some(target);
        self
    }

    /// Optimize a vector index.
    pub fn optimize(&self, builder: &mut dyn VectorIndexWriter) -> Result<OptimizationResult> {
        let initial_memory = builder.estimated_memory_usage();
        let start_time = std::time::Instant::now();

        let mut report = OptimizationResult {
            initial_memory_bytes: initial_memory,
            final_memory_bytes: initial_memory,
            optimization_time_ms: 0.0,
            optimizations_applied: Vec::new(),
            memory_reduction_ratio: 1.0,
            estimated_speedup: 1.0,
        };

        // Apply optimizations based on level
        match self.optimization_level {
            OptimizationLevel::Fast => {
                self.apply_fast_optimizations(builder, &mut report)?;
            }
            OptimizationLevel::Balanced => {
                self.apply_fast_optimizations(builder, &mut report)?;
                self.apply_balanced_optimizations(builder, &mut report)?;
            }
            OptimizationLevel::Aggressive => {
                self.apply_fast_optimizations(builder, &mut report)?;
                self.apply_balanced_optimizations(builder, &mut report)?;
                self.apply_aggressive_optimizations(builder, &mut report)?;
            }
        }

        // Finalize the optimization
        builder.optimize()?;

        let final_memory = builder.estimated_memory_usage();
        let elapsed = start_time.elapsed();

        report.final_memory_bytes = final_memory;
        report.optimization_time_ms = elapsed.as_secs_f64() * 1000.0;
        report.memory_reduction_ratio = if final_memory > 0 {
            initial_memory as f32 / final_memory as f32
        } else {
            1.0
        };

        Ok(report)
    }

    /// Apply fast optimizations.
    fn apply_fast_optimizations(
        &self,
        _builder: &mut dyn VectorIndexWriter,
        report: &mut OptimizationResult,
    ) -> Result<()> {
        // Memory compaction
        report
            .optimizations_applied
            .push("Memory compaction".to_string());
        report.estimated_speedup *= 1.1;

        Ok(())
    }

    /// Apply balanced optimizations.
    fn apply_balanced_optimizations(
        &self,
        _builder: &mut dyn VectorIndexWriter,
        report: &mut OptimizationResult,
    ) -> Result<()> {
        // Data structure reorganization
        report
            .optimizations_applied
            .push("Data structure reorganization".to_string());
        report.estimated_speedup *= 1.2;

        // Cache-friendly layout
        report
            .optimizations_applied
            .push("Cache-friendly layout".to_string());
        report.estimated_speedup *= 1.15;

        Ok(())
    }

    /// Apply aggressive optimizations.
    fn apply_aggressive_optimizations(
        &self,
        _builder: &mut dyn VectorIndexWriter,
        report: &mut OptimizationResult,
    ) -> Result<()> {
        // Vector quantization (if not already applied)
        report
            .optimizations_applied
            .push("Vector quantization".to_string());
        report.estimated_speedup *= 1.3;

        // Graph pruning (for HNSW indexes)
        report
            .optimizations_applied
            .push("Graph pruning".to_string());
        report.estimated_speedup *= 1.25;

        // Connection optimization
        report
            .optimizations_applied
            .push("Connection optimization".to_string());
        report.estimated_speedup *= 1.1;

        Ok(())
    }

    /// Validate optimization constraints.
    #[allow(dead_code)]
    fn validate_constraints(&self, report: &OptimizationResult) -> Result<()> {
        if let Some(memory_target) = self.memory_target
            && report.final_memory_bytes > memory_target
        {
            return Err(LaurusError::InvalidOperation(format!(
                "Final memory usage {} exceeds target {}",
                report.final_memory_bytes, memory_target
            )));
        }

        if let Some(ref target) = self.performance_target
            && report.final_memory_bytes > target.target_memory_bytes
        {
            return Err(LaurusError::InvalidOperation(format!(
                "Memory target {} not achieved, actual: {}",
                target.target_memory_bytes, report.final_memory_bytes
            )));
        }

        Ok(())
    }
}

/// Report of optimization results.
#[derive(Debug, Clone)]
pub struct OptimizationResult {
    /// Initial memory usage before optimization.
    pub initial_memory_bytes: usize,
    /// Final memory usage after optimization.
    pub final_memory_bytes: usize,
    /// Time spent on optimization.
    pub optimization_time_ms: f64,
    /// List of optimizations that were applied.
    pub optimizations_applied: Vec<String>,
    /// Memory reduction ratio (initial/final).
    pub memory_reduction_ratio: f32,
    /// Estimated search speedup factor.
    pub estimated_speedup: f32,
}

impl OptimizationResult {
    /// Get memory savings in bytes.
    pub fn memory_savings(&self) -> usize {
        self.initial_memory_bytes
            .saturating_sub(self.final_memory_bytes)
    }

    /// Get memory reduction percentage.
    pub fn memory_reduction_percentage(&self) -> f32 {
        if self.initial_memory_bytes == 0 {
            0.0
        } else {
            (self.memory_savings() as f32 / self.initial_memory_bytes as f32) * 100.0
        }
    }

    /// Check if optimization was successful.
    pub fn is_successful(&self) -> bool {
        self.final_memory_bytes <= self.initial_memory_bytes && self.estimated_speedup >= 1.0
    }

    /// Print a summary of the optimization results.
    pub fn print_summary(&self) {
        println!("Vector Index Optimization Report");
        println!("================================");
        println!(
            "Initial memory: {} MB",
            self.initial_memory_bytes / 1024 / 1024
        );
        println!("Final memory: {} MB", self.final_memory_bytes / 1024 / 1024);
        println!(
            "Memory saved: {} MB ({:.1}%)",
            self.memory_savings() / 1024 / 1024,
            self.memory_reduction_percentage()
        );
        println!("Optimization time: {:.2} ms", self.optimization_time_ms);
        println!("Estimated speedup: {:.2}x", self.estimated_speedup);
        println!("Optimizations applied:");
        for optimization in &self.optimizations_applied {
            println!("  - {optimization}");
        }
    }
}

impl Default for OptimizationResult {
    fn default() -> Self {
        Self {
            initial_memory_bytes: 0,
            final_memory_bytes: 0,
            optimization_time_ms: 0.0,
            optimizations_applied: Vec::new(),
            memory_reduction_ratio: 1.0,
            estimated_speedup: 1.0,
        }
    }
}