pub mod admin;
pub mod gamenight;
pub mod users;

use rocket::{Build, Rocket};
use rocket_sync_db_pools::database;
use std::ops::Deref;

#[database("gamenight_database")]
pub struct DbConn(diesel::PgConnection);

impl Deref for DbConn {
    type Target = rocket_sync_db_pools::Connection<DbConn, diesel::PgConnection>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

pub enum DatabaseError {
    Hash(password_hash::Error),
    Query(String),
}

pub async fn run_migrations(rocket: Rocket<Build>) -> Rocket<Build> {
    // This macro from `diesel_migrations` defines an `embedded_migrations`
    // module containing a function named `run`. This allows the example to be
    // run and tested without any outside setup of the database.
    embed_migrations!();

    let conn = DbConn::get_one(&rocket).await.expect("database connection");
    conn.run(|c| embedded_migrations::run(c))
        .await
        .expect("can run migrations");

    rocket
}

impl From<diesel::result::Error> for DatabaseError {
    fn from(error: diesel::result::Error) -> Self {
        Self::Query(error.to_string())
    }
}

impl From<password_hash::Error> for DatabaseError {
    fn from(error: password_hash::Error) -> Self {
        Self::Hash(error)
    }
}

impl std::fmt::Display for DatabaseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        match self {
            DatabaseError::Hash(err) => write!(f, "{}", err),
            DatabaseError::Query(err) => write!(f, "{}", err),
        }
    }
}