roundabout

use std::{collections::BTreeMap, fs, path::PathBuf};

use serde::Deserialize;

use crate::{

    paths,

    units::{Amount, Bytes, Dur},

};

#[derive(Debug, Deserialize)]

#[serde(default, deny_unknown_fields)]

pub struct Config {

    pub budget: Budget,

    pub heavy: Heavy,

    pub sizes: BTreeMap<String, Preset>,

    pub queue: Queue,

    pub overrun: Overrun,

    pub enforce: Enforce,

    pub artifacts: Artifacts,

    pub nix: Nix,

    pub detect: Detect,

}

#[derive(Debug, Deserialize)]

#[serde(default, deny_unknown_fields)]

pub struct Budget {

    pub ram: Amount<Bytes>,

    pub ram_reserve: Bytes,

    pub cores: Amount<u32>,

    pub disk_reserve: Bytes,

    /// every lease's disk estimate is charged to all of these as well as its

    /// cwd. pessimistic when they share a fs, which is the point

    pub disk_paths: Vec<PathBuf>,

    /// memory psi `some avg10`. only gates heavies

    pub psi_max: Option<f64>,

}

#[derive(Debug, Deserialize)]

#[serde(default, deny_unknown_fields)]

pub struct Heavy {

    pub ram: Bytes,

    pub cores: Amount<u32>,

    pub disk: Bytes,

}

#[derive(Clone, Copy, Debug, Deserialize)]

#[serde(deny_unknown_fields)]

pub struct Preset {

    pub ram: Bytes,

    pub disk: Bytes,

    pub cores: Amount<u32>,

    pub time: Dur,

}

#[derive(Debug, Deserialize)]

#[serde(default, deny_unknown_fields)]

pub struct Queue {

    pub linger: Dur,

    pub backfill_max_time: Dur,

    pub max_wait: Option<Dur>,

    pub elastic: bool,

    pub intent_ttl: Dur,

}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize)]

#[serde(rename_all = "lowercase")]

pub enum RamOverrun {

    Warn,

    Throttle,

}

#[derive(Debug, Deserialize)]

#[serde(default, deny_unknown_fields)]

pub struct Overrun {

    pub ram: RamOverrun,

    /// multiple of the ram estimate

    pub ram_slack: f64,

    /// multiple of the time estimate

    pub time_grace: f64,

    pub remind_every: Dur,

}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize)]

#[serde(rename_all = "lowercase")]

pub enum Unwrapped {

    Deny,

    Wrap,

    Allow,

}

#[derive(Debug, Deserialize)]

#[serde(default, deny_unknown_fields)]

pub struct Enforce {

    pub unwrapped: Unwrapped,

    pub default_size: String,

}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize)]

#[serde(rename_all = "lowercase")]

pub enum OverCap {

    Warn,

    Block,

}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize)]

#[serde(rename_all = "lowercase")]

pub enum StopPolicy {

    Block,

    Nudge,

    Warn,

    Off,

}

#[derive(Clone, Debug, Deserialize)]

#[serde(deny_unknown_fields)]

pub struct Rule {

    /// trailing `*` for a prefix match, that's all the glob you get

    pub name: String,

    /// sibling that must exist, so we don't go deleting someone's `build/`

    /// because it had a suggestive name

    pub marker: Option<String>,

    pub clean: Option<Vec<String>>,

}

#[derive(Debug, Deserialize)]

#[serde(default, deny_unknown_fields)]

pub struct Artifacts {

    pub project_cap: Bytes,

    pub global_cap: Bytes,

    pub idle_after: Dur,

    pub size_ttl: Dur,

    pub over_cap: OverCap,

    pub stop: StopPolicy,

    pub rules: Vec<Rule>,

    pub extra_rules: Vec<Rule>,

    pub nix_gc: bool,

    pub nix_min_free: Bytes,

}

#[derive(Debug, Deserialize)]

#[serde(default, deny_unknown_fields)]

pub struct Nix {

    pub inject: bool,

    pub cores_per_job: u32,

}

#[derive(Debug, Deserialize)]

#[serde(default, deny_unknown_fields)]

pub struct Detect {

    pub commands: Vec<String>,

    pub extra: Vec<String>,

}

impl Default for Config {

    fn default() -> Self {

        let preset = |ram, disk, cores: &str, time| Preset {

            ram,

            disk,

            cores: cores.parse().unwrap_or(Amount::Abs(1)),

            time: Dur::secs(time),

        };

        let sizes = BTreeMap::from([

            (

                "s".into(),

                preset(Bytes::mib(512), Bytes::mib(256), "1", 60),

            ),

            ("m".into(), preset(Bytes::gib(2), Bytes::gib(1), "4", 300)),

            ("l".into(), preset(Bytes::gib(6), Bytes::gib(5), "50%", 900)),

            (

                "xl".into(),

                preset(Bytes::gib(12), Bytes::gib(20), "100%", 2700),

            ),

        ]);

        Self {

            budget: Budget::default(),

            heavy: Heavy::default(),

            sizes,

            queue: Queue::default(),

            overrun: Overrun::default(),

            enforce: Enforce::default(),

            artifacts: Artifacts::default(),

            nix: Nix::default(),

            detect: Detect::default(),

        }

    }

}

impl Default for Budget {

    fn default() -> Self {

        Self {

            ram: Amount::Percent(75.0),

            ram_reserve: Bytes::gib(4),

            cores: Amount::Percent(100.0),

            disk_reserve: Bytes::gib(20),

            disk_paths: vec!["/nix/store".into()],

            psi_max: Some(40.0),

        }

    }

}

impl Default for Heavy {

    fn default() -> Self {

        Self {

            ram: Bytes::gib(4),

            cores: Amount::Percent(50.0),

            disk: Bytes::gib(5),

        }

    }

}

impl Default for Queue {

    fn default() -> Self {

        Self {

            linger: Dur::secs(5),

            backfill_max_time: Dur::secs(120),

            max_wait: None,

            elastic: true,

            intent_ttl: Dur::secs(1200),

        }

    }

}

impl Default for Overrun {

    fn default() -> Self {

        Self {

            ram: RamOverrun::Warn,

            ram_slack: 1.25,

            time_grace: 1.5,

            remind_every: Dur::secs(300),

        }

    }

}

impl Default for Enforce {

    fn default() -> Self {

        Self {

            unwrapped: Unwrapped::Deny,

            default_size: "m".into(),

        }

    }

}

impl Default for Artifacts {

    fn default() -> Self {

        let rule = |name: &str, marker: Option<&str>| Rule {

            name: name.into(),

            marker: marker.map(Into::into),

            clean: None,

        };

        Self {

            project_cap: Bytes::gib(10),

            global_cap: Bytes::gib(60),

            idle_after: Dur::secs(86_400),

            size_ttl: Dur::secs(600),

            over_cap: OverCap::Warn,

            stop: StopPolicy::Nudge,

            rules: vec![

                rule("target", Some("Cargo.toml")),

                rule("result*", None),

                rule("node_modules", Some("package.json")),

                rule("zig-out", Some("build.zig")),

                rule(".zig-cache", Some("build.zig")),

                rule("_build", Some("dune-project")),

                rule("dist-newstyle", Some("cabal.project")),

            ],

            extra_rules: Vec::new(),

            nix_gc: false,

            nix_min_free: Bytes::gib(30),

        }

    }

}

impl Default for Nix {

    fn default() -> Self {

        Self {

            inject: true,

            cores_per_job: 4,

        }

    }

}

impl Default for Detect {

    fn default() -> Self {

        let commands = [

            "cargo build",

            "cargo b",

            "cargo test",

            "cargo t",

            "cargo check",

            "cargo c",

            "cargo clippy",

            "cargo run",

            "cargo r",

            "cargo nextest",

            "cargo bench",

            "cargo install",

            "cargo doc",

            "nix build",

            "nix flake check",

            "nix develop",

            "nix run",

            "nix shell",

            "nix-build",

            "nix-shell",

            "nixos-rebuild",

            "home-manager switch",

            "home-manager build",

            "make",

            "gmake",

            "cmake --build",

            "ninja",

            "meson compile",

            "go build",

            "go test",

            "zig build",

            "dune build",

            "cabal build",

            "stack build",

            "npm run build",

            "npm test",

            "npm ci",

            "npm install",

            "pnpm build",

            "pnpm install",

            "yarn build",

            "bun run build",

            "docker build",

            "podman build",

            "mvn",

            "gradle",

            "./gradlew",

            "bazel build",

            "bazel test",

        ];

        Self {

            commands: commands.into_iter().map(Into::into).collect(),

            extra: Vec::new(),

        }

    }

}

impl Config {

    pub fn load() -> Result<Self, String> {

        let path = paths::config_file();

        match fs::read_to_string(&path) {

            Ok(text) => Self::parse(&text).map_err(|e| format!("{}: {e}", path.display())),

            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(Self::default()),

            Err(e) => Err(format!("{}: {e}", path.display())),

        }

    }

    pub fn parse(text: &str) -> Result<Self, toml::de::Error> {

        let mut config: Self = toml::from_str(text)?;

        for (name, preset) in Self::default().sizes {

            config.sizes.entry(name).or_insert(preset);

        }

        Ok(config)

    }

    pub fn preset(&self, name: &str) -> Result<Preset, String> {

        self.sizes.get(name).copied().ok_or_else(|| {

            let known: Vec<_> = self.sizes.keys().map(String::as_str).collect();

            format!(

                "unknown size '{name}', known sizes are {}",

                known.join(", ")

            )

        })

    }

    pub fn artifact_rules(&self) -> impl Iterator<Item = &Rule> {

        self.artifacts

            .rules

            .iter()

            .chain(&self.artifacts.extra_rules)

    }

    pub fn detect_patterns(&self) -> impl Iterator<Item = &str> {

        self.detect

            .commands

            .iter()

            .chain(&self.detect.extra)

            .map(String::as_str)

    }

}