use budgeting_app_core::{
    models::account::Account,
    queries::accounts::{get_all_accounts as get_all_accounts_query, insert_account},
};
use diesel::result::DatabaseErrorKind;
use rocket::http::Status;
use rocket::serde::json::Json;
use rocket::{get, post, Responder};

use crate::databases::UserDataDb;

#[get("/account")]
pub async fn get_all_accounts(user_data_db: UserDataDb) -> Result<Json<Vec<Account>>, (Status, String)> {
    user_data_db
        .run(get_all_accounts_query)
        .await
        .map(Json)
        .map_err(|err| (Status::InternalServerError, err.to_string()))
}

#[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 accounts_vec = vec![account.clone()];

    let num_rows_inserted = user_data_db
        .run(move |connection| insert_account(&accounts_vec, 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}"
            )),
        },
    }
}