extern crate serde;
extern crate serde_json;

#[macro_use] extern crate serde_derive;

use serde::Deserialize;
use std::collections::HashMap;

struct Route<P> {
    params: P,
}

impl<P> Route<P> {
    fn new(path_pattern: &str, request_path: &str) -> Route<P> where for<'a> P: Deserialize<'a> {
        let pattern_map: HashMap<String, String> = path_pattern.split('/').zip(
            request_path.split('/')
        ).filter_map(
            |(pattern, path_component)| {
                let is_param = pattern.chars().nth(0)
                    .map(|c| c == ':')
                    .unwrap_or(false);
                if is_param {
                    let param_no_colon: String = pattern.chars().enumerate()
                        .filter_map(|(i, c)| if i == 0 { None } else { Some(c) }).collect();
                    Some((param_no_colon, path_component.to_string()))
                } else {
                    None
                }
            }
        ).collect();

        let params: P = serde_json::from_value(serde_json::to_value(pattern_map).unwrap()).unwrap();

        Route{params: params}
    }
}

#[cfg(test)]
mod tests {
    use super::Route;
    use serde::Deserialize;
    use std::collections::HashMap;

    #[derive(Deserialize, Debug, PartialEq)]
    struct Foo{
        bar: String,
    }

    #[test]
    fn it_works() {
        let route: Route<Foo> = Route::new("/foo/:bar", "/foo/baz");
        let expected_params = Foo{bar: "baz".to_string()};
        assert_eq!(route.params, expected_params);
    }
}