use axum::{
    debug_handler,
    extract::{Path, Query, State},
    response::{IntoResponse, Response},
    Json,
};
use http::StatusCode;
use pasetors::{claims::ClaimsValidationRules, keys::SymmetricKey, version4::V4};
use tracing::{debug, error};

use crate::{
    db::{verify_user, DbPool},
    models::ApiResponse,
    requests::AppState,
    services::auth_token::verify_token,
};

use super::{UserVerifyGetParams, UserVerifyGetResponse};

#[debug_handler]
pub async fn user_verification_get_handler(
    State(state): State<AppState>,
    Path(user_id): Path<i32>,
    Query(query): Query<UserVerifyGetParams>,
) -> Result<Response, Response> {
    let pool = state.pool();
    let env = state.env();

    let UserVerifyGetParams { verification_token } = query;
    let token_key = env.token_key();
    verify_new_user_request(pool, user_id, verification_token, token_key).await
}

async fn verify_new_user_request(
    pool: &DbPool,
    user_id: i32,
    verification_token: String,
    token_key: &SymmetricKey<V4>,
) -> Result<Response, Response> {
    debug!(user_id);

    let validation_rules = {
        let mut rules = ClaimsValidationRules::new();
        rules.validate_audience_with(format!("/user/{user_id}/verify").as_str());

        rules
    };

    let response = verify_token(
        token_key,
        verification_token.as_str(),
        Some(validation_rules),
    )
    .map(|_| UserVerifyGetResponse::new(token_key, user_id))
    .inspect_err(|err| error!(?err))
    .map_err(|err| err.into_response())?;

    verify_user(pool, user_id)
        .await
        .inspect_err(|err| error!(?err))
        .map_err(|err| err.into_response())?;

    Ok((
        StatusCode::OK,
        Json(ApiResponse::<UserVerifyGetResponse>::new(response)),
    )
        .into_response())
}