superconfig 0.1.0

//! File discovery strategies for wildcard configuration loading

use globset::GlobSet;
use std::path::PathBuf;
use walkdir::WalkDir;

/// Defines how to discover files for wildcard matching
///
/// Different search strategies are optimized for different use cases:
/// - **Directories**: Search specific directories only
/// - **Recursive**: Search recursively from root directories
/// - **Current**: Search current directory only
/// - **Custom**: User-defined discovery logic
pub enum SearchStrategy {
    /// Search specific directories (non-recursive)
    ///
    /// Only searches the immediate contents of the specified directories.
    /// Does not descend into subdirectories.
    ///
    /// # Use Cases
    /// - Configuration directories with flat structure
    /// - Performance-critical scenarios where deep traversal is unnecessary
    /// - Well-organized config layouts
    ///
    /// # Example
    /// ```rust
    /// use superconfig::SearchStrategy;
    /// use std::path::PathBuf;
    ///
    /// let strategy = SearchStrategy::Directories(vec![
    ///     PathBuf::from("./config"),
    ///     PathBuf::from("~/.config/myapp"),
    /// ]);
    /// ```
    Directories(Vec<PathBuf>),

    /// Search recursively from root directories
    ///
    /// Searches all subdirectories up to the specified maximum depth.
    /// This is the most flexible strategy for complex directory structures.
    ///
    /// # Use Cases
    /// - Git-like hierarchical configuration discovery
    /// - Plugin systems with nested structure
    /// - Monorepo configurations
    ///
    /// # Performance Notes
    /// - Can be slow on deep directory trees
    /// - Use `max_depth` to limit traversal
    /// - Respects `.gitignore` patterns if configured
    ///
    /// # Example
    /// ```rust
    /// use superconfig::SearchStrategy;
    /// use std::path::PathBuf;
    ///
    /// let strategy = SearchStrategy::Recursive {
    ///     roots: vec![PathBuf::from("."), PathBuf::from("~/.config")],
    ///     max_depth: Some(3),
    /// };
    /// ```
    Recursive {
        roots: Vec<PathBuf>,
        max_depth: Option<usize>,
    },

    /// Search current directory only
    ///
    /// Convenience strategy for simple cases where configuration
    /// files are expected in the current working directory.
    ///
    /// # Use Cases
    /// - Simple applications
    /// - Development environments
    /// - Single-directory projects
    Current,

    /// Custom file discovery function
    ///
    /// Allows users to provide their own file discovery logic.
    /// The function should return a vector of file paths to be
    /// tested against the glob patterns.
    ///
    /// # Use Cases
    /// - Integration with existing file discovery systems
    /// - Complex custom logic (database-driven, network-based, etc.)
    /// - Testing scenarios with mock file systems
    ///
    /// # Example
    /// ```rust
    /// use superconfig::SearchStrategy;
    /// use std::path::PathBuf;
    ///
    /// let strategy = SearchStrategy::Custom(Box::new(|| {
    ///     vec![
    ///         PathBuf::from("custom-config.toml"),
    ///         PathBuf::from("override.yaml"),
    ///     ]
    /// }));
    /// ```
    Custom(Box<dyn Fn() -> Vec<PathBuf> + Send + Sync>),
}

impl std::fmt::Debug for SearchStrategy {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            SearchStrategy::Directories(dirs) => {
                write!(f, "SearchStrategy::Directories({dirs:?})")
            }
            SearchStrategy::Recursive { roots, max_depth } => {
                write!(
                    f,
                    "SearchStrategy::Recursive {{ roots: {roots:?}, max_depth: {max_depth:?} }}"
                )
            }
            SearchStrategy::Current => write!(f, "SearchStrategy::Current"),
            SearchStrategy::Custom(_) => write!(f, "SearchStrategy::Custom(<closure>)"),
        }
    }
}

impl Clone for SearchStrategy {
    fn clone(&self) -> Self {
        match self {
            SearchStrategy::Directories(dirs) => SearchStrategy::Directories(dirs.clone()),
            SearchStrategy::Recursive { roots, max_depth } => SearchStrategy::Recursive {
                roots: roots.clone(),
                max_depth: *max_depth,
            },
            SearchStrategy::Current => SearchStrategy::Current,
            SearchStrategy::Custom(_) => {
                panic!(
                    "Cannot clone SearchStrategy::Custom - use other variants for cloneable strategies"
                )
            }
        }
    }
}

impl Default for SearchStrategy {
    fn default() -> Self {
        Self::Current
    }
}

impl SearchStrategy {
    /// Discover files using this search strategy
    ///
    /// # Arguments
    /// * `glob_set` - Compiled glob patterns to match against
    ///
    /// # Returns
    /// Vector of file paths that match the glob patterns
    ///
    /// # Performance
    /// - **Directories**: O(n) where n is total files in all directories
    /// - **Recursive**: O(n) where n is total files in directory tree
    /// - **Current**: O(n) where n is files in current directory
    /// - **Custom**: Depends on user-provided function
    ///
    /// # Error Handling
    /// - Directories that don't exist are silently skipped
    /// - Files that can't be accessed are silently skipped
    /// - Permission errors during traversal are logged but don't fail the operation
    pub fn discover_files(&self, glob_set: &GlobSet) -> Vec<PathBuf> {
        match self {
            SearchStrategy::Directories(dirs) => discover_in_directories(dirs, glob_set),
            SearchStrategy::Recursive { roots, max_depth } => {
                discover_recursive(roots, glob_set, *max_depth)
            }
            SearchStrategy::Current => discover_in_directories(&[PathBuf::from(".")], glob_set),
            SearchStrategy::Custom(discovery_fn) => {
                let all_files = discovery_fn();
                filter_files_by_globset(&all_files, glob_set)
            }
        }
    }
}

/// Discover files in specific directories (non-recursive)
fn discover_in_directories(directories: &[PathBuf], glob_set: &GlobSet) -> Vec<PathBuf> {
    let mut files = Vec::new();

    for dir in directories {
        if let Ok(entries) = std::fs::read_dir(dir) {
            for entry in entries.flatten() {
                let path = entry.path();
                if path.is_file() && glob_set.is_match(&path) {
                    files.push(path);
                }
            }
        }
        // Silently skip directories that don't exist or can't be read
    }

    files
}

/// Discover files recursively from root directories
fn discover_recursive(
    roots: &[PathBuf],
    glob_set: &GlobSet,
    max_depth: Option<usize>,
) -> Vec<PathBuf> {
    let mut files = Vec::new();

    for root in roots {
        let mut walker = WalkDir::new(root);

        if let Some(depth) = max_depth {
            walker = walker.max_depth(depth);
        }

        for entry in walker.into_iter().filter_map(|e| e.ok()) {
            let path = entry.path();
            if path.is_file() && glob_set.is_match(path) {
                files.push(path.to_path_buf());
            }
        }
    }

    files
}

/// Filter a list of files against a glob set
fn filter_files_by_globset(files: &[PathBuf], glob_set: &GlobSet) -> Vec<PathBuf> {
    files
        .iter()
        .filter(|path| path.is_file() && glob_set.is_match(path))
        .cloned()
        .collect()
}

#[cfg(test)]
mod tests {
    use super::*;
    use globset::{Glob, GlobSetBuilder};
    use std::fs;
    use tempfile::TempDir;

    fn create_test_globset() -> GlobSet {
        let mut builder = GlobSetBuilder::new();
        builder.add(Glob::new("*.toml").unwrap());
        builder.add(Glob::new("*.yaml").unwrap());
        builder.build().unwrap()
    }

    #[test]
    fn test_discover_in_directories() {
        let temp_dir = TempDir::new().unwrap();
        let dir_path = temp_dir.path();

        // Create test files
        fs::write(dir_path.join("config.toml"), "test").unwrap();
        fs::write(dir_path.join("app.yaml"), "test").unwrap();
        fs::write(dir_path.join("readme.txt"), "test").unwrap();

        let glob_set = create_test_globset();
        let files = discover_in_directories(&[dir_path.to_path_buf()], &glob_set);

        assert_eq!(files.len(), 2); // Only .toml and .yaml files
        assert!(
            files
                .iter()
                .any(|p| p.file_name().unwrap() == "config.toml")
        );
        assert!(files.iter().any(|p| p.file_name().unwrap() == "app.yaml"));
    }

    #[test]
    fn test_discover_recursive() {
        let temp_dir = TempDir::new().unwrap();
        let root_path = temp_dir.path();
        let sub_dir = root_path.join("subdir");
        fs::create_dir(&sub_dir).unwrap();

        // Create test files
        fs::write(root_path.join("root.toml"), "test").unwrap();
        fs::write(sub_dir.join("sub.yaml"), "test").unwrap();
        fs::write(root_path.join("ignore.txt"), "test").unwrap();

        let glob_set = create_test_globset();
        let files = discover_recursive(&[root_path.to_path_buf()], &glob_set, None);

        assert_eq!(files.len(), 2); // Only .toml and .yaml files
        assert!(files.iter().any(|p| p.file_name().unwrap() == "root.toml"));
        assert!(files.iter().any(|p| p.file_name().unwrap() == "sub.yaml"));
    }

    #[test]
    fn test_discover_recursive_with_max_depth() {
        let temp_dir = TempDir::new().unwrap();
        let root_path = temp_dir.path();
        let sub_dir = root_path.join("subdir");
        let deep_dir = sub_dir.join("deep");
        fs::create_dir_all(&deep_dir).unwrap();

        // Create test files at different depths
        fs::write(root_path.join("root.toml"), "test").unwrap(); // Depth 0
        fs::write(sub_dir.join("sub.toml"), "test").unwrap(); // Depth 1
        fs::write(deep_dir.join("deep.toml"), "test").unwrap(); // Depth 2

        let glob_set = create_test_globset();

        // Max depth 2 should find root and sub, but not deep
        let files = discover_recursive(&[root_path.to_path_buf()], &glob_set, Some(2));

        assert_eq!(files.len(), 2);
        assert!(files.iter().any(|p| p.file_name().unwrap() == "root.toml"));
        assert!(files.iter().any(|p| p.file_name().unwrap() == "sub.toml"));
        assert!(!files.iter().any(|p| p.file_name().unwrap() == "deep.toml"));
    }

    #[test]
    fn test_custom_discovery() {
        let custom_files = vec![
            PathBuf::from("custom1.toml"),
            PathBuf::from("custom2.yaml"),
            PathBuf::from("custom3.txt"),
        ];

        let strategy = SearchStrategy::Custom(Box::new(move || custom_files.clone()));

        // Note: This test uses non-existent files, so we can't actually test file discovery
        // In a real scenario, the custom function would return actual file paths
        // This test mainly verifies the API structure
        let glob_set = create_test_globset();
        let _files = strategy.discover_files(&glob_set);

        // The custom function returns the files, but since they don't exist,
        // filter_files_by_globset will return an empty vector
        // This is expected behavior for the API
    }

    #[test]
    fn test_current_directory_strategy() {
        let strategy = SearchStrategy::Current;
        let glob_set = create_test_globset();

        // This will search the current directory
        // We don't assert on specific results since we don't control the test environment
        let _files = strategy.discover_files(&glob_set);

        // Just verify it doesn't panic and returns a vector
        // The actual test would depend on files in the current directory
    }
}