luff 0.2.1

//! Pattern matching for ignore rules with config integration

use crate::error::ConfigError;
use crate::fs_utils::GlobMatcher;
use std::borrow::Cow;
use std::collections::HashSet;
use std::fmt;
use std::path::Path;

/// Default binary file extensions to ignore.
///
/// Single source of truth — used by [`IgnorePatterns::default_extensions`]
/// and by property tests to avoid the defaults and test expectations
/// drifting apart.
const DEFAULT_IGNORE_EXTENSIONS: &[&str] = &[
    "png", "jpg", "jpeg", "gif", "bmp", "pdf", "zip", "tar", "gz", "xz", "bz2", "exe", "dll", "so",
    "bin", "iso", "img", "mp3", "mp4", "avi", "mkv", "mov", "wmv", "flv", "swf", "webm",
];

/// Default directory names to ignore.
///
/// Single source of truth — see [`DEFAULT_IGNORE_EXTENSIONS`] for rationale.
const DEFAULT_IGNORE_DIRECTORIES: &[&str] = &[".git", "__pycache__", ".venv", "node_modules"];

/// Default specific filenames to ignore.
///
/// Single source of truth — see [`DEFAULT_IGNORE_EXTENSIONS`] for rationale.
const DEFAULT_IGNORE_FILES: &[&str] = &[".terraform.lock.hcl"];

/// Discriminant for the kind of simple (non-glob) ignore pattern being
/// validated.
///
/// Used by [`IgnorePatterns::validate_simple_pattern`] so the compiler
/// can enforce exhaustive handling when a new variant is added.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum PatternKind {
    /// File extension (e.g. `"png"`). Must be lowercase, no leading dot.
    Extension,
    /// Directory name (e.g. `"build"`). No path separators.
    Directory,
    /// Filename (e.g. `"secret.key"`). No path separators.
    Filename,
}

impl fmt::Display for PatternKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Extension => f.write_str("extension"),
            Self::Directory => f.write_str("directory"),
            Self::Filename => f.write_str("filename"),
        }
    }
}

/// Container for all ignore patterns
#[derive(Debug, Clone)]
pub struct IgnorePatterns {
    /// File extensions that should be ignored (e.g., "png", "jpg")
    extensions: HashSet<String>,
    /// Directory names that should be ignored (e.g., ".git", "__pycache__")
    directories: HashSet<String>,
    /// Specific filenames that should be ignored (e.g., ".terraform.lock.hcl")
    files: HashSet<String>,
    /// Glob patterns for complex matching (e.g., "src/**/*.rs")
    globs: GlobMatcher,
}

impl Default for IgnorePatterns {
    fn default() -> Self {
        Self {
            extensions: Self::default_extensions(),
            directories: Self::default_directories(),
            files: Self::default_files(),
            globs: GlobMatcher::empty(),
        }
    }
}

impl IgnorePatterns {
    /// Create patterns from config values, validating and merging with defaults.
    ///
    /// All simple pattern validation (empty strings, glob metacharacters,
    /// path separators, leading dots on extensions) is performed here,
    /// making this the single gate through which user-supplied patterns
    /// must pass. Callers do not need to pre-validate.
    ///
    /// Merges user-provided extensions, directories, and filenames with
    /// the built-in defaults. Glob patterns are purely user-supplied
    /// (there are no default globs).
    ///
    /// # Arguments
    ///
    /// * `extensions` - Additional extensions to ignore (merged with defaults)
    /// * `directories` - Additional directories to ignore (merged with defaults)
    /// * `files` - Additional filenames to ignore (merged with defaults)
    /// * `globs` - List of glob patterns to ignore (no defaults; user-only)
    ///
    /// # Errors
    ///
    /// Returns [`ConfigError::InvalidPattern`] if any pattern fails validation
    /// or any glob pattern fails to compile.
    pub(crate) fn from_config(
        extensions: &[String],
        directories: &[String],
        files: &[String],
        globs: &[String],
    ) -> Result<Self, ConfigError> {
        let validated_extensions =
            Self::validate_simple_patterns(extensions, PatternKind::Extension)?;
        let validated_directories =
            Self::validate_simple_patterns(directories, PatternKind::Directory)?;
        let validated_files = Self::validate_simple_patterns(files, PatternKind::Filename)?;

        let mut patterns = Self::default();

        // Merge user patterns into the default sets
        patterns.extensions.extend(validated_extensions);
        patterns.directories.extend(validated_directories);
        patterns.files.extend(validated_files);

        // Compile user globs — fail loudly so the user can fix their config.
        // There are no default globs; an empty slice leaves GlobMatcher::empty().
        if !globs.is_empty() {
            patterns.globs = GlobMatcher::new(globs).map_err(|e| ConfigError::InvalidPattern {
                pattern: globs.join(", "),
                pattern_type: "glob".to_string(),
                help: format!("Failed to compile glob patterns: {e}"),
            })?;
        }

        Ok(patterns)
    }

    /// Validate simple (non-glob) ignore patterns.
    ///
    /// The `kind` discriminant controls which additional checks apply
    /// (e.g. extensions reject leading dots and are lowercased, while
    /// directory/filename patterns are stored as-is). Because
    /// `PatternKind` is an enum the compiler will force us to handle
    /// any new variant we add in the future.
    ///
    /// Path separators are rejected for **all** kinds — none of these
    /// simple patterns are meant to express hierarchical paths. Use
    /// glob patterns (`ignore_globs`) for path-based matching.
    fn validate_simple_patterns(
        patterns: &[String],
        kind: PatternKind,
    ) -> Result<Vec<String>, ConfigError> {
        let mut validated = Vec::with_capacity(patterns.len());

        for pattern in patterns {
            // Reject empty patterns — they would silently match files
            // without extensions or produce meaningless HashSet entries
            if pattern.is_empty() {
                return Err(ConfigError::InvalidPattern {
                    pattern: String::new(),
                    pattern_type: kind.to_string(),
                    help: format!("{kind} patterns must not be empty"),
                });
            }

            // Check for glob metacharacters
            if pattern.contains(&['*', '?', '[', ']'][..]) {
                return Err(ConfigError::InvalidPattern {
                    pattern: pattern.clone(),
                    pattern_type: kind.to_string(),
                    help:
                        "Patterns cannot contain glob metacharacters (*, ?, [, ]) in this version"
                            .to_string(),
                });
            }

            // Reject path separators for all simple pattern kinds.
            // Extensions, directory names, and filenames are all
            // single-component — use ignore_globs for path matching.
            if pattern.chars().any(std::path::is_separator) {
                return Err(ConfigError::InvalidPattern {
                    pattern: pattern.clone(),
                    pattern_type: kind.to_string(),
                    help: format!(
                        "{kind} patterns cannot contain path separators; \
                         use ignore_globs for path-based patterns"
                    ),
                });
            }

            match kind {
                PatternKind::Extension => {
                    if pattern.starts_with('.') {
                        return Err(ConfigError::InvalidPattern {
                            pattern: pattern.clone(),
                            pattern_type: kind.to_string(),
                            help: "Extensions should not include the leading dot".to_string(),
                        });
                    }
                    validated.push(pattern.to_lowercase());
                }
                PatternKind::Directory | PatternKind::Filename => {
                    validated.push(pattern.clone());
                }
            }
        }

        Ok(validated)
    }

    /// Returns the default set of binary file extensions to ignore
    fn default_extensions() -> HashSet<String> {
        DEFAULT_IGNORE_EXTENSIONS
            .iter()
            .map(std::string::ToString::to_string)
            .collect()
    }

    /// Returns the default set of directories to ignore
    fn default_directories() -> HashSet<String> {
        DEFAULT_IGNORE_DIRECTORIES
            .iter()
            .map(std::string::ToString::to_string)
            .collect()
    }

    /// Returns the default set of specific files to ignore
    fn default_files() -> HashSet<String> {
        DEFAULT_IGNORE_FILES
            .iter()
            .map(std::string::ToString::to_string)
            .collect()
    }

    /// Check if a file extension should be ignored
    ///
    /// # Performance
    ///
    /// Uses `Cow` to avoid allocation when the extension is already lowercase
    /// (which is the common case).
    #[must_use]
    pub fn should_ignore_extension(&self, ext: &str) -> bool {
        // Optimization: Avoid allocation if the extension contains no uppercase characters
        let ext_lower = if ext.chars().any(char::is_uppercase) {
            Cow::Owned(ext.to_lowercase())
        } else {
            Cow::Borrowed(ext)
        };
        self.extensions.contains(ext_lower.as_ref())
    }

    /// Check if a directory should be ignored
    #[must_use]
    pub fn should_ignore_directory(&self, name: &str) -> bool {
        self.directories.contains(name)
    }

    /// Check if a specific file should be ignored
    #[must_use]
    pub fn should_ignore_file(&self, name: &str) -> bool {
        self.files.contains(name)
    }

    /// Check if a path matches any configured glob pattern
    #[must_use]
    pub fn should_ignore_glob(&self, path: &Path) -> bool {
        self.globs.is_match(path)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use proptest::prelude::*;

    #[test]
    fn test_from_config_with_custom_patterns() {
        let patterns = IgnorePatterns::from_config(
            &["custom".to_string()],
            &["build".to_string()],
            &["secret.key".to_string()],
            &["*.log".to_string()],
        )
        .unwrap();

        assert!(patterns.should_ignore_extension("custom"));
        assert!(patterns.should_ignore_directory("build"));
        assert!(patterns.should_ignore_file("secret.key"));
        assert!(patterns.should_ignore_extension("png")); // defaults still present
        assert!(patterns.should_ignore_glob(Path::new("app.log")));
    }

    #[test]
    fn test_from_config_rejects_invalid_glob() {
        let result = IgnorePatterns::from_config(&[], &[], &[], &["[invalid".to_string()]);
        assert!(result.is_err());
    }

    #[test]
    fn test_from_config_rejects_empty_extension() {
        let result = IgnorePatterns::from_config(&[String::new()], &[], &[], &[]);
        assert!(matches!(
            result.unwrap_err(),
            ConfigError::InvalidPattern { .. }
        ));
    }

    #[test]
    fn test_from_config_rejects_empty_directory() {
        let result = IgnorePatterns::from_config(&[], &[String::new()], &[], &[]);
        assert!(matches!(
            result.unwrap_err(),
            ConfigError::InvalidPattern { .. }
        ));
    }

    #[test]
    fn test_from_config_rejects_empty_file() {
        let result = IgnorePatterns::from_config(&[], &[], &[String::new()], &[]);
        assert!(matches!(
            result.unwrap_err(),
            ConfigError::InvalidPattern { .. }
        ));
    }

    #[test]
    fn test_from_config_rejects_extension_with_leading_dot() {
        let result = IgnorePatterns::from_config(&[".png".to_string()], &[], &[], &[]);
        assert!(matches!(
            result.unwrap_err(),
            ConfigError::InvalidPattern { .. }
        ));
    }

    #[test]
    fn test_from_config_rejects_path_separator_in_extension() {
        let result = IgnorePatterns::from_config(&["foo/bar".to_string()], &[], &[], &[]);
        assert!(matches!(
            result.unwrap_err(),
            ConfigError::InvalidPattern { .. }
        ));
    }

    #[test]
    fn test_from_config_rejects_glob_metachar_in_directory() {
        let result = IgnorePatterns::from_config(&[], &["build*".to_string()], &[], &[]);
        assert!(matches!(
            result.unwrap_err(),
            ConfigError::InvalidPattern { .. }
        ));
    }

    fn arb_case_variation(s: &'static str) -> impl Strategy<Value = String> {
        proptest::collection::vec(proptest::bool::ANY, s.len()).prop_map(move |bits| {
            s.chars()
                .zip(bits)
                .map(|(c, upper)| {
                    if upper {
                        c.to_uppercase().to_string()
                    } else {
                        c.to_lowercase().to_string()
                    }
                })
                .collect()
        })
    }

    proptest! {
        /// `should_ignore_extension` must never panic, regardless of input.
        #[test]
        fn test_extension_matching_never_panics(s in "\\PC{0,10}") {
            let patterns = IgnorePatterns::default();
            let _ = patterns.should_ignore_extension(&s);
        }

        /// `should_ignore_directory` must never panic, regardless of input.
        #[test]
        fn test_directory_matching_never_panics(s in "\\PC{0,64}") {
            let patterns = IgnorePatterns::default();
            let _ = patterns.should_ignore_directory(&s);
        }

        /// `should_ignore_file` must never panic, regardless of input.
        #[test]
        fn test_file_matching_never_panics(s in "\\PC{0,64}") {
            let patterns = IgnorePatterns::default();
            let _ = patterns.should_ignore_file(&s);
        }

        /// Every default extension is ignored regardless of casing.
        #[test]
        fn test_known_extensions_always_ignored_any_case(
            ext_idx in 0..DEFAULT_IGNORE_EXTENSIONS.len(),
        ) {
            let ext = DEFAULT_IGNORE_EXTENSIONS[ext_idx];
            let patterns = IgnorePatterns::default();
            // Lowercase
            prop_assert!(patterns.should_ignore_extension(ext));
            // Uppercase
            prop_assert!(patterns.should_ignore_extension(&ext.to_uppercase()));
        }

        /// Case-insensitivity holds for arbitrary mixed-case variations.
        #[test]
        fn test_extension_case_insensitive_arbitrary(
            variation in prop::sample::select(DEFAULT_IGNORE_EXTENSIONS.to_vec())
                .prop_flat_map(arb_case_variation)
        ) {
            let patterns = IgnorePatterns::default();
            prop_assert!(
                patterns.should_ignore_extension(&variation),
                "expected {:?} to be ignored", variation
            );
        }

        /// User-added extensions are case-insensitively matched for
        /// arbitrary mixed-case queries.
        #[test]
        fn test_user_extension_case_insensitive_arbitrary(
            ext in "[a-z]{2,8}",
            query_upper_bits in proptest::collection::vec(proptest::bool::ANY, 2..=8),
        ) {
            // from_config receives raw extensions; validation lowercases them
            let patterns = IgnorePatterns::from_config(
                std::slice::from_ref(&ext),
                &[],
                &[],
                &[],
            ).unwrap();

            // Build an arbitrary-case variation of the same extension
            let query: String = ext.chars()
                .zip(query_upper_bits.iter().cycle())
                .map(|(c, &upper)| {
                    if upper {
                        c.to_uppercase().to_string()
                    } else {
                        c.to_lowercase().to_string()
                    }
                })
                .collect();

            prop_assert!(
                patterns.should_ignore_extension(&query),
                "user extension {ext:?} should match query {query:?}"
            );
        }

        /// Every default directory is matched exactly.
        #[test]
        fn test_default_directories_always_matched(
            dir_idx in 0..DEFAULT_IGNORE_DIRECTORIES.len(),
        ) {
            let dir = DEFAULT_IGNORE_DIRECTORIES[dir_idx];
            let patterns = IgnorePatterns::default();
            prop_assert!(patterns.should_ignore_directory(dir));
        }

        /// Every default file is matched exactly.
        #[test]
        fn test_default_files_always_matched(
            file_idx in 0..DEFAULT_IGNORE_FILES.len(),
        ) {
            let file = DEFAULT_IGNORE_FILES[file_idx];
            let patterns = IgnorePatterns::default();
            prop_assert!(patterns.should_ignore_file(file));
        }

        /// Strings that are not in the default sets must not be matched.
        /// We generate ASCII alphanumeric strings that cannot collide
        /// with any default.
        #[test]
        fn test_non_default_extension_not_ignored(
            ext in "[a-z]{4,8}"
        ) {
            // Filter out any accidental collisions with the default set
            prop_assume!(!DEFAULT_IGNORE_EXTENSIONS.contains(&ext.as_str()));
            let patterns = IgnorePatterns::default();
            prop_assert!(!patterns.should_ignore_extension(&ext));
        }

        /// Strings not in the default directory set must not be matched.
        #[test]
        fn test_non_default_directory_not_ignored(
            name in "[a-z]{5,12}"
        ) {
            prop_assume!(!DEFAULT_IGNORE_DIRECTORIES.contains(&name.as_str()));
            let patterns = IgnorePatterns::default();
            prop_assert!(!patterns.should_ignore_directory(&name));
        }

        /// Strings not in the default file set must not be matched.
        #[test]
        fn test_non_default_file_not_ignored(
            name in "[a-z]{5,12}\\.[a-z]{1,4}"
        ) {
            prop_assume!(!DEFAULT_IGNORE_FILES.contains(&name.as_str()));
            let patterns = IgnorePatterns::default();
            prop_assert!(!patterns.should_ignore_file(&name));
        }

        /// Custom patterns added via `from_config` are always present
        /// alongside defaults — i.e., defaults are never lost by merging.
        #[test]
        fn test_from_config_preserves_defaults(
            ext in "[a-z]{4,8}",
            dir in "[a-z]{5,12}",
            file in "[a-z]{5,12}\\.[a-z]{1,4}",
        ) {
            prop_assume!(!DEFAULT_IGNORE_EXTENSIONS.contains(&ext.as_str()));
            prop_assume!(!DEFAULT_IGNORE_DIRECTORIES.contains(&dir.as_str()));
            prop_assume!(!DEFAULT_IGNORE_FILES.contains(&file.as_str()));

            let patterns = IgnorePatterns::from_config(
                std::slice::from_ref(&ext),
                std::slice::from_ref(&dir),
                std::slice::from_ref(&file),
                &[],
            ).unwrap();

            // User patterns present
            prop_assert!(patterns.should_ignore_extension(&ext));
            prop_assert!(patterns.should_ignore_directory(&dir));
            prop_assert!(patterns.should_ignore_file(&file));

            // Defaults still present (spot-check first entry from each)
            prop_assert!(patterns.should_ignore_extension(DEFAULT_IGNORE_EXTENSIONS[0]));
            prop_assert!(patterns.should_ignore_directory(DEFAULT_IGNORE_DIRECTORIES[0]));
            prop_assert!(patterns.should_ignore_file(DEFAULT_IGNORE_FILES[0]));
        }

        /// Empty strings are rejected for all simple pattern kinds
        /// when going through `from_config`.
        #[test]
        fn test_empty_pattern_rejected_for_all_kinds(
            kind in prop::sample::select(vec![0u8, 1, 2])
        ) {
            let empty = [String::new()];
            let result = match kind {
                0 => IgnorePatterns::from_config(&empty, &[], &[], &[]),
                1 => IgnorePatterns::from_config(&[], &empty, &[], &[]),
                _ => IgnorePatterns::from_config(&[], &[], &empty, &[]),
            };
            let err = result.expect_err("empty pattern must be rejected");
            prop_assert!(
                matches!(err, ConfigError::InvalidPattern { .. }),
                "unexpected error variant: {err:?}"
            );
        }

        /// Patterns containing glob metacharacters are always rejected for
        /// all simple pattern kinds through `from_config`.
        #[test]
        fn test_glob_metachar_rejected_for_all_kinds(
            kind in prop::sample::select(vec![0u8, 1, 2]),
            metachar in prop::sample::select(vec!['*', '?', '[', ']']),
            prefix in "[a-z]{0,4}",
            suffix in "[a-z]{0,4}",
        ) {
            let pattern = vec![format!("{prefix}{metachar}{suffix}")];
            let result = match kind {
                0 => IgnorePatterns::from_config(&pattern, &[], &[], &[]),
                1 => IgnorePatterns::from_config(&[], &pattern, &[], &[]),
                _ => IgnorePatterns::from_config(&[], &[], &pattern, &[]),
            };
            let err = result.expect_err("glob metachar must be rejected");
            prop_assert!(
                matches!(err, ConfigError::InvalidPattern { .. }),
                "unexpected error variant: {err:?}"
            );
        }

        /// Patterns containing path separators are always rejected for all
        /// simple pattern kinds through `from_config`.
        #[test]
        fn test_path_separator_rejected_for_all_kinds(
            kind in prop::sample::select(vec![0u8, 1, 2]),
            prefix in "[a-z]{1,4}",
            suffix in "[a-z]{1,4}",
        ) {
            let pattern = vec![format!("{prefix}/{suffix}")];
            let result = match kind {
                0 => IgnorePatterns::from_config(&pattern, &[], &[], &[]),
                1 => IgnorePatterns::from_config(&[], &pattern, &[], &[]),
                _ => IgnorePatterns::from_config(&[], &[], &pattern, &[]),
            };
            let err = result.expect_err("path separator must be rejected");
            prop_assert!(
                matches!(err, ConfigError::InvalidPattern { .. }),
                "unexpected error variant: {err:?}"
            );
        }

        /// Extensions with a leading dot are rejected; without are accepted
        /// and lowercased — validated through `from_config`.
        #[test]
        fn test_extension_leading_dot_rejected(ext in "[a-zA-Z]{1,6}") {
            // With leading dot → rejected
            let dotted = vec![format!(".{ext}")];
            let err = IgnorePatterns::from_config(&dotted, &[], &[], &[])
                .expect_err("leading dot must be rejected");
            prop_assert!(
                matches!(err, ConfigError::InvalidPattern { .. }),
                "unexpected error variant: {err:?}"
            );

            // Without leading dot → accepted and lowercased
            let bare = vec![ext.clone()];
            let patterns = IgnorePatterns::from_config(&bare, &[], &[], &[])
                .expect("bare extension must validate");
            prop_assert!(
                patterns.should_ignore_extension(&ext),
                "extension {ext:?} should be ignored after validation"
            );
        }

        /// Valid simple patterns (no metacharacters, no path separators,
        /// non-empty) always succeed for directory and filename kinds
        /// through `from_config`.
        #[test]
        fn test_valid_simple_patterns_accepted(
            kind in prop::sample::select(vec![1u8, 2]),
            name in "[a-zA-Z0-9._-]{1,20}",
        ) {
            let pattern = vec![name.clone()];
            let result = match kind {
                1 => IgnorePatterns::from_config(&[], &pattern, &[], &[]),
                _ => IgnorePatterns::from_config(&[], &[], &pattern, &[]),
            };
            prop_assert!(result.is_ok(), "valid pattern {name:?} must be accepted");
        }
    }
}