jelq

use std::{path::PathBuf, time::Duration};

use crate::game::oracle::OracleTemplate;

use crate::secret::Secret;

pub struct Config {

    pub addr: String,

    pub secret: Secret,

    pub max_runs: usize,

    pub idle_ttl: Duration,

    /// Where finished runs are kept. `None` keeps them in memory, which only tests want.

    pub db: Option<PathBuf>,

    pub(crate) oracle: OracleTemplate,

}

impl Default for Config {

    fn default() -> Self {

        Self {

            addr: "127.0.0.1:6969".into(),

            secret: Secret::random(),

            max_runs: 10_000,

            idle_ttl: Duration::from_secs(6 * 60 * 60),

            db: None,

            oracle: OracleTemplate::Rng,

        }

    }

}

/// The XDG state directory, so `nix run` from anywhere finds the same graveyard.

fn default_db() -> PathBuf {

    let state = std::env::var_os("XDG_STATE_HOME")

        .map(PathBuf::from)

        .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".local/state")));

    match state {

        Some(dir) => dir.join("jelqd").join("jelqd.sqlite"),

        None => PathBuf::from("jelqd.sqlite"),

    }

}

impl Config {

    pub fn from_env() -> Self {

        let var = |name| std::env::var(name).ok();

        let defaults = Self::default();

        Self {

            addr: var("JELQD_ADDR").unwrap_or(defaults.addr),

            db: Some(var("JELQD_DB").map_or_else(default_db, PathBuf::from)),

            secret: var("JELQD_SECRET").map_or(defaults.secret, |s| Secret::new(s.into_bytes())),

            oracle: match var("JELQD_ORACLE").as_deref() {

                Some("clm") => OracleTemplate::Clm {

                    url: var("JELQD_CLM_URL")

                        .unwrap_or_else(|| "http://127.0.0.1:8700/v1/systemone".into()),

                },

                _ => defaults.oracle,

            },

            ..defaults

        }

    }

}