#![feature(plugin, decl_macro)]
#![plugin(rocket_codegen)]

extern crate rocket_contrib;
extern crate rocket;
#[macro_use] extern crate serde_derive;

#[cfg(test)] mod tests;

use rocket::Request;
use rocket::response::Redirect;
use rocket_contrib::Template;
use rocket_contrib::handlebars::{Helper, Handlebars, RenderContext, RenderError, JsonRender};

#[derive(Serialize)]
struct TemplateContext {
    name: String,
    items: Vec<String>
}

#[get("/")]
fn index() -> Redirect {
    Redirect::to("/hello/Unknown")
}

#[get("/hello/<name>")]
fn get(name: String) -> Template {
    let context = TemplateContext {
        name: name,
        items: vec!["One", "Two", "Three"].iter().map(|s| s.to_string()).collect()
    };

    Template::render("index", &context)
}

#[catch(404)]
fn not_found(req: &Request) -> Template {
    let mut map = std::collections::HashMap::new();
    map.insert("path", req.uri().as_str());
    Template::render("error/404", &map)
}

fn rocket() -> rocket::Rocket {
    rocket::ignite()
        .mount("/", routes![index, get])
        .attach(Template::custom(|engines| {
            engines.handlebars.register_helper(
                "echo", Box::new(|h: &Helper,
                                  _: &Handlebars,
                                  rc: &mut RenderContext| -> Result<(), RenderError> {
                                      if let Some(p0) = h.param(0) {
                                          rc.writer.write(p0.value()
                                                          .render()
                                                          .into_bytes()
                                                          .as_ref())?;
                                      }
                                      Ok(())
                                  }));

        }))
        .catch(catchers![not_found])
}

fn main() {
    rocket().launch();
}