path: root/src/config.rs

use std::env;

pub const TEMP_PATH: &str = "/tmp/senator_sperma";

#[derive(Debug, Clone)]
pub struct Config {
    pub token: String,
    pub status_channel_id: Option<u64>,
    pub assistant_keyword: String,
    pub copyparty_url: String,
    pub copyparty_url_upload: String,
    pub copyparty_password: Option<String>,
    /// Deprecated – use llm_api_key instead
    pub openrouter_api_key: Option<String>,
    /// Deprecated – use llm_model instead
    pub openrouter_model: Option<String>,
    pub llm_api_key: Option<String>,
    pub llm_model: Option<String>,
    pub llm_api_url: String,
    pub database_path: String,
    /// Optional path to the Piper TTS `.onnx` model (or a directory of models).
    /// When unset, TTS falls back to Google Translate TTS.
    pub tts_model_path: Option<String>,
    /// Piper voice name, used to resolve the model file when `tts_model_path`
    /// points at a directory. Ignored when it points at a `.onnx` file directly.
    pub tts_voice: String,
    pub recording_enabled: bool,
    pub recording_window_seconds: u64,
}

struct EnvVar {
    name: &'static str,
    required: bool,
    default: Option<&'static str>,
    description: &'static str,
}

const ENV_VARS: &[EnvVar] = &[
    EnvVar {
        name: "TOKEN",
        required: true,
        default: None,
        description: "Discord bot token",
    },
    EnvVar {
        name: "STATUS_CHANNEL_ID",
        required: false,
        default: None,
        description: "status channel ID",
    },
    EnvVar {
        name: "ASSISTANT_KEYWORD",
        required: false,
        default: Some("jarvis"),
        description: "keyword for AI assistant",
    },
    EnvVar {
        name: "COPYPARTY_URL",
        required: false,
        default: Some("http://localhost:3939"),
        description: "Copyparty base URL",
    },
    EnvVar {
        name: "COPYPARTY_URL_UPLOAD",
        required: false,
        default: Some("http://localhost:3939"),
        description: "Copyparty upload URL",
    },
    EnvVar {
        name: "COPYPARTY_PASSWORD",
        required: false,
        default: None,
        description: "Copyparty auth password",
    },
    EnvVar {
        name: "OPENROUTER_API_KEY",
        required: false,
        default: None,
        description: "OpenRouter API key (disables AI if missing)",
    },
    EnvVar {
        name: "OPENROUTER_MODEL",
        required: false,
        default: Some("cognitivecomputations/dolphin-mistral-24b-venice-edition:free"),
        description: "OpenRouter model",
    },
    EnvVar {
        name: "LLM_API_KEY",
        required: false,
        default: None,
        description: "LLM API key (takes priority over OPENROUTER_API_KEY)",
    },
    EnvVar {
        name: "LLM_MODEL",
        required: false,
        default: None,
        description: "LLM model name (takes priority over OPENROUTER_MODEL)",
    },
    EnvVar {
        name: "LLM_API_URL",
        required: false,
        default: Some("https://openrouter.ai/api/v1/chat/completions"),
        description: "LLM API full URL including /chat/completions path",
    },
    EnvVar {
        name: "SENATOR_DB_PATH",
        required: false,
        default: Some("data/senator.db"),
        description: "SQLite database path",
    },
    EnvVar {
        name: "TTS_MODEL_PATH",
        required: false,
        default: None,
        description: "Path to a Piper TTS .onnx model (or a models directory). Unset => Google TTS fallback",
    },
    EnvVar {
        name: "TTS_VOICE",
        required: false,
        default: Some("pl_PL-bass-high"),
        description: "Piper TTS voice name (used when TTS_MODEL_PATH points at a directory)",
    },
    EnvVar {
        name: "RUST_LOG",
        required: false,
        default: Some("info"),
        description: "tracing/logging level filter",
    },
    EnvVar {
        name: "RECORDING_ENABLED",
        required: false,
        default: Some("true"),
        description: "enable continuous voice recording while in a VC (set false to opt out)",
    },
    EnvVar {
        name: "RECORDING_WINDOW_SECONDS",
        required: false,
        default: Some("900"),
        description: "rolling recording buffer length in seconds (memory ~sample_rate*2 bytes/sec)",
    },
];

pub fn check_env_vars() {
    let mut missing_required = Vec::new();
    let mut missing_optional = Vec::new();

    for var in ENV_VARS {
        match env::var(var.name) {
            Ok(_) => continue,
            Err(_) => {
                if var.required {
                    tracing::error!("MISSING REQUIRED: {} ({})", var.name, var.description);
                    missing_required.push(var.name);
                } else {
                    match var.default {
                        Some(default) => {
                            tracing::warn!("{} not set, using default: {}", var.name, default)
                        }
                        None => tracing::warn!("{} not set ({})", var.name, var.description),
                    }
                    missing_optional.push(var.name);
                }
            }
        }
    }

    if !missing_required.is_empty() {
        tracing::error!(
            "Missing required environment variables: {}. The application will not function correctly.",
            missing_required.join(", ")
        );
    }

    if !missing_optional.is_empty() {
        tracing::warn!(
            "Missing optional environment variables: {}. Some features will be disabled or use defaults.",
            missing_optional.join(", ")
        );
    }
}

impl Config {
    pub fn from_env() -> Self {
        let openrouter_api_key = env::var("OPENROUTER_API_KEY").ok();
        let openrouter_model = env::var("OPENROUTER_MODEL").ok();
        let llm_api_key = env::var("LLM_API_KEY").ok();
        let llm_model = env::var("LLM_MODEL").ok();

        // Warn about deprecated env vars (mirrors Python's BACKWARD_COMPAT_MSG)
        if openrouter_api_key.is_some() && llm_api_key.is_none() {
            tracing::warn!("OPENROUTER_API_KEY is deprecated. Use LLM_API_KEY instead.");
        }
        if openrouter_model.is_some() && llm_model.is_none() {
            tracing::warn!("OPENROUTER_MODEL is deprecated. Use LLM_MODEL instead.");
        }

        Self {
            token: env::var("TOKEN").expect("Missing TOKEN"),
            status_channel_id: env::var("STATUS_CHANNEL_ID")
                .ok()
                .and_then(|v| v.parse().ok()),
            assistant_keyword: env::var("ASSISTANT_KEYWORD").unwrap_or_else(|_| "jarvis".into()),
            recording_enabled: env::var("RECORDING_ENABLED")
                .unwrap_or_else(|_| "true".into())
                .parse()
                .unwrap_or(true),
            recording_window_seconds: env::var("RECORDING_WINDOW_SECONDS")
                .unwrap_or_else(|_| "900".into())
                .parse()
                .unwrap_or(900),
            copyparty_url: env::var("COPYPARTY_URL")
                .unwrap_or_else(|_| "http://localhost:3939".into()),
            copyparty_url_upload: env::var("COPYPARTY_URL_UPLOAD")
                .unwrap_or_else(|_| "http://localhost:3939".into()),
            copyparty_password: env::var("COPYPARTY_PASSWORD").ok(),
            openrouter_api_key,
            openrouter_model,
            llm_api_key,
            llm_model,
            llm_api_url: env::var("LLM_API_URL")
                .unwrap_or_else(|_| "https://openrouter.ai/api/v1/chat/completions".into()),
            database_path: env::var("SENATOR_DB_PATH").unwrap_or_else(|_| "data/senator.db".into()),
            tts_model_path: env::var("TTS_MODEL_PATH").ok(),
            tts_voice: env::var("TTS_VOICE").unwrap_or_else(|_| "pl_PL-bass-high".into()),
        }
    }

    /// Resolve the Piper model path to pass to the `piper` CLI.
    ///
    /// - `TTS_MODEL_PATH` set to a `.onnx` file => used verbatim.
    /// - `TTS_MODEL_PATH` set to a directory => `{dir}/{TTS_VOICE}.onnx`.
    /// - `TTS_MODEL_PATH` unset => `None` (caller falls back to Google TTS).
    pub fn piper_model_path(&self) -> Option<std::path::PathBuf> {
        let configured = self.tts_model_path.as_ref()?;
        let path = std::path::PathBuf::from(configured);
        if path.is_dir() {
            Some(path.join(format!("{}.onnx", self.tts_voice)))
        } else {
            Some(path)
        }
    }

    /// Resolve the effective LLM config: (api_url, api_key, model).
    /// LLM_* vars take priority; falls back to OPENROUTER_* for backward compat.
    pub fn resolve_llm(&self) -> (String, String, String) {
        let api_url = self.llm_api_url.clone();
        let api_key = self
            .llm_api_key
            .clone()
            .or_else(|| self.openrouter_api_key.clone())
            .unwrap_or_default();
        let model = self
            .llm_model
            .clone()
            .or_else(|| self.openrouter_model.clone())
            .unwrap_or_else(|| {
                "cognitivecomputations/dolphin-mistral-24b-venice-edition:free".into()
            });
        (api_url, api_key, model)
    }
}