leta_output/

formatters.rs

use std::collections::{HashMap, HashSet};
use std::path::PathBuf;

use leta_types::*;

pub fn format_truncation_with_count(
    command_with_larger_head: &str,
    displayed_count: u32,
    total_count: u32,
    command_base: &str,
) -> String {
    format!(
        "[showing {} of {} results, use `{}` to show more, or `{} -N0` to show all]",
        displayed_count, total_count, command_with_larger_head, command_base
    )
}

pub fn format_truncation_unknown_total(
    command_with_larger_head: &str,
    displayed_count: u32,
    command_base: &str,
) -> String {
    format!(
        "[showing first {} results, use `{}` to show more, or `{} -N0` to show all]",
        displayed_count, command_with_larger_head, command_base
    )
}

pub fn format_grep_result(result: &GrepResult, head: u32, command_base: &str) -> String {
    if let Some(warning) = &result.warning {
        return format!("Warning: {}", warning);
    }
    let mut output = format_symbols(&result.symbols);

    if result.truncated {
        if !output.is_empty() {
            output.push_str("\n\n");
        }
        let next_head = head * 2;
        let cmd = format!("{} --head {}", command_base, next_head);
        if let Some(total) = result.total_count {
            output.push_str(&format_truncation_with_count(
                &cmd,
                result.symbols.len() as u32,
                total,
                command_base,
            ));
        } else {
            output.push_str(&format_truncation_unknown_total(
                &cmd,
                result.symbols.len() as u32,
                command_base,
            ));
        }
    }

    output
}

pub fn format_references_result(
    result: &ReferencesResult,
    head: u32,
    command_base: &str,
) -> String {
    let mut output = format_locations(&result.locations);

    if result.truncated {
        if !output.is_empty() {
            output.push('\n');
        }
        let next_head = head * 2;
        let cmd = format!("{} --head {}", command_base, next_head);
        if let Some(total) = result.total_count {
            output.push_str(&format_truncation_with_count(
                &cmd,
                result.locations.len() as u32,
                total,
                command_base,
            ));
        } else {
            output.push_str(&format_truncation_unknown_total(
                &cmd,
                result.locations.len() as u32,
                command_base,
            ));
        }
    }

    output
}

pub fn format_declaration_result(
    result: &DeclarationResult,
    head: u32,
    command_base: &str,
) -> String {
    let mut output = format_locations(&result.locations);

    if result.truncated {
        if !output.is_empty() {
            output.push('\n');
        }
        let next_head = head * 2;
        let cmd = format!("{} --head {}", command_base, next_head);
        if let Some(total) = result.total_count {
            output.push_str(&format_truncation_with_count(
                &cmd,
                result.locations.len() as u32,
                total,
                command_base,
            ));
        } else {
            output.push_str(&format_truncation_unknown_total(
                &cmd,
                result.locations.len() as u32,
                command_base,
            ));
        }
    }

    output
}

pub fn format_implementations_result(
    result: &ImplementationsResult,
    head: u32,
    command_base: &str,
) -> String {
    if let Some(error) = &result.error {
        return format!("Error: {}", error);
    }
    let mut output = format_locations(&result.locations);

    if result.truncated {
        if !output.is_empty() {
            output.push('\n');
        }
        let next_head = head * 2;
        let cmd = format!("{} --head {}", command_base, next_head);
        if let Some(total) = result.total_count {
            output.push_str(&format_truncation_with_count(
                &cmd,
                result.locations.len() as u32,
                total,
                command_base,
            ));
        } else {
            output.push_str(&format_truncation_unknown_total(
                &cmd,
                result.locations.len() as u32,
                command_base,
            ));
        }
    }

    output
}

pub fn format_subtypes_result(result: &SubtypesResult, head: u32, command_base: &str) -> String {
    let mut output = format_locations(&result.locations);

    if result.truncated {
        if !output.is_empty() {
            output.push('\n');
        }
        let next_head = head * 2;
        let cmd = format!("{} --head {}", command_base, next_head);
        if let Some(total) = result.total_count {
            output.push_str(&format_truncation_with_count(
                &cmd,
                result.locations.len() as u32,
                total,
                command_base,
            ));
        } else {
            output.push_str(&format_truncation_unknown_total(
                &cmd,
                result.locations.len() as u32,
                command_base,
            ));
        }
    }

    output
}

pub fn format_supertypes_result(
    result: &SupertypesResult,
    head: u32,
    command_base: &str,
) -> String {
    let mut output = format_locations(&result.locations);

    if result.truncated {
        if !output.is_empty() {
            output.push('\n');
        }
        let next_head = head * 2;
        let cmd = format!("{} --head {}", command_base, next_head);
        if let Some(total) = result.total_count {
            output.push_str(&format_truncation_with_count(
                &cmd,
                result.locations.len() as u32,
                total,
                command_base,
            ));
        } else {
            output.push_str(&format_truncation_unknown_total(
                &cmd,
                result.locations.len() as u32,
                command_base,
            ));
        }
    }

    output
}

pub fn format_show_result(result: &ShowResult, head: u32) -> String {
    let location = if result.start_line == result.end_line {
        format!("{}:{}", result.path, result.start_line)
    } else {
        format!("{}:{}-{}", result.path, result.start_line, result.end_line)
    };

    let mut lines = vec![location, String::new(), result.content.clone()];

    if result.truncated {
        let total_lines = result.total_lines.unwrap_or(head);
        let symbol = result.symbol.as_deref().unwrap_or("SYMBOL");
        lines.push(String::new());
        lines.push(format!(
            "[truncated after {} lines, use `leta show \"{}\" --head {}` to show the full {} lines]",
            head, symbol, total_lines, total_lines
        ));
    }

    lines.join("\n")
}

pub fn format_rename_result(result: &RenameResult) -> String {
    let mut files: Vec<_> = result.files_changed.iter().collect();
    files.sort();
    format!(
        "Renamed in {} file(s):\n{}",
        files.len(),
        files
            .iter()
            .map(|f| format!("  {}", f))
            .collect::<Vec<_>>()
            .join("\n")
    )
}

pub fn format_move_file_result(result: &MoveFileResult) -> String {
    let mut files: Vec<_> = result.files_changed.iter().collect();
    files.sort();
    if result.imports_updated {
        format!(
            "Moved file and updated imports in {} file(s):\n{}",
            files.len(),
            files
                .iter()
                .map(|f| format!("  {}", f))
                .collect::<Vec<_>>()
                .join("\n")
        )
    } else if let Some(first) = files.first() {
        format!("Moved file (imports not updated):\n  {}", first)
    } else {
        "File moved".to_string()
    }
}

pub fn format_restart_workspace_result(result: &RestartWorkspaceResult) -> String {
    format!(
        "Restarted {} server(s): {}",
        result.restarted.len(),
        result.restarted.join(", ")
    )
}

pub fn format_remove_workspace_result(result: &RemoveWorkspaceResult) -> String {
    format!(
        "Stopped {} server(s): {}",
        result.servers_stopped.len(),
        result.servers_stopped.join(", ")
    )
}

pub fn format_files_result(result: &FilesResult, head: u32, command_base: &str) -> String {
    if result.files.is_empty() && result.excluded_dirs.is_empty() {
        return String::new();
    }

    let tree = build_tree(&result.files, &result.excluded_dirs);
    let mut lines = Vec::new();
    render_tree(&tree, &mut lines, 0);

    if result.truncated {
        lines.push(String::new());
        let next_head = head * 2;
        let cmd = format!("{} --head {}", command_base, next_head);
        lines.push(format_truncation_unknown_total(
            &cmd,
            result.files.len() as u32,
            command_base,
        ));
    }

    lines.join("\n")
}

pub fn format_calls_result(result: &CallsResult, head: u32, command_base: &str) -> String {
    if let Some(error) = &result.error {
        return format!("Error: {}", error);
    }
    if let Some(message) = &result.message {
        return message.clone();
    }
    let mut output = String::new();
    if let Some(root) = &result.root {
        output = format_call_tree(root);
    } else if let Some(path) = &result.path {
        output = format_call_path(path);
    }

    if result.truncated {
        if !output.is_empty() {
            output.push_str("\n\n");
        }
        let next_head = head * 2;
        let cmd = format!("{} --head {}", command_base, next_head);
        output.push_str(&format_truncation_unknown_total(&cmd, head, command_base));
    }

    output
}

pub fn format_describe_session_result(
    result: &DescribeSessionResult,
    show_profiling: bool,
) -> String {
    let mut lines = vec![format!("Daemon PID: {}", result.daemon_pid)];

    if !result.caches.is_empty() {
        lines.push("\nCaches:".to_string());
        if let Some(hover) = result.caches.get("hover_cache") {
            lines.push(format!(
                "  Hover:  {} / {} ({} entries)",
                format_size(hover.current_bytes),
                format_size(hover.max_bytes),
                hover.entries
            ));
        }
        if let Some(symbol) = result.caches.get("symbol_cache") {
            lines.push(format!(
                "  Symbol: {} / {} ({} entries)",
                format_size(symbol.current_bytes),
                format_size(symbol.max_bytes),
                symbol.entries
            ));
        }
    }

    let profiling_map: HashMap<&str, &WorkspaceProfilingData> = result
        .profiling
        .as_ref()
        .map(|data| {
            data.iter()
                .map(|p| (p.workspace_root.as_str(), p))
                .collect()
        })
        .unwrap_or_default();

    let mut workspace_roots: std::collections::HashSet<&str> = result
        .workspaces
        .iter()
        .map(|ws| ws.root.as_str())
        .collect();

    for root in profiling_map.keys() {
        workspace_roots.insert(root);
    }

    if workspace_roots.is_empty() {
        lines.push("\nNo active workspaces".to_string());
    } else {
        lines.push("\nActive workspaces:".to_string());

        let mut sorted_roots: Vec<_> = workspace_roots.into_iter().collect();
        sorted_roots.sort();

        for root in sorted_roots {
            lines.push(format!("\n  {}", root));

            let workspaces_for_root: Vec<_> = result
                .workspaces
                .iter()
                .filter(|ws| ws.root == root)
                .collect();

            let profiling_data = profiling_map.get(root);

            for ws in &workspaces_for_root {
                let status = if ws.server_pid.is_some() {
                    "running"
                } else {
                    "stopped"
                };
                let pid_str = ws
                    .server_pid
                    .map(|p| format!(", PID {}", p))
                    .unwrap_or_default();

                lines.push(format!(
                    "    {} ({}{}) [{} open files]",
                    ws.language,
                    status,
                    pid_str,
                    ws.open_documents.len()
                ));

                if show_profiling {
                    if let Some(profile) = profiling_data.and_then(|p| {
                        p.server_profiles
                            .iter()
                            .find(|sp| sp.server_name == ws.language)
                    }) {
                        if let Some(startup) = &profile.startup {
                            lines.push(format!(
                                "      Startup: {}ms (init: {}ms, ready: {}ms)",
                                startup.total_time_ms, startup.init_time_ms, startup.ready_time_ms
                            ));
                            lines.extend(format_function_stats(&startup.functions, "        ", 5));
                        }
                        if let Some(indexing) = &profile.indexing {
                            let cache = &indexing.cache;
                            let symbol_total = cache.symbol_hits + cache.symbol_misses;
                            let cache_str = if symbol_total > 0 {
                                format!(
                                    ", cache {}/{} ({:.0}%)",
                                    cache.symbol_hits,
                                    symbol_total,
                                    cache.symbol_hit_rate()
                                )
                            } else {
                                String::new()
                            };
                            lines.push(format!(
                                "      Indexing: {}ms ({} files{})",
                                indexing.total_time_ms, indexing.file_count, cache_str
                            ));
                            lines.extend(format_function_stats(
                                &indexing.functions,
                                "        ",
                                10,
                            ));
                        }
                    }
                }
            }

            if show_profiling {
                if let Some(profile) = profiling_data {
                    lines.push(format!(
                        "    Total: {}ms ({} files)",
                        profile.total_time_ms, profile.total_files
                    ));
                }
            }
        }
    }

    lines.join("\n")
}

fn format_duration_us(us: u64) -> String {
    if us >= 1_000_000 {
        format!("{:.2}s", us as f64 / 1_000_000.0)
    } else if us >= 1_000 {
        format!("{:.1}ms", us as f64 / 1_000.0)
    } else {
        format!("{}µs", us)
    }
}

pub fn format_function_name(name: &str) -> &str {
    name.strip_prefix("leta_daemon::handlers::")
        .or_else(|| name.strip_prefix("leta_daemon::"))
        .or_else(|| name.strip_prefix("leta_lsp::"))
        .or_else(|| name.strip_prefix("leta_"))
        .unwrap_or(name)
        .trim_end_matches("::{{closure}}")
}

pub fn format_function_stats(
    functions: &[FunctionStats],
    indent: &str,
    max_lines: usize,
) -> Vec<String> {
    let mut lines = Vec::new();
    if functions.is_empty() {
        return lines;
    }
    lines.push(format!(
        "{}{:<50} {:>6} {:>10} {:>10} {:>10}",
        indent, "Function", "Calls", "Avg", "P90", "Total"
    ));
    for func in functions.iter().take(max_lines) {
        let name = format_function_name(&func.name);
        lines.push(format!(
            "{}{:<50} {:>6} {:>10} {:>10} {:>10}",
            indent,
            name,
            func.calls,
            format_duration_us(func.avg_us),
            format_duration_us(func.p90_us),
            format_duration_us(func.total_us),
        ));
    }
    lines
}

pub fn format_resolve_symbol_result(result: &ResolveSymbolResult) -> String {
    if let Some(error) = &result.error {
        let mut lines = vec![format!("Error: {}", error)];
        if let Some(matches) = &result.matches {
            for m in matches {
                let container = m
                    .container
                    .as_ref()
                    .map(|c| format!(" in {}", c))
                    .unwrap_or_default();
                let kind = format!("[{}] ", m.kind);
                let detail = m
                    .detail
                    .as_ref()
                    .map(|d| format!(" ({})", d))
                    .unwrap_or_default();
                let ref_str = m.reference.as_deref().unwrap_or("");
                lines.push(format!("  {}", ref_str));
                lines.push(format!(
                    "    {}:{} {}{}{}{}",
                    m.path, m.line, kind, m.name, detail, container
                ));
            }
            if let Some(total) = result.total_matches {
                let shown = matches.len() as u32;
                if total > shown {
                    lines.push(format!("  ... and {} more", total - shown));
                }
            }
        }
        return lines.join("\n");
    }
    format!(
        "{}:{}",
        result.path.as_deref().unwrap_or(""),
        result.line.unwrap_or(0)
    )
}

fn format_locations(locations: &[LocationInfo]) -> String {
    let mut lines = Vec::new();
    for loc in locations {
        if let (Some(name), Some(kind)) = (&loc.name, &loc.kind) {
            let mut parts = vec![
                format!("{}:{}", loc.path, loc.line),
                format!("[{}]", kind),
                name.clone(),
            ];
            if let Some(detail) = &loc.detail {
                if !detail.is_empty() && detail != "()" {
                    parts.push(format!("({})", detail));
                }
            }
            lines.push(parts.join(" "));
        } else if let Some(context) = &loc.context_lines {
            let context_start = loc.context_start.unwrap_or(loc.line);
            let context_end = context_start + context.len() as u32 - 1;
            lines.push(format!("{}:{}-{}", loc.path, context_start, context_end));
            for line in context {
                lines.push(line.clone());
            }
            lines.push(String::new());
        } else {
            let line_content = get_line_content(&loc.path, loc.line);
            if let Some(content) = line_content {
                lines.push(format!("{}:{} {}", loc.path, loc.line, content));
            } else {
                lines.push(format!("{}:{}", loc.path, loc.line));
            }
        }
    }
    lines.join("\n")
}

fn get_line_content(path: &str, line: u32) -> Option<String> {
    let file_path = PathBuf::from(path);
    let file_path = if file_path.is_absolute() {
        file_path
    } else {
        std::env::current_dir().ok()?.join(&file_path)
    };

    let content = std::fs::read_to_string(&file_path).ok()?;
    let lines: Vec<&str> = content.lines().collect();
    if line > 0 && (line as usize) <= lines.len() {
        Some(lines[line as usize - 1].to_string())
    } else {
        None
    }
}

pub fn format_file_line(file: &FileInfo) -> String {
    format!(
        "{} ({}, {} lines)",
        file.path,
        format_size(file.bytes),
        file.lines
    )
}

/// Stateful printer for streaming file output with proper indentation.
/// Tracks the current directory path and emits directory headers when needed.
pub struct FileTreePrinter {
    current_path: Vec<String>,
}

impl FileTreePrinter {
    pub fn new() -> Self {
        Self {
            current_path: Vec::new(),
        }
    }

    /// Format a file with proper indentation, emitting directory headers as needed.
    /// Returns a string that may contain multiple lines (directory headers + file).
    pub fn format_file(&mut self, file: &FileInfo) -> String {
        let parts: Vec<&str> = file.path.split('/').collect();
        let (dirs, filename) = parts.split_at(parts.len().saturating_sub(1));

        let mut output = String::new();

        // Find where current path diverges from file path
        let mut common_depth = 0;
        for (i, dir) in dirs.iter().enumerate() {
            if i < self.current_path.len() && self.current_path[i] == *dir {
                common_depth = i + 1;
            } else {
                break;
            }
        }

        // Truncate current path to common prefix
        self.current_path.truncate(common_depth);

        // Add new directory headers
        for (i, dir) in dirs.iter().enumerate().skip(common_depth) {
            let indent = "  ".repeat(i);
            output.push_str(&format!("{}{}/\n", indent, dir));
            self.current_path.push(dir.to_string());
        }

        // Add the file
        let indent = "  ".repeat(dirs.len());
        let info_str = format!("{}, {} lines", format_size(file.bytes), file.lines);
        if let Some(name) = filename.first() {
            output.push_str(&format!("{}{} ({})", indent, name, info_str));
        }

        output
    }

    pub fn format_excluded_dir(&mut self, path: &str) -> String {
        let parts: Vec<&str> = path.split('/').collect();
        if parts.is_empty() {
            return String::new();
        }

        let (parent_dirs, dir_name) = parts.split_at(parts.len().saturating_sub(1));

        let mut output = String::new();

        let mut common_depth = 0;
        for (i, dir) in parent_dirs.iter().enumerate() {
            if i < self.current_path.len() && self.current_path[i] == *dir {
                common_depth = i + 1;
            } else {
                break;
            }
        }

        self.current_path.truncate(common_depth);

        for (i, dir) in parent_dirs.iter().enumerate().skip(common_depth) {
            let indent = "  ".repeat(i);
            output.push_str(&format!("{}{}/\n", indent, dir));
            self.current_path.push(dir.to_string());
        }

        let indent = "  ".repeat(parent_dirs.len());
        if let Some(name) = dir_name.first() {
            output.push_str(&format!("{}{} (excluded)", indent, name));
        }

        output
    }
}

impl Default for FileTreePrinter {
    fn default() -> Self {
        Self::new()
    }
}

pub fn format_symbol_line(sym: &SymbolInfo) -> String {
    let location = format!("{}:{}", sym.path, sym.line);
    let mut parts = vec![location, format!("[{}]", sym.kind), sym.name.clone()];
    if let Some(detail) = &sym.detail {
        if !detail.is_empty() && detail != "()" {
            parts.push(format!("({})", detail));
        }
    }
    if let Some(container) = &sym.container {
        parts.push(format!("in {}", container));
    }
    parts.join(" ")
}

fn format_symbols(symbols: &[SymbolInfo]) -> String {
    let mut lines = Vec::new();
    for sym in symbols {
        lines.push(format_symbol_line(sym));
    }
    lines.join("\n")
}

pub fn format_size(size: u64) -> String {
    if size < 1024 {
        format!("{}B", size)
    } else if size < 1024 * 1024 {
        format!("{:.1}KB", size as f64 / 1024.0)
    } else {
        format!("{:.1}MB", size as f64 / (1024.0 * 1024.0))
    }
}

pub fn format_profiling(profiling: &ProfilingData) -> String {
    let mut lines = Vec::new();

    let cache = &profiling.cache;
    let symbol_total = cache.symbol_hits + cache.symbol_misses;
    let hover_total = cache.hover_hits + cache.hover_misses;

    if symbol_total > 0 || hover_total > 0 {
        lines.push("CACHE".to_string());
        if symbol_total > 0 {
            lines.push(format!(
                "  symbols: {}/{} hits ({:.1}%)",
                cache.symbol_hits,
                symbol_total,
                cache.symbol_hit_rate()
            ));
        }
        if hover_total > 0 {
            lines.push(format!(
                "  hover: {}/{} hits ({:.1}%)",
                cache.hover_hits,
                hover_total,
                cache.hover_hit_rate()
            ));
        }
        lines.push(String::new());
    }

    if let Some(tree) = &profiling.span_tree {
        lines.push(format!(
            "{:<55} {:>7} {:>9} {:>9} {:>9}",
            "Function", "Calls", "Avg", "P90", "Total"
        ));
        lines.push("-".repeat(90));

        for root in &tree.roots {
            format_span_node(root, &mut lines, 0, &tree.functions);
        }

        lines.push("-".repeat(90));
        lines.push(format!(
            "{:<55} {:>7} {:>9} {:>9} {:>9}",
            "TOTAL",
            "",
            "",
            "",
            format_duration_us(tree.total_us)
        ));
    }

    lines.join("\n")
}

fn get_func_stats<'a>(name: &str, functions: &'a [FunctionStats]) -> Option<&'a FunctionStats> {
    functions.iter().find(|f| f.name == name)
}

fn format_span_node(
    node: &SpanNode,
    lines: &mut Vec<String>,
    depth: usize,
    functions: &[FunctionStats],
) {
    let indent = " ".repeat(depth);
    let parallel_marker = if node.is_parallel { " ||" } else { "" };

    let stats = get_func_stats(&node.name, functions);
    let (calls, avg, p90) = if let Some(s) = stats {
        (s.calls, s.avg_us, s.p90_us)
    } else {
        (
            node.calls,
            if node.calls > 0 {
                node.total_us / node.calls as u64
            } else {
                0
            },
            0,
        )
    };

    let name_with_indent = format!("{}{}{}", indent, node.name, parallel_marker);

    lines.push(format!(
        "{:<55} {:>7} {:>9} {:>9} {:>9}",
        truncate_left(&name_with_indent, 55),
        calls,
        format_duration_us(avg),
        format_duration_us(p90),
        format_duration_us(node.total_us)
    ));

    // Show properties if any - extract timing info from properties
    let mut property_time_ms = 0.0f64;
    if !node.properties.is_empty() {
        let props_indent = " ".repeat(depth + 1);

        // Aggregate properties by key, summing numeric values for _ms keys
        let mut aggregated: std::collections::HashMap<&str, (f64, u32)> =
            std::collections::HashMap::new();
        for (k, v) in &node.properties {
            if k.ends_with("_ms") {
                if let Ok(ms) = v.parse::<f64>() {
                    property_time_ms += ms;
                    let entry = aggregated.entry(k.as_str()).or_insert((0.0, 0));
                    entry.0 += ms;
                    entry.1 += 1;
                }
            } else if let Ok(num) = v.parse::<f64>() {
                let entry = aggregated.entry(k.as_str()).or_insert((0.0, 0));
                entry.0 += num;
                entry.1 += 1;
            } else {
                // Non-numeric properties just count occurrences
                let entry = aggregated.entry(k.as_str()).or_insert((0.0, 0));
                entry.1 += 1;
            }
        }

        // Format aggregated properties
        let mut props_str: Vec<String> = aggregated
            .iter()
            .map(|(k, (sum, count))| {
                if *count > 1 {
                    if k.ends_with("_ms") {
                        format!(
                            "{}={:.1}ms total ({} calls)",
                            k.trim_end_matches("_ms"),
                            sum,
                            count
                        )
                    } else {
                        format!("{}={:.0} total", k, sum)
                    }
                } else if k.ends_with("_ms") {
                    format!("{}={:.1}ms", k.trim_end_matches("_ms"), sum)
                } else {
                    format!("{}={:.0}", k, sum)
                }
            })
            .collect();
        props_str.sort();

        lines.push(format!("{}  [{}]", props_indent, props_str.join(", ")));
    }

    for child in &node.children {
        format_span_node(child, lines, depth + 1, functions);
    }

    // Only show unaccounted if:
    // 1. There's significant unaccounted time (> 1ms)
    // 2. There are children (otherwise all time is "self")
    // 3. Properties don't already explain most of the time
    let property_time_us = (property_time_ms * 1000.0) as u64;
    let truly_unaccounted = node.self_us.saturating_sub(property_time_us);

    if truly_unaccounted > 1000 && !node.children.is_empty() {
        let unaccounted_name = format!("{}[unaccounted]", " ".repeat(depth + 1));
        lines.push(format!(
            "{:<55} {:>7} {:>9} {:>9} {:>9}",
            unaccounted_name,
            "",
            "",
            "",
            format_duration_us(truly_unaccounted)
        ));
    }
}

fn truncate_left(s: &str, max_len: usize) -> String {
    if s.len() <= max_len {
        s.to_string()
    } else {
        format!("…{}", &s[s.len() - max_len + 1..])
    }
}

enum TreeNode {
    File(FileInfo),
    Dir(HashMap<String, TreeNode>),
    ExcludedDir,
}

fn build_tree(
    files: &HashMap<String, FileInfo>,
    excluded_dirs: &[String],
) -> HashMap<String, TreeNode> {
    let mut tree: HashMap<String, TreeNode> = HashMap::new();

    for (rel_path, info) in files {
        let parts: Vec<&str> = rel_path.split('/').collect();
        let mut current = &mut tree;

        for (i, part) in parts.iter().enumerate() {
            if i == parts.len() - 1 {
                current.insert(part.to_string(), TreeNode::File(info.clone()));
            } else {
                current = match current
                    .entry(part.to_string())
                    .or_insert_with(|| TreeNode::Dir(HashMap::new()))
                {
                    TreeNode::Dir(map) => map,
                    _ => unreachable!(),
                };
            }
        }
    }

    for excluded_path in excluded_dirs {
        let parts: Vec<&str> = excluded_path.split('/').collect();
        let mut current = &mut tree;

        for (i, part) in parts.iter().enumerate() {
            if i == parts.len() - 1 {
                current
                    .entry(part.to_string())
                    .or_insert(TreeNode::ExcludedDir);
            } else {
                current = match current
                    .entry(part.to_string())
                    .or_insert_with(|| TreeNode::Dir(HashMap::new()))
                {
                    TreeNode::Dir(map) => map,
                    _ => break,
                };
            }
        }
    }

    tree
}

fn render_tree(node: &HashMap<String, TreeNode>, lines: &mut Vec<String>, indent: usize) {
    let mut entries: Vec<_> = node.keys().collect();
    entries.sort();

    let prefix = "  ".repeat(indent);

    for name in entries {
        let child = node.get(name).unwrap();

        match child {
            TreeNode::File(info) => {
                let info_str = format_file_info(info);
                lines.push(format!("{}{} ({})", prefix, name, info_str));
            }
            TreeNode::Dir(children) => {
                lines.push(format!("{}{}/", prefix, name));
                render_tree(children, lines, indent + 1);
            }
            TreeNode::ExcludedDir => {
                lines.push(format!("{}{} (excluded)", prefix, name));
            }
        }
    }
}

fn format_file_info(info: &FileInfo) -> String {
    format!("{}, {} lines", format_size(info.bytes), info.lines)
}

fn is_stdlib_path(path: &str) -> bool {
    path.contains("/typeshed-fallback/stdlib/")
        || path.contains("/typeshed/stdlib/")
        || (path.contains("/libexec/src/") && !path.contains("/mod/"))
        || (path.ends_with(".d.ts")
            && path
                .split('/')
                .next_back()
                .map(|f| f.starts_with("lib."))
                .unwrap_or(false))
        || path.contains("/rustlib/src/rust/library/")
}

fn should_show_detail(detail: &Option<String>) -> bool {
    detail
        .as_ref()
        .map(|d| !d.is_empty() && d != "()")
        .unwrap_or(false)
}

fn format_call_tree(node: &CallNode) -> String {
    let mut lines = Vec::new();

    let mut parts: Vec<String> = Vec::new();
    if let Some(path) = &node.path {
        parts.push(format!("{}:{}", path, node.line.unwrap_or(0)));
    }
    if let Some(kind) = &node.kind {
        parts.push(format!("[{}]", kind));
    }
    parts.push(node.name.clone());
    if should_show_detail(&node.detail) {
        parts.push(format!("({})", node.detail.as_ref().unwrap()));
    }
    lines.push(parts.join(" "));

    if let Some(calls) = &node.calls {
        lines.push(String::new());
        lines.push("Outgoing calls:".to_string());
        if !calls.is_empty() {
            render_calls_tree(calls, &mut lines, "  ", true);
        }
    } else if let Some(called_by) = &node.called_by {
        lines.push(String::new());
        lines.push("Incoming calls:".to_string());
        if !called_by.is_empty() {
            render_calls_tree(called_by, &mut lines, "  ", false);
        }
    }

    lines.join("\n")
}

fn render_calls_tree(items: &[CallNode], lines: &mut Vec<String>, prefix: &str, is_outgoing: bool) {
    for (i, item) in items.iter().enumerate() {
        let is_last = i == items.len() - 1;
        let connector = if is_last { "└── " } else { "├── " };
        let child_prefix = format!("{}{}", prefix, if is_last { "    " } else { "│   " });

        let path = item.path.as_deref().unwrap_or("");
        let line = item.line.unwrap_or(0);

        let mut parts: Vec<String> = Vec::new();
        if !item.in_workspace || is_stdlib_path(path) {
            if let Some(kind) = &item.kind {
                parts.push(format!("[{}]", kind));
            }
        } else {
            parts.push(format!("{}:{}", path, line));
            if let Some(kind) = &item.kind {
                parts.push(format!("[{}]", kind));
            }
        }
        parts.push(item.name.clone());
        if should_show_detail(&item.detail) {
            parts.push(format!("({})", item.detail.as_ref().unwrap()));
        }
        lines.push(format!("{}{}{}", prefix, connector, parts.join(" ")));

        let children = if is_outgoing {
            &item.calls
        } else {
            &item.called_by
        };
        if let Some(children) = children {
            render_calls_tree(children, lines, &child_prefix, is_outgoing);
        }
    }
}

fn format_call_path(path: &[CallNode]) -> String {
    if path.is_empty() {
        return "Empty path".to_string();
    }

    let mut lines = vec!["Call path:".to_string()];
    for (i, item) in path.iter().enumerate() {
        let file_path = item.path.as_deref().unwrap_or("");
        let line = item.line.unwrap_or(0);

        let mut parts = vec![format!("{}:{}", file_path, line)];
        if let Some(kind) = &item.kind {
            parts.push(format!("[{}]", kind));
        }
        parts.push(item.name.clone());
        if should_show_detail(&item.detail) {
            parts.push(format!("({})", item.detail.as_ref().unwrap()));
        }

        let arrow = if i == 0 { "" } else { "  → " };
        lines.push(format!("{}{}", arrow, parts.join(" ")));
    }

    lines.join("\n")
}

pub fn format_graph_result(result: &GraphResult, include_orphans: bool) -> String {
    use leta_types::{CallGraphEdge, CallGraphSymbol};

    let node_key = |s: &CallGraphSymbol| format!("{}:{}:{}", s.path, s.line, s.name);

    let mut outgoing: HashMap<String, Vec<&CallGraphEdge>> = HashMap::new();
    let mut has_incoming: HashSet<String> = HashSet::new();
    let mut has_outgoing: HashSet<String> = HashSet::new();
    let mut self_recursive: HashSet<String> = HashSet::new();
    let mut node_map: HashMap<String, &CallGraphSymbol> = HashMap::new();

    for node in &result.nodes {
        node_map.insert(node_key(node), node);
    }

    for edge in &result.edges {
        let caller_key = node_key(&edge.caller);
        let callee_key = node_key(&edge.callee);

        node_map.entry(callee_key.clone()).or_insert(&edge.callee);

        if caller_key == callee_key {
            self_recursive.insert(caller_key);
            continue;
        }

        outgoing.entry(caller_key.clone()).or_default().push(edge);
        has_incoming.insert(callee_key);
        has_outgoing.insert(caller_key);
    }

    for children in outgoing.values_mut() {
        children.sort_by_key(|e| e.call_site_line.unwrap_or(u32::MAX));
    }

    let mut roots: Vec<String> = Vec::new();
    for key in has_outgoing.iter() {
        if !has_incoming.contains(key) {
            roots.push(key.clone());
        }
    }
    for key in self_recursive.iter() {
        if !has_incoming.contains(key) && !has_outgoing.contains(key) {
            roots.push(key.clone());
        }
    }

    fn count_reachable(
        key: &str,
        outgoing: &HashMap<String, Vec<&CallGraphEdge>>,
        seen: &mut HashSet<String>,
    ) -> usize {
        if !seen.insert(key.to_string()) {
            return 0;
        }
        let mut count = 1;
        let node_key = |s: &CallGraphSymbol| format!("{}:{}:{}", s.path, s.line, s.name);
        if let Some(children) = outgoing.get(key) {
            for edge in children {
                count += count_reachable(&node_key(&edge.callee), outgoing, seen);
            }
        }
        count
    }

    roots.sort_by(|a, b| {
        let size_a = count_reachable(a, &outgoing, &mut HashSet::new());
        let size_b = count_reachable(b, &outgoing, &mut HashSet::new());
        size_b.cmp(&size_a).then_with(|| a.cmp(b))
    });

    let mut roots_by_lang: Vec<(String, Vec<String>)> = Vec::new();
    let mut lang_map: HashMap<String, Vec<String>> = HashMap::new();
    for root_key in roots {
        let lang = node_map
            .get(root_key.as_str())
            .map(|n| language_from_path(&n.path))
            .unwrap_or_else(|| "Unknown".to_string());
        lang_map.entry(lang).or_default().push(root_key);
    }
    for (lang, lang_roots) in lang_map {
        roots_by_lang.push((lang, lang_roots));
    }
    roots_by_lang.sort_by(|a, b| {
        let size_a: usize =
            a.1.iter()
                .map(|r| count_reachable(r, &outgoing, &mut HashSet::new()))
                .sum();
        let size_b: usize =
            b.1.iter()
                .map(|r| count_reachable(r, &outgoing, &mut HashSet::new()))
                .sum();
        size_b.cmp(&size_a).then_with(|| a.0.cmp(&b.0))
    });

    let mut visited: HashSet<String> = HashSet::new();
    let mut lines: Vec<String> = Vec::new();
    let show_lang_headers = roots_by_lang.len() > 1;

    for (lang, lang_roots) in &roots_by_lang {
        if show_lang_headers {
            if !lines.is_empty() {
                lines.push(String::new());
            }
            lines.push(lang.clone());
            lines.push("═".repeat(lang.len()));
            lines.push(String::new());
        }

        for root_key in lang_roots {
            let node = match node_map.get(root_key.as_str()) {
                Some(n) => n,
                None => continue,
            };

            let mut root_line = format_graph_node_label(node, true);
            let has_children = outgoing.contains_key(root_key.as_str());
            let is_self_recursive = self_recursive.contains(root_key.as_str());

            if is_self_recursive && !has_children {
                root_line.push_str(" ↻");
                lines.push(root_line);
                lines.push(String::new());
                visited.insert(root_key.clone());
                continue;
            }

            if is_self_recursive {
                root_line.push_str(" ↻");
            }

            lines.push(root_line);
            visited.insert(root_key.clone());

            if let Some(children) = outgoing.get(root_key.as_str()) {
                render_graph_tree(
                    children,
                    &outgoing,
                    &self_recursive,
                    &mut visited,
                    &mut lines,
                    "",
                );
            }

            lines.push(String::new());
        }
    }

    // Leaf-only nodes (have incoming but no outgoing, not self-recursive) are
    // already shown as leaves in the trees above, so skip them.
    // But if include_orphans, show nodes with no edges at all.
    if include_orphans {
        for node in &result.nodes {
            let key = node_key(node);
            if !has_incoming.contains(&key)
                && !has_outgoing.contains(&key)
                && !self_recursive.contains(&key)
            {
                lines.push(format!("{} (orphan)", format_graph_node_label(node, true)));
                lines.push(String::new());
            }
        }
    }

    lines.join("\n")
}

fn format_graph_node_label(node: &leta_types::CallGraphSymbol, show_path: bool) -> String {
    let mut parts = Vec::new();
    if show_path {
        parts.push(format!("{}:{}", node.path, node.line));
    }
    parts.push(format!("[{}]", node.kind));
    parts.push(node.name.clone());
    if let Some(detail) = &node.detail {
        if !detail.is_empty() && detail != "()" {
            let oneline: String = detail.split_whitespace().collect::<Vec<_>>().join(" ");
            let trimmed = if show_path {
                oneline.split(" • ").next().unwrap_or(&oneline)
            } else {
                &oneline
            };
            parts.push(format!("({})", trimmed));
        }
    }
    parts.join(" ")
}

fn render_graph_tree(
    children: &[&leta_types::CallGraphEdge],
    outgoing: &HashMap<String, Vec<&leta_types::CallGraphEdge>>,
    self_recursive: &HashSet<String>,
    visited: &mut HashSet<String>,
    lines: &mut Vec<String>,
    prefix: &str,
) {
    let node_key = |s: &leta_types::CallGraphSymbol| format!("{}:{}:{}", s.path, s.line, s.name);

    for (i, edge) in children.iter().enumerate() {
        let callee = &edge.callee;
        let in_workspace = edge.in_workspace;
        let is_last = i == children.len() - 1;
        let connector = if is_last { "└── " } else { "├── " };
        let child_prefix = format!("{}{}", prefix, if is_last { "    " } else { "│   " });

        let key = node_key(callee);
        let label = format_graph_node_label(callee, in_workspace);
        let is_self_recursive = self_recursive.contains(&key);

        if !visited.insert(key.clone()) {
            let mut line = format!("{}{}{}", prefix, connector, label);
            if is_self_recursive {
                line.push_str(" ↻");
            }
            if outgoing.contains_key(key.as_str()) {
                line.push_str(" ↑");
            }
            lines.push(line);
            continue;
        }

        let grandchildren = outgoing.get(key.as_str());
        let mut line = format!("{}{}{}", prefix, connector, label);
        if is_self_recursive {
            line.push_str(" ↻");
        }
        lines.push(line);

        if let Some(grandchildren) = grandchildren {
            render_graph_tree(
                grandchildren,
                outgoing,
                self_recursive,
                visited,
                lines,
                &child_prefix,
            );
        }
    }
}

fn language_from_path(path: &str) -> String {
    let ext = path.rsplit('.').next().unwrap_or("");
    match ext {
        "py" => "Python",
        "rs" => "Rust",
        "go" => "Go",
        "ts" | "tsx" => "TypeScript",
        "js" | "jsx" => "JavaScript",
        "java" => "Java",
        "rb" => "Ruby",
        "cpp" | "cc" | "cxx" | "c" | "h" | "hpp" => "C/C++",
        "php" => "PHP",
        "lua" => "Lua",
        "ml" | "mli" => "OCaml",
        "zig" => "Zig",
        _ => ext,
    }
    .to_string()
}