use diesel::prelude::*;
use diesel::result::DatabaseErrorKind;
use rocket::serde::json::Json;
use rocket::{get, post, Responder};

use crate::databases::UserDataDb;
use crate::models::account::Account;
use crate::schema::accounts::dsl::accounts;

#[get("/account")]
pub async fn get_all_accounts(user_data_db: UserDataDb) -> Json<Vec<Account>> {
    user_data_db
        .run(|connection| {
            Json(
                accounts
                    .select(Account::as_select())
                    .load(connection)
                    .expect("Error getting accounts"),
            )
        })
        .await
}

#[derive(Responder)]
pub enum CreateAccountResponder {
    #[response(status = 500, content_type = "text")]
    InternalServerError(String),

    #[response(status = 202, content_type = "json")]
    Created(Json<Account>),

    #[response(status = 400, content_type = "text")]
    BadRequest(String),
}

#[post("/account", data = "<account>", format = "json")]
pub async fn create_account(
    account: Json<Account>,
    user_data_db: UserDataDb,
) -> CreateAccountResponder {
    let account = account.into_inner();
    let account_clone = account.clone();

    let num_rows_inserted = user_data_db
        .run(|connection| {
            diesel::insert_into(accounts)
                .values(vec![account_clone])
                .execute(connection)
        })
        .await;

    match num_rows_inserted {
        Ok(_) => CreateAccountResponder::Created(Json(account)),
        Err(err) => match err {
            diesel::result::Error::DatabaseError(DatabaseErrorKind::UniqueViolation, info) => {
                let column = info.column_name().unwrap_or("account");
                CreateAccountResponder::BadRequest(format!(
                    "Error creating account: {column} was not unique."
                ))
            }
            _ => CreateAccountResponder::InternalServerError(format!(
                "Error creating account: {err}"
            )),
        },
    }
}