use serde::Deserialize;
use std::default::Default;
use std::fs;

#[derive(Deserialize, Debug, Clone, Default)]
pub(crate) struct Config {
    pub idle: IdleConfig,
}

impl Config {
    pub fn load() -> Config {
        fs::read_to_string("jmb-bar.conf")
            .ok()
            .and_then(|s| toml::from_str::<Config>(&s).ok())
            .unwrap_or_default()
    }
}

#[derive(Deserialize, Debug, Clone)]
pub(crate) struct IdleConfig {
    idle_timeout: u64,
    dim_timeout: u64,
    lock_timeout: u64,
    sleep_timeout: u64,
    lock_command: String,
    sleep_command: String,
}

impl Default for IdleConfig {
    fn default() -> Self {
        Self {
            idle_timeout: 20,
            dim_timeout: 60,
            lock_timeout: 300,
            sleep_timeout: 320,
            lock_command: String::default(),
            sleep_command: String::default(),
        }
    }
}

impl IdleConfig {
    pub fn idle_timeout(&self) -> u64 {
        self.idle_timeout
    }

    pub fn dim_timeout(&self) -> u64 {
        self.dim_timeout
    }

    pub fn lock_timeout(&self) -> u64 {
        self.lock_timeout
    }

    pub fn sleep_timeout(&self) -> u64 {
        self.sleep_timeout
    }

    pub fn dim_timeout_delta(&self) -> u64 {
        self.dim_timeout - self.idle_timeout
    }

    pub fn lock_timeout_delta(&self) -> u64 {
        self.lock_timeout - self.dim_timeout_delta()
    }

    pub fn sleep_timeout_delta(&self) -> u64 {
        self.sleep_timeout - self.lock_timeout_delta()
    }

    pub fn lock_command(&self) -> &str {
        &self.lock_command
    }

    pub fn sleep_command(&self) -> &str {
        &self.sleep_command
    }
}