// matchers.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.

//! Structs and types for matching files and directories.

use crate::{

    dirstate::dirs_multiset::DirsChildrenMultiset,

    filepatterns::{

        build_single_regex, filter_subincludes, get_patterns_from_file,

        PatternFileWarning, PatternResult,

    },

    utils::{

        files::find_dirs,

        hg_path::{HgPath, HgPathBuf},

        Escaped,

    },

    DirsMultiset, DirstateMapError, FastHashMap, IgnorePattern, PatternError,

    PatternSyntax,

};

use crate::filepatterns::normalize_path_bytes;

use std::borrow::ToOwned;

use std::collections::HashSet;

use std::fmt::{Display, Error, Formatter};

use std::iter::FromIterator;

use std::ops::Deref;

use std::path::{Path, PathBuf};

use micro_timer::timed;

#[derive(Debug, PartialEq)]

pub enum VisitChildrenSet<'a> {

    /// Don't visit anything

    Empty,

    /// Only visit this directory

    This,

    /// Visit this directory and these subdirectories

    /// TODO Should we implement a `NonEmptyHashSet`?

    Set(HashSet<&'a HgPath>),

    /// Visit this directory and all subdirectories

    Recursive,

}

pub trait Matcher {

    /// Explicitly listed files

    fn file_set(&self) -> Option<&HashSet<&HgPath>>;

    /// Returns whether `filename` is in `file_set`

    fn exact_match(&self, filename: &HgPath) -> bool;

    /// Returns whether `filename` is matched by this matcher

    fn matches(&self, filename: &HgPath) -> bool;

    /// Decides whether a directory should be visited based on whether it

    /// has potential matches in it or one of its subdirectories, and

    /// potentially lists which subdirectories of that directory should be

    /// visited. This is based on the match's primary, included, and excluded

    /// patterns.

    ///

    /// # Example

    ///

    /// Assume matchers `['path:foo/bar', 'rootfilesin:qux']`, we would

    /// return the following values (assuming the implementation of

    /// visit_children_set is capable of recognizing this; some implementations

    /// are not).

    ///

    /// ```text

    /// ```ignore

    /// '' -> {'foo', 'qux'}

    /// 'baz' -> set()

    /// 'foo' -> {'bar'}

    /// // Ideally this would be `Recursive`, but since the prefix nature of

    /// // matchers is applied to the entire matcher, we have to downgrade this

    /// // to `This` due to the (yet to be implemented in Rust) non-prefix

    /// // `RootFilesIn'-kind matcher being mixed in.

    /// 'foo/bar' -> 'this'

    /// 'qux' -> 'this'

    /// ```

    /// # Important

    ///

    /// Most matchers do not know if they're representing files or

    /// directories. They see `['path:dir/f']` and don't know whether `f` is a

    /// file or a directory, so `visit_children_set('dir')` for most matchers

    /// will return `HashSet{ HgPath { "f" } }`, but if the matcher knows it's

    /// a file (like the yet to be implemented in Rust `ExactMatcher` does),

    /// it may return `VisitChildrenSet::This`.

    /// Do not rely on the return being a `HashSet` indicating that there are

    /// no files in this dir to investigate (or equivalently that if there are

    /// files to investigate in 'dir' that it will always return

    /// `VisitChildrenSet::This`).

    fn visit_children_set(&self, directory: &HgPath) -> VisitChildrenSet;

    /// Matcher will match everything and `files_set()` will be empty:

    /// optimization might be possible.

    fn matches_everything(&self) -> bool;

    /// Matcher will match exactly the files in `files_set()`: optimization

    /// might be possible.

    fn is_exact(&self) -> bool;

}

/// Matches everything.

///```

/// use hg::{ matchers::{Matcher, AlwaysMatcher}, utils::hg_path::HgPath };

///

/// let matcher = AlwaysMatcher;

///

/// assert_eq!(matcher.matches(HgPath::new(b"whatever")), true);

/// assert_eq!(matcher.matches(HgPath::new(b"b.txt")), true);

/// assert_eq!(matcher.matches(HgPath::new(b"main.c")), true);

/// assert_eq!(matcher.matches(HgPath::new(br"re:.*\.c$")), true);

/// ```

#[derive(Debug)]

pub struct AlwaysMatcher;

impl Matcher for AlwaysMatcher {

    fn file_set(&self) -> Option<&HashSet<&HgPath>> {

        None

    }

    fn exact_match(&self, _filename: &HgPath) -> bool {

        false

    }

    fn matches(&self, _filename: &HgPath) -> bool {

        true

    }

    fn visit_children_set(&self, _directory: &HgPath) -> VisitChildrenSet {

        VisitChildrenSet::Recursive

    }

    fn matches_everything(&self) -> bool {

        true

    }

    fn is_exact(&self) -> bool {

        false

    }

}

/// Matches the input files exactly. They are interpreted as paths, not

/// patterns.

///

///```

/// use hg::{ matchers::{Matcher, FileMatcher}, utils::hg_path::{HgPath, HgPathBuf} };

///

/// let files = [HgPathBuf::from_bytes(b"a.txt"), HgPathBuf::from_bytes(br"re:.*\.c$")];

/// let matcher = FileMatcher::new(&files).unwrap();

///

/// assert_eq!(matcher.matches(HgPath::new(b"a.txt")), true);

/// assert_eq!(matcher.matches(HgPath::new(b"b.txt")), false);

/// assert_eq!(matcher.matches(HgPath::new(b"main.c")), false);

/// assert_eq!(matcher.matches(HgPath::new(br"re:.*\.c$")), true);

/// ```

#[derive(Debug)]

pub struct FileMatcher<'a> {

    files: HashSet<&'a HgPath>,

    dirs: DirsMultiset,

}

impl<'a> FileMatcher<'a> {

    pub fn new(files: &'a [HgPathBuf]) -> Result<Self, DirstateMapError> {

        Ok(Self {

            files: HashSet::from_iter(files.iter().map(AsRef::as_ref)),

            dirs: DirsMultiset::from_manifest(files)?,

        })

    }

    fn inner_matches(&self, filename: &HgPath) -> bool {

        self.files.contains(filename.as_ref())

    }

}

impl<'a> Matcher for FileMatcher<'a> {

    fn file_set(&self) -> Option<&HashSet<&HgPath>> {

        Some(&self.files)

    }

    fn exact_match(&self, filename: &HgPath) -> bool {

        self.inner_matches(filename)

    }

    fn matches(&self, filename: &HgPath) -> bool {

        self.inner_matches(filename)

    }

    fn visit_children_set(&self, directory: &HgPath) -> VisitChildrenSet {

        if self.files.is_empty() || !self.dirs.contains(&directory) {

            return VisitChildrenSet::Empty;

        }

        let dirs_as_set = self.dirs.iter().map(Deref::deref).collect();

        let mut candidates: HashSet<&HgPath> =

            self.files.union(&dirs_as_set).cloned().collect();

        candidates.remove(HgPath::new(b""));

        if !directory.as_ref().is_empty() {

            let directory = [directory.as_ref().as_bytes(), b"/"].concat();

            candidates = candidates

                .iter()

                .filter_map(|c| {

                    if c.as_bytes().starts_with(&directory) {

                        Some(HgPath::new(&c.as_bytes()[directory.len()..]))

                    } else {

                        None

                    }

                })

                .collect();

        }

        // `self.dirs` includes all of the directories, recursively, so if

        // we're attempting to match 'foo/bar/baz.txt', it'll have '', 'foo',

        // 'foo/bar' in it. Thus we can safely ignore a candidate that has a

        // '/' in it, indicating it's for a subdir-of-a-subdir; the immediate

        // subdir will be in there without a slash.

        VisitChildrenSet::Set(

            candidates

                .iter()

                .filter_map(|c| {

                    if c.bytes().all(|b| *b != b'/') {

                        Some(*c)

                    } else {

                        None

                    }

                })

                .collect(),

        )

    }

    fn matches_everything(&self) -> bool {

        false

    }

    fn is_exact(&self) -> bool {

        true

    }

}

/// Matches files that are included in the ignore rules.

/// ```

/// use hg::{

///     matchers::{IncludeMatcher, Matcher},

///     IgnorePattern,

///     PatternSyntax,

///     utils::hg_path::HgPath

/// };

/// use std::path::Path;

/// ///

/// let ignore_patterns =

/// vec![IgnorePattern::new(PatternSyntax::RootGlob, b"this*", Path::new(""))];

/// let matcher = IncludeMatcher::new(ignore_patterns).unwrap();

/// ///

/// assert_eq!(matcher.matches(HgPath::new(b"testing")), false);

/// assert_eq!(matcher.matches(HgPath::new(b"this should work")), true);

/// assert_eq!(matcher.matches(HgPath::new(b"this also")), true);

/// assert_eq!(matcher.matches(HgPath::new(b"but not this")), false);

/// ```

pub struct IncludeMatcher<'a> {

    patterns: Vec<u8>,

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

    /// Whether all the patterns match a prefix (i.e. recursively)

    prefix: bool,

    roots: HashSet<HgPathBuf>,

    dirs: HashSet<HgPathBuf>,

    parents: HashSet<HgPathBuf>,

}

impl<'a> Matcher for IncludeMatcher<'a> {

    fn file_set(&self) -> Option<&HashSet<&HgPath>> {

        None

    }

    fn exact_match(&self, _filename: &HgPath) -> bool {

        false

    }

    fn matches(&self, filename: &HgPath) -> bool {

        (self.match_fn)(filename.as_ref())

    }

    fn visit_children_set(&self, directory: &HgPath) -> VisitChildrenSet {

        let dir = directory.as_ref();

        if self.prefix && self.roots.contains(dir) {

            return VisitChildrenSet::Recursive;

        }

        if self.roots.contains(HgPath::new(b""))

            || self.roots.contains(dir)

            || self.dirs.contains(dir)

            || find_dirs(dir).any(|parent_dir| self.roots.contains(parent_dir))

        {

            return VisitChildrenSet::This;

        }

        if self.parents.contains(directory.as_ref()) {

            let multiset = self.get_all_parents_children();

            if let Some(children) = multiset.get(dir) {

                return VisitChildrenSet::Set(children.to_owned());

            }

        }

        VisitChildrenSet::Empty

    }

    fn matches_everything(&self) -> bool {

        false

    }

    fn is_exact(&self) -> bool {

        false

    }

}

/// Returns a function that matches an `HgPath` against the given regex

/// pattern.

///

/// This can fail when the pattern is invalid or not supported by the

/// underlying engine (the `regex` crate), for instance anything with

/// back-references.

#[timed]

fn re_matcher(

    pattern: &[u8],

) -> PatternResult<impl Fn(&HgPath) -> bool + Sync> {

    use std::io::Write;

    // The `regex` crate adds `.*` to the start and end of expressions if there

    // are no anchors, so add the start anchor.

    let mut escaped_bytes = vec![b'^', b'(', b'?', b':'];

    for byte in pattern {

        if *byte > 127 {

            write!(escaped_bytes, "\\x{:x}", *byte).unwrap();

        } else {

            escaped_bytes.push(*byte);

        }

    }

    escaped_bytes.push(b')');

    // Avoid the cost of UTF8 checking

    //

    // # Safety

    // This is safe because we escaped all non-ASCII bytes.

    let pattern_string = unsafe { String::from_utf8_unchecked(escaped_bytes) };

    let re = regex::bytes::RegexBuilder::new(&pattern_string)

        .unicode(false)

        // Big repos with big `.hgignore` will hit the default limit and

        // incur a significant performance hit. One repo's `hg status` hit

        // multiple *minutes*.

        .dfa_size_limit(50 * (1 << 20))

        .build()

        .map_err(|e| PatternError::UnsupportedSyntax(e.to_string()))?;

    Ok(move |path: &HgPath| re.is_match(path.as_bytes()))

}

/// Returns the regex pattern and a function that matches an `HgPath` against

/// said regex formed by the given ignore patterns.

fn build_regex_match(

    ignore_patterns: &[IgnorePattern],

) -> PatternResult<(Vec<u8>, Box<dyn Fn(&HgPath) -> bool + Sync>)> {

    let mut regexps = vec![];

    let mut exact_set = HashSet::new();

    for pattern in ignore_patterns {

        if let Some(re) = build_single_regex(pattern)? {

            regexps.push(re);

        } else {

            let exact = normalize_path_bytes(&pattern.pattern);

            exact_set.insert(HgPathBuf::from_bytes(&exact));

        }

    }

    let full_regex = regexps.join(&b'|');

    // An empty pattern would cause the regex engine to incorrectly match the

    // (empty) root directory

    let func = if !(regexps.is_empty()) {

        let matcher = re_matcher(&full_regex)?;

        let func = move |filename: &HgPath| {