leindex 2.1.1

use crate::phase::options::{DocsMode, PhaseOptions};
use anyhow::{Context, Result};
use std::path::{Path, PathBuf};

/// Files selected for a phase run.
#[derive(Debug, Clone, Default)]
pub struct CollectedFiles {
    /// Source-code files supported by leparse.
    pub code_files: Vec<PathBuf>,
    /// Optional docs files (markdown/text) when explicitly enabled.
    pub docs_files: Vec<PathBuf>,
}

/// Collect source files with optional docs based on options.
pub fn collect_files(root: &Path, options: &PhaseOptions) -> Result<CollectedFiles> {
    if !options.focus_files.is_empty() {
        let focused = collect_focused_files(root, options);
        if !focused.code_files.is_empty() || !focused.docs_files.is_empty() {
            return Ok(focused);
        }
    }

    if !options.universe.is_empty() {
        return Ok(collect_from_universe(options));
    }

    Ok(collect_walked_files(root, options))
}

/// Select code files from the index's own file set instead of walking the tree.
fn collect_from_universe(options: &PhaseOptions) -> CollectedFiles {
    let mut collected = CollectedFiles::default();
    for path in options.universe.iter() {
        let is_code = path
            .extension()
            .and_then(|extension| extension.to_str())
            .is_some_and(|extension| is_code_extension(&extension.to_ascii_lowercase()))
            || is_code_suffix(path);
        if is_code {
            collected.code_files.push(path.clone());
        }
    }
    deduplicate_collected_files(&mut collected);
    collected.code_files.truncate(options.max_files);
    collected
}

fn collect_focused_files(root: &Path, options: &PhaseOptions) -> CollectedFiles {
    let mut collected = CollectedFiles::default();
    for raw_path in &options.focus_files {
        let candidate = if raw_path.is_absolute() {
            raw_path.clone()
        } else {
            root.join(raw_path)
        };
        if !candidate.is_file() {
            continue;
        }

        classify_file(&candidate, options, &mut collected);
        if collected.code_files.len() >= options.max_files {
            break;
        }
    }
    deduplicate_collected_files(&mut collected);
    collected
}

fn collect_walked_files(root: &Path, options: &PhaseOptions) -> CollectedFiles {
    let mut collected = CollectedFiles::default();
    let mut walker = walkdir::WalkDir::new(root).into_iter();

    while let Some(entry) = walker.next() {
        let Ok(entry) = entry else {
            continue;
        };
        let path = entry.path();
        if entry.file_type().is_dir() {
            if should_skip_dir(&entry.file_name().to_string_lossy()) {
                walker.skip_current_dir();
            }
            continue;
        }
        if !entry.file_type().is_file() {
            continue;
        }

        classify_file(path, options, &mut collected);
        if collected.code_files.len() >= options.max_files {
            break;
        }
    }

    collected
}

fn classify_file(path: &Path, options: &PhaseOptions, collected: &mut CollectedFiles) {
    if let Some(extension) = path.extension().and_then(|extension| extension.to_str()) {
        let extension = extension.to_ascii_lowercase();
        if is_code_extension(&extension) {
            collected.code_files.push(path.to_path_buf());
            return;
        }
        if options.include_docs && include_docs_extension(&extension, options.docs_mode) {
            collected.docs_files.push(path.to_path_buf());
        }
    }

    if is_code_suffix(path) {
        collected.code_files.push(path.to_path_buf());
    }
}

fn deduplicate_collected_files(collected: &mut CollectedFiles) {
    collected.code_files.sort();
    collected.code_files.dedup();
    collected.docs_files.sort();
    collected.docs_files.dedup();
}

fn is_code_extension(extension: &str) -> bool {
    [
        "rs", "py", "js", "jsx", "mjs", "cjs", "ts", "tsx", "mts", "cts", "go", "java", "cpp",
        "cc", "cxx", "c", "h", "hpp", "cs", "rb", "php", "lua", "scala", "sc", "sh", "bash",
        "json",
    ]
    .contains(&extension)
}

fn is_code_suffix(path: &Path) -> bool {
    path.to_string_lossy().ends_with(".rs.in")
}

/// Build (path, hash) inventory for freshness checks.
pub fn hash_inventory(paths: &[PathBuf]) -> Result<Vec<(PathBuf, String)>> {
    use rayon::prelude::*;
    let mut out = paths
        .par_iter()
        .map(|path| {
            let bytes = std::fs::read(path)
                .with_context(|| format!("failed reading file for hashing: {}", path.display()))?;
            Ok((path.clone(), blake3::hash(&bytes).to_hex().to_string()))
        })
        .collect::<Result<Vec<_>>>()?;
    out.sort_by(|a, b| a.0.cmp(&b.0));
    Ok(out)
}

/// Render a path relative to root when possible.
pub fn display_path(root: &Path, path: &Path) -> String {
    path.strip_prefix(root)
        .map(|p| p.display().to_string())
        .unwrap_or_else(|_| path.display().to_string())
}

fn should_skip_dir(file_name: &str) -> bool {
    // Must stay in sync with lepasserelle::leindex::ALWAYS_SKIP_DIRS
    // and config::ExclusionConfig defaults.
    matches!(
        file_name,
        // Archived / deprecated code
        ".archive" | "archive"
        // Version control
        | ".git" | ".hg" | ".svn"
        // Build outputs
        | "target" | "build" | "dist" | "out" | ".next" | "coverage"
        // Package managers / dependencies
        | "node_modules" | "vendor" | "bower_components"
        // Python virtual environments & caches
        | ".venv" | "venv" | "env" | "__pycache__" | ".tox" | ".mypy_cache"
        | ".pytest_cache" | ".ruff_cache"
        // IDE / editor metadata
        | ".idea" | ".vscode"
        // Misc generated
        | ".leindex"
    )
}

fn include_docs_extension(ext: &str, mode: DocsMode) -> bool {
    (mode.include_markdown() && matches!(ext, "md" | "markdown"))
        || (mode.include_text() && matches!(ext, "txt" | "text"))
}

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

    #[test]
    fn collect_files_respects_docs_gating_and_skips_dirs() {
        let dir = tempdir().expect("tempdir");
        std::fs::create_dir_all(dir.path().join("src")).expect("mkdir src");
        std::fs::create_dir_all(dir.path().join("target")).expect("mkdir target");

        std::fs::write(dir.path().join("src/lib.rs"), "pub fn f(){}\n").expect("write code");
        std::fs::write(dir.path().join("README.md"), "# Doc\n").expect("write readme");
        std::fs::write(dir.path().join("notes.txt"), "hello\n").expect("write text");
        std::fs::write(dir.path().join("target/ignored.rs"), "pub fn g(){}\n")
            .expect("write ignored");

        let no_docs = collect_files(
            dir.path(),
            &PhaseOptions {
                root: dir.path().to_path_buf(),
                include_docs: false,
                docs_mode: DocsMode::All,
                ..PhaseOptions::default()
            },
        )
        .expect("collect no docs");

        assert_eq!(no_docs.code_files.len(), 1);
        assert!(no_docs.docs_files.is_empty());

        let with_docs = collect_files(
            dir.path(),
            &PhaseOptions {
                root: dir.path().to_path_buf(),
                include_docs: true,
                docs_mode: DocsMode::All,
                ..PhaseOptions::default()
            },
        )
        .expect("collect docs");

        assert_eq!(with_docs.code_files.len(), 1);
        assert_eq!(with_docs.docs_files.len(), 2);
    }

    #[test]
    fn hash_inventory_and_display_path_work() {
        let dir = tempdir().expect("tempdir");
        let file = dir.path().join("src/lib.rs");
        std::fs::create_dir_all(file.parent().expect("parent")).expect("mkdir");
        std::fs::write(&file, "pub fn f(){}\n").expect("write");

        let inventory = hash_inventory(std::slice::from_ref(&file)).expect("inventory");
        assert_eq!(inventory.len(), 1);
        assert_eq!(inventory[0].0, file);
        assert!(!inventory[0].1.is_empty());

        let rendered = display_path(dir.path(), &inventory[0].0);
        assert_eq!(rendered, "src/lib.rs");
    }

    #[test]
    fn collect_files_respects_max_files_limit() {
        let dir = tempdir().expect("tempdir");
        std::fs::create_dir_all(dir.path().join("src")).expect("mkdir src");
        std::fs::write(dir.path().join("src/a.rs"), "pub fn a(){}\n").expect("write a");
        std::fs::write(dir.path().join("src/b.rs"), "pub fn b(){}\n").expect("write b");

        let collected = collect_files(
            dir.path(),
            &PhaseOptions {
                root: dir.path().to_path_buf(),
                max_files: 1,
                ..PhaseOptions::default()
            },
        )
        .expect("collect limited");

        assert_eq!(collected.code_files.len(), 1);
    }

    #[test]
    fn docs_mode_filters_markdown_vs_text() {
        let dir = tempdir().expect("tempdir");
        std::fs::create_dir_all(dir.path().join("src")).expect("mkdir src");
        std::fs::write(dir.path().join("src/lib.rs"), "pub fn x(){}\n").expect("write code");
        std::fs::write(dir.path().join("README.md"), "# Doc\n").expect("write md");
        std::fs::write(dir.path().join("notes.txt"), "text\n").expect("write txt");

        let markdown_only = collect_files(
            dir.path(),
            &PhaseOptions {
                root: dir.path().to_path_buf(),
                include_docs: true,
                docs_mode: DocsMode::Markdown,
                ..PhaseOptions::default()
            },
        )
        .expect("collect markdown");
        assert_eq!(markdown_only.docs_files.len(), 1);

        let text_only = collect_files(
            dir.path(),
            &PhaseOptions {
                root: dir.path().to_path_buf(),
                include_docs: true,
                docs_mode: DocsMode::Text,
                ..PhaseOptions::default()
            },
        )
        .expect("collect text");
        assert_eq!(text_only.docs_files.len(), 1);
    }

    #[test]
    fn collect_files_uses_focus_files_when_provided() {
        let dir = tempdir().expect("tempdir");
        std::fs::create_dir_all(dir.path().join("src")).expect("mkdir src");
        let a = dir.path().join("src/a.rs");
        let b = dir.path().join("src/b.rs");
        std::fs::write(&a, "pub fn a(){}\n").expect("write a");
        std::fs::write(&b, "pub fn b(){}\n").expect("write b");

        let collected = collect_files(
            dir.path(),
            &PhaseOptions {
                root: dir.path().to_path_buf(),
                focus_files: vec![b.clone()],
                max_files: 1,
                ..PhaseOptions::default()
            },
        )
        .expect("collect focused");

        assert_eq!(collected.code_files, vec![b]);
    }

    #[test]
    fn should_skip_dir_covers_all_build_output_dirs() {
        // Version control
        assert!(should_skip_dir(".git"));
        assert!(should_skip_dir(".hg"));
        assert!(should_skip_dir(".svn"));
        // Build outputs
        assert!(should_skip_dir("target"));
        assert!(should_skip_dir("build"));
        assert!(should_skip_dir("dist"));
        assert!(should_skip_dir("out"));
        assert!(should_skip_dir(".next"));
        assert!(should_skip_dir("coverage"));
        // Package managers / dependencies
        assert!(should_skip_dir("node_modules"));
        assert!(should_skip_dir("vendor"));
        assert!(should_skip_dir("bower_components"));
        // Python virtual environments & caches
        assert!(should_skip_dir(".venv"));
        assert!(should_skip_dir("venv"));
        assert!(should_skip_dir("env"));
        assert!(should_skip_dir("__pycache__"));
        assert!(should_skip_dir(".tox"));
        assert!(should_skip_dir(".mypy_cache"));
        assert!(should_skip_dir(".pytest_cache"));
        assert!(should_skip_dir(".ruff_cache"));
        // IDE / editor metadata
        assert!(should_skip_dir(".idea"));
        assert!(should_skip_dir(".vscode"));
        // Misc generated
        assert!(should_skip_dir(".leindex"));
        // Archived / deprecated code
        assert!(should_skip_dir("archive"));
        assert!(should_skip_dir(".archive"));
        // Ensure normal dirs are NOT skipped
        assert!(!should_skip_dir("src"));
        assert!(!should_skip_dir("lib"));
        assert!(!should_skip_dir("tests"));
        assert!(!should_skip_dir("docs"));
    }

    #[test]
    fn collect_files_skips_all_build_output_dirs() {
        let dir = tempdir().expect("tempdir");
        std::fs::create_dir_all(dir.path().join("src")).expect("mkdir src");
        std::fs::write(dir.path().join("src/lib.rs"), "pub fn f(){}\n").expect("write code");

        // Create files inside build output directories - they should be skipped
        for build_dir in &["target", "build", "dist", "out", ".next", "coverage"] {
            std::fs::create_dir_all(dir.path().join(build_dir)).expect("mkdir build_dir");
            std::fs::write(
                dir.path().join(format!("{}/generated.rs", build_dir)),
                "pub fn g(){}\n",
            )
            .expect("write generated");
        }

        let collected = collect_files(
            dir.path(),
            &PhaseOptions {
                root: dir.path().to_path_buf(),
                ..PhaseOptions::default()
            },
        )
        .expect("collect");

        assert_eq!(
            collected.code_files.len(),
            1,
            "only src/lib.rs should be collected"
        );
        assert!(
            collected.code_files[0].ends_with("src/lib.rs"),
            "collected file should be src/lib.rs, got: {:?}",
            collected.code_files[0]
        );
    }

    #[test]
    fn test_collect_files_stays_inside_the_index_universe() {
        let dir = tempfile::tempdir().expect("tempdir");
        std::fs::create_dir_all(dir.path().join("src")).expect("mkdir");
        for name in ["src/a.rs", "src/b.rs", ".hidden.rs", "notes.md"] {
            std::fs::write(dir.path().join(name), "pub fn f(){}\n").expect("write");
        }
        let options = PhaseOptions {
            root: dir.path().to_path_buf(),
            // The index tracks a.rs and a doc, but not b.rs or the dotfile.
            universe: std::sync::Arc::new(vec![
                dir.path().join("src/a.rs"),
                dir.path().join("notes.md"),
            ]),
            ..PhaseOptions::default()
        };
        let collected = collect_files(dir.path(), &options).expect("collect");
        assert_eq!(collected.code_files, vec![dir.path().join("src/a.rs")]);
    }
}