use clap::Parser;
use std::path::{Path, PathBuf};

/// Solar system central backend
#[derive(Parser, Debug)]
#[command(version, about, long_about = None)]
pub struct AppConfig {
    /// The port the server will listen to (using HTTPS)
    #[arg(short, long, env, default_value = "0.0.0.0:8443")]
    listen_address: String,

    /// The port the server will listen to (using HTTP, for unsecure connections)
    #[arg(short, long, env, default_value = "0.0.0.0:8080")]
    unsecure_listen_address: String,

    /// Public server hostname (assuming that the ports used are the same for listen address)
    #[arg(short('H'), long, env, default_value = "localhost")]
    hostname: String,

    /// Server storage path
    #[arg(short, long, env, default_value = "storage")]
    storage: String,
}

lazy_static::lazy_static! {
    static ref ARGS: AppConfig = {
        AppConfig::parse()
    };
}

impl AppConfig {
    /// Get parsed command line arguments
    pub fn get() -> &'static AppConfig {
        &ARGS
    }

    /// URL for unsecure connections
    pub fn unsecure_origin(&self) -> String {
        format!(
            "http://{}:{}",
            self.hostname,
            self.unsecure_listen_address.split_once(':').unwrap().1
        )
    }

    /// URL for secure connections
    pub fn secure_origin(&self) -> String {
        format!(
            "https://{}:{}",
            self.hostname,
            self.listen_address.split_once(':').unwrap().1
        )
    }

    /// Get storage path
    pub fn storage_path(&self) -> PathBuf {
        Path::new(&self.storage).to_path_buf()
    }

    /// Get PKI storage path
    pub fn pki_path(&self) -> PathBuf {
        self.storage_path().join("pki")
    }

    /// Get PKI root CA cert path
    pub fn root_ca_cert_path(&self) -> PathBuf {
        self.pki_path().join("root_ca.pem")
    }

    /// Get PKI root CA CRL path
    pub fn root_ca_crl_path(&self) -> PathBuf {
        self.pki_path().join("root_ca.crl")
    }

    /// Get PKI root CA private key path
    pub fn root_ca_priv_key_path(&self) -> PathBuf {
        self.pki_path().join("root_ca.key")
    }

    /// Get PKI web CA cert path
    pub fn web_ca_cert_path(&self) -> PathBuf {
        self.pki_path().join("web_ca.pem")
    }

    /// Get PKI web CA CRL path
    pub fn web_ca_crl_path(&self) -> PathBuf {
        self.pki_path().join("web_ca.crl")
    }

    /// Get PKI web CA private key path
    pub fn web_ca_priv_key_path(&self) -> PathBuf {
        self.pki_path().join("web_ca.key")
    }

    /// Get PKI devices CA cert path
    pub fn devices_ca_cert_path(&self) -> PathBuf {
        self.pki_path().join("devices_ca.pem")
    }

    /// Get PKI devices CA CRL path
    pub fn devices_ca_crl_path(&self) -> PathBuf {
        self.pki_path().join("devices_ca.crl")
    }

    /// Get PKI devices CA private key path
    pub fn devices_ca_priv_key_path(&self) -> PathBuf {
        self.pki_path().join("devices_ca.key")
    }
}

#[cfg(test)]
mod test {
    use crate::app_config::AppConfig;

    #[test]
    fn verify_cli() {
        use clap::CommandFactory;
        AppConfig::command().debug_assert()
    }
}