// License: see LICENSE file at root directory of `master` branch

//! # Path filter
//!
//! This module provides [`Filter`][::Filter] trait and some common filters.
//!
//! [::Filter]: trait.Filter.html

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

/// # Filter
pub trait Filter {

    /// # Returns `true` to accept given path, `false` to ignore it
    fn accept(&self, path: &Path) -> bool;

}

/// # A [filter][::Filter] that accepts all paths
///
/// [::Filter]: trait.Filter.html
#[derive(Debug, Clone)]
pub struct AllPaths {

    /// # Lock
    _lock: (),

}

impl AllPaths {

    /// # Makes new instance
    pub fn new() -> Self {
        Self {
            _lock: (),
        }
    }

}

impl Filter for AllPaths {

    fn accept(&self, _: &Path) -> bool {
        true
    }

}

/// # A [filter][::Filter] that ignores directories by names you provide
///
/// ## Examples
///
/// ```
/// use std::path::PathBuf;
/// use dia_files::path_filter::IgnoredDirNames;
///
/// const IGNORED_DIR_NAMES: &[&str] = &[
///     ".git", ".hg", ".svn", ".gradle", "target", "build", "release", "debug",
/// ];
///
/// let dir = PathBuf::from(file!()).parent().unwrap().to_path_buf();
/// let filter = IgnoredDirNames::new(IGNORED_DIR_NAMES);
/// assert!(dia_files::find_files(dir, false, filter).unwrap().count() > 0);
/// ```
///
/// [::Filter]: trait.Filter.html
#[derive(Debug, Clone)]
pub struct IgnoredDirNames<'a> {

    /// # Directory names
    dir_names: &'a [&'a str],

}

impl<'a> IgnoredDirNames<'a> {

    /// # Makes new instance
    pub fn new(dir_names: &'a [&'a str]) -> Self {
        Self {
            dir_names,
        }
    }

}

impl Filter for IgnoredDirNames<'_> {

    fn accept(&self, p: &Path) -> bool {
        if p.is_dir() {
            if let Some(Some(name)) = p.file_name().map(|n| n.to_str()) {
                return self.dir_names.contains(&name) == false;
            }
        }
        true
    }

}

/// # A [filter][::Filter] that only accepts files by extensions you provide
///
/// ## Notes
///
/// File extensions do _not_ contain leading dot `.`.
///
/// ## Examples
///
/// ```
/// use std::path::PathBuf;
/// use dia_files::path_filter::SomeFileExts;
///
/// const FILE_EXTS: &[&str] = &["rs"];
///
/// let dir = PathBuf::from(file!()).parent().unwrap().to_path_buf();
/// let filter = SomeFileExts::new(FILE_EXTS);
/// assert!(dia_files::find_files(dir, false, filter).unwrap().count() > 0);
/// ```
///
/// [::Filter]: trait.Filter.html
#[derive(Debug, Clone)]
pub struct SomeFileExts<'a> {

    /// # File extensions
    file_exts: &'a [&'a str],

}

impl<'a> SomeFileExts<'a> {

    /// # Makes new instance
    pub fn new(file_exts: &'a [&'a str]) -> Self {
        Self {
            file_exts,
        }
    }

}

impl<'a> Filter for SomeFileExts<'a> {

    fn accept(&self, p: &Path) -> bool {
        if p.is_file() {
            return match p.extension().map(|e| e.to_str()) {
                Some(Some(ext)) => self.file_exts.contains(&ext),
                _ => false,
            };
        }
        true
    }

}

/// # A [filter][::Filter] that ignores files by extensions you provide
///
/// ## Notes
///
/// File extensions do _not_ contain leading dot `.`.
///
/// ## Examples
///
/// ```
/// use std::path::PathBuf;
/// use dia_files::path_filter::IgnoredFileExts;
///
/// const IGNORED_FILE_EXTS: &[&str] = &["rs"];
///
/// let dir = PathBuf::from(file!()).parent().unwrap().to_path_buf();
/// let filter = IgnoredFileExts::new(IGNORED_FILE_EXTS);
/// assert_eq!(
///     dia_files::find_files(dir, false, filter).unwrap().count(),
///     0
/// );
/// ```
///
/// [::Filter]: trait.Filter.html
#[derive(Debug, Clone)]
pub struct IgnoredFileExts<'a> {

    /// # File extensions
    file_exts: &'a [&'a str],

}

impl<'a> IgnoredFileExts<'a> {

    /// # Makes new instance
    pub fn new(file_exts: &'a [&'a str]) -> Self {
        Self {
            file_exts,
        }
    }

}

impl<'a> Filter for IgnoredFileExts<'a> {

    fn accept(&self, p: &Path) -> bool {
        if p.is_file() {
            return match p.extension().map(|e| e.to_str()) {
                Some(Some(ext)) => self.file_exts.contains(&ext) == false,
                _ => true,
            };
        }
        true
    }

}

/// # A [filter][::Filter] that only _accepts_ symbolic link files
///
/// [::Filter]: trait.Filter.html
#[derive(Debug, Clone)]
pub struct SymlinkFiles {

    /// # Lock
    _lock: (),

}

impl SymlinkFiles {

    /// # Makes new instance
    pub fn new() -> Self {
        Self {
            _lock: (),
        }
    }

}

impl Filter for SymlinkFiles {

    fn accept(&self, p: &Path) -> bool {
        if p.is_file() {
            return match p.metadata().map(|m| m.file_type().is_symlink()) {
                Ok(true) => true,
                _ => false,
            };
        }
        true
    }

}

/// # A [filter][::Filter] that _rejects_ symbolic link files
///
/// [::Filter]: trait.Filter.html
#[derive(Debug, Clone)]
pub struct NonSymlinkFiles {

    /// # Lock
    _lock: (),

}

impl NonSymlinkFiles {

    /// # Makes new instance
    pub fn new() -> Self {
        Self {
            _lock: (),
        }
    }

}

impl Filter for NonSymlinkFiles {

    fn accept(&self, p: &Path) -> bool {
        if p.is_file() {
            if let Ok(true) = p.metadata().map(|m| m.file_type().is_symlink()) {
                return false;
            }
        }
        true
    }

}

/// # A [filter][::Filter] that combines all filters you provide, using _logical conjunction_
///
/// ## Notes
///
/// - If you provide an empty list, this filter _rejects_ all paths.
/// - Files are only accepted if _all_ filters accept them.
///
/// ## Examples
///
/// To find all Rust source files, ignoring vesion control systems' and build directories:
///
/// ```
/// use std::path::PathBuf;
/// use dia_files::path_filter::{All, Filter, IgnoredDirNames, SomeFileExts};
///
/// const IGNORED_DIR_NAMES: &[&str] = &[
///     ".git", ".hg", ".svn", ".gradle", "target", "build", "release", "debug",
/// ];
/// const FILE_EXTS: &[&str] = &["rs"];
///
/// let dir = PathBuf::from(file!()).parent().unwrap().to_path_buf();
/// let filters: Vec<Box<Filter>> = vec![
///     Box::new(IgnoredDirNames::new(IGNORED_DIR_NAMES)),
///     Box::new(SomeFileExts::new(FILE_EXTS)),
/// ];
/// let filter = All::new(filters);
/// assert!(dia_files::find_files(dir, false, filter).unwrap().count() > 0);
/// ```
///
/// [::Filter]: trait.Filter.html
pub struct All {

    /// # Filters
    filters: Vec<Box<Filter>>,

}

impl All {

    /// # Makes new instance
    pub fn new(filters: Vec<Box<Filter>>) -> Self {
        Self {
            filters,
        }
    }

}

impl Filter for All {

    fn accept(&self, p: &Path) -> bool {
        match self.filters.is_empty() {
            true => false,
            false => self.filters.iter().all(|f| f.accept(p)),
        }
    }

}

/// # A [filter][::Filter] that combines all filters you provide, using _logical disjunction_
///
/// ## Notes
///
/// - If you provide an empty list, this filter _rejects_ all paths.
/// - Files are accepted if _any_ of the filters accepts them.
///
/// [::Filter]: trait.Filter.html
pub struct Any {

    /// # Filters
    filters: Vec<Box<Filter>>,

}

impl Any {

    /// # Makes new instance
    pub fn new(filters: Vec<Box<Filter>>) -> Self {
        Self {
            filters,
        }
    }

}

impl Filter for Any {

    fn accept(&self, p: &Path) -> bool {
        self.filters.iter().any(|f| f.accept(p))
    }

}