use argon2::{self, Config};
use dotenv::{self};
use tide::utils::After;

mod fs;
mod middleware;
mod post;
mod routes;
mod templates;
mod util;

use middleware::*;

#[derive(Clone)]
pub struct State {
    pub login_path: String,
}

pub async fn build_app() -> Result<tide::Server<State>, tide::Error> {
    dotenv::dotenv().ok();

    let login_path = std::env::var("LOGIN_PATH").unwrap_or(String::from("/login"));
    let mut app = tide::with_state(State {
        login_path: login_path.clone(),
    });

    app.with(After(errors));
    app.with(session());

    app.at("/").get(routes::index);
    app.at("/static/:filename").get(routes::static_file);
    app.at("/posts")
        .with(require_auth)
        .post(routes::create_post);
    app.at("/posts/new")
        .with(require_auth)
        .get(routes::new_post);
    app.at("/posts/:slug").get(routes::single_post);
    app.at("/posts/:slug")
        .with(require_auth)
        .post(routes::update_post)
        .delete(routes::delete_post);
    app.at("/posts/:slug/edit")
        .with(require_auth)
        .get(routes::edit_post);
    app.at(&login_path)
        .with(require_guest)
        .get(routes::login_page)
        .post(routes::login);
    app.at("/preview")
        .with(require_auth)
        .post(routes::preview_post);
    app.at("/logout").with(require_auth).post(routes::logout);

    Ok(app)
}

pub fn hash_password(password: &str, username: &str) -> String {
    let password = password.as_bytes();
    let salt = format!("{}{}", &username, &username);
    let salt = salt.as_bytes();
    let config = Config::default();
    argon2::hash_encoded(password, salt, &config).unwrap()
}