use axum::extract::{Json, State};
use axum::http::StatusCode;
use axum::response::IntoResponse;
use regex::Regex;
use serde::{Deserialize, Serialize};

use crate::AppState;
use crate::routes::auth::{AuthUser, hash_password};
use super::errors::RouteError;

#[derive(Deserialize)]
pub(crate) struct CreateUserRequest {
    email: String,
    username: String,
    password: String,
    register_code: String,
}

pub async fn create_user(
    State(state): State<AppState>,
    Json(request): Json<CreateUserRequest>
) -> Result<impl IntoResponse, RouteError> {

    if request.register_code != state.register_code {
        return Err(RouteError::AuthorizationFailure());
    }

    let email_re = Regex::new(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$").unwrap();
    if !email_re.is_match(&request.email) {
        return Err(RouteError::MalformedField("email".into()));
    }

    let username_re = Regex::new(r"^[a-zA-Z0-9_\-]+$").unwrap();
    if !username_re.is_match(&request.username) {
        return Err(RouteError::MalformedField("username".into()));
    }
    
    match state.database.fetch_user_by_email(&request.email) {
        Err(_) => return Err(RouteError::Internal("database action failed".into())),
        Ok(Some(_)) => return Err(RouteError::UserCreateEmailExists(request.email)),
        Ok(None) => {},
    };

    match state.database.fetch_user_by_username(&request.username) {
        Err(_) => return Err(RouteError::Internal("database action failed".into())),
        Ok(Some(_)) => return Err(RouteError::UserCreateUsernameExists(request.username)),
        Ok(None) => {},
    };
    
    let Ok(password_hash) = hash_password(&request.password) else {
        return Err(RouteError::Internal("failed to hash password".into()))
    };

    let Ok(user) = state.database.insert_user(&request.email, &request.username, &password_hash, false) else {
        return Err(RouteError::Internal("failed to create user".into()));
    };

    return Ok((StatusCode::CREATED, Json(user)));
}

#[derive(Serialize)]
struct MeResponse {
    username: String,
}

pub async fn me(
    AuthUser(claims): AuthUser,
) -> Result<impl IntoResponse, RouteError> {
    Ok(Json(MeResponse { username: claims.username }))
}