use anyhow::{anyhow, Result};

use std::{path::PathBuf, sync::Arc};

use crate::common::AppConfig;
use crate::crypto_provider::ICryptoProvider;
use crate::openssl::internal::OpenSSLInternalProvider;

pub(crate) struct Certs<T>
where
    T: ICryptoProvider,
{
    pub(crate) key_file: PathBuf,
    pub(crate) cert_file: PathBuf,
    pub(crate) provider: Arc<T>,
}

impl<T> Certs<T>
where
    T: ICryptoProvider,
{
    pub(crate) fn new(cfg: &AppConfig, provider: T) -> Self {
        let base_dir = PathBuf::from(&cfg.base_directory);
        let keys_dir = base_dir.clone().join(cfg.keys_subdir.clone());
        let name = cfg.name.clone();

        Certs {
            key_file: keys_dir.join(format!("{}.key", &name)),
            cert_file: keys_dir.join(format!("{}.crt", &name)),
            provider: Arc::new(provider),
        }
    }

    pub(crate) async fn request(&self) -> Result<()> {
        self.provider.request().await
    }

    pub(crate) async fn sign(&self) -> Result<()> {
        self.provider.sign().await
    }
}

pub async fn build_cert(config: &AppConfig) -> Result<()> {
    let certs = Certs::new(config, OpenSSLInternalProvider::from_cfg(config));
    certs.request().await?;
    certs.sign().await?;

    let key_file = certs
        .key_file
        .to_str()
        .ok_or(anyhow!("key_file PathBuf to str convert error"))?;

    let cert_file = certs
        .cert_file
        .to_str()
        .ok_or(anyhow!("req_file PathBuf to str convert error"))?;

    println!("created: \n key: {key_file},\n cert: {cert_file}");
    Ok(())
}