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

/// Electrical consumption fetcher backend
#[derive(Subcommand, Debug, Clone)]
pub enum ConsumptionBackend {
    /// Constant consumption value
    Constant {
        #[clap(long, default_value_t = 500)]
        value: i32,
    },

    /// Generate random consumption value
    Random {
        #[clap(long, default_value_t = -5000)]
        min: i32,
        #[clap(long, default_value_t = 20000)]
        max: i32,
    },
}

/// 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")]
    pub 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")]
    pub 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")]
    pub hostname: String,

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

    /// Consumption backend provider
    #[clap(subcommand)]
    pub consumption_backend: Option<ConsumptionBackend>,
}

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")
    }

    /// Get PKI server cert path
    pub fn server_cert_path(&self) -> PathBuf {
        self.pki_path().join("server.pem")
    }

    /// Get PKI server private key path
    pub fn server_priv_key_path(&self) -> PathBuf {
        self.pki_path().join("server.key")
    }
}

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

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