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

        },

        path_auditor::PathAuditor,

    },

    CopyMap, DirstateEntry, DirstateMap, EntryState, FastHashMap,

    PatternError,

};

use lazy_static::lazy_static;

use rayon::prelude::*;

use std::{

    borrow::Cow,

    collections::HashSet,

    fs::{read_dir, DirEntry},

    io::ErrorKind,

    ops::Deref,

    path::Path,

};

/// 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 ToString for BadType {

    fn to_string(&self) -> String {

        match self {

            BadType::CharacterDevice => "character device",

            BadType::BlockDevice => "block device",

            BadType::FIFO => "fifo",

            BadType::Socket => "socket",

            BadType::Directory => "directory",

            BadType::Unknown => "unknown",

        }

        .to_string()

    }

}

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

#[derive(Debug, Copy, Clone)]

pub enum BadMatch {

    OsError(i32),

    BadType(BadType),

}

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

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

/// 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((HgPathBuf::from(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())

            {

                Dispatch::Modified

            } else if mod_compare(mtime, st_mtime as i32) {

                Dispatch::Unsure

            } else if 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,

    }

}

lazy_static! {

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

        let mut h = HashSet::new();

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

        h

    };

}

/// Get stat data about the files explicitly specified by match.

/// TODO subrepos

fn walk_explicit<'a>(

    files: Option<&'a HashSet<&HgPath>>,

    dmap: &'a DirstateMap,

    root_dir: impl AsRef<Path> + Sync + Send + 'a,

    options: StatusOptions,

) -> impl ParallelIterator<Item = IoResult<(&'a HgPath, Dispatch)>> {

    files

        .unwrap_or(&DEFAULT_WORK)

        .par_iter()

        .map(move |filename| {

            // TODO normalization

            let normalized = filename.as_ref();

            let buf = match hg_path_to_path_buf(normalized) {

                Ok(x) => x,

                Err(e) => return Some(Err(e.into())),

            };

            let target = root_dir.as_ref().join(buf);

            let st = target.symlink_metadata();

            let in_dmap = dmap.get(normalized);

            match st {

                Ok(meta) => {

                    let file_type = meta.file_type();

                    return if file_type.is_file() || file_type.is_symlink() {

                        if let Some(entry) = in_dmap {

                            return Some(Ok((

                                normalized,

                                dispatch_found(

                                    &normalized,

                                    *entry,

                                    HgMetadata::from_metadata(meta),

                                    &dmap.copy_map,

                                    options,

                                ),

                            )));

                        }

                        Some(Ok((normalized, Dispatch::Unknown)))

                    } else {

                        if file_type.is_dir() {

                            Some(Ok((

                                normalized,

                                Dispatch::Directory {

                                    was_file: in_dmap.is_some(),

                                },

                            )))

                        } else {

                            Some(Ok((

                                normalized,

                                Dispatch::Bad(BadMatch::BadType(

                                    // TODO do more than unknown

                                    // Support for all `BadType` variant

                                    // varies greatly between platforms.

                                    // So far, no tests check the type and

                                    // this should be good enough for most

                                    // users.

                                    BadType::Unknown,

                                )),

                            )))

                        }

                    };

                }

                Err(_) => {

                    if let Some(entry) = in_dmap {

                        return Some(Ok((

                            normalized,

                            dispatch_missing(entry.state),

                        )));

                    }

                }

            };

            None

        })

        .flatten()

}

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

}

/// Dispatch a single entry (file, folder, symlink...) found during `traverse`.

/// If the entry is a folder that needs to be traversed, it will be handled

/// in a separate thread.

fn handle_traversed_entry<'a>(

    scope: &rayon::Scope<'a>,

    files_sender: &'a crossbeam::Sender<IoResult<(HgPathBuf, Dispatch)>>,

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

    root_dir: impl AsRef<Path> + Sync + Send + Copy + 'a,

    dmap: &'a DirstateMap,

    old_results: &'a FastHashMap<Cow<HgPath>, Dispatch>,

    ignore_fn: &'a (impl for<'r> Fn(&'r HgPath) -> bool + Sync),

    dir_ignore_fn: &'a (impl for<'r> Fn(&'r HgPath) -> bool + Sync),

    options: StatusOptions,

    filename: HgPathBuf,

    dir_entry: DirEntry,

) -> IoResult<()> {

    let file_type = dir_entry.file_type()?;

    let entry_option = dmap.get(&filename);

    if file_type.is_dir() {

        handle_traversed_dir(

            scope,

            files_sender,

            matcher,

            root_dir,

            dmap,

            old_results,

            ignore_fn,

            dir_ignore_fn,

            options,

            entry_option,

            filename,

        );

    } else if file_type.is_file() || file_type.is_symlink() {

        if let Some(entry) = entry_option {

            if matcher.matches_everything() || matcher.matches(&filename) {

                let metadata = dir_entry.metadata()?;

                files_sender

                    .send(Ok((

                        filename.to_owned(),

                        dispatch_found(

                            &filename,

                            *entry,

                            HgMetadata::from_metadata(metadata),

                            &dmap.copy_map,

                            options,

                        ),

                    )))

                    .unwrap();

            }

        } else if (matcher.matches_everything() || matcher.matches(&filename))

            && !ignore_fn(&filename)