pub fn filter_substring<'a>(needle: &str, haystack: &Vec<&'a str>) -> Vec<&'a str> {
    return haystack
        .iter()
        .filter(|s| s.contains(needle))
        .cloned()
        .collect();
}

pub fn filter_subsequence<'a>(needle: &str, haystack: &Vec<&'a str>) -> Vec<&'a str> {
    return haystack
        .iter()
        .filter(|s| is_subsequence(needle, s))
        .cloned()
        .collect();
}

fn is_subsequence(needle: &str, string: &str) -> bool {
    // we need to explicitly convert here to iterate over chars
    // (UTF-8, so possibly multiple bytes long)
    let mut chars = string.chars();
    'needle: for nc in needle.chars() {
        for c in &mut chars {
            if c == nc {
                continue 'needle;
            }
        }
        return false;
    }
    true
}

#[cfg(test)]
mod tests {
    use crate::{filter_subsequence, filter_substring};

    #[test]
    fn test_filter_substring_single() {
        let needle = "sdf";
        let hay = vec!["asdf", "qwer"];
        let expected = vec!["asdf"];
        assert_eq!(filter_substring(&needle, &hay), expected);
    }

    #[test]
    fn test_filter_substring_none() {
        let needle = "sdf";
        let hay = vec!["qwertz"];
        let expected: Vec<&str> = Vec::new();
        assert_eq!(filter_substring(&needle, &hay), expected);
    }

    #[test]
    fn test_filter_substring_multiple() {
        let needle = "sdf";
        let hay = vec!["asdf", "asd", "sdfg", "dfgh"];
        let expected = vec!["asdf", "sdfg"];
        assert_eq!(filter_substring(&needle, &hay), expected);
    }

    #[test]
    fn test_filter_subsequence_single() {
        let needle = "asa";
        let hay = vec!["aaass", "aasda"];
        let expected = vec!["aasda"];
        assert_eq!(filter_subsequence(&needle, &hay), expected);
    }

    #[test]
    fn test_filter_subsequence_none() {
        let needle = "asa";
        let hay = vec!["aas"];
        let expected: Vec<&str> = Vec::new();
        assert_eq!(filter_subsequence(&needle, &hay), expected);
    }

    #[test]
    fn test_filter_subsequence_multiple() {
        let needle = "asa";
        let hay = vec!["asa", "assa", "qwerafwfsferfssaas"];
        assert_eq!(filter_subsequence(&needle, &hay), hay);
    }
}