use std::sync::Arc;

use tracing::{error, info};

use crate::{config::settings::Settings, db, service};

pub async fn gen_agent_certs(
    settings: &Settings,
    output: String,
    agent_id: String,
    zip: bool,
) -> Result<(), Box<dyn std::error::Error>> {
    info!("Generating certificates to output directory: {}", output);
    use service::certificate::CertificateService;
    //
    let cert_service = service::certificate::CertificateServiceImpl::new(
        #[expect(clippy::expect_used)]
        db::establish_connection(&settings.database.url)
            .await
            .expect("Failed to connect to database"),
        output.clone(),
        Arc::new(settings.clone()),
    );

    let output = cert_service
        .generate_agent_certs(&agent_id, &output)
        .await
        .map_err(|e| {
            error!("Failed to generate agent certificates: {}", e);
            std::process::exit(1);
        })
        .unwrap();

    info!(
        "Successfully generated agent certificates at: cert path: {}, key path: {}, ca cert path: {}",
        output.cert_path, output.key_path, output.ca_cert_path
    );
    if zip {
        // Implementation for zipping certificates
        info!("Zipping generated certificates...");
        if let Err(e) = cert_service
            .zip_certificates(&output.cert_path, &output.key_path, &output.ca_cert_path)
            .await
        {
            error!("Failed to zip certificates: {}", e);
            std::process::exit(1);
        }
        info!("Successfully zipped certificates.");
    }

    Ok(())
}