use crate::error::Error;
use crate::models;
use bcrypt;
use diesel::connection::Connection;
use diesel::pg::PgConnection;
use diesel::ExpressionMethods;
use diesel::QueryDsl;
use diesel::RunQueryDsl;

pub const COST: u32 = 10;

pub fn create_config(conn: &PgConnection, config: &models::Config) -> Result<(), Error> {
    use crate::schema::config;

    conn.transaction(|| {
        diesel::delete(config::table).execute(conn)?;

        diesel::insert_into(config::table)
            .values(config)
            .execute(conn)?;
        Ok(())
    })
}

pub fn insert_strava_token(conn: &PgConnection, token: &models::StravaToken) -> Result<(), Error> {
    use crate::schema::strava_tokens;
    conn.transaction(|| {
        diesel::delete(strava_tokens::table)
            .filter(strava_tokens::username.eq(&token.username))
            .execute(conn)?;
        diesel::insert_into(strava_tokens::table)
            .values(token)
            .execute(conn)?;
        Ok(())
    })
}

pub fn get_config(conn: &PgConnection) -> Result<models::Config, Error> {
    use crate::schema::config;
    config::table
        .get_result::<models::Config>(conn)
        .map_err(From::from)
}

pub fn adduser(conn: &PgConnection, username: &str, password: &str) -> Result<(), Error> {
    use crate::schema::users;

    let hashed = bcrypt::hash(password, COST)?;
    let rows = diesel::insert_into(users::table)
        .values(models::NewUser {
            username,
            password: &hashed,
        })
        .execute(conn)?;
    if rows != 1 {
        Err(Error::AlreadyExists)?;
    }
    Ok(())
}

pub fn authenticate(
    conn: &PgConnection,
    username: &str,
    typed_password: &str,
) -> Result<models::User, Error> {
    use crate::schema::users;

    let mut user = users::table
        .filter(users::username.eq(username))
        .get_result::<models::User>(conn)?;

    if bcrypt::verify(typed_password, &user.password)? {
        user.password = "".to_string();
        Ok(user)
    } else {
        Err(Error::NotFound)
    }
}

pub fn get_user(conn: &PgConnection, username: &str) -> Result<models::User, Error> {
    use crate::schema::users;

    let mut user = users::table
        .filter(users::username.eq(username))
        .get_result::<models::User>(conn)?;
    user.password = "".to_string();
    Ok(user)
}

pub fn get_strava_token(conn: &PgConnection, user: &models::User)
                        -> Result<models::StravaToken, Error> {
    use crate::schema::strava_tokens;

    let token = strava_tokens::table
        .filter(strava_tokens::username.eq(&user.username))
        .get_result::<models::StravaToken>(conn)?;
    Ok(token)
}