oxwm

use super::Block;

use crate::errors::BlockError;

use std::fs;

use std::time::Duration;

pub struct Battery {

    format_charging: String,

    format_discharging: String,

    format_full: String,

    interval: Duration,

    color: u32,

    battery_path: String,

}

impl Battery {

    pub fn new(

        format_charging: &str,

        format_discharging: &str,

        format_full: &str,

        interval_secs: u64,

        color: u32,

        battery_name: Option<String>,

    ) -> Self {

        Self {

            format_charging: format_charging.to_string(),

            format_discharging: format_discharging.to_string(),

            format_full: format_full.to_string(),

            interval: Duration::from_secs(interval_secs),

            color,

            battery_path: format!(

                "/sys/class/power_supply/{}",

                battery_name.unwrap_or_else(|| "BAT0".to_string())

            ),

        }

    }

    fn read_file(&self, filename: &str) -> Result<String, BlockError> {

        let path = format!("{}/{}", self.battery_path, filename);

        Ok(fs::read_to_string(path)?.trim().to_string())

    }

    fn get_capacity(&self) -> Result<u32, BlockError> {

        Ok(self.read_file("capacity")?.parse()?)

    }

    fn get_status(&self) -> Result<String, BlockError> {

        self.read_file("status")

    }

}

impl Block for Battery {

    fn content(&mut self) -> Result<String, BlockError> {

        let capacity = self.get_capacity()?;

        let status = self.get_status()?;

        let format = match status.as_str() {

            "Charging" => &self.format_charging,

            "Full" => &self.format_full,

            _ => &self.format_discharging,

        };

        Ok(format.replace("{}", &capacity.to_string()))

    }

    fn interval(&self) -> Duration {

        self.interval

    }

    fn color(&self) -> u32 {

        self.color

    }

}