use crate::registry::{services, types::*};
use axum::{
    extract::{Path, State},
    http::StatusCode,
    Json,
};
use sqlx::PgPool;

// ===== EUA Minting Handlers =====

pub async fn log_eua_minting_handler(
    State(pool): State<PgPool>,
    Json(req): Json<LogEuaMintingRequest>,
) -> Result<Json<EuaMintingLog>, (StatusCode, Json<ErrorResponse>)> {
    match services::eua_logs::insert_into_eua_minting_log(&pool, req).await {
        Ok(log) => Ok(Json(log)),
        Err(e) => Err((
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ErrorResponse {
                error: format!("Failed to insert EUA minting log: {}", e),
            }),
        )),
    }
}

pub async fn get_eua_minting_logs_handler(
    State(pool): State<PgPool>,
    Path(company_pubkey): Path<String>,
) -> Result<Json<Vec<EuaMintingLog>>, (StatusCode, Json<ErrorResponse>)> {
    match services::eua_logs::select_eua_minting_logs_by_company(&pool, &company_pubkey).await {
        Ok(logs) => Ok(Json(logs)),
        Err(e) => Err((
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ErrorResponse {
                error: format!("Failed to select EUA minting logs: {}", e),
            }),
        )),
    }
}

pub async fn get_eua_minting_log_by_id_handler(
    State(pool): State<PgPool>,
    Path(log_id): Path<i32>,
) -> Result<Json<EuaMintingLog>, (StatusCode, Json<ErrorResponse>)> {
    match services::eua_logs::select_eua_minting_log_by_id(&pool, log_id).await {
        Ok(log) => Ok(Json(log)),
        Err(e) => Err((
            StatusCode::NOT_FOUND,
            Json(ErrorResponse {
                error: format!("Failed to select EUA minting log: {}", e),
            }),
        )),
    }
}

pub async fn get_all_eua_minting_logs_handler(
    State(pool): State<PgPool>,
) -> Result<Json<Vec<EuaMintingLog>>, (StatusCode, Json<ErrorResponse>)> {
    match services::eua_logs::select_all_eua_minting_logs(&pool).await {
        Ok(logs) => Ok(Json(logs)),
        Err(e) => Err((
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ErrorResponse {
                error: format!("Failed to select all EUA minting logs: {}", e),
            }),
        )),
    }
}

// ===== EUA Transfer Handlers =====

pub async fn log_eua_transfer_handler(
    State(pool): State<PgPool>,
    Json(req): Json<LogEuaTransferRequest>,
) -> Result<Json<EuaTransferLog>, (StatusCode, Json<ErrorResponse>)> {
    match services::eua_logs::insert_into_eua_transfer_log(&pool, req).await {
        Ok(log) => Ok(Json(log)),
        Err(e) => Err((
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ErrorResponse {
                error: format!("Failed to insert EUA transfer log: {}", e),
            }),
        )),
    }
}

pub async fn get_eua_transfer_logs_handler(
    State(pool): State<PgPool>,
    Path(company_pubkey): Path<String>,
) -> Result<Json<Vec<EuaTransferLog>>, (StatusCode, Json<ErrorResponse>)> {
    match services::eua_logs::select_eua_transfer_logs_by_company(&pool, &company_pubkey).await {
        Ok(logs) => Ok(Json(logs)),
        Err(e) => Err((
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ErrorResponse {
                error: format!("Failed to select EUA transfer logs: {}", e),
            }),
        )),
    }
}

pub async fn get_eua_transfer_logs_sent_handler(
    State(pool): State<PgPool>,
    Path(company_pubkey): Path<String>,
) -> Result<Json<Vec<EuaTransferLog>>, (StatusCode, Json<ErrorResponse>)> {
    match services::eua_logs::select_eua_transfer_logs_sent_by_company(&pool, &company_pubkey).await
    {
        Ok(logs) => Ok(Json(logs)),
        Err(e) => Err((
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ErrorResponse {
                error: format!("Failed to select sent EUA transfer logs: {}", e),
            }),
        )),
    }
}

pub async fn get_eua_transfer_logs_received_handler(
    State(pool): State<PgPool>,
    Path(company_pubkey): Path<String>,
) -> Result<Json<Vec<EuaTransferLog>>, (StatusCode, Json<ErrorResponse>)> {
    match services::eua_logs::select_eua_transfer_logs_received_by_company(&pool, &company_pubkey)
        .await
    {
        Ok(logs) => Ok(Json(logs)),
        Err(e) => Err((
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ErrorResponse {
                error: format!("Failed to select received EUA transfer logs: {}", e),
            }),
        )),
    }
}

pub async fn get_eua_transfer_log_by_id_handler(
    State(pool): State<PgPool>,
    Path(log_id): Path<i32>,
) -> Result<Json<EuaTransferLog>, (StatusCode, Json<ErrorResponse>)> {
    match services::eua_logs::select_eua_transfer_log_by_id(&pool, log_id).await {
        Ok(log) => Ok(Json(log)),
        Err(e) => Err((
            StatusCode::NOT_FOUND,
            Json(ErrorResponse {
                error: format!("Failed to select EUA transfer log: {}", e),
            }),
        )),
    }
}

pub async fn get_all_eua_transfer_logs_handler(
    State(pool): State<PgPool>,
) -> Result<Json<Vec<EuaTransferLog>>, (StatusCode, Json<ErrorResponse>)> {
    match services::eua_logs::select_all_eua_transfer_logs(&pool).await {
        Ok(logs) => Ok(Json(logs)),
        Err(e) => Err((
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ErrorResponse {
                error: format!("Failed to select all EUA transfer logs: {}", e),
            }),
        )),
    }
}