use crate::dirstate::entry::TruncatedTimestamp;

use crate::dirstate::status::IgnoreFnType;

use crate::dirstate::status::StatusPath;

use crate::dirstate_tree::dirstate_map::BorrowedPath;

use crate::dirstate_tree::dirstate_map::ChildNodesRef;

use crate::dirstate_tree::dirstate_map::DirstateMap;

use crate::dirstate_tree::dirstate_map::DirstateVersion;

use crate::dirstate_tree::dirstate_map::NodeRef;

use crate::dirstate_tree::on_disk::DirstateV2ParseError;

use crate::matchers::get_ignore_function;

use crate::matchers::{Matcher, VisitChildrenSet};

use crate::utils::files::get_bytes_from_os_string;

use crate::utils::files::get_bytes_from_path;

use crate::utils::files::get_path_from_bytes;

use crate::utils::hg_path::hg_path_to_path_buf;

use crate::utils::hg_path::HgPath;

use crate::BadMatch;

use crate::BadType;

use crate::DirstateStatus;

use crate::HgPathCow;

use crate::PatternFileWarning;

use crate::StatusError;

use crate::StatusOptions;

use once_cell::sync::OnceCell;

use rayon::prelude::*;

use sha1::{Digest, Sha1};

use std::borrow::Cow;

use std::io;

use std::os::unix::prelude::FileTypeExt;

use std::path::Path;

use std::path::PathBuf;

use std::sync::Mutex;

use std::time::SystemTime;

/// Returns the status of the working directory compared to its parent

/// changeset.

///

/// This algorithm is based on traversing the filesystem tree (`fs` in function

/// and variable names) and dirstate tree at the same time. The core of this

/// traversal is the recursive `traverse_fs_directory_and_dirstate` function

/// and its use of `itertools::merge_join_by`. When reaching a path that only

/// exists in one of the two trees, depending on information requested by

/// `options` we may need to traverse the remaining subtree.

#[logging_timer::time("trace")]

pub fn status<'dirstate>(

    dmap: &'dirstate mut DirstateMap,

    matcher: &(dyn Matcher + Sync),

    root_dir: PathBuf,

    ignore_files: Vec<PathBuf>,

    options: StatusOptions,

) -> Result<(DirstateStatus<'dirstate>, Vec<PatternFileWarning>), StatusError>

{

    // Also cap for a Python caller of this function, but don't complain if

    // the global threadpool has already been set since this code path is also

    // being used by `rhg`, which calls this early.

    let _ = crate::utils::cap_default_rayon_threads();

    let (ignore_fn, warnings, patterns_changed): (IgnoreFnType, _, _) =

        if options.list_ignored || options.list_unknown {

            let (ignore_fn, warnings, changed) = match dmap.dirstate_version {

                DirstateVersion::V1 => {

                    let (ignore_fn, warnings) = get_ignore_function(

                        ignore_files,

                        &root_dir,

                        &mut |_source, _pattern_bytes| {},

                    )?;

                    (ignore_fn, warnings, None)

                }

                DirstateVersion::V2 => {

                    let mut hasher = Sha1::new();

                    let (ignore_fn, warnings) = get_ignore_function(

                        ignore_files,

                        &root_dir,

                        &mut |source, pattern_bytes| {

                            // If inside the repo, use the relative version to

                            // make it deterministic inside tests.

                            // The performance hit should be negligible.

                            let source = source

                                .strip_prefix(&root_dir)

                                .unwrap_or(source);

                            let source = get_bytes_from_path(source);

                            let mut subhasher = Sha1::new();

                            subhasher.update(pattern_bytes);

                            let patterns_hash = subhasher.finalize();

                            hasher.update(source);

                            hasher.update(b" ");

                            hasher.update(patterns_hash);

                            hasher.update(b"\n");

                        },

                    )?;

                    let new_hash = *hasher.finalize().as_ref();

                    let changed = new_hash != dmap.ignore_patterns_hash;

                    dmap.ignore_patterns_hash = new_hash;

                    (ignore_fn, warnings, Some(changed))

                }

            };

            (ignore_fn, warnings, changed)

        } else {

            (Box::new(|&_| true), vec![], None)

        };

    let filesystem_time_at_status_start =

        filesystem_now(&root_dir).ok().map(TruncatedTimestamp::from);

    // If the repository is under the current directory, prefer using a

    // relative path, so the kernel needs to traverse fewer directory in every

    // call to `read_dir` or `symlink_metadata`.

    // This is effective in the common case where the current directory is the

    // repository root.

    // TODO: Better yet would be to use libc functions like `openat` and

    // `fstatat` to remove such repeated traversals entirely, but the standard

    // library does not provide APIs based on those.

    // Maybe with a crate like https://crates.io/crates/openat instead?

    let root_dir = if let Some(relative) = std::env::current_dir()

        .ok()

        .and_then(|cwd| root_dir.strip_prefix(cwd).ok())

    {

        relative

    } else {

        &root_dir

    };

    let outcome = DirstateStatus {

        filesystem_time_at_status_start,

        ..Default::default()

    };

    let common = StatusCommon {

        dmap,

        options,

        matcher,

        ignore_fn,

        outcome: Mutex::new(outcome),

        ignore_patterns_have_changed: patterns_changed,

        new_cacheable_directories: Default::default(),

        outdated_cached_directories: Default::default(),

        filesystem_time_at_status_start,

    };

    let is_at_repo_root = true;

    let hg_path = &BorrowedPath::OnDisk(HgPath::new(""));

    let has_ignored_ancestor = HasIgnoredAncestor::create(None, hg_path);

    let root_cached_mtime = None;

    // If the path we have for the repository root is a symlink, do follow it.

    // (As opposed to symlinks within the working directory which are not

    // followed, using `std::fs::symlink_metadata`.)

    common.traverse_fs_directory_and_dirstate(

        &has_ignored_ancestor,

        dmap.root.as_ref(),

        hg_path,

        &DirEntry {

            hg_path: Cow::Borrowed(HgPath::new(b"")),

            fs_path: Cow::Borrowed(root_dir),

            symlink_metadata: None,

            file_type: FakeFileType::Directory,

        },

        root_cached_mtime,

        is_at_repo_root,

    )?;

    if let Some(file_set) = common.matcher.file_set() {

        for file in file_set {

            if !file.is_empty() && !dmap.has_node(file)? {

                let path = hg_path_to_path_buf(file)?;

                if let io::Result::Err(error) =

                    root_dir.join(path).symlink_metadata()

                {

                    common.io_error(error, file)

                }

            }

        }

    }

    let mut outcome = common.outcome.into_inner().unwrap();

    let new_cacheable = common.new_cacheable_directories.into_inner().unwrap();

    let outdated = common.outdated_cached_directories.into_inner().unwrap();

    outcome.dirty = common.ignore_patterns_have_changed == Some(true)

        || !outdated.is_empty()

        || (!new_cacheable.is_empty()

            && dmap.dirstate_version == DirstateVersion::V2);

    // Remove outdated mtimes before adding new mtimes, in case a given

    // directory is both

    for path in &outdated {

        dmap.clear_cached_mtime(path)?;

    }

    for (path, mtime) in &new_cacheable {

        dmap.set_cached_mtime(path, *mtime)?;

    }

    Ok((outcome, warnings))

}

/// Bag of random things needed by various parts of the algorithm. Reduces the

/// number of parameters passed to functions.

struct StatusCommon<'a, 'tree, 'on_disk: 'tree> {

    dmap: &'tree DirstateMap<'on_disk>,

    options: StatusOptions,

    matcher: &'a (dyn Matcher + Sync),

    ignore_fn: IgnoreFnType<'a>,

    outcome: Mutex<DirstateStatus<'on_disk>>,

    /// New timestamps of directories to be used for caching their readdirs

    new_cacheable_directories:

        Mutex<Vec<(Cow<'on_disk, HgPath>, TruncatedTimestamp)>>,

    /// Used to invalidate the readdir cache of directories

    outdated_cached_directories: Mutex<Vec<Cow<'on_disk, HgPath>>>,

    /// Whether ignore files like `.hgignore` have changed since the previous

    /// time a `status()` call wrote their hash to the dirstate. `None` means

    /// we don’t know as this run doesn’t list either ignored or uknown files

    /// and therefore isn’t reading `.hgignore`.

    ignore_patterns_have_changed: Option<bool>,

    /// The current time at the start of the `status()` algorithm, as measured

    /// and possibly truncated by the filesystem.

    filesystem_time_at_status_start: Option<TruncatedTimestamp>,

}

enum Outcome {

    Modified,

    Added,

    Removed,

    Deleted,

    Clean,

    Ignored,

    Unknown,

    Unsure,

}

/// Lazy computation of whether a given path has a hgignored

/// ancestor.

struct HasIgnoredAncestor<'a> {

    /// `path` and `parent` constitute the inputs to the computation,

    /// `cache` stores the outcome.

    path: &'a HgPath,

    parent: Option<&'a HasIgnoredAncestor<'a>>,

    cache: OnceCell<bool>,

}

impl<'a> HasIgnoredAncestor<'a> {

    fn create(

        parent: Option<&'a HasIgnoredAncestor<'a>>,

        path: &'a HgPath,

    ) -> HasIgnoredAncestor<'a> {

        Self {

            path,

            parent,

            cache: OnceCell::new(),

        }

    }

    fn force(&self, ignore_fn: &IgnoreFnType<'_>) -> bool {

        match self.parent {

            None => false,

            Some(parent) => {

                *(self.cache.get_or_init(|| {

                    parent.force(ignore_fn) || ignore_fn(self.path)

                }))

            }

        }

    }

}

impl<'a, 'tree, 'on_disk> StatusCommon<'a, 'tree, 'on_disk> {

    fn push_outcome(

        &self,

        which: Outcome,

        dirstate_node: &NodeRef<'tree, 'on_disk>,

    ) -> Result<(), DirstateV2ParseError> {

        let path = dirstate_node

            .full_path_borrowed(self.dmap.on_disk)?

            .detach_from_tree();

        let copy_source = if self.options.list_copies {

            dirstate_node

                .copy_source_borrowed(self.dmap.on_disk)?

                .map(|source| source.detach_from_tree())

        } else {

            None

        };

        self.push_outcome_common(which, path, copy_source);

        Ok(())

    }

    fn push_outcome_without_copy_source(

        &self,

        which: Outcome,

        path: &BorrowedPath<'_, 'on_disk>,

    ) {

        self.push_outcome_common(which, path.detach_from_tree(), None)

    }

    fn push_outcome_common(

        &self,

        which: Outcome,

        path: HgPathCow<'on_disk>,

        copy_source: Option<HgPathCow<'on_disk>>,

    ) {

        let mut outcome = self.outcome.lock().unwrap();

        let vec = match which {

            Outcome::Modified => &mut outcome.modified,

            Outcome::Added => &mut outcome.added,

            Outcome::Removed => &mut outcome.removed,

            Outcome::Deleted => &mut outcome.deleted,

            Outcome::Clean => &mut outcome.clean,

            Outcome::Ignored => &mut outcome.ignored,

            Outcome::Unknown => &mut outcome.unknown,

            Outcome::Unsure => &mut outcome.unsure,

        };

        vec.push(StatusPath { path, copy_source });

    }

    fn read_dir(

        &self,

        hg_path: &HgPath,

        fs_path: &Path,

        is_at_repo_root: bool,

    ) -> Result<Vec<DirEntry>, ()> {

        DirEntry::read_dir(fs_path, is_at_repo_root)

            .map_err(|error| self.io_error(error, hg_path))

    }

    fn io_error(&self, error: std::io::Error, hg_path: &HgPath) {

        let errno = error.raw_os_error().expect("expected real OS error");

        self.outcome

            .lock()

            .unwrap()

            .bad

            .push((hg_path.to_owned().into(), BadMatch::OsError(errno)))

    }

    fn check_for_outdated_directory_cache(

        &self,

        dirstate_node: &NodeRef<'tree, 'on_disk>,

    ) -> Result<bool, DirstateV2ParseError> {

        if self.ignore_patterns_have_changed == Some(true)

            && dirstate_node.cached_directory_mtime()?.is_some()

        {

            self.outdated_cached_directories.lock().unwrap().push(