zinit 0.3.9

//! Configuration types for service and target definitions.
//!
//! Services and targets are defined in TOML files.

use std::collections::HashMap;
use std::path::Path;

use serde::{Deserialize, Serialize};

/// Complete service configuration.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ServiceConfig {
    pub service: ServiceDef,
    #[serde(default)]
    pub dependencies: DependencyDef,
    #[serde(default)]
    pub lifecycle: LifecycleDef,
    #[serde(default)]
    pub health: Option<HealthDef>,
    #[serde(default)]
    pub logging: LoggingDef,
}

impl ServiceConfig {
    /// Load a service configuration from a TOML file.
    pub fn from_file(path: &Path) -> Result<Self, ConfigError> {
        let content = std::fs::read_to_string(path).map_err(|e| ConfigError::Io(e.to_string()))?;
        Self::parse(&content)
    }

    /// Parse a service configuration from a TOML string.
    pub fn parse(content: &str) -> Result<Self, ConfigError> {
        toml::from_str(content).map_err(|e| ConfigError::Parse(e.to_string()))
    }

    /// Serialize to TOML string.
    pub fn to_toml(&self) -> Result<String, ConfigError> {
        toml::to_string_pretty(self).map_err(|e| ConfigError::Parse(e.to_string()))
    }
}

/// Service definition section.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ServiceDef {
    pub name: String,
    pub exec: String,
    #[serde(default)]
    pub dir: Option<String>,
    #[serde(default)]
    pub oneshot: bool,
    #[serde(default)]
    pub env: HashMap<String, String>,
    /// Desired status: start (default), stop, or ignore.
    /// - start: supervisor ensures service is running
    /// - stop: supervisor ensures service is stopped
    /// - ignore: supervisor doesn't manage state (manual control)
    #[serde(default)]
    pub status: Status,
    /// Service class: user (default) or system.
    /// - user: normal service, affected by bulk operations (*_all)
    /// - system: protected service, skipped by bulk operations
    #[serde(default)]
    pub class: ServiceClass,
    /// If true, failure triggers emergency shell (PID1 mode only).
    #[serde(default)]
    pub critical: bool,
    /// TCP ports used by this service (checked for conflicts on startup).
    /// If a port is already in use by another service, start will fail with a clear error.
    #[serde(default)]
    pub ports: Vec<u16>,
    /// If true, kill other processes using declared ports before starting this service.
    /// This allows clean startup without manual cleanup of conflicting processes.
    #[serde(default)]
    pub kill_others: bool,
    /// Process name filters for conflict detection (case-insensitive partial match).
    /// If set, zinit checks if any process with a name containing these substrings
    /// is running before starting this service.
    ///
    /// Examples:
    /// - ["Server"] matches: "myServer", "ServerApp", "TestServer"
    /// - ["nginx", "python"] matches: "nginx", "nginx-worker", "python", "python3"
    ///
    /// Combined with kill_others, this allows clean service startup by killing
    /// conflicting processes first. All matching processes are killed.
    #[serde(default)]
    pub process_filters: Vec<String>,
}

/// Dependency definition section.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DependencyDef {
    #[serde(default)]
    pub after: Vec<String>,
    #[serde(default)]
    pub requires: Vec<String>,
    #[serde(default)]
    pub wants: Vec<String>,
    #[serde(default)]
    pub conflicts: Vec<String>,
}

/// Lifecycle configuration section.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LifecycleDef {
    #[serde(default = "default_restart_policy")]
    pub restart: RestartPolicy,
    /// Initial restart delay in milliseconds (doubles each restart for exponential backoff).
    #[serde(default = "default_restart_delay_ms")]
    pub restart_delay_ms: u64,
    /// Maximum restart delay in milliseconds (cap for exponential backoff).
    #[serde(default = "default_restart_delay_max_ms")]
    pub restart_delay_max_ms: u64,
    /// Maximum number of restart attempts (0 = unlimited).
    #[serde(default = "default_max_restarts")]
    pub max_restarts: u32,
    /// How long a service must run before backoff counter is reset (milliseconds).
    /// If a service crashes before this period, backoff continues to increase.
    #[serde(default = "default_stability_period_ms")]
    pub stability_period_ms: u64,
    #[serde(default = "default_start_timeout_ms")]
    pub start_timeout_ms: u64,
    #[serde(default = "default_stop_timeout_ms")]
    pub stop_timeout_ms: u64,
    #[serde(default = "default_stop_signal")]
    pub stop_signal: String,
}

impl Default for LifecycleDef {
    fn default() -> Self {
        Self {
            restart: default_restart_policy(),
            restart_delay_ms: default_restart_delay_ms(),
            restart_delay_max_ms: default_restart_delay_max_ms(),
            max_restarts: default_max_restarts(),
            stability_period_ms: default_stability_period_ms(),
            start_timeout_ms: default_start_timeout_ms(),
            stop_timeout_ms: default_stop_timeout_ms(),
            stop_signal: default_stop_signal(),
        }
    }
}

fn default_restart_policy() -> RestartPolicy {
    RestartPolicy::OnFailure
}

fn default_restart_delay_ms() -> u64 {
    1000
}

fn default_restart_delay_max_ms() -> u64 {
    300000 // 5 minutes
}

fn default_max_restarts() -> u32 {
    10 // 0 = unlimited
}

fn default_stability_period_ms() -> u64 {
    30000 // 30 seconds - service must run this long before backoff resets
}

fn default_start_timeout_ms() -> u64 {
    30000
}

fn default_stop_timeout_ms() -> u64 {
    10000
}

fn default_stop_signal() -> String {
    "SIGTERM".to_string()
}

/// Restart policy for a service.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum RestartPolicy {
    /// Always restart the service when it exits.
    Always,
    /// Only restart if the service exits with failure.
    #[default]
    OnFailure,
    /// Never restart the service.
    Never,
}

/// Desired status of a service - what the supervisor should enforce.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Status {
    /// Supervisor ensures service is running (default).
    #[default]
    Start,
    /// Supervisor ensures service is stopped.
    Stop,
    /// Supervisor doesn't manage service state (manual control only).
    Ignore,
}

impl Status {
    /// Returns true if the service should be auto-started.
    pub fn should_autostart(&self) -> bool {
        matches!(self, Status::Start)
    }

    /// Returns true if the service should be kept stopped.
    pub fn should_stop(&self) -> bool {
        matches!(self, Status::Stop)
    }

    /// Returns true if the service is under manual control.
    pub fn is_manual(&self) -> bool {
        matches!(self, Status::Ignore)
    }
}

/// Service class - determines protection level and behavior.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ServiceClass {
    /// User service (default) - affected by bulk operations (*_all).
    #[default]
    User,
    /// System service - protected from bulk operations, essential for system function.
    /// Loaded from /etc/zinit/system/ when running as PID1.
    System,
}

impl ServiceClass {
    /// Returns true if this is a system service (protected).
    pub fn is_system(&self) -> bool {
        matches!(self, ServiceClass::System)
    }

    /// Returns true if this is a user service (not protected).
    pub fn is_user(&self) -> bool {
        matches!(self, ServiceClass::User)
    }
}

/// Health check definition.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "lowercase")]
pub enum HealthDef {
    /// TCP connection health check.
    Tcp {
        target: String,
        #[serde(flatten)]
        common: HealthCommon,
    },
    /// HTTP health check.
    Http {
        target: String,
        #[serde(default = "default_http_status")]
        expect_status: u16,
        #[serde(flatten)]
        common: HealthCommon,
    },
    /// Command execution health check.
    Exec {
        target: String,
        #[serde(flatten)]
        common: HealthCommon,
    },
}

fn default_http_status() -> u16 {
    200
}

/// Common health check parameters.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct HealthCommon {
    #[serde(default = "default_health_interval_ms")]
    pub interval_ms: u64,
    #[serde(default = "default_health_timeout_ms")]
    pub timeout_ms: u64,
    #[serde(default = "default_health_retries")]
    pub retries: u32,
    #[serde(default = "default_health_start_period_ms")]
    pub start_period_ms: u64,
}

impl Default for HealthCommon {
    fn default() -> Self {
        Self {
            interval_ms: default_health_interval_ms(),
            timeout_ms: default_health_timeout_ms(),
            retries: default_health_retries(),
            start_period_ms: default_health_start_period_ms(),
        }
    }
}

fn default_health_interval_ms() -> u64 {
    10000
}

fn default_health_timeout_ms() -> u64 {
    5000
}

fn default_health_retries() -> u32 {
    3
}

fn default_health_start_period_ms() -> u64 {
    0
}

/// Logging configuration section.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LoggingDef {
    #[serde(default = "default_buffer_lines")]
    pub buffer_lines: usize,
    #[serde(default)]
    pub file: Option<String>,
    #[serde(default)]
    pub forward: Option<String>,
}

impl Default for LoggingDef {
    fn default() -> Self {
        Self {
            buffer_lines: default_buffer_lines(),
            file: None,
            forward: None,
        }
    }
}

fn default_buffer_lines() -> usize {
    1000
}

/// Target configuration (virtual service with no process).
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TargetConfig {
    pub target: TargetDef,
    #[serde(default)]
    pub dependencies: DependencyDef,
}

impl TargetConfig {
    /// Load a target configuration from a TOML file.
    pub fn from_file(path: &Path) -> Result<Self, ConfigError> {
        let content = std::fs::read_to_string(path).map_err(|e| ConfigError::Io(e.to_string()))?;
        Self::parse(&content)
    }

    /// Parse a target configuration from a TOML string.
    pub fn parse(content: &str) -> Result<Self, ConfigError> {
        toml::from_str(content).map_err(|e| ConfigError::Parse(e.to_string()))
    }
}

/// Target definition section.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TargetDef {
    pub name: String,
    /// If true, failure to reach this target triggers emergency shell (PID1 mode only).
    #[serde(default)]
    pub critical: bool,
}

/// Configuration parsing errors.
#[derive(Debug, Clone, thiserror::Error)]
pub enum ConfigError {
    #[error("IO error: {0}")]
    Io(String),
    #[error("Parse error: {0}")]
    Parse(String),
}

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

    #[test]
    fn test_parse_minimal_service() {
        let toml = r#"
[service]
name = "test"
exec = "/bin/test"
"#;
        let config = ServiceConfig::parse(toml).unwrap();
        assert_eq!(config.service.name, "test");
        assert_eq!(config.service.exec, "/bin/test");
        assert!(!config.service.oneshot);
        assert!(config.dependencies.requires.is_empty());
        assert_eq!(config.lifecycle.restart, RestartPolicy::OnFailure);
    }

    #[test]
    fn test_parse_full_service() {
        let toml = r#"
[service]
name = "web-server"
exec = "/usr/bin/nginx -g 'daemon off;'"
dir = "/var/www"
oneshot = false

[service.env]
PORT = "8080"
DEBUG = "true"

[dependencies]
requires = ["network-ready"]
after = ["logger"]
wants = ["metrics"]
conflicts = ["old-web-server"]

[lifecycle]
restart = "always"
restart_delay_ms = 3000
start_timeout_ms = 60000
stop_timeout_ms = 30000
stop_signal = "SIGQUIT"

[health]
type = "http"
target = "http://localhost:8080/health"
expect_status = 200
interval_ms = 5000
timeout_ms = 2000
retries = 5
start_period_ms = 10000

[logging]
buffer_lines = 500
file = "/var/log/web-server.log"
"#;
        let config = ServiceConfig::parse(toml).unwrap();
        assert_eq!(config.service.name, "web-server");
        assert_eq!(config.service.dir, Some("/var/www".to_string()));
        assert_eq!(config.service.env.get("PORT"), Some(&"8080".to_string()));
        assert_eq!(config.dependencies.requires, vec!["network-ready"]);
        assert_eq!(config.dependencies.after, vec!["logger"]);
        assert_eq!(config.lifecycle.restart, RestartPolicy::Always);
        assert_eq!(config.lifecycle.stop_signal, "SIGQUIT");

        match &config.health {
            Some(HealthDef::Http {
                target,
                expect_status,
                common,
            }) => {
                assert_eq!(target, "http://localhost:8080/health");
                assert_eq!(*expect_status, 200);
                assert_eq!(common.retries, 5);
            }
            _ => panic!("Expected HTTP health check"),
        }

        assert_eq!(config.logging.buffer_lines, 500);
    }

    #[test]
    fn test_parse_target() {
        let toml = r#"
[target]
name = "multi-user"

[dependencies]
requires = ["network", "logging"]
"#;
        let config = TargetConfig::parse(toml).unwrap();
        assert_eq!(config.target.name, "multi-user");
        assert_eq!(config.dependencies.requires, vec!["network", "logging"]);
    }

    #[test]
    fn test_restart_policy_serialization() {
        assert_eq!(
            serde_json::to_string(&RestartPolicy::Always).unwrap(),
            "\"always\""
        );
        assert_eq!(
            serde_json::to_string(&RestartPolicy::OnFailure).unwrap(),
            "\"on-failure\""
        );
        assert_eq!(
            serde_json::to_string(&RestartPolicy::Never).unwrap(),
            "\"never\""
        );
    }

    #[test]
    fn test_health_check_types() {
        let tcp_toml = r#"
[service]
name = "tcp-test"
exec = "/bin/test"

[health]
type = "tcp"
target = "localhost:5432"
"#;
        let config = ServiceConfig::parse(tcp_toml).unwrap();
        assert!(matches!(config.health, Some(HealthDef::Tcp { .. })));

        let exec_toml = r#"
[service]
name = "exec-test"
exec = "/bin/test"

[health]
type = "exec"
target = "/usr/bin/healthcheck.sh"
"#;
        let config = ServiceConfig::parse(exec_toml).unwrap();
        assert!(matches!(config.health, Some(HealthDef::Exec { .. })));
    }

    #[test]
    fn test_roundtrip() {
        let config = ServiceConfig {
            service: ServiceDef {
                name: "test".to_string(),
                exec: "/bin/test".to_string(),
                dir: None,
                oneshot: false,
                env: HashMap::new(),
                status: Status::default(),
                class: ServiceClass::default(),
                critical: false,
                ports: Vec::new(),
                kill_others: false,
                process_filters: Vec::new(),
            },
            dependencies: DependencyDef::default(),
            lifecycle: LifecycleDef::default(),
            health: None,
            logging: LoggingDef::default(),
        };

        let toml = config.to_toml().unwrap();
        let parsed = ServiceConfig::parse(&toml).unwrap();
        assert_eq!(config, parsed);
    }

    #[test]
    fn test_status_enum() {
        // Test serialization
        assert_eq!(serde_json::to_string(&Status::Start).unwrap(), "\"start\"");
        assert_eq!(serde_json::to_string(&Status::Stop).unwrap(), "\"stop\"");
        assert_eq!(
            serde_json::to_string(&Status::Ignore).unwrap(),
            "\"ignore\""
        );

        // Test deserialization
        assert_eq!(
            serde_json::from_str::<Status>("\"start\"").unwrap(),
            Status::Start
        );
        assert_eq!(
            serde_json::from_str::<Status>("\"stop\"").unwrap(),
            Status::Stop
        );
        assert_eq!(
            serde_json::from_str::<Status>("\"ignore\"").unwrap(),
            Status::Ignore
        );

        // Test default
        assert_eq!(Status::default(), Status::Start);

        // Test helper methods
        assert!(Status::Start.should_autostart());
        assert!(!Status::Stop.should_autostart());
        assert!(!Status::Ignore.should_autostart());

        assert!(!Status::Start.should_stop());
        assert!(Status::Stop.should_stop());
        assert!(!Status::Ignore.should_stop());

        assert!(!Status::Start.is_manual());
        assert!(!Status::Stop.is_manual());
        assert!(Status::Ignore.is_manual());
    }

    #[test]
    fn test_status_in_service_config() {
        // Test default (no status specified)
        let toml_default = r#"
[service]
name = "test"
exec = "/bin/test"
"#;
        let config = ServiceConfig::parse(toml_default).unwrap();
        assert_eq!(config.service.status, Status::Start);

        // Test explicit status = "stop"
        let toml_stop = r#"
[service]
name = "test"
exec = "/bin/test"
status = "stop"
"#;
        let config = ServiceConfig::parse(toml_stop).unwrap();
        assert_eq!(config.service.status, Status::Stop);

        // Test explicit status = "ignore"
        let toml_ignore = r#"
[service]
name = "test"
exec = "/bin/test"
status = "ignore"
"#;
        let config = ServiceConfig::parse(toml_ignore).unwrap();
        assert_eq!(config.service.status, Status::Ignore);
    }

    #[test]
    fn test_service_class_enum() {
        // Test serialization
        assert_eq!(
            serde_json::to_string(&ServiceClass::User).unwrap(),
            "\"user\""
        );
        assert_eq!(
            serde_json::to_string(&ServiceClass::System).unwrap(),
            "\"system\""
        );

        // Test deserialization
        assert_eq!(
            serde_json::from_str::<ServiceClass>("\"user\"").unwrap(),
            ServiceClass::User
        );
        assert_eq!(
            serde_json::from_str::<ServiceClass>("\"system\"").unwrap(),
            ServiceClass::System
        );

        // Test default
        assert_eq!(ServiceClass::default(), ServiceClass::User);

        // Test helper methods
        assert!(!ServiceClass::User.is_system());
        assert!(ServiceClass::System.is_system());

        assert!(ServiceClass::User.is_user());
        assert!(!ServiceClass::System.is_user());
    }

    #[test]
    fn test_class_in_service_config() {
        // Test default (no class specified)
        let toml_default = r#"
[service]
name = "test"
exec = "/bin/test"
"#;
        let config = ServiceConfig::parse(toml_default).unwrap();
        assert_eq!(config.service.class, ServiceClass::User);

        // Test explicit class = "user"
        let toml_user = r#"
[service]
name = "test"
exec = "/bin/test"
class = "user"
"#;
        let config = ServiceConfig::parse(toml_user).unwrap();
        assert_eq!(config.service.class, ServiceClass::User);

        // Test explicit class = "system"
        let toml_system = r#"
[service]
name = "test"
exec = "/bin/test"
class = "system"
"#;
        let config = ServiceConfig::parse(toml_system).unwrap();
        assert_eq!(config.service.class, ServiceClass::System);
    }
}