use std::error::Error;

use yaml_rust::{Yaml, YamlLoader};

use crate::data::group_id::GroupID;

/// Server configuration
///
/// @author Pierre Hubert
#[derive(Debug)]
pub struct DatabaseConfig {
    pub host: String,
    pub name: String,
    pub username: String,
    pub password: String,
    pub log_all_queries: bool,
}

#[derive(Debug)]
pub struct RtcRelayConfig {
    pub ip: String,
    pub token: String,
    pub ice_servers: Vec<String>,
    pub max_users_per_calls: u64,
    pub allow_video: bool,
    pub max_users_per_video_calls: u64,
}

#[derive(Debug)]
pub struct IndependentPushService {
    pub control_url: String,
    pub control_token: String,
    pub public_url: String,
}

#[derive(Debug)]
pub struct Config {
    pub port: i32,
    pub listen_address: String,
    pub storage_url: String,
    pub storage_path: String,
    pub serve_storage_file: bool,
    pub terms_url: String,
    pub privacy_policy_url: String,
    pub contact_email: String,
    pub password_reset_url: String,
    pub play_store_url: String,
    pub android_direct_download_url: String,
    pub proxy: Option<String>,
    pub verbose_mode: bool,
    pub independent_push_service: Option<IndependentPushService>,
    pub database: DatabaseConfig,
    pub rtc_relay: Option<RtcRelayConfig>,
    pub admin_url: String,
    pub forez_groups: Vec<GroupID>,
}

/// Globally available configuration
static mut CONF: Option<Config> = None;

impl Config {
    fn yaml_i32(parsed: &Yaml, name: &str) -> i32 {
        parsed[name].as_i64().expect(format!("{} is missing (int)", name).as_str()) as i32
    }

    fn yaml_u64(parsed: &Yaml, name: &str) -> u64 {
        parsed[name].as_i64().expect(format!("{} is missing (int)", name).as_str()) as u64
    }

    fn yaml_str(parsed: &Yaml, name: &str) -> String {
        parsed[name].as_str().expect(format!("{} is missing (str)", name).as_str()).to_string()
    }

    fn yaml_bool(parsed: &Yaml, name: &str) -> bool {
        parsed[name].as_bool().expect(format!("{} is missing (bool)", name).as_str())
    }

    /// Load the configuration from a given path
    pub fn load(path: &str) -> Result<(), Box<dyn Error>> {

        // Read & parse configuration
        let conf_str = std::fs::read_to_string(path)?;
        let parsed = YamlLoader::load_from_str(&conf_str)?;

        if parsed.len() != 1 {
            panic!("parsed.len() != 1");
        }
        let parsed = &parsed[0];

        // Read configuration
        let parsed_db = &parsed["database"];
        let database_conf = DatabaseConfig {
            host: Config::yaml_str(parsed_db, "host"),
            name: Config::yaml_str(parsed_db, "name"),
            username: Config::yaml_str(parsed_db, "username"),
            password: Config::yaml_str(parsed_db, "password"),
            log_all_queries: Config::yaml_bool(parsed_db, "log-all-queries"),
        };

        let parsed_rtc = &parsed["rtc-relay"];
        let rtc_config = match parsed_rtc.is_badvalue() {
            true => None,
            false => Some(RtcRelayConfig {
                ip: Config::yaml_str(parsed_rtc, "ip"),
                token: Config::yaml_str(parsed_rtc, "token"),
                ice_servers: parsed_rtc["ice-servers"].as_vec().unwrap().iter().map(|f| f.as_str().unwrap().to_string()).collect(),
                max_users_per_calls: Config::yaml_u64(parsed_rtc, "max-users-per-calls"),
                allow_video: Config::yaml_bool(parsed_rtc, "allow-video"),
                max_users_per_video_calls: Config::yaml_u64(parsed_rtc, "max-users-per-video-calls"),
            })
        };

        let proxy = Config::yaml_str(parsed, "proxy");

        let parsed_independent_push_service = &parsed["independent-push-service"];
        let independent_push_service = match parsed_independent_push_service.is_badvalue() {
            true => None,
            false => Some(IndependentPushService {
                control_url: Config::yaml_str(parsed_independent_push_service, "control-url"),
                control_token: Config::yaml_str(parsed_independent_push_service, "control-token"),
                public_url: Config::yaml_str(parsed_independent_push_service, "public-url"),
            })
        };

        let conf = Config {
            port: Config::yaml_i32(parsed, "server-port") as i32,
            listen_address: Config::yaml_str(parsed, "server-address"),

            storage_url: Config::yaml_str(parsed, "storage-url"),
            storage_path: Config::yaml_str(parsed, "storage-path"),

            serve_storage_file: Config::yaml_bool(parsed, "serve-storage-files"),

            terms_url: Config::yaml_str(parsed, "terms-url"),
            privacy_policy_url: Config::yaml_str(parsed, "privacy-policy-url"),

            contact_email: Config::yaml_str(parsed, "contact-email"),
            password_reset_url: Config::yaml_str(parsed, "password-reset-url"),

            play_store_url: Config::yaml_str(parsed, "play-store-url"),
            android_direct_download_url: Config::yaml_str(parsed, "android-direct-download-url"),

            proxy: match proxy.as_ref() {
                "none" => None,
                s => Some(s.to_string())
            },

            verbose_mode: Config::yaml_bool(parsed, "verbose-mode"),

            independent_push_service,

            database: database_conf,

            rtc_relay: rtc_config,

            admin_url: Self::yaml_str(parsed, "admin-url"),

            forez_groups: parsed["forez_groups"]
                .as_vec()
                .unwrap_or(&vec![])
                .iter()
                .map(|f| GroupID::new(f.as_i64().unwrap() as u64))
                .collect(),
        };

        // Save new configuration in memory
        unsafe {
            CONF = Some(conf);
        }

        Ok(())
    }

    /// Get the address this server listen to
    pub fn server_listen_address(&self) -> String {
        format!("{}:{}", self.listen_address, self.port)
    }

    /// Check if independent push notifications service is enabled
    pub fn is_independent_push_notifications_service_enabled(&self) -> bool {
        self.independent_push_service.is_some()
    }
}

/// Get an instance of the configuration
pub fn conf() -> &'static Config {
    unsafe {
        return &CONF.as_ref().unwrap();
    }
}