// 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::dirstate::status::IgnoreFnType;

use crate::filepatterns::normalize_path_bytes;

use std::borrow::ToOwned;

use std::collections::HashSet;

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

use std::ops::Deref;

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

#[derive(Debug, PartialEq)]

pub enum VisitChildrenSet {

    /// Don't visit anything

    Empty,

    /// Only visit this directory

    This,

    /// Visit this directory and these subdirectories

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

    Set(HashSet<HgPathBuf>),

    /// Visit this directory and all subdirectories

    Recursive,

}

pub trait Matcher: core::fmt::Debug {

    /// Explicitly listed files

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

    /// 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<HgPathBuf>> {

        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 nothing.

#[derive(Debug)]

pub struct NeverMatcher;

impl Matcher for NeverMatcher {

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

        None

    }

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

        false

    }

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

        false

    }

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

        VisitChildrenSet::Empty

    }

    fn matches_everything(&self) -> bool {

        false

    }

    fn is_exact(&self) -> bool {

        true

    }

}

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

/// patterns.

///

///```

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

///

/// let files = vec![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 {

    files: HashSet<HgPathBuf>,

    dirs: DirsMultiset,

}

impl FileMatcher {

    pub fn new(files: Vec<HgPathBuf>) -> Result<Self, DirstateMapError> {

        let dirs = DirsMultiset::from_manifest(&files)?;

        Ok(Self {

            files: HashSet::from_iter(files.into_iter()),

            dirs,

        })

    }

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

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

    }

}

impl Matcher for FileMatcher {

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

        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 mut candidates: HashSet<HgPathBuf> =

            self.dirs.iter().cloned().collect();

        candidates.extend(self.files.iter().cloned());

        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(HgPathBuf::from_bytes(

                            &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

                .into_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: IgnoreFnType<'a>,

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

    prefix: bool,

    roots: HashSet<HgPathBuf>,

    dirs: HashSet<HgPathBuf>,

    parents: HashSet<HgPathBuf>,

}

impl core::fmt::Debug for IncludeMatcher<'_> {

    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {

        f.debug_struct("IncludeMatcher")

            .field("patterns", &String::from_utf8_lossy(&self.patterns))

            .field("prefix", &self.prefix)

            .field("roots", &self.roots)

            .field("dirs", &self.dirs)

            .field("parents", &self.parents)

            .finish()

    }

}

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

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

        None

    }

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

        false

    }

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

        (self.match_fn)(filename)

    }

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

        let dir = directory;

        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(dir.as_ref()) {

            let multiset = self.get_all_parents_children();

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

                return VisitChildrenSet::Set(

                    children.iter().map(HgPathBuf::from).collect(),

                );

            }

        }

        VisitChildrenSet::Empty

    }

    fn matches_everything(&self) -> bool {

        false

    }

    fn is_exact(&self) -> bool {

        false

    }

}

/// The union of multiple matchers. Will match if any of the matchers match.

#[derive(Debug)]

pub struct UnionMatcher {

    matchers: Vec<Box<dyn Matcher + Sync>>,

}

impl Matcher for UnionMatcher {

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

        None

    }

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

        false

    }

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

        self.matchers.iter().any(|m| m.matches(filename))

    }

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

        let mut result = HashSet::new();

        let mut this = false;

        for matcher in self.matchers.iter() {

            let visit = matcher.visit_children_set(directory);

            match visit {

                VisitChildrenSet::Empty => continue,

                VisitChildrenSet::This => {