use rocket;
use rocket::request::Form;
use rocket::response::{Flash, Redirect};
use utils;

#[derive(BartDisplay)]
#[template = "templates/users.html"]
pub struct UsersTemplate {
    users: Vec<::models::User>
}

implement_responder_for!(UsersTemplate);

#[get("/", format = "text/html")]
fn index(flash: Option<rocket::request::FlashMessage>, conn: utils::DbConn) -> utils::Page<UsersTemplate> {
    utils::Page {
        title: String::from("Users"),
        flash: flash.map_or(None, |f| Some(f.msg().to_string())),
        content: UsersTemplate {
            users: ::models::User::all(conn).unwrap()
        }
    }
}

#[derive(BartDisplay)]
#[template = "templates/new_user.html"]
pub struct NewUserTemplate {
    user: ::models::NewUser
}

implement_responder_for!(NewUserTemplate);

#[get("/new", format = "text/html")]
fn new(flash: Option<rocket::request::FlashMessage>) -> utils::Page<NewUserTemplate> {
    utils::Page {
        title: String::from("New user"),
        flash: flash.map_or(None, |f| Some(f.msg().to_string())),
        content: NewUserTemplate {
            user: Default::default()
        }
    }
}

#[derive(FromForm)]
struct RegisterUserForm {
    username: String,
    realname: Option<String>,
    email: Option<String>,
    password: String,
    password_confirm: String
}

impl RegisterUserForm {
    fn new_user(&self) -> Result<::models::NewUser, &'static str> {
        if self.password != self.password_confirm {
            Err("Passwords don't match")
        }
        else {
            Ok(::models::NewUser {
                username: self.username.clone(),
                realname: self.realname.clone(),
                email: self.email.clone(),
                password: self.password.clone()
            })
        }
    }
}

#[post("/create", data="<user>")]
fn create(user: Form<RegisterUserForm>, route: &rocket::Route, conn: utils::DbConn) -> Flash<Redirect> {
    match user.get().new_user() {
        Ok(new_user) => {
            match ::models::User::create(&new_user, conn) {
                Ok(_) => Flash::success(Redirect::to(route.base.path()), "User successfully created!"),
                Err(_) => Flash::error(Redirect::to("/"), "Could not create user!")
            }
        },
        Err(msg) => Flash::error(Redirect::to(&format!("{}/new", route.base.path())), &msg)
    }
}

pub fn routes() -> Vec<rocket::Route> {
    routes![index, new, create]
}