use axum::Json;
use axum::extract::{Path, State};

use api_types::{ProviderConfigRequest, ProviderConfigResponse};
use application::providers::{
    DeleteProviderCommand, GetProviderQuery, ListProvidersQuery, UpsertProviderCommand,
};
use domain::DomainError;

use crate::errors::AppError;
use crate::extractors::AdminUser;
use crate::state::AppState;

pub async fn list_providers(
    State(state): State<AppState>,
    AdminUser(_user): AdminUser,
) -> Result<Json<Vec<ProviderConfigResponse>>, AppError> {
    let providers =
        application::providers::list::execute(&state.provider_deps, ListProvidersQuery).await?;
    Ok(Json(
        providers
            .into_iter()
            .map(ProviderConfigResponse::from)
            .collect(),
    ))
}

pub async fn get_provider(
    State(state): State<AppState>,
    AdminUser(_user): AdminUser,
    Path(id): Path<String>,
) -> Result<Json<ProviderConfigResponse>, AppError> {
    let query = GetProviderQuery { id: id.clone() };
    let provider = application::providers::get::execute(&state.provider_deps, query)
        .await?
        .ok_or_else(|| AppError(DomainError::NotFound(format!("Provider {id} not found"))))?;
    Ok(Json(ProviderConfigResponse::from(provider)))
}

pub async fn upsert_provider(
    State(state): State<AppState>,
    AdminUser(_user): AdminUser,
    Path(id): Path<String>,
    Json(req): Json<ProviderConfigRequest>,
) -> Result<Json<serde_json::Value>, AppError> {
    let config_json = serde_json::to_string(&req.config)
        .map_err(|e| AppError(DomainError::ValidationError(format!("Invalid config JSON: {e}"))))?;

    let cmd = UpsertProviderCommand {
        id,
        provider_type: req.provider_type,
        config_json,
        enabled: req.enabled,
    };
    application::providers::upsert::execute(&state.provider_deps, cmd).await?;
    Ok(Json(serde_json::json!({"status": "ok"})))
}

pub async fn delete_provider(
    State(state): State<AppState>,
    AdminUser(_user): AdminUser,
    Path(id): Path<String>,
) -> Result<axum::http::StatusCode, AppError> {
    let cmd = DeleteProviderCommand { id };
    application::providers::delete::execute(&state.provider_deps, cmd).await?;
    Ok(axum::http::StatusCode::NO_CONTENT)
}