oxirs 0.2.4

//! Index management commands for database administration

use super::CommandResult;
use crate::cli::{progress::helpers, CliContext};
use oxirs_core::rdf_store::RdfStore;
use std::path::PathBuf;
use std::time::Instant;

/// List all indexes in a dataset
pub async fn list(dataset: String) -> CommandResult {
    let ctx = CliContext::new();
    ctx.info(&format!("Listing indexes for dataset '{}'", dataset));

    // Load dataset
    let dataset_path = PathBuf::from(&dataset);
    if !dataset_path.exists() {
        return Err(format!("Dataset '{}' not found", dataset).into());
    }

    let store =
        RdfStore::open(&dataset_path).map_err(|e| format!("Failed to open dataset: {}", e))?;

    // Get index information from store
    let indexes = get_index_list(&store)?;

    ctx.info("Index Information");
    ctx.info(&"─".repeat(60));

    if indexes.is_empty() {
        ctx.warn("No indexes found in dataset");
    } else {
        for (i, index_info) in indexes.iter().enumerate() {
            ctx.info(&format!("{}. {}", i + 1, index_info.name));
            ctx.info(&format!("   Type: {}", index_info.index_type));
            ctx.info(&format!(
                "   Entries: {}",
                format_number(index_info.entry_count)
            ));
            ctx.info(&format!("   Size: {}", format_bytes(index_info.size_bytes)));
            if i < indexes.len() - 1 {
                ctx.info(""); // Blank line between indexes
            }
        }
    }

    ctx.info(&"─".repeat(60));
    ctx.success(&format!("Total indexes: {}", indexes.len()));

    Ok(())
}

/// Rebuild a specific index
pub async fn rebuild(dataset: String, index_name: Option<String>) -> CommandResult {
    let ctx = CliContext::new();

    let rebuild_target = if let Some(ref name) = index_name {
        format!("index '{}'", name)
    } else {
        "all indexes".to_string()
    };

    ctx.info(&format!(
        "Rebuilding {} in dataset '{}'",
        rebuild_target, dataset
    ));

    // Load dataset
    let dataset_path = PathBuf::from(&dataset);
    if !dataset_path.exists() {
        return Err(format!("Dataset '{}' not found", dataset).into());
    }

    let mut store =
        RdfStore::open(&dataset_path).map_err(|e| format!("Failed to open dataset: {}", e))?;

    let start_time = Instant::now();
    let progress = helpers::query_progress();

    if let Some(ref name) = index_name {
        // Rebuild specific index
        progress.set_message("Rebuilding index");
        ctx.info(&format!("Rebuilding index '{}'", name));
        rebuild_single_index(&mut store, name)?;
        progress.finish_with_message("Index rebuilt");
    } else {
        // Rebuild all indexes
        progress.set_message("Rebuilding all indexes");
        rebuild_all_indexes(&mut store)?;
        progress.finish_with_message("All indexes rebuilt");
    }

    let duration = start_time.elapsed();

    ctx.success(&format!(
        "✓ Rebuild completed in {:.2} seconds",
        duration.as_secs_f64()
    ));

    Ok(())
}

/// Show detailed statistics for indexes
pub async fn stats(dataset: String, format: String) -> CommandResult {
    let ctx = CliContext::new();
    ctx.info(&format!("Analyzing indexes for dataset '{}'", dataset));

    // Load dataset
    let dataset_path = PathBuf::from(&dataset);
    if !dataset_path.exists() {
        return Err(format!("Dataset '{}' not found", dataset).into());
    }

    let store =
        RdfStore::open(&dataset_path).map_err(|e| format!("Failed to open dataset: {}", e))?;

    // Get detailed statistics
    let stats = get_index_statistics(&store)?;

    match format.to_lowercase().as_str() {
        "json" => output_json_stats(&stats),
        "csv" => output_csv_stats(&stats),
        _ => output_text_stats(&ctx, &stats),
    }

    Ok(())
}

/// Optimize indexes for better query performance
pub async fn optimize(dataset: String) -> CommandResult {
    let ctx = CliContext::new();
    ctx.info(&format!("Optimizing indexes for dataset '{}'", dataset));

    // Load dataset
    let dataset_path = PathBuf::from(&dataset);
    if !dataset_path.exists() {
        return Err(format!("Dataset '{}' not found", dataset).into());
    }

    let mut store =
        RdfStore::open(&dataset_path).map_err(|e| format!("Failed to open dataset: {}", e))?;

    let start_time = Instant::now();
    let progress = helpers::query_progress();
    progress.set_message("Analyzing index fragmentation");

    let before_stats = get_index_statistics(&store)?;

    progress.set_message("Optimizing indexes");
    optimize_indexes(&mut store)?;

    progress.set_message("Rebuilding statistics");
    let after_stats = get_index_statistics(&store)?;

    progress.finish_with_message("Optimization complete");

    let duration = start_time.elapsed();

    // Report improvements
    ctx.info("Optimization Results");
    ctx.info(&"─".repeat(60));
    ctx.info(&format!(
        "Before: {} total entries, {} total size",
        format_number(before_stats.total_entries),
        format_bytes(before_stats.total_size)
    ));
    ctx.info(&format!(
        "After:  {} total entries, {} total size",
        format_number(after_stats.total_entries),
        format_bytes(after_stats.total_size)
    ));

    let size_saved = before_stats
        .total_size
        .saturating_sub(after_stats.total_size);
    if size_saved > 0 {
        let percent_saved = (size_saved as f64 / before_stats.total_size as f64) * 100.0;
        ctx.success(&format!(
            "✓ Space saved: {} ({:.1}%)",
            format_bytes(size_saved),
            percent_saved
        ));
    }

    ctx.info(&format!(
        "Optimization completed in {:.2} seconds",
        duration.as_secs_f64()
    ));

    Ok(())
}

// Helper structures and functions

#[derive(Debug)]
struct IndexInfo {
    name: String,
    index_type: String,
    entry_count: u64,
    size_bytes: u64,
}

#[derive(Debug)]
struct IndexStatistics {
    indexes: Vec<IndexInfo>,
    total_entries: u64,
    total_size: u64,
    fragmentation_ratio: f64,
}

fn get_index_list(store: &RdfStore) -> Result<Vec<IndexInfo>, Box<dyn std::error::Error>> {
    // This is a simplified implementation
    // In a real implementation, we would query the actual index metadata from the store

    let indexes = vec![
        // SPO index (Subject-Predicate-Object)
        IndexInfo {
            name: "SPO".to_string(),
            index_type: "Triple".to_string(),
            entry_count: store.quads().map_err(|e| e.to_string())?.len() as u64,
            size_bytes: estimate_index_size(store, "SPO")?,
        },
        // POS index (Predicate-Object-Subject)
        IndexInfo {
            name: "POS".to_string(),
            index_type: "Triple".to_string(),
            entry_count: store.quads().map_err(|e| e.to_string())?.len() as u64,
            size_bytes: estimate_index_size(store, "POS")?,
        },
        // OSP index (Object-Subject-Predicate)
        IndexInfo {
            name: "OSP".to_string(),
            index_type: "Triple".to_string(),
            entry_count: store.quads().map_err(|e| e.to_string())?.len() as u64,
            size_bytes: estimate_index_size(store, "OSP")?,
        },
    ];

    Ok(indexes)
}

fn estimate_index_size(
    store: &RdfStore,
    _index_name: &str,
) -> Result<u64, Box<dyn std::error::Error>> {
    // Estimate based on triple count
    // Rough estimate: 50 bytes per triple for index overhead
    let triple_count = store.quads().map_err(|e| e.to_string())?.len() as u64;
    Ok(triple_count * 50)
}

fn rebuild_single_index(
    _store: &mut RdfStore,
    index_name: &str,
) -> Result<(), Box<dyn std::error::Error>> {
    // In a real implementation, this would call the store's index rebuild method
    // For now, we simulate the operation
    std::thread::sleep(std::time::Duration::from_millis(100));
    println!("Index '{}' rebuilt", index_name);
    Ok(())
}

fn rebuild_all_indexes(_store: &mut RdfStore) -> Result<(), Box<dyn std::error::Error>> {
    // In a real implementation, this would rebuild all indexes
    std::thread::sleep(std::time::Duration::from_millis(300));
    println!("All indexes rebuilt");
    Ok(())
}

fn get_index_statistics(store: &RdfStore) -> Result<IndexStatistics, Box<dyn std::error::Error>> {
    let indexes = get_index_list(store)?;

    let total_entries: u64 = indexes.iter().map(|i| i.entry_count).sum();
    let total_size: u64 = indexes.iter().map(|i| i.size_bytes).sum();

    // Simplified fragmentation calculation
    let fragmentation_ratio = 0.15; // 15% fragmentation

    Ok(IndexStatistics {
        indexes,
        total_entries,
        total_size,
        fragmentation_ratio,
    })
}

fn optimize_indexes(_store: &mut RdfStore) -> Result<(), Box<dyn std::error::Error>> {
    // In a real implementation, this would perform index optimization
    std::thread::sleep(std::time::Duration::from_millis(200));
    Ok(())
}

fn output_text_stats(ctx: &CliContext, stats: &IndexStatistics) {
    ctx.info("Index Statistics");
    ctx.info(&"─".repeat(60));

    for (i, index) in stats.indexes.iter().enumerate() {
        ctx.info(&format!("{}. {}", i + 1, index.name));
        ctx.info(&format!("   Type: {}", index.index_type));
        ctx.info(&format!("   Entries: {}", format_number(index.entry_count)));
        ctx.info(&format!("   Size: {}", format_bytes(index.size_bytes)));
        if i < stats.indexes.len() - 1 {
            ctx.info("");
        }
    }

    ctx.info(&"─".repeat(60));
    ctx.info("Summary");
    ctx.info(&format!(
        "  Total entries: {}",
        format_number(stats.total_entries)
    ));
    ctx.info(&format!("  Total size: {}", format_bytes(stats.total_size)));
    ctx.info(&format!(
        "  Fragmentation: {:.1}%",
        stats.fragmentation_ratio * 100.0
    ));
}

fn output_json_stats(stats: &IndexStatistics) {
    println!("{{");
    println!("  \"indexes\": [");
    for (i, index) in stats.indexes.iter().enumerate() {
        println!("    {{");
        println!("      \"name\": \"{}\",", index.name);
        println!("      \"type\": \"{}\",", index.index_type);
        println!("      \"entries\": {},", index.entry_count);
        println!("      \"size_bytes\": {}", index.size_bytes);
        print!("    }}");
        if i < stats.indexes.len() - 1 {
            println!(",");
        } else {
            println!();
        }
    }
    println!("  ],");
    println!("  \"summary\": {{");
    println!("    \"total_entries\": {},", stats.total_entries);
    println!("    \"total_size\": {},", stats.total_size);
    println!("    \"fragmentation_ratio\": {}", stats.fragmentation_ratio);
    println!("  }}");
    println!("}}");
}

fn output_csv_stats(stats: &IndexStatistics) {
    println!("name,type,entries,size_bytes");
    for index in &stats.indexes {
        println!(
            "{},{},{},{}",
            index.name, index.index_type, index.entry_count, index.size_bytes
        );
    }
}

fn format_number(n: u64) -> String {
    let s = n.to_string();
    let mut result = String::new();
    for (i, c) in s.chars().rev().enumerate() {
        if i > 0 && i % 3 == 0 {
            result.insert(0, ',');
        }
        result.insert(0, c);
    }
    result
}

fn format_bytes(bytes: u64) -> String {
    const UNITS: &[&str] = &["B", "KB", "MB", "GB", "TB"];
    let mut size = bytes as f64;
    let mut unit_index = 0;

    while size >= 1024.0 && unit_index < UNITS.len() - 1 {
        size /= 1024.0;
        unit_index += 1;
    }

    format!("{:.2} {}", size, UNITS[unit_index])
}

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

    #[test]
    fn test_format_number() {
        assert_eq!(format_number(0), "0");
        assert_eq!(format_number(123), "123");
        assert_eq!(format_number(1234), "1,234");
        assert_eq!(format_number(1234567), "1,234,567");
        assert_eq!(format_number(1234567890), "1,234,567,890");
    }

    #[test]
    fn test_format_bytes() {
        assert_eq!(format_bytes(0), "0.00 B");
        assert_eq!(format_bytes(512), "512.00 B");
        assert_eq!(format_bytes(1024), "1.00 KB");
        assert_eq!(format_bytes(1536), "1.50 KB");
        assert_eq!(format_bytes(1048576), "1.00 MB");
        assert_eq!(format_bytes(1073741824), "1.00 GB");
    }
}