// status.rs

//

// Copyright 2019 Raphaël Gomès <rgomes@octobus.net>

//

// This software may be used and distributed according to the terms of the

// GNU General Public License version 2 or any later version.

//! Rust implementation of dirstate.status (dirstate.py).

//! It is currently missing a lot of functionality compared to the Python one

//! and will only be triggered in narrow cases.

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

use crate::utils::path_auditor::PathAuditor;

use crate::{

    dirstate::SIZE_FROM_OTHER_PARENT,

    filepatterns::PatternFileWarning,

    matchers::{get_ignore_function, Matcher, VisitChildrenSet},

    utils::{

        files::{find_dirs, HgMetadata},

        hg_path::{

            hg_path_to_path_buf, os_string_to_hg_path_buf, HgPath, HgPathBuf,

            HgPathError,

        },

    },

    CopyMap, DirstateEntry, DirstateMap, EntryState, FastHashMap,

    PatternError,

};

use lazy_static::lazy_static;

use micro_timer::timed;

use rayon::prelude::*;

use std::{

    borrow::Cow,

    collections::HashSet,

    fmt,

    fs::{read_dir, DirEntry},

    io::ErrorKind,

    ops::Deref,

    path::{Path, PathBuf},

};

/// Wrong type of file from a `BadMatch`

/// Note: a lot of those don't exist on all platforms.

#[derive(Debug, Copy, Clone)]

pub enum BadType {

    CharacterDevice,

    BlockDevice,

    FIFO,

    Socket,

    Directory,

    Unknown,

}

impl fmt::Display for BadType {

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

        f.write_str(match self {

            BadType::CharacterDevice => "character device",

            BadType::BlockDevice => "block device",

            BadType::FIFO => "fifo",

            BadType::Socket => "socket",

            BadType::Directory => "directory",

            BadType::Unknown => "unknown",

        })

    }

}

/// Was explicitly matched but cannot be found/accessed

#[derive(Debug, Copy, Clone)]

pub enum BadMatch {

    OsError(i32),

    BadType(BadType),

}

/// Enum used to dispatch new status entries into the right collections.

/// Is similar to `crate::EntryState`, but represents the transient state of

/// entries during the lifetime of a command.

#[derive(Debug, Copy, Clone)]

pub enum Dispatch {

    Unsure,

    Modified,

    Added,

    Removed,

    Deleted,

    Clean,

    Unknown,

    Ignored,

    /// Empty dispatch, the file is not worth listing

    None,

    /// Was explicitly matched but cannot be found/accessed

    Bad(BadMatch),

    Directory {

        /// True if the directory used to be a file in the dmap so we can say

        /// that it's been removed.

        was_file: bool,

    },

}

type IoResult<T> = std::io::Result<T>;

/// `Box<dyn Trait>` is syntactic sugar for `Box<dyn Trait + 'static>`, so add

/// an explicit lifetime here to not fight `'static` bounds "out of nowhere".

pub type IgnoreFnType<'a> =

    Box<dyn for<'r> Fn(&'r HgPath) -> bool + Sync + 'a>;

/// We have a good mix of owned (from directory traversal) and borrowed (from

/// the dirstate/explicit) paths, this comes up a lot.

pub type HgPathCow<'a> = Cow<'a, HgPath>;

/// A path with its computed ``Dispatch`` information

type DispatchedPath<'a> = (HgPathCow<'a>, Dispatch);

/// The conversion from `HgPath` to a real fs path failed.

/// `22` is the error code for "Invalid argument"

const INVALID_PATH_DISPATCH: Dispatch = Dispatch::Bad(BadMatch::OsError(22));

/// Dates and times that are outside the 31-bit signed range are compared

/// modulo 2^31. This should prevent hg from behaving badly with very large

/// files or corrupt dates while still having a high probability of detecting

/// changes. (issue2608)

/// TODO I haven't found a way of having `b` be `Into<i32>`, since `From<u64>`

/// is not defined for `i32`, and there is no `As` trait. This forces the

/// caller to cast `b` as `i32`.

fn mod_compare(a: i32, b: i32) -> bool {

    a & i32::max_value() != b & i32::max_value()

}

/// Return a sorted list containing information about the entries

/// in the directory.

///

/// * `skip_dot_hg` - Return an empty vec if `path` contains a `.hg` directory

fn list_directory(

    path: impl AsRef<Path>,

    skip_dot_hg: bool,

) -> std::io::Result<Vec<(HgPathBuf, DirEntry)>> {

    let mut results = vec![];

    let entries = read_dir(path.as_ref())?;

    for entry in entries {

        let entry = entry?;

        let filename = os_string_to_hg_path_buf(entry.file_name())?;

        let file_type = entry.file_type()?;

        if skip_dot_hg && filename.as_bytes() == b".hg" && file_type.is_dir() {

            return Ok(vec![]);

        } else {

            results.push((filename, entry))

        }

    }

    results.sort_unstable_by_key(|e| e.0.clone());

    Ok(results)

}

/// The file corresponding to the dirstate entry was found on the filesystem.

fn dispatch_found(

    filename: impl AsRef<HgPath>,

    entry: DirstateEntry,

    metadata: HgMetadata,

    copy_map: &CopyMap,

    options: StatusOptions,

) -> Dispatch {

            let size_changed = mod_compare(size, st_size as i32);

            let mode_changed =

                (mode ^ st_mode as i32) & 0o100 != 0o000 && options.check_exec;

            let metadata_changed = size >= 0 && (size_changed || mode_changed);

            let other_parent = size == SIZE_FROM_OTHER_PARENT;

            if metadata_changed

                || other_parent

                || copy_map.contains_key(filename.as_ref())

            {

                if metadata.is_symlink() && size_changed {

                    // issue6456: Size returned may be longer due to encryption

                    // on EXT-4 fscrypt. TODO maybe only do it on EXT4?

                    Dispatch::Unsure

                } else {

                    Dispatch::Modified

                }

            } else if mod_compare(mtime, st_mtime as i32)

                || st_mtime == options.last_normal_time

            {

                // the file may have just been marked as normal and

                // it may have changed in the same second without

                // changing its size. This can happen if we quickly

                // do multiple commits. Force lookup, so we don't

                // miss such a racy file change.

                Dispatch::Unsure

            } else if options.list_clean {

                Dispatch::Clean

            } else {

                Dispatch::None

            }

        }

        EntryState::Merged => Dispatch::Modified,

        EntryState::Added => Dispatch::Added,

        EntryState::Removed => Dispatch::Removed,

        EntryState::Unknown => Dispatch::Unknown,

    }

}

/// The file corresponding to this Dirstate entry is missing.

fn dispatch_missing(state: EntryState) -> Dispatch {

    match state {

        // File was removed from the filesystem during commands

        EntryState::Normal | EntryState::Merged | EntryState::Added => {

            Dispatch::Deleted

        }

        // File was removed, everything is normal

        EntryState::Removed => Dispatch::Removed,

        // File is unknown to Mercurial, everything is normal

        EntryState::Unknown => Dispatch::Unknown,

    }

}

fn dispatch_os_error(e: &std::io::Error) -> Dispatch {

    Dispatch::Bad(BadMatch::OsError(

        e.raw_os_error().expect("expected real OS error"),

    ))

}

lazy_static! {

    static ref DEFAULT_WORK: HashSet<&'static HgPath> = {

        let mut h = HashSet::new();

        h.insert(HgPath::new(b""));

        h

    };

}

#[derive(Debug, Copy, Clone)]

pub struct StatusOptions {

    /// Remember the most recent modification timeslot for status, to make

    /// sure we won't miss future size-preserving file content modifications

    /// that happen within the same timeslot.

    pub last_normal_time: i64,

    /// Whether we are on a filesystem with UNIX-like exec flags

    pub check_exec: bool,

    pub list_clean: bool,

    pub list_unknown: bool,

    pub list_ignored: bool,

    /// Whether to collect traversed dirs for applying a callback later.

    /// Used by `hg purge` for example.

    pub collect_traversed_dirs: bool,

}

#[derive(Debug, Default)]

pub struct DirstateStatus<'a> {

    /// Tracked files whose contents have changed since the parent revision

    pub modified: Vec<HgPathCow<'a>>,

    /// Newly-tracked files that were not present in the parent

    pub added: Vec<HgPathCow<'a>>,

    /// Previously-tracked files that have been (re)moved with an hg command

    pub removed: Vec<HgPathCow<'a>>,

    /// (Still) tracked files that are missing, (re)moved with an non-hg

    /// command

    pub deleted: Vec<HgPathCow<'a>>,

    /// Tracked files that are up to date with the parent.

    /// Only pupulated if `StatusOptions::list_clean` is true.

    pub clean: Vec<HgPathCow<'a>>,

    /// Files in the working directory that are ignored with `.hgignore`.

    /// Only pupulated if `StatusOptions::list_ignored` is true.

    pub ignored: Vec<HgPathCow<'a>>,

    /// Files in the working directory that are neither tracked nor ignored.

    /// Only pupulated if `StatusOptions::list_unknown` is true.

    pub unknown: Vec<HgPathCow<'a>>,

    /// Was explicitly matched but cannot be found/accessed

    pub bad: Vec<(HgPathCow<'a>, BadMatch)>,

    /// Either clean or modified, but we can’t tell from filesystem metadata

    /// alone. The file contents need to be read and compared with that in

    /// the parent.

    pub unsure: Vec<HgPathCow<'a>>,

    /// Only filled if `collect_traversed_dirs` is `true`

    pub traversed: Vec<HgPathCow<'a>>,

    /// Whether `status()` made changed to the `DirstateMap` that should be

    /// written back to disk

    pub dirty: bool,

}

#[derive(Debug, derive_more::From)]

pub enum StatusError {

    /// Generic IO error

    IO(std::io::Error),

    /// An invalid path that cannot be represented in Mercurial was found

    Path(HgPathError),

    /// An invalid "ignore" pattern was found

    Pattern(PatternError),

    /// Corrupted dirstate

    DirstateV2ParseError(DirstateV2ParseError),

}

pub type StatusResult<T> = Result<T, StatusError>;

impl fmt::Display for StatusError {

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

        match self {

            StatusError::IO(error) => error.fmt(f),

            StatusError::Path(error) => error.fmt(f),

            StatusError::Pattern(error) => error.fmt(f),

            StatusError::DirstateV2ParseError(_) => {

                f.write_str("dirstate-v2 parse error")

            }

        }

    }

}

/// Gives information about which files are changed in the working directory

/// and how, compared to the revision we're based on

pub struct Status<'a, M: ?Sized + Matcher + Sync> {

    dmap: &'a DirstateMap,

    pub(crate) matcher: &'a M,

    root_dir: PathBuf,

    pub(crate) options: StatusOptions,

    ignore_fn: IgnoreFnType<'a>,

}

impl<'a, M> Status<'a, M>

where

    M: ?Sized + Matcher + Sync,

{

    pub fn new(

        dmap: &'a DirstateMap,

        matcher: &'a M,

        root_dir: PathBuf,

        ignore_files: Vec<PathBuf>,

        options: StatusOptions,

    ) -> StatusResult<(Self, Vec<PatternFileWarning>)> {

        // Needs to outlive `dir_ignore_fn` since it's captured.

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

            if options.list_ignored || options.list_unknown {

                get_ignore_function(ignore_files, &root_dir, &mut |_| {})?

            } else {

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

            };

        Ok((

            Self {

                dmap,

                matcher,

                root_dir,