smirrors 0.1.0

//! Systemd integration for SMirrors
//!
//! This module provides integration with systemd, including service
//! management, status checking, and journal log retrieval.

use anyhow::{Context, Result};
use std::process::{Command, Output};
use tracing::{debug, info, warn};

/// Systemd service name
const SERVICE_NAME: &str = "smirrors.service";
const TIMER_NAME: &str = "smirrors.timer";

/// Service status
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ServiceStatus {
    Running,
    Stopped,
    Failed,
    Unknown,
}

impl std::fmt::Display for ServiceStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Running => write!(f, "running"),
            Self::Stopped => write!(f, "stopped"),
            Self::Failed => write!(f, "failed"),
            Self::Unknown => write!(f, "unknown"),
        }
    }
}

/// Systemd manager for controlling the SMirrors service
pub struct SystemdManager {
    service_name: String,
    timer_name: String,
}

impl SystemdManager {
    /// Create a new systemd manager
    pub fn new() -> Self {
        Self {
            service_name: SERVICE_NAME.to_string(),
            timer_name: TIMER_NAME.to_string(),
        }
    }

    /// Start the service
    ///
    /// # Returns
    /// Result indicating success or failure
    pub fn start(&self) -> Result<()> {
        info!("Starting {} service", self.service_name);

        let output = Command::new("systemctl")
            .args(&["start", &self.service_name])
            .output()
            .context("Failed to execute systemctl start")?;

        self.check_command_output(output, "start")?;

        info!("Service started successfully");
        Ok(())
    }

    /// Stop the service
    ///
    /// # Returns
    /// Result indicating success or failure
    pub fn stop(&self) -> Result<()> {
        info!("Stopping {} service", self.service_name);

        let output = Command::new("systemctl")
            .args(&["stop", &self.service_name])
            .output()
            .context("Failed to execute systemctl stop")?;

        self.check_command_output(output, "stop")?;

        info!("Service stopped successfully");
        Ok(())
    }

    /// Restart the service
    ///
    /// # Returns
    /// Result indicating success or failure
    pub fn restart(&self) -> Result<()> {
        info!("Restarting {} service", self.service_name);

        let output = Command::new("systemctl")
            .args(&["restart", &self.service_name])
            .output()
            .context("Failed to execute systemctl restart")?;

        self.check_command_output(output, "restart")?;

        info!("Service restarted successfully");
        Ok(())
    }

    /// Reload the service configuration (sends SIGHUP)
    ///
    /// # Returns
    /// Result indicating success or failure
    pub fn reload(&self) -> Result<()> {
        info!("Reloading {} service configuration", self.service_name);

        let output = Command::new("systemctl")
            .args(&["reload", &self.service_name])
            .output()
            .context("Failed to execute systemctl reload")?;

        self.check_command_output(output, "reload")?;

        info!("Service configuration reloaded successfully");
        Ok(())
    }

    /// Enable the service to start on boot
    ///
    /// # Returns
    /// Result indicating success or failure
    pub fn enable(&self) -> Result<()> {
        info!("Enabling {} service", self.service_name);

        let output = Command::new("systemctl")
            .args(&["enable", &self.service_name])
            .output()
            .context("Failed to execute systemctl enable")?;

        self.check_command_output(output, "enable")?;

        info!("Service enabled successfully");
        Ok(())
    }

    /// Disable the service from starting on boot
    ///
    /// # Returns
    /// Result indicating success or failure
    pub fn disable(&self) -> Result<()> {
        info!("Disabling {} service", self.service_name);

        let output = Command::new("systemctl")
            .args(&["disable", &self.service_name])
            .output()
            .context("Failed to execute systemctl disable")?;

        self.check_command_output(output, "disable")?;

        info!("Service disabled successfully");
        Ok(())
    }

    /// Get the current service status
    ///
    /// # Returns
    /// ServiceStatus indicating the current state
    pub fn status(&self) -> ServiceStatus {
        debug!("Checking status of {} service", self.service_name);

        let output = match Command::new("systemctl")
            .args(&["is-active", &self.service_name])
            .output()
        {
            Ok(output) => output,
            Err(e) => {
                warn!("Failed to check service status: {}", e);
                return ServiceStatus::Unknown;
            }
        };

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

        match status_str.as_str() {
            "active" => ServiceStatus::Running,
            "inactive" | "dead" => ServiceStatus::Stopped,
            "failed" => ServiceStatus::Failed,
            _ => ServiceStatus::Unknown,
        }
    }

    /// Check if the service is running
    ///
    /// # Returns
    /// true if running, false otherwise
    pub fn is_running(&self) -> bool {
        self.status() == ServiceStatus::Running
    }

    /// Check if the service is enabled
    ///
    /// # Returns
    /// true if enabled, false otherwise
    pub fn is_enabled(&self) -> bool {
        let output = match Command::new("systemctl")
            .args(&["is-enabled", &self.service_name])
            .output()
        {
            Ok(output) => output,
            Err(e) => {
                warn!("Failed to check if service is enabled: {}", e);
                return false;
            }
        };

        output.status.success()
    }

    /// Get detailed service status information
    ///
    /// # Returns
    /// Status information as a string
    pub fn get_status_info(&self) -> Result<String> {
        debug!("Getting detailed status for {}", self.service_name);

        let output = Command::new("systemctl")
            .args(&["status", &self.service_name, "--no-pager"])
            .output()
            .context("Failed to execute systemctl status")?;

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

        Ok(status_info)
    }

    /// Start the timer
    ///
    /// # Returns
    /// Result indicating success or failure
    pub fn start_timer(&self) -> Result<()> {
        info!("Starting {} timer", self.timer_name);

        let output = Command::new("systemctl")
            .args(&["start", &self.timer_name])
            .output()
            .context("Failed to execute systemctl start timer")?;

        self.check_command_output(output, "start timer")?;

        info!("Timer started successfully");
        Ok(())
    }

    /// Stop the timer
    ///
    /// # Returns
    /// Result indicating success or failure
    pub fn stop_timer(&self) -> Result<()> {
        info!("Stopping {} timer", self.timer_name);

        let output = Command::new("systemctl")
            .args(&["stop", &self.timer_name])
            .output()
            .context("Failed to execute systemctl stop timer")?;

        self.check_command_output(output, "stop timer")?;

        info!("Timer stopped successfully");
        Ok(())
    }

    /// Enable the timer
    ///
    /// # Returns
    /// Result indicating success or failure
    pub fn enable_timer(&self) -> Result<()> {
        info!("Enabling {} timer", self.timer_name);

        let output = Command::new("systemctl")
            .args(&["enable", &self.timer_name])
            .output()
            .context("Failed to execute systemctl enable timer")?;

        self.check_command_output(output, "enable timer")?;

        info!("Timer enabled successfully");
        Ok(())
    }

    /// Disable the timer
    ///
    /// # Returns
    /// Result indicating success or failure
    pub fn disable_timer(&self) -> Result<()> {
        info!("Disabling {} timer", self.timer_name);

        let output = Command::new("systemctl")
            .args(&["disable", &self.timer_name])
            .output()
            .context("Failed to execute systemctl disable timer")?;

        self.check_command_output(output, "disable timer")?;

        info!("Timer disabled successfully");
        Ok(())
    }

    /// Get service logs from journalctl
    ///
    /// # Arguments
    /// * `lines` - Number of log lines to retrieve
    ///
    /// # Returns
    /// Log entries as a string
    pub fn get_logs(&self, lines: usize) -> Result<String> {
        debug!("Retrieving {} log lines", lines);

        let output = Command::new("journalctl")
            .args(&[
                "-u",
                &self.service_name,
                "-n",
                &lines.to_string(),
                "--no-pager",
            ])
            .output()
            .context("Failed to execute journalctl")?;

        if !output.status.success() {
            let error = String::from_utf8_lossy(&output.stderr);
            anyhow::bail!("Failed to retrieve logs: {}", error);
        }

        let logs = String::from_utf8_lossy(&output.stdout).to_string();
        Ok(logs)
    }

    /// Follow service logs in real-time (async)
    ///
    /// # Returns
    /// A spawned child process for following logs
    pub fn follow_logs(&self) -> Result<std::process::Child> {
        debug!("Starting to follow logs");

        let child = Command::new("journalctl")
            .args(&["-u", &self.service_name, "-f", "--no-pager"])
            .spawn()
            .context("Failed to spawn journalctl for log following")?;

        Ok(child)
    }

    /// Trigger an immediate update (sends SIGUSR1)
    ///
    /// # Returns
    /// Result indicating success or failure
    pub fn trigger_update(&self) -> Result<()> {
        info!("Triggering immediate update");

        let output = Command::new("systemctl")
            .args(&["kill", "-s", "SIGUSR1", &self.service_name])
            .output()
            .context("Failed to send SIGUSR1 signal")?;

        self.check_command_output(output, "trigger update")?;

        info!("Update triggered successfully");
        Ok(())
    }

    /// Run health check (sends SIGUSR2)
    ///
    /// # Returns
    /// Result indicating success or failure
    pub fn health_check(&self) -> Result<()> {
        info!("Running health check");

        let output = Command::new("systemctl")
            .args(&["kill", "-s", "SIGUSR2", &self.service_name])
            .output()
            .context("Failed to send SIGUSR2 signal")?;

        self.check_command_output(output, "health check")?;

        info!("Health check triggered successfully");
        Ok(())
    }

    /// Reload daemon configuration (systemctl daemon-reload)
    ///
    /// # Returns
    /// Result indicating success or failure
    pub fn daemon_reload() -> Result<()> {
        info!("Reloading systemd daemon configuration");

        let output = Command::new("systemctl")
            .args(&["daemon-reload"])
            .output()
            .context("Failed to execute systemctl daemon-reload")?;

        if !output.status.success() {
            let error = String::from_utf8_lossy(&output.stderr);
            anyhow::bail!("Failed to reload daemon: {}", error);
        }

        info!("Daemon configuration reloaded successfully");
        Ok(())
    }

    /// Check if systemd is available on this system
    ///
    /// # Returns
    /// true if systemd is available, false otherwise
    pub fn is_systemd_available() -> bool {
        Command::new("systemctl")
            .arg("--version")
            .output()
            .map(|o| o.status.success())
            .unwrap_or(false)
    }

    /// Validate unit file syntax
    ///
    /// # Arguments
    /// * `unit_file` - Path to the unit file to validate
    ///
    /// # Returns
    /// Result indicating if the unit file is valid
    pub fn validate_unit_file(unit_file: &str) -> Result<()> {
        debug!("Validating unit file: {}", unit_file);

        let output = Command::new("systemd-analyze")
            .args(&["verify", unit_file])
            .output()
            .context("Failed to execute systemd-analyze")?;

        if !output.status.success() {
            let error = String::from_utf8_lossy(&output.stderr);
            anyhow::bail!("Unit file validation failed: {}", error);
        }

        info!("Unit file is valid");
        Ok(())
    }

    /// Check command output and return error if failed
    fn check_command_output(&self, output: Output, operation: &str) -> Result<()> {
        if !output.status.success() {
            let error = String::from_utf8_lossy(&output.stderr);
            anyhow::bail!("Failed to {}: {}", operation, error);
        }
        Ok(())
    }
}

impl Default for SystemdManager {
    fn default() -> Self {
        Self::new()
    }
}

/// Install systemd unit files
///
/// # Arguments
/// * `service_content` - Content of the service unit file
/// * `timer_content` - Content of the timer unit file
///
/// # Returns
/// Result indicating success or failure
pub fn install_unit_files(service_content: &str, timer_content: &str) -> Result<()> {
    info!("Installing systemd unit files");

    let systemd_dir = std::path::PathBuf::from("/etc/systemd/system");

    // Ensure directory exists
    std::fs::create_dir_all(&systemd_dir)
        .context("Failed to create systemd directory")?;

    // Write service file
    let service_path = systemd_dir.join(SERVICE_NAME);
    std::fs::write(&service_path, service_content)
        .context("Failed to write service file")?;

    // Write timer file
    let timer_path = systemd_dir.join(TIMER_NAME);
    std::fs::write(&timer_path, timer_content)
        .context("Failed to write timer file")?;

    // Reload systemd daemon
    SystemdManager::daemon_reload()?;

    info!("Systemd unit files installed successfully");
    Ok(())
}

/// Uninstall systemd unit files
///
/// # Returns
/// Result indicating success or failure
pub fn uninstall_unit_files() -> Result<()> {
    info!("Uninstalling systemd unit files");

    let systemd_dir = std::path::PathBuf::from("/etc/systemd/system");

    // Remove service file
    let service_path = systemd_dir.join(SERVICE_NAME);
    if service_path.exists() {
        std::fs::remove_file(&service_path)
            .context("Failed to remove service file")?;
    }

    // Remove timer file
    let timer_path = systemd_dir.join(TIMER_NAME);
    if timer_path.exists() {
        std::fs::remove_file(&timer_path)
            .context("Failed to remove timer file")?;
    }

    // Reload systemd daemon
    SystemdManager::daemon_reload()?;

    info!("Systemd unit files uninstalled successfully");
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_systemd_manager_creation() {
        let manager = SystemdManager::new();
        assert_eq!(manager.service_name, SERVICE_NAME);
        assert_eq!(manager.timer_name, TIMER_NAME);
    }

    #[test]
    fn test_service_status_display() {
        assert_eq!(ServiceStatus::Running.to_string(), "running");
        assert_eq!(ServiceStatus::Stopped.to_string(), "stopped");
        assert_eq!(ServiceStatus::Failed.to_string(), "failed");
        assert_eq!(ServiceStatus::Unknown.to_string(), "unknown");
    }

    #[test]
    fn test_is_systemd_available() {
        // This test might fail on systems without systemd
        // but that's okay for unit testing
        let _ = SystemdManager::is_systemd_available();
    }
}