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::NodeData;

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

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

use crate::matchers::get_ignore_function;

use crate::matchers::Matcher;

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

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

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

use crate::BadMatch;

use crate::DirstateStatus;

use crate::EntryState;

use crate::HgPathBuf;

use crate::HgPathCow;

use crate::PatternFileWarning;

use crate::StatusError;

use crate::StatusOptions;

use micro_timer::timed;

use rayon::prelude::*;

use sha1::{Digest, Sha1};

use std::borrow::Cow;

use std::io;

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.

#[timed]

    matcher: &(dyn Matcher + Sync),

    root_dir: PathBuf,

    ignore_files: Vec<PathBuf>,

    options: StatusOptions,

    // Force the global rayon threadpool to not exceed 16 concurrent threads.

    // This is a stop-gap measure until we figure out why using more than 16

    // threads makes `status` slower for each additional thread.

    // We use `ok()` in case the global threadpool has already been

    // instantiated in `rhg` or some other caller.

    // TODO find the underlying cause and fix it, then remove this.

    rayon::ThreadPoolBuilder::new()

        .num_threads(16)

        .build_global()

        .ok();

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

        if options.list_ignored || options.list_unknown {

            let mut hasher = Sha1::new();

            let (ignore_fn, warnings) = get_ignore_function(

                ignore_files,

                &root_dir,

                &mut |pattern_bytes| hasher.update(pattern_bytes),

            )?;

            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))

        } 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_cachable_directories: Default::default(),

        outated_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 = false;

    let root_cached_mtime = None;

    let root_dir_metadata = 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,

        &root_dir,

        root_dir_metadata,

        root_cached_mtime,

        is_at_repo_root,

    )?;

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

    let new_cachable = common.new_cachable_directories.into_inner().unwrap();

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

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

        || !outdated.is_empty()

        || !new_cachable.is_empty();

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

    // directory is both

    for path in &outdated {

        let node = dmap.get_or_insert(path)?;

        if let NodeData::CachedDirectory { .. } = &node.data {

            node.data = NodeData::None

        }

    }

    for (path, mtime) in &new_cachable {

        let node = dmap.get_or_insert(path)?;

        match &node.data {

            NodeData::Entry(_) => {} // Don’t overwrite an entry

            NodeData::CachedDirectory { .. } | NodeData::None => {

                node.data = NodeData::CachedDirectory { mtime: *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_cachable_directories:

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

    outated_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,

}

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<(), DirstateV2ParseError> {

        if self.ignore_patterns_have_changed == Some(true)

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

        {

            self.outated_cached_directories.lock().unwrap().push(

                dirstate_node

                    .full_path_borrowed(self.dmap.on_disk)?

                    .detach_from_tree(),

            )

        }

        Ok(())

    }

    /// If this returns true, we can get accurate results by only using

    /// `symlink_metadata` for child nodes that exist in the dirstate and don’t

    /// need to call `read_dir`.

    fn can_skip_fs_readdir(

        &self,

        directory_metadata: Option<&std::fs::Metadata>,

        cached_directory_mtime: Option<TruncatedTimestamp>,

    ) -> bool {

        if !self.options.list_unknown && !self.options.list_ignored {

            // All states that we care about listing have corresponding

            // dirstate entries.

            // This happens for example with `hg status -mard`.

            return true;

        }

        if !self.options.list_ignored

            && self.ignore_patterns_have_changed == Some(false)

        {

            if let Some(cached_mtime) = cached_directory_mtime {

                // The dirstate contains a cached mtime for this directory, set

                // by a previous run of the `status` algorithm which found this

                // directory eligible for `read_dir` caching.

                if let Some(meta) = directory_metadata {

                    if cached_mtime

                        .likely_equal_to_mtime_of(meta)

                        .unwrap_or(false)

                    {

                        // The mtime of that directory has not changed

                        // since then, which means that the results of

                        // `read_dir` should also be unchanged.

                        return true;

                    }

                }

            }

        }

        false

    }

    /// Returns whether all child entries of the filesystem directory have a

    /// corresponding dirstate node or are ignored.

    fn traverse_fs_directory_and_dirstate(

        &self,

        has_ignored_ancestor: bool,

        dirstate_nodes: ChildNodesRef<'tree, 'on_disk>,

        directory_hg_path: &BorrowedPath<'tree, 'on_disk>,

        directory_fs_path: &Path,

        directory_metadata: Option<&std::fs::Metadata>,

        cached_directory_mtime: Option<TruncatedTimestamp>,

        is_at_repo_root: bool,

    ) -> Result<bool, DirstateV2ParseError> {

        if self.can_skip_fs_readdir(directory_metadata, cached_directory_mtime)

        {

            dirstate_nodes

                .par_iter()

                .map(|dirstate_node| {

                    let fs_path = directory_fs_path.join(get_path_from_bytes(

                        dirstate_node.base_name(self.dmap.on_disk)?.as_bytes(),

                    ));

                    match std::fs::symlink_metadata(&fs_path) {

                        Ok(fs_metadata) => self.traverse_fs_and_dirstate(

                            &fs_path,

                            &fs_metadata,

                            dirstate_node,

                            has_ignored_ancestor,

                        ),

                        Err(e) if e.kind() == std::io::ErrorKind::NotFound => {