Lumar / src / config.rs

use serde::{Deserialize, Serialize};
use std::fs;
use std::path::PathBuf;

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct Config {
    pub commands: Commands,
    pub flake: FlakeConfig,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct Commands {
    pub nixos: String,
    pub home_manager: String,
    pub colmena: String,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct FlakeConfig {
    /// Path to the flake (default: ".")
    pub path: String,
    /// Default execution mode when multiple configs are selected
    pub parallel: bool,
}

impl Default for Config {
    fn default() -> Self {
        Config {
            commands: Commands {
                nixos: "nixos-rebuild switch --flake .#{name}".into(),
                home_manager: "home-manager switch --flake .#{name}".into(),
                colmena: "cd {path} && colmena apply --on {name}".into(),
            },
            flake: FlakeConfig {
                path: ".".into(),
                parallel: false,
            },
        }
    }
}

pub fn config_path() -> PathBuf {
    let config_dir = std::env::var("XDG_CONFIG_HOME")
        .map(PathBuf::from)
        .unwrap_or_else(|_| {
            PathBuf::from(std::env::var("HOME").unwrap_or_else(|_| ".".into())).join(".config")
        });
    config_dir.join("lumar").join("config.toml")
}

pub fn load_or_default() -> Config {
    let path = config_path();
    if path.exists() {
        match fs::read_to_string(&path) {
            Ok(content) => match toml::from_str(&content) {
                Ok(cfg) => return cfg,
                Err(e) => eprintln!("Warning: failed to parse config at {}: {e}", path.display()),
            },
            Err(e) => eprintln!("Warning: failed to read config at {}: {e}", path.display()),
        }
    }
    Config::default()
}