use actix_web::http::header::ContentType;
use actix_web::{web, get, post, HttpResponse, Responder};
use validator::ValidateArgs;
use crate::DbPool;
use crate::request::requests::{Login, Register, RegisterContext};
use crate::request::error::ApiError;
use crate::request::responses::LoginResponse;
use crate::request::authorization::get_token;
use crate::util::GetConnection;
use crate::schema::{self};
use serde_json;

impl From<Login> for schema::user::LoginUser {
    fn from(val: Login) -> Self {
        schema::user::LoginUser {
            username: val.username,
            password: val.password
        }
    }
}

impl From<Register> for schema::user::Register {
    fn from(val: Register) -> Self {
        schema::user::Register {
            email: val.email,
            username: val.username,
            password: val.password
        }
    }
}

#[get("/token")]
pub async fn login(pool: web::Data<DbPool>, login_data: web::Json<Login>) -> Result<impl Responder, ApiError> {
    let data = login_data.into_inner();

    if let Ok(Some(user)) = web::block(move || {
        let mut conn = pool.get_conn();
        schema::login(&mut conn, data.into())
    })
    .await?
    {
        let token = get_token(&user)?;
        let response = LoginResponse::success(user.id, token);
        Ok(HttpResponse::Ok()
            .content_type(ContentType::json())
            .body(serde_json::to_string(&response)?)
        )
    }
    else {
        Err(ApiError{status: 401, message: "User doesn't exist or password doesn't match".to_string()})
    }
}

#[post("/user")]
pub async fn register(pool: web::Data<DbPool>, register_data: web::Json<Register>) -> Result<impl Responder, ApiError> {
    web::block(move || -> Result<(), ApiError> {
        register_data.validate_with_args(&RegisterContext{pool: &pool})?;
        let register_request = register_data.into_inner().into();
        let mut conn = pool.get_conn();
        schema::register(&mut conn, register_request)?;
        Ok(())
    }).await??;

    Ok(HttpResponse::Ok())
}