oxwm

use super::Block;

use crate::errors::BlockError;

use std::process::Command;

use std::time::{Duration, Instant};

pub struct ShellBlock {

    format: String,

    command: String,

    interval: Duration,

    color: u32,

    cached_output: Option<String>,

    last_run: Option<Instant>,

}

impl ShellBlock {

    pub fn new(format: &str, command: &str, interval_secs: u64, color: u32) -> Self {

        Self {

            format: format.to_string(),

            command: command.to_string(),

            interval: Duration::from_secs(interval_secs),

            color,

            cached_output: None,

            last_run: None,

        }

    }

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

        let output = Command::new("sh")

            .arg("-c")

            .arg(&self.command)

            .output()

            .map_err(|e| BlockError::CommandFailed(format!("Failed to execute command: {}", e)))?;

        if !output.status.success() {

            return Err(BlockError::CommandFailed(format!(

                "Command exited with status: {}",

                output.status

            )));

        }

        let result = String::from_utf8_lossy(&output.stdout).trim().to_string();

        let formatted = self.format.replace("{}", &result);

        self.cached_output = Some(formatted.clone());

        self.last_run = Some(Instant::now());

        Ok(formatted)

    }

}

impl Block for ShellBlock {

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

        let should_refresh = match self.last_run {

            None => true,

            Some(last) => last.elapsed() >= self.interval,

        };

        if should_refresh {

            return self.execute();

        }

        self.cached_output

            .clone()

            .ok_or_else(|| BlockError::CommandFailed("No cached output".to_string()))

    }

    fn interval(&self) -> Duration {

        self.interval

    }

    fn color(&self) -> u32 {

        self.color

    }

}