// 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::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".

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 DirstateEntry {

        state,

        mode,

        mtime,

        size,

    } = entry;

    let HgMetadata {

        st_mode,

        st_size,

        st_mtime,

        ..

    } = metadata;

    match state {

        EntryState::Normal => {

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

pub struct DirstateStatus<'a> {

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

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

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

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

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

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

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

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

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

    pub traversed: Vec<HgPathBuf>,

}

#[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),

}

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

        }

    }

}

/// 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: 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: 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)?

            } else {

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

            };

        Ok((

            Self {

                dmap,

                matcher,

                root_dir,

                options,

                ignore_fn,

            },

            warnings,

        ))

    }

    /// Is the path ignored?

    pub fn is_ignored(&self, path: impl AsRef<HgPath>) -> bool {

        (self.ignore_fn)(path.as_ref())

    }

    /// Is the path or one of its ancestors ignored?

    pub fn dir_ignore(&self, dir: impl AsRef<HgPath>) -> bool {

        // Only involve ignore mechanism if we're listing unknowns or ignored.

        if self.options.list_ignored || self.options.list_unknown {

            if self.is_ignored(&dir) {

                true

            } else {

                for p in find_dirs(dir.as_ref()) {

                    if self.is_ignored(p) {

                        return true;

                    }

                }

                false

            }

        } else {

            true

        }

    }