smart-tree 8.0.1

//! Daemon CLI Handlers - HTTP endpoints for thin-client CLI operations
//!
//! This module provides the daemon endpoints that the `st` thin client
//! calls to perform scanning and formatting operations. All the heavy
//! lifting happens here in the daemon.
//!
//! "The meat stays in the daemon!" - Hue

use crate::formatters::{
    ai::AiFormatter,
    classic::ClassicFormatter,
    csv::CsvFormatter,
    digest::DigestFormatter,
    hex::HexFormatter,
    json::JsonFormatter,
    ls::LsFormatter,
    markdown::MarkdownFormatter,
    marqant::MarqantFormatter,
    mermaid::{MermaidFormatter, MermaidStyle},
    projects::ProjectsFormatter,
    quantum::QuantumFormatter,
    semantic::SemanticFormatter,
    smart::SmartFormatter,
    stats::StatsFormatter,
    tsv::TsvFormatter,
    waste::WasteFormatter,
    Formatter, PathDisplayMode,
};
use crate::{parse_size, Scanner, ScannerConfig, TreeStats};
use anyhow::{Context, Result};
use axum::{
    extract::State,
    http::StatusCode,
    response::IntoResponse,
    Json,
};
use base64::{engine::general_purpose, Engine as _};
use flate2::write::ZlibEncoder;
use flate2::Compression;
use regex::Regex;
use serde::{Deserialize, Serialize};
use std::io::Write;
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Instant;
use tokio::sync::RwLock;

use crate::daemon::DaemonState;

/// CLI scan request - all options from the CLI
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CliScanRequest {
    /// Path to scan (required)
    pub path: String,

    /// Output mode (classic, ai, quantum, json, etc.)
    #[serde(default = "default_mode")]
    pub mode: String,

    /// Max depth (0 = auto based on mode)
    #[serde(default)]
    pub depth: usize,

    /// Show hidden files
    #[serde(default)]
    pub all: bool,

    /// Respect .gitignore
    #[serde(default = "default_true")]
    pub respect_gitignore: bool,

    /// Use default ignores (node_modules, etc.)
    #[serde(default = "default_true")]
    pub default_ignores: bool,

    /// Show ignored entries
    #[serde(default)]
    pub show_ignored: bool,

    /// Find pattern (regex for filename matching)
    pub find: Option<String>,

    /// File type filter (e.g., "rs", "py")
    pub file_type: Option<String>,

    /// Entry type filter ("f" for files, "d" for directories)
    pub entry_type: Option<String>,

    /// Min file size (e.g., "1M", "500K")
    pub min_size: Option<String>,

    /// Max file size
    pub max_size: Option<String>,

    /// Sort field (name, size, date, type)
    pub sort: Option<String>,

    /// Top N results (used with sort)
    pub top: Option<usize>,

    /// Search content keyword
    pub search: Option<String>,

    /// Enable zlib compression on output
    #[serde(default)]
    pub compress: bool,

    /// No emoji in output
    #[serde(default)]
    pub no_emoji: bool,

    /// Use color in output
    #[serde(default = "default_true")]
    pub use_color: bool,

    /// Path display mode (off, relative, full)
    #[serde(default = "default_path_mode")]
    pub path_mode: String,

    /// Focus file (for relations mode)
    pub focus: Option<String>,

    /// Relations filter
    pub relations_filter: Option<String>,

    /// Show filesystem type indicators
    #[serde(default)]
    pub show_filesystems: bool,

    /// Include line content in search results
    #[serde(default)]
    pub include_line_content: bool,

    /// Compact JSON output
    #[serde(default)]
    pub compact: bool,

    // --- Smart Scanning Options (Phase 2: Intelligent Context-Aware Scanning) ---

    /// Enable smart mode - groups by interest, shows changes, minimal output
    #[serde(default)]
    pub smart: bool,

    /// Only show changes since last scan
    #[serde(default)]
    pub changes_only: bool,

    /// Minimum interest level to show (0.0-1.0)
    #[serde(default)]
    pub min_interest: f32,

    /// Enable security scanning
    #[serde(default = "default_true")]
    pub security: bool,
}

fn default_mode() -> String {
    "classic".to_string()
}

fn default_true() -> bool {
    true
}

fn default_path_mode() -> String {
    "relative".to_string()
}

/// CLI scan response
#[derive(Debug, Serialize, Deserialize)]
pub struct CliScanResponse {
    /// Formatted output (ready to print)
    pub output: String,

    /// Was output compressed?
    pub compressed: bool,

    /// Stats about the scan
    pub stats: ScanStats,
}

/// Scan statistics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ScanStats {
    pub total_files: u64,
    pub total_dirs: u64,
    pub total_size: u64,
    pub scan_time_ms: u64,
    pub format_time_ms: u64,
}

/// Error response
#[derive(Debug, Serialize)]
pub struct CliErrorResponse {
    pub error: String,
    pub details: Option<String>,
}

/// Handle CLI scan request
pub async fn cli_scan_handler(
    State(state): State<Arc<RwLock<DaemonState>>>,
    Json(req): Json<CliScanRequest>,
) -> Result<impl IntoResponse, (StatusCode, Json<CliErrorResponse>)> {
    // Build scanner config from request
    let config = build_scanner_config(&req).map_err(|e| {
        (
            StatusCode::BAD_REQUEST,
            Json(CliErrorResponse {
                error: "Invalid request".to_string(),
                details: Some(e.to_string()),
            }),
        )
    })?;

    // Resolve path
    let path = PathBuf::from(&req.path);
    let path = if path.is_absolute() {
        path
    } else {
        std::env::current_dir()
            .unwrap_or_else(|_| PathBuf::from("."))
            .join(&path)
    };

    // Create scanner and scan
    let scanner = Scanner::new(&path, config).map_err(|e| {
        (
            StatusCode::BAD_REQUEST,
            Json(CliErrorResponse {
                error: "Failed to create scanner".to_string(),
                details: Some(e.to_string()),
            }),
        )
    })?;

    let scan_start = Instant::now();
    let (nodes, tree_stats) = scanner.scan().map_err(|e| {
        (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(CliErrorResponse {
                error: "Scan failed".to_string(),
                details: Some(e.to_string()),
            }),
        )
    })?;
    let scan_time = scan_start.elapsed();

    // Select formatter and format output
    let format_start = Instant::now();
    let path_display = parse_path_mode(&req.path_mode);

    let mut output_buffer = Vec::new();
    format_output(&req, &mut output_buffer, &nodes, &tree_stats, &path, path_display).map_err(
        |e| {
            (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(CliErrorResponse {
                    error: "Format failed".to_string(),
                    details: Some(e.to_string()),
                }),
            )
        },
    )?;
    let format_time = format_start.elapsed();

    // Optionally compress
    let (output, compressed) = if req.compress {
        let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
        encoder.write_all(&output_buffer).map_err(|e| {
            (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(CliErrorResponse {
                    error: "Compression failed".to_string(),
                    details: Some(e.to_string()),
                }),
            )
        })?;
        let compressed_data = encoder.finish().map_err(|e| {
            (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(CliErrorResponse {
                    error: "Compression failed".to_string(),
                    details: Some(e.to_string()),
                }),
            )
        })?;
        (general_purpose::STANDARD.encode(&compressed_data), true)
    } else {
        (
            String::from_utf8_lossy(&output_buffer).to_string(),
            false,
        )
    };

    // Build stats
    let stats = ScanStats {
        total_files: tree_stats.total_files,
        total_dirs: tree_stats.total_dirs,
        total_size: tree_stats.total_size,
        scan_time_ms: scan_time.as_millis() as u64,
        format_time_ms: format_time.as_millis() as u64,
    };

    // Record token savings in daemon state (if compressed)
    if compressed {
        let savings = output_buffer.len().saturating_sub(output.len()) as u64;
        if let Ok(mut state) = state.try_write() {
            state
                .credits
                .record_savings(savings, &format!("CLI scan: {}", req.path));
        }
    }

    Ok(Json(CliScanResponse {
        output,
        compressed,
        stats,
    }))
}

/// Handle streaming CLI scan request (SSE) - simplified version
/// For now, this just returns the full response as JSON
/// TODO: Implement proper SSE streaming
pub async fn cli_stream_handler(
    State(state): State<Arc<RwLock<DaemonState>>>,
    Json(req): Json<CliScanRequest>,
) -> Result<impl IntoResponse, (StatusCode, Json<CliErrorResponse>)> {
    // For now, just use the regular handler
    // Real SSE streaming can be added later
    cli_scan_handler(State(state), Json(req)).await
}

/// Build ScannerConfig from CliScanRequest
fn build_scanner_config(req: &CliScanRequest) -> Result<ScannerConfig> {
    let find_pattern = if let Some(ref pattern) = req.find {
        Some(Regex::new(pattern).context("Invalid find pattern regex")?)
    } else {
        None
    };

    let min_size = if let Some(ref s) = req.min_size {
        Some(parse_size(s).context("Invalid min_size")?)
    } else {
        None
    };

    let max_size = if let Some(ref s) = req.max_size {
        Some(parse_size(s).context("Invalid max_size")?)
    } else {
        None
    };

    // Determine depth based on mode if not specified
    let max_depth = if req.depth == 0 {
        get_ideal_depth_for_mode(&req.mode)
    } else {
        req.depth
    };

    Ok(ScannerConfig {
        max_depth,
        follow_symlinks: false,
        respect_gitignore: req.respect_gitignore,
        show_hidden: req.all,
        show_ignored: req.show_ignored,
        find_pattern,
        file_type_filter: req.file_type.clone(),
        entry_type_filter: req.entry_type.clone(),
        min_size,
        max_size,
        newer_than: None, // TODO: parse date strings
        older_than: None,
        use_default_ignores: req.default_ignores,
        search_keyword: req.search.clone(),
        show_filesystems: req.show_filesystems,
        sort_field: req.sort.clone(),
        top_n: req.top,
        include_line_content: req.include_line_content,
        // Smart scanning options
        compute_interest: req.smart,
        security_scan: req.security,
        min_interest: req.min_interest,
        track_traversal: req.smart,
        changes_only: req.changes_only,
        compare_state: None,
        smart_mode: req.smart,
    })
}

/// Get ideal depth for a given mode
fn get_ideal_depth_for_mode(mode: &str) -> usize {
    match mode.to_lowercase().as_str() {
        "quantum" | "quantum_semantic" => 10,
        "ai" | "semantic" | "smart" => 5,
        "digest" | "stats" => 20,
        "relations" => 3,
        "projects" => 5,
        _ => 3, // Default for classic, json, etc.
    }
}

/// Parse path display mode
fn parse_path_mode(mode: &str) -> PathDisplayMode {
    match mode.to_lowercase().as_str() {
        "off" | "none" => PathDisplayMode::Off,
        "full" | "absolute" => PathDisplayMode::Full,
        _ => PathDisplayMode::Relative,
    }
}

/// Format output using the appropriate formatter
fn format_output(
    req: &CliScanRequest,
    writer: &mut dyn Write,
    nodes: &[crate::FileNode],
    stats: &TreeStats,
    root_path: &std::path::Path,
    path_display: PathDisplayMode,
) -> Result<()> {
    let mode = req.mode.to_lowercase();
    let no_emoji = req.no_emoji;
    let use_color = req.use_color;

    match mode.as_str() {
        "classic" => {
            let formatter = ClassicFormatter::new(no_emoji, use_color, path_display);
            formatter.format(writer, nodes, stats, root_path)?;
        }
        "hex" => {
            let formatter = HexFormatter::new(
                use_color,
                no_emoji,
                req.show_ignored,
                path_display,
                req.show_filesystems,
            );
            formatter.format(writer, nodes, stats, root_path)?;
        }
        "json" => {
            let formatter = JsonFormatter::new(req.compact);
            formatter.format(writer, nodes, stats, root_path)?;
        }
        "ls" => {
            let formatter = LsFormatter::new(!no_emoji, use_color);
            formatter.format(writer, nodes, stats, root_path)?;
        }
        "ai" => {
            let formatter = AiFormatter::new(no_emoji, path_display);
            formatter.format(writer, nodes, stats, root_path)?;
        }
        "stats" => {
            let formatter = StatsFormatter::new();
            formatter.format(writer, nodes, stats, root_path)?;
        }
        "csv" => {
            let formatter = CsvFormatter::new();
            formatter.format(writer, nodes, stats, root_path)?;
        }
        "tsv" => {
            let formatter = TsvFormatter::new();
            formatter.format(writer, nodes, stats, root_path)?;
        }
        "digest" => {
            let formatter = DigestFormatter::new();
            formatter.format(writer, nodes, stats, root_path)?;
        }
        "quantum" => {
            let formatter = QuantumFormatter::new();
            formatter.format(writer, nodes, stats, root_path)?;
        }
        "semantic" => {
            let formatter = SemanticFormatter::new(path_display, no_emoji);
            formatter.format(writer, nodes, stats, root_path)?;
        }
        "projects" => {
            let formatter = ProjectsFormatter::new();
            formatter.format(writer, nodes, stats, root_path)?;
        }
        "mermaid" => {
            let formatter = MermaidFormatter::new(MermaidStyle::Flowchart, no_emoji, path_display);
            formatter.format(writer, nodes, stats, root_path)?;
        }
        "markdown" => {
            let formatter = MarkdownFormatter::new(path_display, no_emoji, true, true, true);
            formatter.format(writer, nodes, stats, root_path)?;
        }
        "waste" => {
            let formatter = WasteFormatter::new();
            formatter.format(writer, nodes, stats, root_path)?;
        }
        "marqant" => {
            let formatter = MarqantFormatter::new(path_display, no_emoji);
            formatter.format(writer, nodes, stats, root_path)?;
        }
        "smart" => {
            // The star of the show! Surface what matters, not everything.
            let formatter = SmartFormatter::new(use_color, !no_emoji)
                .with_path_mode(path_display);
            formatter.format(writer, nodes, stats, root_path)?;
        }
        // Default to classic for unknown modes
        _ => {
            let formatter = ClassicFormatter::new(no_emoji, use_color, path_display);
            formatter.format(writer, nodes, stats, root_path)?;
        }
    }

    Ok(())
}