//!
//! Module to handle `pre-boot params` of the monitor (calling also as `settings`)
//!
#[allow(unused_imports)]
use anyhow::{Error, Result};
use dotenv::dotenv;
use log::warn;
use std::env::var;
use std::path::PathBuf;

/// # Enum `MetricsPrebootParams`
/// ## for setting up metrics mode as preboot param from command prompt
///
/// examples:
/// ``` bash
/// noxis-rs ... --metrics full
/// noxis-rs ... --metrics system
/// noxis-rs ... --metrics processes
/// noxis-rs ... --metrics net
/// noxis-rs ... --metrics none
/// ```
///
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub enum MetricsPrebootParams {
    Full,
    System,
    Processes,
    Net,
    None,
}

impl MetricsPrebootParams {
    fn from_env(var: &str) -> Self {
        match var.trim().to_lowercase().as_str() {
            "full" => Self::Full,
            "system" => Self::System,
            "processes" => Self::Processes,
            "net" => Self::Net,
            "none" => Self::None,
            _ => Self::Full,
        }
    }
}

/// # `std::fmt::Display` implementation for `MetricsPrebootParams`
/// ## to enable parsing object to String
impl std::fmt::Display for MetricsPrebootParams {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            MetricsPrebootParams::Full => write!(f, "full"),
            MetricsPrebootParams::System => write!(f, "system"),
            MetricsPrebootParams::Processes => write!(f, "processes"),
            MetricsPrebootParams::Net => write!(f, "net"),
            MetricsPrebootParams::None => write!(f, "none"),
        }
    }
}

/// struct to handle Noxis settings (that were set as `.env` or global env vars)
///
/// to parse and set up all modes as preboot params from `.env` or using `export $VAR $VAL` command  
///
/// # Settings :
///
/// All settings are divided by `actions` and `values`.
/// 1. `Actions` - true or false on var exist check
///  > `Actions` is not about values, it can handle any data
///
/// 2. `Values` - classic string-driven environment variables
///
/// # `Actions` vars
///
/// 1. `NOXIS_NO_HAGENT` - to disable hagent work module and set up work mode as autonomous
///
/// **usage** :
/// ``` toml
/// ...
/// NOXIS_NO_HAGENT = "random-text"
/// ...
/// ```
/// or
/// ``` bash
/// export NOXIS_NO_HAGENT "random-text"
/// ```
///
///
/// 2. `NOXIS_NO_LOGS` - to disable logging at all  
/// **usage** :
/// ``` toml
/// ...
/// NOXIS_NO_LOGS = "random-text"
/// ...
/// ```
/// or
/// ``` bash
/// export NOXIS_NO_LOGS "random-text"
/// ```
///
/// 3. `NOXIS_REFRESH_LOGS` - to truncate logs directory
///
/// ### usage :
/// ``` toml
/// ...
/// NOXIS_REFRESH_LOGS = "random-text"
/// ...
/// ```
/// or
/// ``` bash
/// export NOXIS_REFRESH_LOGS "random-text"
/// ```
///
/// 4. `NOXIS_NO_SUB` - to disable Redis subscribtion mechanism  
///
/// ### usage :
/// ``` toml
/// NOXIS_NO_SUB = "random-text"
/// ```
/// or
/// ``` bash
/// export NOXIS_NO_SUB "random-text"
/// ```
///
/// # `Values` vars
///
/// 1. `NOXIS_HAGENT_SOCKET_PATH` - to set Unix Domain Socket file's directory
///
/// ### usage :
/// ``` toml
/// NOXIS_HAGENT_SOCKET_PATH = "/var/run/example/hostagent.sock"
/// ```
/// or
/// ``` bash
/// export NOXIS_HAGENT_SOCKET_PATH  "/var/run/example/hostagent.sock"
/// ```
///
/// 2 `NOXIS_LOG_TO` - to set directory for logs
///
/// ### usage :
/// ``` toml
/// NOXIS_LOG_TO = "/var/log/noxis/noxis.log"
/// ```
/// or
/// ``` bash
/// export NOXIS_LOG_TO  "/var/log/noxis/noxis.log"
/// ```
///
/// 3. `NOXIS_REMOTE_SERVER_URL` - to set Redis Server
///
/// ### usage :
/// ``` toml
/// NOXIS_REMOTE_SERVER_URL = "ip.ip.ip.ip:port"
/// ```
/// or
/// ``` bash
/// export NOXIS_REMOTE_SERVER_URL  "ip.ip.ip.ip:port"
/// ```
///
/// 4. `NOXIS_CONFIG_PATH` - to set Noxis' config full path
///
///  ### usage :
/// ``` toml
/// NOXIS_CONFIG_PATH = "./settings.json"
/// ```
/// or
/// ``` bash
/// export NOXIS_CONFIG_PATH  "./settings.json"
/// ```
///
/// 5. `NOXIS_METRICS_MODE` - to set metrics mode
///
/// ### usage :
/// ``` toml
/// NOXIS_METRICS_MODE = "full"
/// ```
/// or
/// ``` bash
/// export NOXIS_METRICS_MODE  "full"
/// ```
///
#[derive(Debug, serde::Serialize, serde::Deserialize)]
pub struct PrebootParams {
    // pub no_hostagent : bool,
    pub no_logs: bool,
    pub refresh_logs: bool,
    pub no_sub: bool,
    // pub socket_path : PathBuf,
    pub log_to: PathBuf,
    pub remote_server_url: String,
    pub config: PathBuf,
    pub metrics: MetricsPrebootParams,
    pub self_socket: PathBuf,
}

/// # implementation for `MetricsPrebootParams`
/// ## to enable validation mechanism
impl PrebootParams {
    pub fn validate() -> Self {
        dotenv().ok();
        Self {
            // bool
            // no_hostagent : {
            //     match var("NOXIS_NO_HAGENT") {
            //         Ok(_) => true,
            //         Err(_) => false,
            //     }
            // },
            no_logs: {
                match var("NOXIS_NO_LOGS") {
                    Ok(_) => true,
                    Err(_) => false,
                }
            },
            refresh_logs: {
                match var("NOXIS_REFRESH_LOGS") {
                    Ok(_) => true,
                    Err(_) => false,
                }
            },
            no_sub: {
                match var("NOXIS_NO_SUB") {
                    Ok(_) => true,
                    Err(_) => false,
                }
            },
            // vals
            // socket_path :  {
            //     match var("NOXIS_HAGENT_SOCKET_PATH") {
            //         Ok(val) => PathBuf::from(val),
            //         Err(_) => PathBuf::from("/var/run/enode/hostagent.sock"),
            //     }
            // },
            log_to: {
                match var("NOXIS_LOG_TO") {
                    Ok(val) => PathBuf::from(val),
                    Err(_) => PathBuf::from("./"),
                }
            },
            remote_server_url: {
                match var("NOXIS_REMOTE_SERVER_URL") {
                    Ok(val) => val,
                    Err(_) => String::from("localhost"),
                }
            },
            config: {
                match var("NOXIS_CONFIG_PATH") {
                    Ok(val) => PathBuf::from(val),
                    Err(_) => PathBuf::from("./settings.json"),
                }
            },
            metrics: {
                match var("NOXIS_METRICS_MODE") {
                    Ok(val) => MetricsPrebootParams::from_env(&val),
                    Err(_) => MetricsPrebootParams::Full,
                }
            },
            self_socket: {
                match var("NOXIS_SOCKET_PATH") {
                    Ok(val) => PathBuf::from(val),
                    Err(_) => {
                        let default = std::env::current_dir()
                            .expect("Crushed on getting current_dir path. Check fs state!");
                        warn!(
                            "$NOXIS_SOCKET_PATH wans't set. Default value - {}",
                            default.display()
                        );
                        PathBuf::from(default)
                    }
                }
            },
        }
    }
}

// unit tests of preboot params parsing mech
// #[cfg(test)]
// mod preboot_unitests{
//     use super::*;

//     #[test]
//     fn parsing_zero_args() {
//         assert!(PrebootParams::try_parse_from(vec!["runner-rs"]).is_ok())
//     }
//     #[test]
//     fn parsing_hagent_valid_args() {
//         assert!(PrebootParams::try_parse_from(vec![
//             "runner-rs",
//             "--socket-path", "/path/to/socket"
//         ]).is_ok())
// }
//     #[test]
//     fn parsing_hagent_invalid_args() {
//         assert!(PrebootParams::try_parse_from(vec![
//             "runner-rs",
//             "--socket-path", "/path/to/socket",
//             "--no-hagent"
//         ]).is_err())
//     }
//     #[test]
//     fn parsing_log_valid_args() {
//         assert!(PrebootParams::try_parse_from(vec![
//             "runner-rs",
//             "--log-to", "/path/to/log/dir"
//         ]).is_ok())
//     }
//     #[test]
//     fn parsing_log_invalid_args() {
//         assert!(PrebootParams::try_parse_from(vec![
//             "runner-rs",
//             "--log-to /path/to/log/dir",
//             "--no-logs"
//         ]).is_err())
//     }
//     #[test]
//     fn parsing_config_valid_args() {
//         assert!(PrebootParams::try_parse_from(vec![
//             "runner-rs",
//             "--no-sub",
//             "--remote-server-url", "redis://127.0.0.1"
//         ]).is_err())
//     }
//     // #[test]
//     // fn parsing_config_invalid_args_noremote_nosub() {
//     //     assert!(PrebootParams::try_parse_from(vec![
//     //         "runner-rs",
//     //         "--no-remote-config", "--no-sub"
//     //     ]).is_err())
//     // }
//     #[test]
//     fn parsing_config_invalid_args_noremote_remoteurl() {
//         assert!(PrebootParams::try_parse_from(vec![
//             "runner-rs",
//             "--no-sub",
//             "--remote-server-url", "redis://127.0.0.1"
//         ]).is_err())
//     }
//     #[test]
//     fn parsing_metrics_args_using_value_enum() {
//         assert!(PrebootParams::try_parse_from(vec!["runner-rs", "--metrics", "full"]).is_ok());
//         assert!(PrebootParams::try_parse_from(vec!["runner-rs", "--metrics", "system"]).is_ok());
//         assert!(PrebootParams::try_parse_from(vec!["runner-rs", "--metrics", "processes"]).is_ok());
//         assert!(PrebootParams::try_parse_from(vec!["runner-rs", "--metrics", "net"]).is_ok());
//         assert!(PrebootParams::try_parse_from(vec!["runner-rs", "--metrics", "none"]).is_ok());
//         assert!(PrebootParams::try_parse_from(vec!["runner-rs", "--metrics", "unusual_value"]).is_err());
//     }
// }