//! Listing the working copy (spec §12.3): every file and symlink under the

//! root, found in parallel. `.oxy` is skipped, and so is a nested

//! repository (a directory holding `.oxy` or `.git`), which is reported

//! instead. `.oxyignore` files exclude paths with gitignore syntax, the

//! nearest file deciding; `.gitignore` and `.ignore` files count too, below

//! `.oxyignore` in the same directory (oxygen#44), so a project coming from

//! Git does not commit what Git ignored, and `.oxyignore` can still say

//! otherwise with `!`.

//!

//! Each directory is read once; a file's stat comes from its directory

//! entry, and results are gathered a directory at a time, so a tree of

//! 100 000 files costs about what its system calls cost.

use super::*;

use ignore::gitignore::{Gitignore, GitignoreBuilder};

use ignore::Match;

use std::sync::{Arc, Mutex};

/// What a listing found, each list in path order.

#[derive(Default)]

pub(crate) struct Listing {

    /// Regular files: path relative to the root (with `/`), full path, stat.

    pub files: Vec<(String, PathBuf, fs::Metadata)>,

    /// Symbolic links and their targets.

    pub symlinks: Vec<(String, Vec<u8>)>,

    /// Directories holding a repository of their own.

    pub nested: Vec<PathBuf>,

    /// Every directory listed (the root as ""), with its modification time

    /// read before its entries were: a later change to its entries moves

    /// the time, so a manifest that keeps these can skip reading a

    /// directory whose time has not moved.

    pub dirs: Vec<(String, u128)>,

}

/// The ignore files in force for a directory, innermost first.

#[derive(Clone, Default)]

struct Rules(Option<Arc<(Gitignore, Rules)>>);

impl Rules {

    /// The rules for `dir`, adding its own ignore files if it has any.

    fn enter(&self, dir: &Path, names: &[String]) -> Rules {

        // Later files win: .oxyignore over .ignore over .gitignore.

        let files: Vec<&str> = [".gitignore", ".ignore", ".oxyignore"]

            .into_iter()

            .filter(|f| names.iter().any(|n| n == f))

            .collect();

        if files.is_empty() {

            return self.clone();

        }

        let mut b = GitignoreBuilder::new(dir);

        for f in files {

            // An unreadable or malformed ignore file excludes nothing.

            let _ = b.add(dir.join(f));

        }

        match b.build() {

            Ok(g) if !g.is_empty() => Rules(Some(Arc::new((g, self.clone())))),

            _ => self.clone(),

        }

    }

    fn ignored(&self, path: &Path, is_dir: bool) -> bool {

        let mut at = &self.0;

        while let Some(node) = at {

            match node.0.matched(path, is_dir) {

                Match::Ignore(_) => return true,

                Match::Whitelist(_) => return false,

                Match::None => {}

            }

            at = &(node.1).0;

        }

        false

    }

}

struct Ctx<'a> {

    in_scope: &'a (dyn Fn(&str) -> bool + Sync),

    known: &'a (dyn Fn(&str) -> bool + Sync),

    out: Mutex<Listing>,

    failed: Mutex<Option<String>>,

}

/// List the working copy under `root`; files outside `in_scope` (a sparse

/// checkout's paths) are left out, though every directory is visited.

pub(crate) fn list(root: &Path, in_scope: &(dyn Fn(&str) -> bool + Sync)) -> Result<Listing> {

    list_knowing(root, in_scope, &|_| false)

}

/// [`list`], taking files `known` says are tracked without asking the

/// ignore rules, which apply to untracked paths only: on the Linux tree,

/// matching every file against its 400 `.gitignore` files cost more than

/// a manifest lookup.

pub(crate) fn list_knowing(

    root: &Path,

    in_scope: &(dyn Fn(&str) -> bool + Sync),

    known: &(dyn Fn(&str) -> bool + Sync),

) -> Result<Listing> {

    let ctx = Ctx {

        in_scope,

        known,

        out: Mutex::new(Listing::default()),

        failed: Mutex::new(None),

    };

    let root_time = fs::metadata(root)

        .map(|m| super::prompt::mtime_ns(&m))

        .unwrap_or(0);

    rayon::scope(|s| {

        visit(

            s,

            root.to_path_buf(),

            String::new(),

            root_time,

            true,

            Rules::default(),

            &ctx,

        )

    });

    if let Some(e) = ctx.failed.into_inner().unwrap_or_else(|e| e.into_inner()) {

        return fail(e);

    }

    let mut out = ctx.out.into_inner().unwrap_or_else(|e| e.into_inner());

    // In path order, as the maps built from it want.

    {

        use rayon::prelude::*;

        out.files.par_sort_unstable_by(|a, b| a.0.cmp(&b.0));

        out.symlinks.sort_unstable_by(|a, b| a.0.cmp(&b.0));

        out.dirs.sort_unstable_by(|a, b| a.0.cmp(&b.0));

        out.nested.sort_unstable();

    }

    Ok(out)

}

#[allow(clippy::too_many_arguments)]

fn visit<'s>(

    s: &rayon::Scope<'s>,

    dir: PathBuf,

    rel: String,

    mtime: u128,

    top: bool,

    rules: Rules,

    ctx: &'s Ctx<'s>,

) {

    let read = || -> std::io::Result<Vec<fs::DirEntry>> { fs::read_dir(&dir)?.collect() };

    let entries = match read() {

        Ok(e) => e,

        Err(e) => {

            ctx.failed

                .lock()

                .unwrap_or_else(|e| e.into_inner())

                .get_or_insert_with(|| format!("{}: {e}", dir.display()));

            return;

        }

    };

    let names: Vec<String> = entries

        .iter()

        .map(|e| e.file_name().to_string_lossy().into_owned())

        .collect();

    if !top && names.iter().any(|n| n == OXY_DIR || n == ".git") {

        ctx.out

            .lock()

            .unwrap_or_else(|e| e.into_inner())

            .nested

            .push(dir);

        return;

    }

    let rules = rules.enter(&dir, &names);

    let mut mine = Listing::default();

    mine.dirs.push((rel.clone(), mtime));

    for (e, name) in entries.into_iter().zip(names) {

        if name == OXY_DIR {

            continue;

        }

        let Ok(ft) = e.file_type() else { continue };

        let path = e.path();

        let child = if rel.is_empty() {

            name

        } else {

            format!("{rel}/{name}")

        };

        if (ft.is_dir() || !(ctx.known)(&child)) && rules.ignored(&path, ft.is_dir()) {

            continue;

        }

        if ft.is_dir() {

            let rules = rules.clone();

            // The directory's time now, before it is read.

            let time = e

                .metadata()

                .map(|m| super::prompt::mtime_ns(&m))

                .unwrap_or(0);

            s.spawn(move |s| visit(s, path, child, time, false, rules, ctx));

        } else if !(ctx.in_scope)(&child) {

        } else if ft.is_symlink() {

            match fs::read_link(&path) {

                Ok(t) => mine

                    .symlinks

                    .push((child, t.to_string_lossy().as_bytes().to_vec())),

                Err(e) => {

                    ctx.failed

                        .lock()

                        .unwrap_or_else(|e| e.into_inner())

                        .get_or_insert_with(|| format!("{}: {e}", path.display()));

                }

            }

        } else if ft.is_file() {

            match e.metadata() {

                Ok(m) => mine.files.push((child, path, m)),

                Err(e) => {

                    ctx.failed

                        .lock()

                        .unwrap_or_else(|e| e.into_inner())

                        .get_or_insert_with(|| format!("{}: {e}", path.display()));

                }

            }

        }

    }

    let mut out = ctx.out.lock().unwrap_or_else(|e| e.into_inner());

    out.files.append(&mut mine.files);

    out.symlinks.append(&mut mine.symlinks);

    out.dirs.append(&mut mine.dirs);

}

#[cfg(test)]

mod tests {

    use super::*;

    fn write(root: &Path, rel: &str, text: &str) {

        let p = root.join(rel);

        fs::create_dir_all(p.parent().unwrap()).unwrap();

        fs::write(p, text).unwrap();

    }

    fn listed(root: &Path, in_scope: &(dyn Fn(&str) -> bool + Sync)) -> (Vec<String>, Vec<String>) {

        let l = list(root, in_scope).unwrap();

        let mut files: Vec<String> = l.files.into_iter().map(|(r, _, _)| r).collect();

        files.extend(l.symlinks.into_iter().map(|(r, _)| r));

        files.sort();

        let mut nested: Vec<String> = l

            .nested

            .iter()

            .map(|d| {

                d.strip_prefix(root)

                    .unwrap()

                    .to_string_lossy()

                    .replace('\\', "/")

            })

            .collect();

        nested.sort();

        (files, nested)

    }

    #[test]

    fn ignore_files_nested_repositories_and_scope() {

        let dir = tempfile::tempdir().unwrap();

        let root = dir.path();

        write(root, ".oxy/config", "");

        write(root, ".oxyignore", "*.log\nbuild/\n");

        write(root, ".hidden", "");

        write(root, "a.txt", "");

        write(root, "a.log", "");

        write(root, "build/out.o", "");

        write(root, "src/main.c", "");

        write(root, "src/deep/x.log", "");

        // A nearer file overrides an outer rule, and `.ignore` counts too.

        write(root, "keep/.oxyignore", "!*.log\n");

        write(root, "keep/k.log", "");

        write(root, "other/.ignore", "secret\n");

        write(root, "other/secret", "");

        write(root, "other/public", "");

        // .gitignore counts, below .oxyignore in the same directory.

        write(root, "gitproj/.gitignore", "build/\n*.tmp\nkeep.tmp\n");

        write(root, "gitproj/.oxyignore", "!keep.tmp\n");

        write(root, "gitproj/build/out.bin", "");

        write(root, "gitproj/x.tmp", "");

        write(root, "gitproj/keep.tmp", "");

        write(root, "gitproj/src.c", "");

        // Nested repositories are reported, not entered.

        write(root, "sub/.oxy/config", "");

        write(root, "sub/inner.txt", "");

        write(root, "vendor/g/.git/HEAD", "");

        #[cfg(unix)]

        std::os::unix::fs::symlink("a.txt", root.join("link")).unwrap();

        let (files, nested) = listed(root, &|_| true);

        let mut want = vec![

            ".hidden",

            ".oxyignore",

            "a.txt",

            "gitproj/.gitignore",

            "gitproj/.oxyignore",

            "gitproj/keep.tmp",

            "gitproj/src.c",

            "keep/.oxyignore",

            "keep/k.log",

            "other/.ignore",

            "other/public",

            "src/main.c",

        ];

        if cfg!(unix) {

            want.push("link");

        }

        want.sort();

        assert_eq!(files, want);

        assert_eq!(nested, vec!["sub", "vendor/g"]);

        // A sparse scope leaves files out but still visits directories.

        let (files, _) = listed(root, &|p: &str| p.starts_with("src/"));

        assert_eq!(files, vec!["src/main.c"]);

    }

}