//! Match strings against a simple wildcard pattern.

//! Tests a wildcard pattern `p` against an input string `s`. Returns true only when `p` matches the entirety of `s`.

//!

//! See also the example described on [wikipedia](https://en.wikipedia.org/wiki/Matching_wildcards) for matching wildcards.

//!

//! No escape characters are defined.

//!

//! - `?` matches exactly one occurrence of any character.

//! - `*` matches arbitrary many (including zero) occurrences of any character.

//!

//! Examples matching wildcards:

//! ``` rust

//! # extern crate wildmatch; use wildmatch::WildMatch;

//! assert!(WildMatch::new("cat").is_match("cat"));

//! assert!(WildMatch::new("*cat*").is_match("dog_cat_dog"));

//! assert!(WildMatch::new("c?t").is_match("cat"));

//! assert!(WildMatch::new("c?t").is_match("cot"));

//! ```

//! Examples not matching wildcards:

//! ``` rust

//! # extern crate wildmatch; use wildmatch::WildMatch;

//! assert!(!WildMatch::new("dog").is_match("cat"));

//! assert!(!WildMatch::new("*d").is_match("cat"));

//! assert!(!WildMatch::new("????").is_match("cat"));

//! assert!(!WildMatch::new("?").is_match("cat"));

//! ```


/// Wildcard matcher used to match strings.

#[derive(Debug, Clone)]
pub struct WildMatch {
    pattern: Vec<State>,
}

#[derive(Debug, Clone)]
struct State {
    next_char: Option<char>,
    in_char: Option<char>,
    has_wildcard: bool,
}

impl ToString for WildMatch {
    fn to_string(&self) -> String {
        return self.pattern.iter().filter_map(|f| f.next_char).collect();
    }
}

impl WildMatch {
    /// Constructor with pattern which can be used for matching.

    pub fn new(pattern: &str) -> WildMatch {
        let mut simplified: Vec<State> = Vec::new();
        let mut prev_was_star = false;
        let mut prev = None;
        for current_char in pattern.chars() {
            match current_char {
                '*' => {
                    prev_was_star = true;
                }
                _ => {
                    let s = State {
                        next_char: Some(current_char),
                        in_char: prev,
                        has_wildcard: prev_was_star,
                    };
                    simplified.push(s);
                    prev_was_star = false;
                }
            }
            prev = Some(current_char);
        }

        if pattern.chars().count() > 0 {
            let final_state = State {
                next_char: None,
                in_char: prev,
                has_wildcard: prev_was_star,
            };
            simplified.push(final_state);
        }

        WildMatch {
            pattern: simplified,
        }
    }

    /// Indicates whether the matcher finds a match in the input string.

    pub fn is_match(&self, input: &str) -> bool {
        let mut pattern_idx = 0;
        for input_char in input.chars() {
            match self.pattern.get(pattern_idx) {
                None => {
                    return false;
                }
                Some(p) if p.next_char == Some('?') => {
                    pattern_idx += 1;
                }
                Some(p) if p.next_char == Some(input_char) => {
                    pattern_idx += 1;
                }
                Some(p) if p.has_wildcard => {
                    if p.next_char == None {
                        return true;
                    }
                }
                Some(p) if p.in_char == Some(input_char) => {}
                _ => {
                    // Go back to last state with wildcard

                    while let Some(pattern) = self.pattern.get(pattern_idx) {
                        if pattern.has_wildcard {
                            break;
                        }
                        if pattern_idx == 0 {
                            return false;
                        };
                        pattern_idx -= 1;
                    }
                }
            }
        }
        return self.pattern.get(pattern_idx).unwrap().next_char.is_none();
    }
}

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

    #[test_case("**")]
    #[test_case("*")]
    #[test_case("*?*")]
    #[test_case("c*")]
    #[test_case("c?*")]
    #[test_case("???")]
    #[test_case("c?t")]
    #[test_case("cat")]
    #[test_case("*cat")]
    #[test_case("cat*")]
    fn is_match(pattern: &str) {
        let m = WildMatch::new(pattern);
        assert!(m.is_match("cat"));
    }

    #[test_case("*d*")]
    #[test_case("*d")]
    #[test_case("d*")]
    #[test_case("*c")]
    #[test_case("?")]
    #[test_case("??")]
    #[test_case("????")]
    #[test_case("?????")]
    #[test_case("*????")]
    #[test_case("cats")]
    #[test_case("cat?")]
    #[test_case("cacat")]
    #[test_case("cat*dog")]
    fn no_match(pattern: &str) {
        let m = WildMatch::new(pattern);
        assert_false!(m.is_match("cat"));
    }

    #[test_case("cat?", "wildcats")]
    #[test_case("cat*", "wildcats")]
    #[test_case("*x*", "wildcats")]
    #[test_case("*a", "wildcats")]
    #[test_case("", "wildcats")]
    #[test_case(" ", "wildcats")]
    #[test_case("???", "wildcats")]
    fn no_match_long(pattern: &str, expected: &str) {
        let m = WildMatch::new(pattern);
        assert_false!(m.is_match(expected))
    }

    #[test_case("*cat*", "d&(*og_cat_dog")]
    #[test_case("*?*", "d&(*og_cat_dog")]
    #[test_case("*a*", "d&(*og_cat_dog")]
    #[test_case("*", "*")]
    #[test_case("*", "?")]
    #[test_case("?", "?")]
    #[test_case("wildcats", "wildcats")]
    #[test_case("wild*cats", "wild?cats")]
    #[test_case("wi*ca*s", "wildcats")]
    #[test_case("wi*ca?s", "wildcats")]
    #[test_case("*o?", "hog_cat_dog")]
    #[test_case("*o?", "cat_dog")]
    #[test_case("*at_dog", "cat_dog")]
    #[test_case(" ", " ")]
    #[test_case("* ", "\n ")]
    #[test_case("\n", "\n", name = "special_chars")]
    #[test_case("*32", "432")]
    #[test_case("*32", "332")]
    #[test_case("33*", "333")]
    fn match_long(pattern: &str, expected: &str) {
        let m = WildMatch::new(pattern);
        assert!(m.is_match(expected))
    }

    #[test]
    fn print_string() {
        let m = WildMatch::new("Foo/Bar");
        assert_eq!("Foo/Bar", m.to_string());
    }

    #[test]
    fn to_string_f() {
        let m = WildMatch::new("F");
        assert_eq!("F", m.to_string());
    }

    #[test]
    fn to_string_empty() {
        let m = WildMatch::new("");
        assert_eq!("", m.to_string());
    }
}