use actix_web::http::header::ContentType;
use actix_web::{get, post, web, HttpResponse, Responder};
use serde::Deserialize;
use uuid::Uuid;
use validator::ValidateArgs;
use crate::models::user::User;
use crate::request::requests::{Login, Register, RegisterContext};
use crate::request::error::ApiError;
use crate::request::responses::LoginResponse;
use crate::request::authorization::get_token;
use serde_json;
use gamenight_database::{DbPool, GetConnection};

use super::authorization::AuthUser;

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

impl From<Register> for gamenight_database::user::Register {
    fn from(val: Register) -> Self {
        gamenight_database::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();
        gamenight_database::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();
        gamenight_database::register(&mut conn, register_request)?;
        Ok(())
    }).await??;

    Ok(HttpResponse::Ok())
}

#[derive(Deserialize)]
struct UserInfo {
    pub uuid: String
}

impl From<gamenight_database::user::User> for User {
    fn from(value: gamenight_database::user::User) -> Self {
        Self {
            id: Some(value.id.to_string()),
            username: value.username,
            email: None,

        }
    }
}

#[get("/user/{user_id}")]
pub async fn get_user(pool: web::Data<DbPool>, _user: AuthUser, path: web::Path<UserInfo>) -> Result<impl Responder, ApiError> {
    let mut conn = pool.get_conn();
    
    let user = gamenight_database::user::get_user(&mut conn, Uuid::parse_str(&path.uuid)?)?;
    Ok(HttpResponse::Ok()
            .content_type(ContentType::json())
            .body(serde_json::to_string(&user)?))
}

#[get("/user/{user_id}")]
pub async fn get_user_unauthenticated(_path: web::Path<UserInfo>) -> Result<impl Responder, ApiError> {
    Ok(HttpResponse::Forbidden())
}