zlob 1.3.3

use crate::error::ZlobError;
use crate::ffi;
use crate::flags::ZlobFlags;
use std::ffi::{c_char, CString};
use std::ops::Index;
use std::slice;

/// Result of a `zlob()` call.
///
/// This type automatically frees the allocated memory when dropped.
/// It provides zero-copy access to matched paths via the `pathlen` array.
///
/// # Example
///
/// ```no_run
/// use zlob::{zlob, ZlobFlags};
///
/// if let Some(result) = zlob("**/*.rs", ZlobFlags::empty())? {
///     // Iterate over paths
///     for path in &result {
///         println!("{}", path);
///     }
///
///     // Index access
///     if !result.is_empty() {
///         println!("First: {}", &result[0]);
///     }
///
///     // Convert to Vec
///     let paths: Vec<String> = result.to_strings();
/// }
/// # Ok::<(), zlob::ZlobError>(())
/// ```
pub struct Zlob {
    inner: ffi::zlob_t,
}

impl Zlob {
    /// Returns the number of matched paths.
    #[inline]
    pub fn len(&self) -> usize {
        self.inner.zlo_pathc
    }

    /// Returns `true` if no paths matched.
    #[inline]
    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }

    /// Returns the path at the given index, or `None` if out of bounds.
    ///
    /// This is a zero-copy operation that uses `pathlen` to create
    /// a string slice without calling `strlen()`.
    #[inline]
    pub fn get(&self, index: usize) -> Option<&str> {
        if index >= self.len() {
            return None;
        }
        unsafe {
            let ptr = *self.inner.zlo_pathv.add(index) as *const u8;
            let len = *self.inner.zlo_pathlen.add(index);
            let bytes = slice::from_raw_parts(ptr, len);
            // SAFETY: zlob guarantees UTF-8 valid paths (they come from the filesystem)
            Some(std::str::from_utf8_unchecked(bytes))
        }
    }

    /// Returns an iterator over the matched paths.
    #[inline]
    pub fn iter(&self) -> ZlobIter<'_> {
        ZlobIter {
            zlob: self,
            front: 0,
            back: self.len(),
        }
    }

    /// Returns all paths as a vector of string slices.
    ///
    /// This is a zero-copy operation - the strings reference the internal buffer.
    pub fn as_strs(&self) -> Vec<&str> {
        self.iter().collect()
    }

    /// Converts to a vector of owned strings.
    ///
    /// This copies all path data into new `String` allocations.
    pub fn to_strings(&self) -> Vec<String> {
        self.iter().map(|s| s.to_string()).collect()
    }

    /// Returns raw pointers to path data for advanced zero-copy access.
    ///
    /// # Safety
    ///
    /// The returned slices are valid only while this `Zlob` instance exists.
    /// Do not use them after the `Zlob` is dropped.
    ///
    /// # Returns
    ///
    /// A tuple of `(pathv, pathlen)` where:
    /// - `pathv[i]` is a pointer to the i-th path (null-terminated)
    /// - `pathlen[i]` is the length of the i-th path (excluding null terminator)
    pub unsafe fn raw_parts(&self) -> (&[*mut c_char], &[usize]) {
        let pathv = slice::from_raw_parts(self.inner.zlo_pathv, self.len());
        let pathlen = slice::from_raw_parts(self.inner.zlo_pathlen, self.len());
        (pathv, pathlen)
    }
}

impl Drop for Zlob {
    fn drop(&mut self) {
        unsafe {
            ffi::zlobfree(&mut self.inner);
        }
    }
}

impl Index<usize> for Zlob {
    type Output = str;

    /// Returns the path at the given index.
    ///
    /// # Panics
    ///
    /// Panics if `index >= self.len()`.
    fn index(&self, index: usize) -> &Self::Output {
        self.get(index).expect("index out of bounds")
    }
}

impl<'a> IntoIterator for &'a Zlob {
    type Item = &'a str;
    type IntoIter = ZlobIter<'a>;

    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

// SAFETY: Zlob owns its data and can be sent between threads
unsafe impl Send for Zlob {}
// SAFETY: Zlob's methods only take &self and don't mutate shared state
unsafe impl Sync for Zlob {}

/// Iterator over `Zlob` results.
///
/// This iterator yields `&str` references to each matched path.
/// It implements `ExactSizeIterator` and `DoubleEndedIterator`.
pub struct ZlobIter<'a> {
    zlob: &'a Zlob,
    front: usize,
    back: usize,
}

impl<'a> Iterator for ZlobIter<'a> {
    type Item = &'a str;

    fn next(&mut self) -> Option<Self::Item> {
        if self.front >= self.back {
            return None;
        }
        let item = self.zlob.get(self.front)?;
        self.front += 1;
        Some(item)
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let remaining = self.back - self.front;
        (remaining, Some(remaining))
    }

    fn count(self) -> usize {
        self.back - self.front
    }

    fn nth(&mut self, n: usize) -> Option<Self::Item> {
        if n >= self.back - self.front {
            self.front = self.back;
            return None;
        }
        self.front += n;
        self.next()
    }

    fn last(mut self) -> Option<Self::Item> {
        self.next_back()
    }
}

impl ExactSizeIterator for ZlobIter<'_> {
    fn len(&self) -> usize {
        self.back - self.front
    }
}

impl DoubleEndedIterator for ZlobIter<'_> {
    fn next_back(&mut self) -> Option<Self::Item> {
        if self.front >= self.back {
            return None;
        }
        self.back -= 1;
        self.zlob.get(self.back)
    }

    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
        if n >= self.back - self.front {
            self.front = self.back;
            return None;
        }
        self.back -= n;
        self.next_back()
    }
}

impl std::iter::FusedIterator for ZlobIter<'_> {}

/// Perform glob pattern matching on the filesystem.
///
/// This function finds all files matching the given glob pattern.
///
/// # Arguments
///
/// * `pattern` - The glob pattern to match (e.g., `"**/*.rs"`, `"src/{lib,main}.rs"`)
/// * `flags` - Flags controlling the matching behavior
///
/// # Returns
///
/// * `Ok(Some(Zlob))` - Matches were found
/// * `Ok(None)` - No matches found (pattern is valid but no files match)
/// * `Err(ZlobError)` - An error occurred (out of memory, read error, etc.)
///
/// # Example
///
/// ```no_run
/// use zlob::{zlob, ZlobFlags};
///
/// // Find all Rust files recursively
/// if let Some(result) = zlob("**/*.rs", ZlobFlags::RECOMMENDED)? {
///     for path in &result {
///         println!("{}", path);
///     }
/// } else {
///     println!("No matches found");
/// }
///
/// // Enable git ignore support
/// let result = zlob("src/{lib,main}.rs", ZlobFlags::RECOMMENDED | ZlobFlags::GITIGNORE)?;
///
/// assert!(result.is_some());
/// # Ok::<(), zlob::ZlobError>(())
/// ```
///
/// # Supported Patterns
///
/// We support all the varieties of glob pattern supported by rust's `glob` crate, posix `glob(3)`,
/// glibc `glob()` implementation and many more.
///
/// Here are some of the most common patterns:
///
/// | Pattern | Description |
/// |---------|-------------|
/// | `*` | Matches any string (including empty) |
/// | `?` | Matches any single character |
/// | `[abc]` | Matches one character from the set |
/// | `[!abc]` | Matches one character NOT in the set |
/// | `[a-z]` | Matches one character in the range |
/// | `**` | Matches zero or more path components (recursive) |
/// | `{a,b}` | Matches alternatives (requires `BRACE` flag) |
/// | `~` | Home directory (requires `TILDE` flag) |
pub fn zlob(pattern: &str, flags: ZlobFlags) -> Result<Option<Zlob>, ZlobError> {
    let pattern_c = CString::new(pattern).map_err(|_| ZlobError::Aborted)?;
    let mut inner = ffi::zlob_t::default();

    let result = unsafe { ffi::zlob(pattern_c.as_ptr(), flags.bits(), None, &mut inner) };

    match ZlobError::from_code(result) {
        Ok(true) => Ok(Some(Zlob { inner })),
        Ok(false) => Ok(None), // No matches
        Err(err) => Err(err),
    }
}

/// Perform glob pattern matching within a specific base directory.
///
/// This function is similar to `zlob()` but operates relative to the specified
/// `base_path` instead of the current working directory.
///
/// # Arguments
///
/// * `base_path` - Absolute path to the base directory (must start with '/')
/// * `pattern` - The glob pattern to match (relative to base_path)
/// * `flags` - Flags controlling the matching behavior
///
/// # Returns
///
/// * `Ok(Some(Zlob))` - Matches were found
/// * `Ok(None)` - No matches found (pattern is valid but no files match)
/// * `Err(ZlobError::Aborted)` - base_path is not an absolute path, or another error occurred
/// * `Err(ZlobError::NoSpace)` - Out of memory
///
/// # Example
///
/// ```no_run
/// use zlob::{zlob_at, ZlobFlags};
///
/// // Find all Rust files in /home/user/project
/// if let Some(result) = zlob_at("/home/user/project", "**/*.rs", ZlobFlags::RECOMMENDED)? {
///     for path in &result {
///         println!("{}", path);  // Paths are relative to /home/user/project
///     }
/// }
/// # Ok::<(), zlob::ZlobError>(())
/// ```
pub fn zlob_at(
    base_path: &str,
    pattern: &str,
    flags: ZlobFlags,
) -> Result<Option<Zlob>, ZlobError> {
    let base_path_c = CString::new(base_path).map_err(|_| ZlobError::Aborted)?;
    let pattern_c = CString::new(pattern).map_err(|_| ZlobError::Aborted)?;
    let mut inner = ffi::zlob_t::default();

    let result = unsafe {
        ffi::zlob_at(
            base_path_c.as_ptr(),
            pattern_c.as_ptr(),
            flags.bits(),
            None,
            &mut inner,
        )
    };

    match ZlobError::from_code(result) {
        Ok(true) => Ok(Some(Zlob { inner })),
        Ok(false) => Ok(None), // No matches
        Err(err) => Err(err),
    }
}

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

    #[test]
    fn test_zlob_basic() {
        // this relies on the cwd being rust/ folder itself
        let result = zlob("Cargo.toml", ZlobFlags::empty());
        assert!(result.is_ok());
        let result = result.unwrap();
        assert!(result.is_some());
        let result = result.unwrap();
        assert_eq!(result.len(), 1);
        assert_eq!(&result[0], "Cargo.toml");
    }

    #[test]
    fn test_zlob_no_match() {
        let result = zlob("nonexistent_file_12345.xyz", ZlobFlags::empty());
        assert!(result.is_ok());
        assert!(result.unwrap().is_none());
    }

    #[test]
    fn test_zlob_iterator() {
        let result = zlob("*.toml", ZlobFlags::empty()).unwrap().unwrap();
        let paths: Vec<&str> = result.iter().collect();
        assert!(paths.contains(&"Cargo.toml"));
    }

    #[test]
    fn test_zlob_double_ended_iterator() {
        let result = zlob("*.toml", ZlobFlags::empty()).unwrap().unwrap();
        let mut iter = result.iter();
        let first = iter.next();
        let last = iter.next_back();

        assert!(first.is_some());
        assert!(last.is_none()); // only single toml file

        let result = zlob("src/*.rs", ZlobFlags::empty()).unwrap().unwrap();
        let mut iter = result.iter();

        let first = iter.next().unwrap();
        let last = iter.next_back().unwrap();

        assert_ne!(first, last);
    }

    #[test]
    fn test_zlob_exact_size_iterator() {
        let result = zlob("*.toml", ZlobFlags::empty()).unwrap().unwrap();
        let iter = result.iter();
        assert_eq!(iter.len(), 1);
        assert_eq!(result.len(), 1);
    }

    #[test]
    fn test_zlob_brace_expansion() {
        // both individual and brace combination work correctly
        let result = zlob("*.toml", ZlobFlags::empty()).unwrap().unwrap();
        assert!(result.len() >= 1);

        let result = zlob("*.lock", ZlobFlags::empty()).unwrap().unwrap();
        assert!(result.len() >= 1);

        let result = zlob("*.{toml,lock}", ZlobFlags::empty()).unwrap();
        assert!(result.is_none());

        let result = zlob("*.{toml,lock}", ZlobFlags::BRACE).unwrap().unwrap();
        assert!(matches!(result.len(), 2));
    }

    #[test]
    fn test_recursive_globbing() {
        // based on the rust/ folder contents
        // Need DOUBLESTAR_RECURSIVE for ** to work recursively
        let result = zlob(
            "**/*.{rs,toml}",
            ZlobFlags::BRACE | ZlobFlags::DOUBLESTAR_RECURSIVE,
        )
        .unwrap()
        .unwrap();

        for path in &result {
            println!("{}", path);
        }

        // At least 8 files: Cargo.toml, build.rs, src/*.rs (5 files), Cargo.lock
        // May be more if examples exist
        assert!(result.len() >= 8);
    }

    #[test]
    fn test_extglob_filesystem_negation() {
        use std::fs::File;
        use tempfile::tempdir;

        // Create temp directory with test files
        let dir = tempdir().unwrap();
        let dir_path = dir.path();

        // Create test files: app.js, app.ts, app.css, app.html
        File::create(dir_path.join("app.js")).unwrap();
        File::create(dir_path.join("app.ts")).unwrap();
        File::create(dir_path.join("app.css")).unwrap();
        File::create(dir_path.join("app.html")).unwrap();

        // Test !(js|ts) - should match app.css and app.html but NOT app.js or app.ts
        let pattern = dir_path.join("app.!(js|ts)");
        let pattern_str = pattern.to_str().unwrap();

        let result = zlob(pattern_str, ZlobFlags::EXTGLOB).unwrap().unwrap();

        assert_eq!(result.len(), 2);
        let paths: Vec<&str> = result.iter().collect();

        // Should contain css and html
        assert!(paths.iter().any(|p| p.ends_with("app.css")));
        assert!(paths.iter().any(|p| p.ends_with("app.html")));

        // Should NOT contain js or ts
        assert!(!paths.iter().any(|p| p.ends_with("app.js")));
        assert!(!paths.iter().any(|p| p.ends_with("app.ts")));
    }

    #[test]
    fn test_extglob_filesystem_exactly_one() {
        use std::fs::File;
        use tempfile::tempdir;

        // Create temp directory with test files
        let dir = tempdir().unwrap();
        let dir_path = dir.path();

        // Create test files: foo.txt, bar.txt, baz.txt, qux.txt
        File::create(dir_path.join("foo.txt")).unwrap();
        File::create(dir_path.join("bar.txt")).unwrap();
        File::create(dir_path.join("baz.txt")).unwrap();
        File::create(dir_path.join("qux.txt")).unwrap();

        // Test @(foo|bar).txt - should match exactly foo.txt and bar.txt
        let pattern = dir_path.join("@(foo|bar).txt");
        let pattern_str = pattern.to_str().unwrap();

        let result = zlob(pattern_str, ZlobFlags::EXTGLOB).unwrap().unwrap();

        assert_eq!(result.len(), 2);
        let paths: Vec<&str> = result.iter().collect();

        // Should contain foo.txt and bar.txt
        assert!(paths.iter().any(|p| p.ends_with("foo.txt")));
        assert!(paths.iter().any(|p| p.ends_with("bar.txt")));

        // Should NOT contain baz.txt or qux.txt
        assert!(!paths.iter().any(|p| p.ends_with("baz.txt")));
        assert!(!paths.iter().any(|p| p.ends_with("qux.txt")));
    }
}