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

//! # Glob

use std::{
    borrow::Cow,
    fmt,
};

const ANY: char = '*';
const ONE_CHAR: char = '?';

/// # Parts of a `&str`
#[derive(Debug, Eq, PartialEq, Hash)]
enum Part<'a> {

    /// # A string
    Str(Cow<'a, str>),

    /// # Any (`*`)
    Any,

    /// # One character (`?`)
    OneChar,
}

macro_rules! str_to_cow {
    // Do NOT remove the casting -- we're using some dangerous tool in a safe language
    ($s: expr) => { Cow::from($s as &str) }
}

macro_rules! clone_str_to_cow {
    // Do NOT remove the casting -- we're using some dangerous tool in a safe language
    ($s: expr) => { Cow::from(String::from($s as &str)) }
}

macro_rules! parse_parts {
    ($s: ident, $str_handler: ident) => {{
        let mut result = vec![];
        loop {
            match $s.find(|c| match c { self::ANY | self::ONE_CHAR => true, _ => false }) {
                Some(i) => {
                    if i > 0 {
                        result.push(Part::Str($str_handler!(&$s[..i])));
                    }
                    match $s.as_bytes()[i] as char {
                        self::ANY => if result.last() != Some(&Part::Any) {
                            result.push(Part::Any);
                        },
                        self::ONE_CHAR => result.push(Part::OneChar),
                        _ => {},
                    };
                    if i + 1 == $s.len() {
                        break;
                    }
                    $s = &$s[i + 1..];
                },
                None => {
                    if $s.is_empty() == false {
                        result.push(Part::Str($str_handler!($s)));
                    }
                    break;
                },
            };
        }

        result
    }}
}

impl<'a> Part<'a> {

    /// # Parses a `&str`
    fn parse_str(mut s: &'a str) -> Vec<Self> {
        parse_parts!(s, str_to_cow)
    }

    /// # Parses a [`String`][r://String]
    ///
    /// [r://String]: https://doc.rust-lang.org/std/string/struct.String.html
    fn parse_string(s: String) -> Vec<Self> {
        let mut s = s.as_str();
        parse_parts!(s, clone_str_to_cow)
    }

}

/// # Glob
///
/// This struct is used to find matches from a pattern string against some string.
///
/// The pattern string supports 2 special characters: `*` and `?`:
///
/// - `*`: matches any characters or nothing at all.
/// - `?`: matches one single character.
///
/// ## Notes
///
/// - The idea is inspired by <https://en.wikipedia.org/wiki/Glob_%28programming%29>, but this is _not_ an implementation of that specification.
/// - Matches are _case sensitive_. If you want to ignore case, consider using [`to_lowercase()`][r://String/to_lowercase()] (or
///   [`to_uppercase()`][r://String/to_uppercase()]) on _both_ pattern and target string.
/// - [`Display`][r://Display] implementation prints _parsed_ pattern, not the original one.
/// - Converting from a `&str` always means borrowing its content. However converting from a [`String`][r://String] will _clone_ its content.
///
/// ## Examples
///
/// ```
/// use sub_strs::Glob;
///
/// let g = Glob::from("*r?st.rs");
/// for s in &["rust.rs", "rEst.rs", "it's rust.rs"] {
///     assert!(g.matches(s));
/// }
/// for s in &["it's not Rust", "rest", "rust!.rs"] {
///     assert!(g.matches(s) == false);
/// }
/// ```
///
/// [r://String]: https://doc.rust-lang.org/std/string/struct.String.html
/// [r://String/to_lowercase()]: https://doc.rust-lang.org/std/string/struct.String.html#method.to_lowercase
/// [r://String/to_uppercase()]: https://doc.rust-lang.org/std/string/struct.String.html#method.to_uppercase
/// [r://Display]: https://doc.rust-lang.org/std/fmt/trait.Display.html
#[derive(Debug, Eq, PartialEq, Hash)]
pub struct Glob<'a> {

    /// # Parts
    parts: Vec<Part<'a>>,

}

impl<'a> Glob<'a> {

    /// # Checks if this glob matches a string
    pub fn matches<S>(&self, s: S) -> bool where S: AsRef<str> {
        let mut s = s.as_ref();

        if self.parts.is_empty() {
            return s.is_empty();
        }

        let mut parts = self.parts.iter().peekable();
        let mut must_start_with = true;
        loop {
            match parts.next() {
                Some(Part::Any) => {
                    let mut min_target_chars: usize = 0;
                    loop {
                        match parts.peek() {
                            Some(Part::Any) => drop(parts.next()),
                            Some(Part::OneChar) => {
                                parts.next();
                                min_target_chars += 1;
                            },
                            Some(Part::Str(_)) => {
                                let mut i = 0;
                                let mut chars = s.chars();
                                for _ in 0..min_target_chars {
                                    match chars.next() {
                                        Some(c) => i += c.len_utf8(),
                                        None => return false,
                                    };
                                }
                                s = &s[i..];
                                break;
                            },
                            None => return s.chars().count() >= min_target_chars,
                        };
                    }
                    must_start_with = false;
                },
                Some(Part::OneChar) => match s.chars().next() {
                    Some(c) => {
                        s = &s[c.len_utf8()..];
                        must_start_with = true;
                    },
                    None => return false,
                },
                Some(Part::Str(sub)) => match s.find(sub.as_ref()) {
                    Some(i) if i == 0 || must_start_with == false => {
                        s = &s[i + sub.len()..];
                        must_start_with = true;
                    },
                    _ => return false,
                },
                None => return s.is_empty(),
            };
        }
    }

}

/// # Converts from a `&str` to [`Glob`][::Glob]
///
/// [::Glob]: struct.Glob.html
impl<'a> From<&'a str> for Glob<'a> {

    fn from(src: &'a str) -> Self {
        Self {
            parts: Part::parse_str(src),
        }
    }

}

/// # Converts from a [`&String`][r://String] to [`Glob`][::Glob]
///
/// [::Glob]: struct.Glob.html
/// [r://String]: https://doc.rust-lang.org/std/string/struct.String.html
impl<'a> From<&'a String> for Glob<'a> {

    fn from(src: &'a String) -> Self {
        Self::from(src.as_str())
    }

}

/// # Converts from a [`String`][r://String] to [`Glob`][::Glob]
///
/// [::Glob]: struct.Glob.html
/// [r://String]: https://doc.rust-lang.org/std/string/struct.String.html
impl From<String> for Glob<'_> {

    fn from(src: String) -> Self {
        Self {
            parts: Part::parse_string(src),
        }
    }

}

impl fmt::Display for Glob<'_> {

    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
        use fmt::Write;

        for p in self.parts.iter() {
            match p {
                Part::Str(s) => f.write_str(s)?,
                Part::Any => f.write_char(ANY)?,
                Part::OneChar => f.write_char(ONE_CHAR)?,
            };
        }

        Ok(())
    }

}