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

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

use crate::StatusError;

use crate::StatusOptions;

use micro_timer::timed;

use rayon::prelude::*;

use std::io;

use std::path::Path;

use std::path::PathBuf;

use std::sync::Mutex;

/// 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]

pub fn status<'tree, 'on_disk: 'tree>(

    dmap: &'tree mut DirstateMap<'on_disk>,

    matcher: &(dyn Matcher + Sync),

    root_dir: PathBuf,

    ignore_files: Vec<PathBuf>,

    options: StatusOptions,

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

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

        if options.list_ignored || options.list_unknown {

            get_ignore_function(ignore_files, &root_dir)?

        } else {

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

        };

    let common = StatusCommon {

        dmap,

        options,

        matcher,

        ignore_fn,

    };

    let is_at_repo_root = true;

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

    let has_ignored_ancestor = false;

    common.traverse_fs_directory_and_dirstate(

        has_ignored_ancestor,

        dmap.root.as_ref(),

        hg_path,

        &root_dir,

        is_at_repo_root,

    )?;

}

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

}

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

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

        is_at_repo_root: bool,

                .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 => {

                            self.traverse_dirstate_only(dirstate_node)

                        }

                        Err(error) => {

                            let hg_path =

                                dirstate_node.full_path(self.dmap.on_disk)?;

                            Ok(self.io_error(error, hg_path))

                        }

                    }

                })

        }

        let mut fs_entries = if let Ok(entries) = self.read_dir(

            directory_hg_path,

            directory_fs_path,

            is_at_repo_root,

        ) {

            entries

        } else {

            // Treat an unreadable directory (typically because of insufficient

            // permissions) like an empty directory. `self.read_dir` has

            // already called `self.io_error` so a warning will be emitted.

            Vec::new()

        };

        // `merge_join_by` requires both its input iterators to be sorted:

        let dirstate_nodes = dirstate_nodes.sorted();

        // `sort_unstable_by_key` doesn’t allow keys borrowing from the value:

        // https://github.com/rust-lang/rust/issues/34162

        fs_entries.sort_unstable_by(|e1, e2| e1.base_name.cmp(&e2.base_name));

        // Propagate here any error that would happen inside the comparison

        // callback below

        for dirstate_node in &dirstate_nodes {

            dirstate_node.base_name(self.dmap.on_disk)?;

        }

        itertools::merge_join_by(

            dirstate_nodes,

            &fs_entries,

            |dirstate_node, fs_entry| {

                // This `unwrap` never panics because we already propagated

                // those errors above

                dirstate_node

                    .base_name(self.dmap.on_disk)

                    .unwrap()

                    .cmp(&fs_entry.base_name)

            },

        )

        .par_bridge()

        .map(|pair| {

            use itertools::EitherOrBoth::*;

            match pair {

                Both(dirstate_node, fs_entry) => self

                    .traverse_fs_and_dirstate(

                        &fs_entry.full_path,

                        &fs_entry.metadata,

                        dirstate_node,

                        has_ignored_ancestor,

                Left(dirstate_node) => {

                }

                    has_ignored_ancestor,

                    directory_hg_path,

                    fs_entry,

            }

        })

    }

    fn traverse_fs_and_dirstate(

        &self,

        fs_path: &Path,

        fs_metadata: &std::fs::Metadata,

        dirstate_node: NodeRef<'tree, 'on_disk>,

        has_ignored_ancestor: bool,

    ) -> Result<(), DirstateV2ParseError> {

        let hg_path = &dirstate_node.full_path_borrowed(self.dmap.on_disk)?;

        let file_type = fs_metadata.file_type();

        let file_or_symlink = file_type.is_file() || file_type.is_symlink();

        if !file_or_symlink {

            // If we previously had a file here, it was removed (with

            // `hg rm` or similar) or deleted before it could be

            // replaced by a directory or something else.

            self.mark_removed_or_deleted_if_file(

                &hg_path,

                dirstate_node.state()?,

            );

        }

        if file_type.is_dir() {

            if self.options.collect_traversed_dirs {

                self.outcome

                    .lock()

                    .unwrap()

                    .traversed

                    .push(hg_path.detach_from_tree())

            }

            let is_ignored = has_ignored_ancestor || (self.ignore_fn)(hg_path);

            let is_at_repo_root = false;

            )?

        } else {

            if file_or_symlink && self.matcher.matches(hg_path) {

                if let Some(state) = dirstate_node.state()? {

                    match state {

                        EntryState::Added => self

                            .outcome

                            .lock()

                            .unwrap()

                            .added

                            .push(hg_path.detach_from_tree()),

                        EntryState::Removed => self

                            .outcome

                            .lock()

                            .unwrap()

                            .removed

                            .push(hg_path.detach_from_tree()),

                        EntryState::Merged => self

                            .outcome

                            .lock()

                            .unwrap()