monolith

//! The TOML config. Parsing and validation only, the compositor applies it.

use monolith_ipc::Command;

use regex::Regex;

use serde::Deserialize;

use serde::de::DeserializeOwned;

use std::fmt;

use std::path::{Path, PathBuf};

pub const DEFAULT: &str = include_str!("../default.toml");

#[derive(Debug, Clone)]

pub struct Config {

    pub general: General,

    pub output: Outputs,

    pub decoration: Decoration,

    pub animation: Animation,

    pub keyboard: Keyboard,

    pub binds: Vec<Bind>,

    pub rules: Vec<Rule>,

    pub startup: Vec<Vec<String>>,

}

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

#[serde(default, deny_unknown_fields)]

pub struct General {

    /// What `Mod` means in binds.

    #[serde(rename = "mod")]

    pub mod_key: Modifier,

    pub gaps: Gaps,

    /// What a window move does when it meets a neighbour.

    #[serde(rename = "move")]

    pub move_mode: MoveMode,

    pub focus_follows_mouse: bool,

    pub mouse_follows_focus: bool,

    /// The first window to land on or move to an empty tag nobody is

    /// viewing brings that tag into view on its output.

    pub view_tag_on_first_window: bool,

}

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

#[serde(rename_all = "lowercase")]

pub enum MoveMode {

    /// Trade places with it.

    #[default]

    Swap,

    /// Join its lane, stacking with it if it is alone.

    Merge,

}

impl Default for General {

    fn default() -> Self {

        Self {

            mod_key: Modifier::Super,

            gaps: Gaps::default(),

            move_mode: MoveMode::Swap,

            focus_follows_mouse: false,

            mouse_follows_focus: false,

            view_tag_on_first_window: true,

        }

    }

}

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

#[serde(default, deny_unknown_fields)]

pub struct Gaps {

    pub inner: f64,

    pub outer: f64,

}

impl Default for Gaps {

    fn default() -> Self {

        Self {

            inner: 8.0,

            outer: 8.0,

        }

    }

}

#[derive(Deserialize, Debug, Clone, PartialEq, Default)]

#[serde(default)]

pub struct Outputs {

    pub vrr: Vrr,

    /// Settings for one connector, by name, like `DP-1`.

    #[serde(flatten)]

    pub named: std::collections::BTreeMap<String, OutputConfig>,

}

/// Transform and position follow a reload. A new mode waits for a restart

/// or a replug, since it means a modeset.

#[derive(Deserialize, Debug, Clone, PartialEq, Default)]

#[serde(default, deny_unknown_fields)]

pub struct OutputConfig {

    pub transform: OutputTransform,

    /// Top left corner in the global layout. Outputs without one are placed

    /// to the right of the others.

    pub position: Option<[i32; 2]>,

    /// `WIDTHxHEIGHT` or `WIDTHxHEIGHT@HZ`. Without a rate the highest one

    /// for that size wins.

    pub mode: Option<String>,

}

/// Counterclockwise rotation, optionally after flipping horizontally.

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

#[serde(rename_all = "kebab-case")]

pub enum OutputTransform {

    #[default]

    Normal,

    #[serde(rename = "90")]

    Rotate90,

    #[serde(rename = "180")]

    Rotate180,

    #[serde(rename = "270")]

    Rotate270,

    Flipped,

    #[serde(rename = "flipped-90")]

    Flipped90,

    #[serde(rename = "flipped-180")]

    Flipped180,

    #[serde(rename = "flipped-270")]

    Flipped270,

}

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

#[serde(rename_all = "lowercase")]

pub enum Vrr {

    Off,

    On,

    /// Only while a fullscreen window is shown, where a game sets the pace.

    #[default]

    Fullscreen,

}

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

#[serde(default, deny_unknown_fields)]

pub struct Decoration {

    /// Border width in logical pixels, drawn in the gap around each window.

    pub border: u32,

    pub radius: Corners,

    pub focused: Color,

    pub unfocused: Color,

}

/// Corner radii in logical pixels, top left, top right, bottom right and

/// bottom left. One number rounds every corner alike.

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

#[serde(from = "CornersToml")]

pub struct Corners(pub [u32; 4]);

#[derive(Deserialize)]

#[serde(

    untagged,

    expecting = "expected a number or [top left, top right, bottom right, bottom left]"

)]

enum CornersToml {

    All(u32),

    Each([u32; 4]),

}

impl From<CornersToml> for Corners {

    fn from(c: CornersToml) -> Self {

        match c {

            CornersToml::All(r) => Self([r; 4]),

            CornersToml::Each(r) => Self(r),

        }

    }

}

impl Default for Decoration {

    fn default() -> Self {

        Self {

            border: 2,

            radius: Corners([0; 4]),

            focused: Color::rgb(0x88, 0xbf, 0xd1),

            unfocused: Color::rgb(0x3b, 0x42, 0x52),

        }

    }

}

/// Straight RGBA from `#rrggbb` or `#rrggbbaa`.

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

pub struct Color(pub [f32; 4]);

impl Color {

    pub const fn rgb(r: u8, g: u8, b: u8) -> Self {

        Self([r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0, 1.0])

    }

}

impl<'de> Deserialize<'de> for Color {

    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {

        let s = String::deserialize(d)?;

        let hex = s.strip_prefix('#').unwrap_or(&s);

        let bad =

            || serde::de::Error::custom(format!("bad colour {s:?}, use #rrggbb or #rrggbbaa"));

        if !matches!(hex.len(), 6 | 8) || !hex.is_ascii() {

            return Err(bad());

        }

        let mut c = [1.0f32; 4];

        for (i, v) in c.iter_mut().enumerate().take(hex.len() / 2) {

            let byte = u8::from_str_radix(&hex[i * 2..i * 2 + 2], 16).map_err(|_| bad())?;

            *v = f32::from(byte) / 255.0;

        }

        Ok(Self(c))

    }

}

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

#[serde(default, deny_unknown_fields)]

pub struct Animation {

    pub enabled: bool,

    pub style: AnimationStyle,

    /// Every phase of a planned transition lasts this long.

    pub phase_ms: u64,

    /// A cubic bezier, as in CSS.

    pub curve: [f64; 4],

}

impl Default for Animation {

    fn default() -> Self {

        Self {

            enabled: true,

            style: AnimationStyle::Orthogonal,

            phase_ms: 160,

            curve: [0.45, 0.0, 0.2, 1.0],

        }

    }

}

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

#[serde(rename_all = "lowercase")]

pub enum AnimationStyle {

    Orthogonal,

    Direct,

}

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

#[serde(default, deny_unknown_fields)]

pub struct Keyboard {

    pub rules: String,

    pub model: String,

    pub layout: String,

    pub variant: String,

    pub options: Option<String>,

    pub repeat_delay: i32,

    pub repeat_rate: i32,

}

impl Default for Keyboard {

    fn default() -> Self {

        Self {

            rules: String::new(),

            model: String::new(),

            layout: String::new(),

            variant: String::new(),

            options: None,

            repeat_delay: 200,

            repeat_rate: 25,

        }

    }

}

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

#[serde(rename_all = "lowercase")]

pub enum Modifier {

    Super,

    Alt,

    Ctrl,

    Shift,

}

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

pub struct Mods {

    pub logo: bool,

    pub alt: bool,

    pub ctrl: bool,

    pub shift: bool,

}

impl Mods {

    pub fn has(&self, m: Modifier) -> bool {

        match m {

            Modifier::Super => self.logo,

            Modifier::Alt => self.alt,

            Modifier::Ctrl => self.ctrl,

            Modifier::Shift => self.shift,

        }

    }

    fn set(&mut self, m: Modifier) {

        match m {

            Modifier::Super => self.logo = true,

            Modifier::Alt => self.alt = true,

            Modifier::Ctrl => self.ctrl = true,

            Modifier::Shift => self.shift = true,

        }

    }

}

#[derive(Debug, Clone, PartialEq)]

pub struct Bind {

    pub mods: Mods,

    /// An xkb keysym name, resolved by the compositor.

    pub key: String,

    pub command: Command,

}

#[derive(Debug, Clone)]

pub struct Rule {

    pub app_id: Option<Regex>,

    pub title: Option<Regex>,

    pub tag: Option<String>,

    pub output: Option<String>,

    pub floating: Option<bool>,

    pub sticky: Option<bool>,

    pub scratchpad: Option<String>,

}

/// Everything the matching rules say about a window, later rules winning.

#[derive(Debug, Clone, Default, PartialEq)]

pub struct Placement {

    pub tag: Option<String>,

    pub output: Option<String>,

    pub floating: Option<bool>,

    pub sticky: Option<bool>,

    pub scratchpad: Option<String>,

}

#[derive(Debug)]

pub enum Error {

    Io(PathBuf, std::io::Error),

    Toml(toml::de::Error),

}

impl fmt::Display for Error {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        match self {

            Error::Io(p, e) => write!(f, "{}: {e}", p.display()),

            Error::Toml(e) => write!(f, "{e}"),

        }

    }

}

impl std::error::Error for Error {}

#[derive(Deserialize)]

#[serde(untagged)]

enum Words {

    Line(String),

    List(Vec<String>),

}

#[derive(Deserialize)]

#[serde(deny_unknown_fields)]

struct RawRule {

    app_id: Option<String>,

    title: Option<String>,

    tag: Option<String>,

    output: Option<String>,

    floating: Option<bool>,

    sticky: Option<bool>,

    scratchpad: Option<String>,

}

impl Config {

    /// `$MONOLITH_CONFIG`, else `$XDG_CONFIG_HOME/monolith/config.toml`.

    pub fn path() -> Option<PathBuf> {

        if let Some(p) = std::env::var_os("MONOLITH_CONFIG") {

            return Some(p.into());

        }

        let base = std::env::var_os("XDG_CONFIG_HOME")

            .map(PathBuf::from)

            .or_else(|| std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".config")))?;

        Some(base.join("monolith/config.toml"))

    }

    /// Loads `path`, or the built-in default when it does not exist.

    pub fn load(path: Option<&Path>) -> Result<Loaded, Error> {

        match path {

            Some(p) => match std::fs::read_to_string(p) {

                Ok(text) => Self::parse(&text),

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

                Err(e) => Err(Error::Io(p.to_owned(), e)),

            },

            None => Self::parse(DEFAULT),

        }

    }

    /// Only broken TOML fails. A bad option, bind or rule is left out with a

    /// warning, so one typo does not throw away the rest of the file.

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

        let mut table: toml::Table = toml::from_str(text).map_err(Error::Toml)?;

        let mut warnings = Vec::new();

        let w = &mut warnings;

        let general: General = section("general", table.remove("general"), w);

        let keyboard = section("keyboard", table.remove("keyboard"), w);

        let animation = section("animation", table.remove("animation"), w);

        let decoration = section("decoration", table.remove("decoration"), w);

        let output: Outputs = section("output", table.remove("output"), w);

        for name in output.named.keys().filter(|n| !connector_like(n)) {

            w.push(format!(

                "output.{name}: not a connector name like DP-1 or HDMI-A-1, matches nothing"

            ));

        }

        let startup = items("startup", table.remove("startup"), w);

        let mut binds = Vec::new();

        if let Some(value) = table.remove("binds") {

            let entries: toml::Table = entry("binds", value, w).unwrap_or_default();

            for (combo, value) in entries {

                let name = format!("binds.{combo:?}");

                let bind = entry::<Words>(&name, value, w)

                    .map(|words| parse_bind(&combo, words, general.mod_key));

                match bind {

                    Some(Ok(b)) => binds.push(b),

                    Some(Err(e)) => w.push(format!("{name}: {e}, left out")),

                    None => {}

                }

            }

        }

        let regex = |p: Option<String>| p.map(|p| Regex::new(&p)).transpose();

        let mut rules = Vec::new();

        for (i, raw) in items::<RawRule>("rules", table.remove("rules"), w)

            .into_iter()

            .enumerate()

        {

            match (regex(raw.app_id), regex(raw.title)) {

                (Ok(app_id), Ok(title)) => rules.push(Rule {

                    app_id,

                    title,

                    tag: raw.tag,

                    output: raw.output,

                    floating: raw.floating,

                    sticky: raw.sticky,

                    scratchpad: raw.scratchpad,

                }),

                (Err(e), _) | (_, Err(e)) => {

                    let e = e

                        .to_string()

                        .split_whitespace()

                        .collect::<Vec<_>>()

                        .join(" ");

                    w.push(format!("rules[{i}]: {e}, left out"));

                }

            }

        }

        for key in table.keys() {

            w.push(format!("unknown section [{key}], ignored"));

        }

        let config = Self {

            general,

            animation,

            decoration,

            output,

            keyboard,

            binds,

            rules,

            startup,

        };

        Ok(Loaded { config, warnings })

    }

    pub fn placement(&self, app_id: &str, title: &str) -> Placement {

        let mut p = Placement::default();

        let hit = |re: &Option<Regex>, s: &str| re.as_ref().is_none_or(|re| re.is_match(s));

        for r in &self.rules {

            if !hit(&r.app_id, app_id) || !hit(&r.title, title) {

                continue;

            }

            p.tag = r.tag.clone().or(p.tag);