gnaw-ctx 0.1.1

//! Token map visualization and analysis.
//!
//! This module provides functionality for generating and displaying visual token maps
//! that show how tokens are distributed across files in a codebase. It creates
//! hierarchical tree structures with visual bars and colors, similar to disk usage
//! analyzers but for token consumption.
use lscolors::{Indicator, LsColors};
use serde::Deserialize;
use std::cmp::Ordering;
use std::collections::{BTreeMap, BinaryHeap, HashMap};
use std::path::Component;
use std::path::Path;
use unicode_width::UnicodeWidthStr;

/// Color information for TUI rendering
#[derive(Debug, Clone)]
pub enum TuiColor {
    White,
    Gray,
    Red,
    Green,
    Blue,
    Yellow,
    Cyan,
    Magenta,
    LightRed,
    LightGreen,
    LightBlue,
    LightYellow,
    LightCyan,
    LightMagenta,
}

/// Formatted line for TUI token map display with separate components
#[derive(Debug, Clone)]
pub struct TuiTokenMapLine {
    pub tokens_part: String,
    pub prefix_part: String,
    pub name_part: String,
    pub name_color: TuiColor,
    pub bar_part: String,
    pub percentage_part: String,
}

#[derive(Debug, Clone, Copy, Deserialize)]
pub struct EntryMetadata {
    pub is_dir: bool,
}
/// Minimal per-file input for the token map. The map reconstructs the
/// directory tree from `path` (splitting on '/'), so callers supply only leaf
/// files — no directory entries, no is_dir flag. Both the legacy FileEntry
/// path and the pipeline's chunks adapt into this, so the token map no longer
/// depends on gnaw_core::path::FileEntry.
pub struct TokenMapFile {
    pub path: String,
    pub tokens: usize,
}
#[derive(Debug, Clone)]
struct TreeNode {
    tokens: usize,
    children: BTreeMap<String, TreeNode>,
    path: String,
    metadata: Option<EntryMetadata>,
}

impl TreeNode {
    fn with_path(path: String) -> Self {
        TreeNode {
            tokens: 0,
            children: BTreeMap::new(),
            path,
            metadata: None,
        }
    }
}

// For priority queue ordering
#[derive(Debug, Clone, Eq, PartialEq)]
struct NodePriority {
    tokens: usize,
    path: String,
    depth: usize,
}

impl Ord for NodePriority {
    fn cmp(&self, other: &Self) -> Ordering {
        // Order by tokens (descending), then by depth (ascending), then by path
        self.tokens
            .cmp(&other.tokens)
            .then_with(|| other.depth.cmp(&self.depth))
            .then_with(|| self.path.cmp(&other.path))
    }
}

impl PartialOrd for NodePriority {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

/// Generate a hierarchical token map with optional display limits.
///
/// Creates a tree structure showing token distribution across files and directories,
/// with optional limits on the number of entries and minimum percentage thresholds
/// for inclusion in the output.
///
/// # Arguments
///
/// * `files` - Array of file metadata from the gnaw session
/// * `total_tokens` - Total token count for percentage calculations
/// * `max_lines` - Maximum number of entries to return (None for unlimited)
/// * `min_percent` - Minimum percentage threshold for inclusion (None for no limit)
///
/// # Returns
///
/// * `Vec<TokenMapEntry>` - Hierarchical list of token map entries ready for display
pub fn generate_token_map_with_limit(
    files: &[TokenMapFile],
    total_tokens: usize,
    max_lines: Option<usize>,
    min_percent: Option<f64>,
) -> Vec<TokenMapEntry> {
    let max_lines = max_lines.unwrap_or(20);
    let min_percent = min_percent.unwrap_or(0.1);

    let mut root = TreeNode::with_path(String::new());
    root.tokens = total_tokens;

    // Insert all files into the tree
    for file in files {
        let path = Path::new(&file.path);
        let components: Vec<&str> = path
            .components()
            .filter_map(|c| match c {
                Component::Normal(s) => s.to_str(),
                _ => None,
            })
            .collect();
        // inputs are always leaf files → is_dir: false; insert_path creates
        // intermediate dir nodes itself, marking those is_dir: true.
        insert_path(
            &mut root,
            &components,
            file.tokens,
            String::new(),
            EntryMetadata { is_dir: false },
        );
    }

    // Use priority queue to select most significant entries
    let allowed_nodes = select_nodes_to_display(&root, total_tokens, max_lines, min_percent);

    // Convert tree to sorted entries for display
    let mut entries = Vec::new();
    rebuild_filtered_tree(
        &root,
        String::new(),
        &allowed_nodes,
        &mut entries,
        0,
        total_tokens,
        true,
    );

    // A displayed "leaf" is a shown node with no shown child: its bar already
    // represents its entire subtree. Summing only leaves counts every covered
    // token exactly once (no parent/child double counting), whether the leaf is
    // a file or a directory whose children weren't selected. The old version
    // counted files only, so a directory-heavy display dumped nearly everything
    // into "(other files)".
    let displayed_tokens: usize = entries
        .iter()
        .enumerate()
        .filter_map(|(idx, e)| {
            // entries are pre-order DFS, so a node's descendants immediately
            // follow it with greater depth.
            let is_leaf = entries
                .get(idx + 1)
                .is_none_or(|next| next.depth <= e.depth);
            is_leaf.then_some(e.tokens)
        })
        .sum();

    let hidden_tokens = total_tokens.saturating_sub(displayed_tokens);
    if hidden_tokens > 0 {
        entries.push(TokenMapEntry {
            path: "(other files)".to_string(),
            name: "(other files)".to_string(),
            tokens: hidden_tokens,
            percentage: (hidden_tokens as f64 / total_tokens as f64) * 100.0,
            depth: 0,
            is_last: true,
            metadata: EntryMetadata { is_dir: false },
        });
    }

    entries
}

fn insert_path(
    node: &mut TreeNode,
    components: &[&str],
    tokens: usize,
    parent_path: String,
    file_metadata: EntryMetadata,
) {
    if components.is_empty() {
        return;
    }

    if components.len() == 1 {
        // This is a file
        let file_name = components[0].to_string();
        let file_path = if parent_path.is_empty() {
            file_name.clone()
        } else {
            format!("{}/{}", parent_path, file_name)
        };
        let child = node
            .children
            .entry(file_name)
            .or_insert_with(|| TreeNode::with_path(file_path));
        child.tokens = tokens;
        child.metadata = Some(file_metadata);
    } else {
        // This is a directory
        let dir_name = components[0].to_string();
        let dir_path = if parent_path.is_empty() {
            dir_name.clone()
        } else {
            format!("{}/{}", parent_path, dir_name)
        };
        let child = node
            .children
            .entry(dir_name)
            .or_insert_with(|| TreeNode::with_path(dir_path.clone()));
        child.tokens += tokens;
        child.metadata = Some(EntryMetadata { is_dir: true });
        insert_path(child, &components[1..], tokens, dir_path, file_metadata);
    }
}

#[derive(Debug, Clone)]
pub struct TokenMapEntry {
    pub path: String,
    pub name: String,
    pub tokens: usize,
    pub percentage: f64,
    pub depth: usize,
    pub is_last: bool,
    pub metadata: EntryMetadata,
}

/// Select nodes to display using priority queue
fn select_nodes_to_display(
    root: &TreeNode,
    total_tokens: usize,
    max_lines: usize,
    min_percent: f64,
) -> HashMap<String, usize> {
    let mut heap = BinaryHeap::new();
    let mut allowed_nodes = HashMap::new();
    let min_tokens = (total_tokens as f64 * min_percent / 100.0) as usize;

    // Start with root children
    for child in root.children.values() {
        if child.tokens >= min_tokens {
            heap.push(NodePriority {
                tokens: child.tokens,
                path: child.path.clone(),
                depth: 0,
            });
        }
    }

    // Process nodes by priority
    while allowed_nodes.len() < max_lines.saturating_sub(1) && !heap.is_empty() {
        if let Some(node_priority) = heap.pop() {
            allowed_nodes.insert(node_priority.path.clone(), node_priority.depth);

            // Find the node in the tree and add its children
            if let Some(node) = find_node_by_path(root, &node_priority.path) {
                for child in node.children.values() {
                    if child.tokens >= min_tokens && !allowed_nodes.contains_key(&child.path) {
                        heap.push(NodePriority {
                            tokens: child.tokens,
                            path: child.path.clone(),
                            depth: node_priority.depth + 1,
                        });
                    }
                }
            }
        }
    }

    allowed_nodes
}

/// Find a node by its path
fn find_node_by_path<'a>(root: &'a TreeNode, path: &str) -> Option<&'a TreeNode> {
    if path.is_empty() {
        return Some(root);
    }

    let components: Vec<&str> = path.split('/').collect();
    let mut current = root;

    for component in components {
        let child = current.children.get(component)?;
        current = child;
    }

    Some(current)
}

/// Rebuild tree with only allowed nodes
fn rebuild_filtered_tree(
    node: &TreeNode,
    path: String,
    allowed_nodes: &HashMap<String, usize>,
    entries: &mut Vec<TokenMapEntry>,
    depth: usize,
    total_tokens: usize,
    is_last: bool,
) {
    // Check if this node should be included
    if !path.is_empty() && allowed_nodes.contains_key(&path) {
        let percentage = (node.tokens as f64 / total_tokens as f64) * 100.0;
        let name = path.split('/').next_back().unwrap_or(&path).to_string();

        let metadata = node.metadata.unwrap_or(EntryMetadata { is_dir: true });

        entries.push(TokenMapEntry {
            path: path.clone(),
            name,
            tokens: node.tokens,
            percentage,
            depth,
            is_last,
            metadata,
        });
    }

    // Process children that are in allowed_nodes
    let mut filtered_children: Vec<_> = node
        .children
        .iter()
        .filter(|(_, child)| allowed_nodes.contains_key(&child.path))
        .collect();

    // Sort by tokens descending
    filtered_children.sort_by_key(|b| std::cmp::Reverse(b.1.tokens));

    let child_count = filtered_children.len();
    for (i, (name, child)) in filtered_children.into_iter().enumerate() {
        let child_path = if path.is_empty() {
            name.clone()
        } else {
            format!("{}/{}", path, name)
        };

        let is_last_child = i == child_count - 1;
        rebuild_filtered_tree(
            child,
            child_path,
            allowed_nodes,
            entries,
            depth + 1,
            total_tokens,
            is_last_child,
        );
    }
}

fn should_enable_colors() -> bool {
    // Check NO_COLOR environment variable (https://no-color.org/)
    if std::env::var_os("NO_COLOR").is_some() {
        return false;
    }

    // Check if we're in a terminal
    if terminal_size::terminal_size().is_none() {
        return false;
    }

    // On Windows, enable ANSI support
    #[cfg(windows)]
    {
        use log::error;
        match ansi_term::enable_ansi_support() {
            Ok(_) => true,
            Err(_) => {
                error!("This version of Windows does not support ANSI colors");
                false
            }
        }
    }

    #[cfg(not(windows))]
    {
        true
    }
}

/// Display a visual token map with colors and hierarchical tree structure.
///
/// Renders the token map entries as a formatted tree with visual progress bars,
/// colors based on file types, and proper Unicode tree drawing characters.
/// Automatically adapts to terminal width and applies appropriate colors.
///
/// # Arguments
///
/// * `entries` - The token map entries to display
/// * `total_tokens` - Total token count for percentage calculations
pub fn display_token_map(entries: &[TokenMapEntry], total_tokens: usize) {
    if entries.is_empty() {
        return;
    }

    // Initialize LsColors from environment
    let ls_colors = LsColors::from_env().unwrap_or_default();
    let colors_enabled = should_enable_colors();

    // Terminal width detection
    let terminal_width = terminal_size::terminal_size()
        .map(|(terminal_size::Width(w), _)| w as usize)
        .unwrap_or(80);

    // Calculate max token width for alignment
    let max_token_width = entries
        .iter()
        .map(|e| format_tokens(e.tokens).len())
        .max()
        .unwrap_or(3)
        .max(format_tokens(total_tokens).len())
        .max(4);

    // Calculate max name length including tree prefix
    let max_name_length = entries
        .iter()
        .map(|e| {
            let prefix_width = if e.depth == 0 { 3 } else { (e.depth * 2) + 3 };
            prefix_width + UnicodeWidthStr::width(e.name.as_str())
        })
        .max()
        .unwrap_or(20)
        .min(terminal_width / 2);

    // Calculate bar width
    let bar_width = terminal_width
        .saturating_sub(max_token_width + 3 + max_name_length + 2 + 2 + 5)
        .max(20);

    // Initialize parent bars array
    let mut parent_bars: Vec<String> = vec![String::new(); 10];
    parent_bars[0] = "█".repeat(bar_width);

    for (i, entry) in entries.iter().enumerate() {
        // Build tree prefix using shared logic
        let prefix = build_tree_prefix(entry, entries, i);

        // Format tokens
        let tokens_str = format_tokens(entry.tokens);

        // Generate hierarchical bar
        let parent_bar = if entry.depth > 0 {
            // depth can exceed parent_bars in deep trees; clamp to the last slot
            // rather than index out of bounds.
            &parent_bars[(entry.depth - 1).min(parent_bars.len() - 1)]
        } else {
            &parent_bars[0]
        };

        let bar = generate_hierarchical_bar(bar_width, parent_bar, entry.percentage, entry.depth);

        // Update parent bars
        let slot = entry.depth.min(parent_bars.len() - 1);
        parent_bars[slot] = bar.clone();

        // Format percentage
        let percentage_str = format!("{:>4.0}%", entry.percentage);

        // Calculate padding for name
        let prefix_display_width = prefix.chars().count();
        let name_padding = max_name_length
            .saturating_sub(prefix_display_width + UnicodeWidthStr::width(entry.name.as_str()));

        // Create name with padding FIRST
        let name_with_padding = format!("{}{}", entry.name, " ".repeat(name_padding));

        // THEN apply colors to the name+padding combination
        let colored_name_with_padding = if colors_enabled && entry.name != "(other files)" {
            // Use our cached metadata to choose the coloring strategy
            let ansi_style = if entry.metadata.is_dir {
                // For directories, we know the type. No need to hit the filesystem.
                ls_colors
                    .style_for_indicator(Indicator::Directory)
                    .map(|s| s.to_ansi_term_style())
                    .unwrap_or_default()
            } else {
                // For files, rely on extension-based styling (no filesystem stat).
                ls_colors
                    .style_for_path(std::path::Path::new(&entry.path))
                    .map(lscolors::Style::to_ansi_term_style)
                    .unwrap_or_default()
            };

            // Apply style to name WITH padding
            format!("{}", ansi_style.paint(name_with_padding))
        } else {
            name_with_padding
        };

        eprintln!(
            "{:>width$}   {}{} │{}│ {}",
            tokens_str,
            prefix,
            colored_name_with_padding,
            bar,
            percentage_str,
            width = max_token_width
        );
    }
}

/// Build tree prefix for an entry (shared logic for CLI and TUI)
fn build_tree_prefix(entry: &TokenMapEntry, entries: &[TokenMapEntry], index: usize) -> String {
    let mut prefix = String::new();

    // Add vertical lines for parent levels
    for d in 0..entry.depth {
        if d < entry.depth - 1 {
            // Check if we need a vertical line at this depth
            let needs_line = entries
                .iter()
                .skip(index + 1)
                .take_while(|entry| entry.depth > d)
                .any(|entry| entry.depth == d + 1);
            if needs_line {
                prefix.push_str("│ ");
            } else {
                prefix.push_str("  ");
            }
        } else if entry.is_last {
            prefix.push_str("└─");
        } else {
            prefix.push_str("├─");
        }
    }

    // Special handling for root
    if entry.depth == 0 && index == 0 && entry.name != "(other files)" {
        prefix = "┌─".to_string();
    }

    // Check if has children
    let has_children = entries
        .get(index + 1)
        .map(|next| next.depth > entry.depth)
        .unwrap_or(false);

    // Add the connecting character
    if entry.depth > 0 || entry.name == "(other files)" {
        if has_children {
            prefix.push('┬');
        } else {
            prefix.push('─');
        }
    } else if index == 0 {
        prefix.push('┴');
    }

    prefix.push(' ');
    prefix
}

/// Determine TUI color for an entry based on file type and extension
fn determine_tui_color(entry: &TokenMapEntry) -> TuiColor {
    if entry.metadata.is_dir {
        TuiColor::Cyan
    } else {
        match entry.name.split('.').next_back().unwrap_or("") {
            // Systems / compiled langs
            "rs" => TuiColor::Yellow,
            "c" | "h" | "cpp" | "cxx" | "hpp" => TuiColor::Blue,
            "go" => TuiColor::LightBlue,
            "java" | "kt" | "kts" => TuiColor::Red,
            "swift" => TuiColor::LightRed,
            "zig" => TuiColor::LightYellow,

            // Web
            "js" | "mjs" | "cjs" => TuiColor::LightGreen,
            "ts" | "tsx" | "jsx" => TuiColor::LightCyan,
            "html" | "htm" => TuiColor::Magenta,
            "css" | "scss" | "less" => TuiColor::LightMagenta,

            // Scripting / automation
            "py" => TuiColor::LightYellow,
            "sh" | "bash" | "zsh" => TuiColor::Gray,
            "rb" => TuiColor::LightRed,
            "pl" => TuiColor::LightCyan,
            "php" => TuiColor::LightMagenta,
            "lua" => TuiColor::LightBlue,

            // Data / config / markup
            "json" | "toml" | "yaml" | "yml" => TuiColor::Magenta,
            "xml" => TuiColor::LightGreen,
            "csv" => TuiColor::Green,
            "ini" => TuiColor::Gray,

            // Docs
            "md" | "txt" | "rst" | "adoc" => TuiColor::Green,
            "pdf" => TuiColor::Red,

            // Default
            _ => TuiColor::White,
        }
    }
}

/// Format token map entries for TUI display with adaptive layout.
///
/// Creates formatted lines with tree structure and color information suitable
/// for rendering in a TUI interface using ratatui. This function uses the same
/// adaptive layout logic as the CLI version but returns structured data components
/// instead of printing directly.
///
/// # Arguments
///
/// * `entries` - The token map entries to format
/// * `total_tokens` - Total token count for percentage calculations
/// * `terminal_width` - Width of the terminal/TUI area for adaptive layout
///
/// # Returns
///
/// * `Vec<TuiTokenMapLine>` - Formatted lines ready for TUI rendering
pub fn format_token_map_for_tui(
    entries: &[TokenMapEntry],
    total_tokens: usize,
    terminal_width: usize,
) -> Vec<TuiTokenMapLine> {
    if entries.is_empty() {
        return Vec::new();
    }

    // Use the same adaptive layout logic as CLI
    let terminal_width = terminal_width.max(80); // Minimum width

    // Calculate max token width for alignment (same as CLI)
    let max_token_width = entries
        .iter()
        .map(|e| format_tokens(e.tokens).len())
        .max()
        .unwrap_or(3)
        .max(format_tokens(total_tokens).len())
        .max(4);

    // Calculate max name length including tree prefix (same as CLI)
    let max_name_length = entries
        .iter()
        .map(|e| {
            let prefix_width = if e.depth == 0 { 3 } else { (e.depth * 2) + 3 };
            prefix_width + UnicodeWidthStr::width(e.name.as_str())
        })
        .max()
        .unwrap_or(20)
        .min(terminal_width / 2);

    // Calculate bar width (adjusted for TUI to prevent overflow)
    // TUI needs a bit more space than CLI to prevent the percentage column from overflowing
    let bar_width = terminal_width
        .saturating_sub(max_token_width + 3 + max_name_length + 2 + 2 + 7) // +2 more chars for TUI
        .max(15); // Minimum bar width reduced slightly for TUI

    // Initialize parent bars array (same as CLI)
    let mut parent_bars: Vec<String> = vec![String::new(); 10];
    parent_bars[0] = "█".repeat(bar_width);

    let mut lines = Vec::new();

    for (i, entry) in entries.iter().enumerate() {
        // Build tree prefix using shared logic
        let prefix = build_tree_prefix(entry, entries, i);

        // Format tokens
        let tokens_str = format_tokens(entry.tokens);

        // Generate hierarchical bar (same as CLI)
        let parent_bar = if entry.depth > 0 {
            &parent_bars[entry.depth - 1]
        } else {
            &parent_bars[0]
        };

        let bar = generate_hierarchical_bar(bar_width, parent_bar, entry.percentage, entry.depth);

        // Update parent bars (same as CLI)
        if entry.depth < parent_bars.len() {
            parent_bars[entry.depth] = bar.clone();
        }

        // Format percentage
        let percentage_str = format!("{:>4.0}%", entry.percentage);

        // Calculate padding for name (same as CLI)
        let prefix_display_width = prefix.chars().count();
        let name_padding = max_name_length
            .saturating_sub(prefix_display_width + UnicodeWidthStr::width(entry.name.as_str()));

        // Create name with padding
        let name_with_padding = format!("{}{}", entry.name, " ".repeat(name_padding));

        // Determine color based on entry type and extension
        let name_color = determine_tui_color(entry);

        // Create structured components for TUI rendering
        lines.push(TuiTokenMapLine {
            tokens_part: format!("{:>width$}", tokens_str, width = max_token_width),
            prefix_part: prefix,
            name_part: name_with_padding,
            name_color,
            bar_part: format!("│{}│", bar),
            percentage_part: percentage_str,
        });
    }

    lines
}

// Format token counts with K/M suffixes (dust-style)
fn format_tokens(tokens: usize) -> String {
    if tokens >= 1_000_000 {
        let millions = (tokens + 500_000) / 1_000_000;
        format!("{}M", millions)
    } else if tokens >= 1_000 {
        let thousands = (tokens + 500) / 1_000;
        format!("{}K", thousands)
    } else {
        format!("{}", tokens)
    }
}

// Generate bar with dust-style depth shading
fn generate_hierarchical_bar(
    bar_width: usize,
    parent_bar: &str,
    percentage: f64,
    depth: usize,
) -> String {
    // Calculate how many characters should be filled for this entry
    let filled_chars = ((percentage / 100.0) * bar_width as f64).round() as usize;
    let mut result = String::new();

    // Depth determines which shade to use for parent's solid blocks
    let shade_char = match depth.max(1) {
        1 => ' ', // Level 1: parent blocks become spaces
        2 => '░', // Level 2: light shade
        3 => '▒', // Level 3: medium shade
        _ => '▓', // Level 4+: dark shade
    };

    // Process each character position
    let parent_chars: Vec<char> = parent_bar.chars().collect();
    for i in 0..bar_width {
        if i < filled_chars {
            // This is our filled portion - always solid
            result.push('█');
        } else if i < parent_chars.len() {
            // This is parent's portion
            let parent_char = parent_chars[i];
            if parent_char == '█' {
                // Replace parent's solid blocks with our shade
                result.push(shade_char);
            } else {
                // Keep parent's existing shading
                result.push(parent_char);
            }
        } else {
            // Beyond parent's bar - empty
            result.push(' ');
        }
    }

    result
}

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

    /// Terse constructor — inputs are always leaf files; the engine rebuilds
    /// the directory structure from the '/'-separated path.
    fn mf(path: &str, tokens: usize) -> TokenMapFile {
        TokenMapFile {
            path: path.to_string(),
            tokens,
        }
    }

    #[test]
    fn builds_simple_tree_with_dir_aggregate() {
        let files = vec![mf("src/main.rs", 100), mf("src/lib.rs", 200)];
        let entries = generate_token_map_with_limit(&files, 300, Some(100), Some(0.0));

        let src = entries.iter().find(|e| e.name == "src").expect("src dir");
        assert_eq!(src.tokens, 300, "src should aggregate its children");
        assert!(src.metadata.is_dir, "src is a synthesized directory node");

        let main = entries
            .iter()
            .find(|e| e.name == "main.rs")
            .expect("main.rs");
        assert!(!main.metadata.is_dir, "leaf files are not directories");
    }

    #[test]
    fn directories_accumulate_child_tokens() {
        // The key property of the single-pass insert: a directory's token count
        // is the sum of everything beneath it, including grandchildren.
        let files = vec![
            mf("src/a.rs", 100),
            mf("src/b.rs", 200),
            mf("src/sub/c.rs", 50),
        ];
        let entries = generate_token_map_with_limit(&files, 350, Some(100), Some(0.0));

        let src = entries.iter().find(|e| e.name == "src").expect("src");
        assert_eq!(src.tokens, 350, "src = 100 + 200 + 50");

        let sub = entries.iter().find(|e| e.name == "sub").expect("sub");
        assert_eq!(sub.tokens, 50, "sub holds only its own child");
    }

    #[test]
    fn nested_structure_increases_depth() {
        let files = vec![
            mf("website/public/assets/logo.svg", 100),
            mf("website/public/favicon.ico", 50),
        ];
        let entries = generate_token_map_with_limit(&files, 150, Some(100), Some(0.0));

        let depth = |name: &str| {
            entries
                .iter()
                .find(|e| e.name == name)
                .map(|e| e.depth)
                .unwrap_or_else(|| panic!("missing entry: {name}"))
        };

        let website = depth("website");
        let public = depth("public");
        let assets = depth("assets");
        let logo = depth("logo.svg");
        let favicon = depth("favicon.ico");

        // Root is depth 0 and never emitted, so the first visible level is
        // depth 1 (gnaw differs from upstream's 0-based depths here). Assert the
        // relationships rather than exact numbers so this stays robust.
        assert!(
            website < public && public < assets && assets < logo,
            "depth must strictly increase down the chain: {website} {public} {assets} {logo}"
        );
        // favicon.ico sits directly under public — same level as assets.
        assert_eq!(favicon, assets, "favicon.ico is a sibling level of assets");
    }

    #[test]
    fn max_lines_limits_displayed_files() {
        let files = vec![
            mf("a.rs", 1000),
            mf("b.rs", 500),
            mf("c.rs", 200),
            mf("d.rs", 100),
        ];
        let entries = generate_token_map_with_limit(&files, 1800, Some(2), Some(0.0));

        // The heaviest file is always kept (highest priority in the heap).
        assert!(
            entries.iter().any(|e| e.name == "a.rs"),
            "a.rs must survive"
        );

        // With a tight budget the rest collapse into "(other files)"; count only
        // non-directory rows (real files + the aggregate).
        let file_rows = entries.iter().filter(|e| !e.metadata.is_dir).count();
        assert!(
            file_rows <= 3,
            "expected at most 3 file rows, got {file_rows}"
        );
    }

    #[test]
    fn min_percent_filters_small_files() {
        // 10% of 950 = 95; small.rs (50) falls below the floor and is dropped.
        let files = vec![mf("big.rs", 900), mf("small.rs", 50)];
        let entries = generate_token_map_with_limit(&files, 950, Some(100), Some(10.0));

        assert!(entries.iter().any(|e| e.name == "big.rs"), "big.rs kept");
        assert!(
            entries.iter().all(|e| e.name != "small.rs"),
            "small.rs filtered by min_percent"
        );
    }

    #[test]
    fn hidden_tokens_become_other_files() {
        // Same setup as the min_percent test, but assert the remainder is
        // accounted for rather than silently dropped.
        let files = vec![mf("big.rs", 900), mf("small.rs", 50)];
        let entries = generate_token_map_with_limit(&files, 950, Some(100), Some(10.0));

        let other = entries
            .iter()
            .find(|e| e.name == "(other files)")
            .expect("filtered tokens should surface as (other files)");
        assert_eq!(other.tokens, 50, "the dropped 50 tokens are aggregated");
    }

    #[test]
    fn no_other_files_when_everything_shown() {
        // Everything fits: no remainder, so no aggregate row.
        let files = vec![mf("a.rs", 100), mf("b.rs", 200)];
        let entries = generate_token_map_with_limit(&files, 300, Some(100), Some(0.0));
        assert!(
            entries.iter().all(|e| e.name != "(other files)"),
            "nothing hidden ⇒ no (other files) row"
        );
    }

    #[test]
    fn single_file_is_one_leaf() {
        let entries = generate_token_map_with_limit(&[mf("a.rs", 100)], 100, Some(100), Some(0.0));
        assert_eq!(entries.len(), 1);
        assert_eq!(entries[0].name, "a.rs");
        assert_eq!(entries[0].tokens, 100);
        assert!(!entries[0].metadata.is_dir);
    }

    #[test]
    fn empty_input_yields_no_entries() {
        let entries = generate_token_map_with_limit(&[], 0, Some(100), Some(0.0));
        assert!(
            entries.is_empty(),
            "no files ⇒ no entries (and no divide-by-zero)"
        );
    }

    #[test]
    fn realistic_multi_crate_layout() {
        let files = vec![
            mf("crates/gnaw/src/main.rs", 5000),
            mf("crates/gnaw/src/args.rs", 3000),
            mf("crates/gnaw-core/src/analysis.rs", 2000),
            mf("website/src/index.html", 1000),
            mf("website/public/favicon.ico", 500),
            mf("README.md", 200),
        ];
        let total: usize = files.iter().map(|f| f.tokens).sum();
        let entries = generate_token_map_with_limit(&files, total, Some(50), Some(0.0));

        assert!(!entries.is_empty(), "should produce a tree");
        assert!(
            entries.iter().any(|e| e.name == "crates"),
            "top-level 'crates' directory present"
        );
        assert!(
            entries.iter().any(|e| e.depth >= 3),
            "deep nesting (crates/<pkg>/src/<file>) should reach depth >= 3"
        );
    }

    #[test]
    fn entries_are_valid_preorder() {
        // Structural invariant: walking the flat list, depth never *increases*
        // by more than one step at a time (a child is exactly parent.depth + 1;
        // uncles and the trailing "(other files)" only ever step back down).
        let files = vec![mf("a/b/c/d.rs", 100), mf("a/b/e.rs", 200), mf("f.rs", 50)];
        let entries = generate_token_map_with_limit(&files, 350, Some(100), Some(0.0));

        for w in entries.windows(2) {
            assert!(
                w[1].depth <= w[0].depth + 1,
                "depth jumped from {} to {} — not a valid pre-order walk",
                w[0].depth,
                w[1].depth
            );
        }
    }

    #[test]
    fn percentages_match_token_share() {
        let files = vec![mf("a.rs", 250), mf("b.rs", 750)];
        let total = 1000;
        let entries = generate_token_map_with_limit(&files, total, Some(100), Some(0.0));

        for e in &entries {
            let expected = e.tokens as f64 / total as f64 * 100.0;
            assert!(
                (e.percentage - expected).abs() < 1e-6,
                "{}: percentage {} != {}",
                e.name,
                e.percentage,
                expected
            );
        }
    }
}