use rocket_sync_db_pools::database;
use serde::{Serialize, Deserialize};
use rocket::{Rocket, Build};
use diesel::RunQueryDsl;


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

table! {
    gamenight (id) {
        id -> Integer,
        game -> Text,
        datetime -> Text,
    }
}

table! {
    known_games (game) {
        id -> Integer,
        game -> Text,
    }
}

allow_tables_to_appear_in_same_query!(
    gamenight,
    known_games,
);

pub async fn get_all_gamenights(conn: DbConn) -> Vec::<GameNight> {
    conn.run(|c| {
        gamenight::table.load::<GameNight>(c).unwrap()
    }).await
}

pub async fn insert_gamenight(conn: DbConn, new_gamenight: GameNightNoId) -> () {
    conn.run(|c| {
        diesel::insert_into(gamenight::table)
            .values(new_gamenight)
            .execute(c)
            .unwrap()
    }).await;
}

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
}

#[derive(Serialize, Deserialize, Debug, FromForm, Insertable)]
#[table_name="known_games"]
pub struct GameNoId {
    pub game : String,
}

#[derive(Serialize, Deserialize, Debug, FromForm, Queryable)]
pub struct Game {
    pub id: i32,
    pub game : String,
}

#[derive(Serialize, Deserialize, Debug, FromForm, Insertable)]
#[table_name="gamenight"]
pub struct GameNightNoId {
    pub game : String,
    pub datetime : String, 
}

#[derive(Serialize, Deserialize, Debug, FromForm, Queryable)]
pub struct GameNight {
    pub id: i32,
    pub game : String,
    pub datetime : String, 
}