use crate::database::establish_connection;
use crate::diesel;
use crate::error::AppError;
use crate::json_serialization::new_user::NewUserSchema;
use crate::models::user::new_user::{validate_password, NewUser};
use crate::schema::users;
use actix_web::{web, HttpResponse};
use diesel::prelude::*;

pub async fn create(new_user: web::Json<NewUserSchema>) -> Result<HttpResponse, AppError> {
    let mut connection = establish_connection();
    let name: String = new_user.name.clone();
    let email: String = new_user.email.clone();
    let new_password: String = new_user.password.clone();

    if let Err(message) = validate_password(&new_password) {
        return Ok(HttpResponse::BadRequest().body(message));
    }

    let new_user = NewUser::new(name, email, new_password)?;

    let insert_result = diesel::insert_into(users::table)
        .values(&new_user)
        .execute(&mut connection);

    Ok(match insert_result {
        Ok(_) => HttpResponse::Created().finish(),
        Err(_) => HttpResponse::Conflict().finish(),
    })
}

#[cfg(test)]
mod tests {
    use actix_web::http::StatusCode;
    use actix_web::{test, web, App};
    use diesel::prelude::*;

    use super::create;
    use crate::database::establish_connection;
    use crate::schema::users;
    use crate::test_helpers::{delete_user, insert_user, unique_suffix};

    #[actix_web::test]
    async fn create_succeeds_for_new_user() {
        let suffix = unique_suffix();
        let username = format!("new_user_{suffix}");
        let email = format!("new_{suffix}@example.test");

        let app = test::init_service(App::new().route("/create", web::post().to(create))).await;
        let req = test::TestRequest::post()
            .uri("/create")
            .set_json(serde_json::json!({
                "name": username,
                "email": email,
                "password": "secret"
            }))
            .to_request();
        let resp = test::call_service(&app, req).await;

        assert_eq!(StatusCode::CREATED, resp.status());

        let mut connection = establish_connection();
        diesel::delete(users::table.filter(users::username.eq(&username)))
            .execute(&mut connection)
            .ok();
    }

    #[actix_web::test]
    async fn create_fails_for_short_password() {
        let suffix = unique_suffix();

        let app = test::init_service(App::new().route("/create", web::post().to(create))).await;
        let req = test::TestRequest::post()
            .uri("/create")
            .set_json(serde_json::json!({
                "name": format!("short_pw_{suffix}"),
                "email": format!("short_{suffix}@example.test"),
                "password": "abc"
            }))
            .to_request();
        let resp = test::call_service(&app, req).await;

        assert_eq!(StatusCode::BAD_REQUEST, resp.status());
    }

    #[actix_web::test]
    async fn create_fails_for_duplicate_user() {
        let mut connection = establish_connection();
        let user = insert_user(&mut connection, "secret");

        let app = test::init_service(App::new().route("/create", web::post().to(create))).await;
        let req = test::TestRequest::post()
            .uri("/create")
            .set_json(serde_json::json!({
                "name": user.username,
                "email": user.email,
                "password": "secret"
            }))
            .to_request();
        let resp = test::call_service(&app, req).await;

        assert_eq!(StatusCode::CONFLICT, resp.status());

        delete_user(&mut connection, user.id);
    }
}