onedrop_gui/

settings.rs

//! Persistent user settings for the OneDrop GUI.
//!
//! Stored at `${XDG_CONFIG_HOME:-~/.config}/onedrop/settings.toml`.
//! The file is loaded once at startup; the Options overlay calls
//! [`Settings::save`] whenever the user tweaks a value so the change
//! survives the next launch.
//!
//! Runtime state that isn't user-authored (ratings, history) lives
//! under [`data_dir()`] — `${XDG_DATA_HOME:-~/.local/share}/onedrop/`.
//! Use [`data_path`] to resolve a leaf file inside it.

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

/// User-facing knobs persisted between launches.
///
/// Every field is `pub` so the Options UI can edit them in place. We
/// intentionally don't validate ranges here — the renderer setters
/// (`set_mesh_size`, etc.) clamp at apply time.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct Settings {
    /// Visuals tab.
    #[serde(default)]
    pub visuals: VisualsSettings,
    /// Engine tab.
    #[serde(default)]
    pub engine: EngineSettings,
    /// Playback tab.
    #[serde(default)]
    pub playback: PlaybackSettings,
    /// Audio tab.
    #[serde(default)]
    pub audio: AudioSettings,
    /// Window tab.
    #[serde(default)]
    pub window: WindowSettings,
    /// Preset library behaviour: selection mode, transition feel,
    /// history depth. Persisted ratings live separately under
    /// [`data_path`] so the user-facing config stays human-curated.
    #[serde(default)]
    pub presets: PresetsSettings,
    /// Keymap overrides. Empty by default — the GUI's built-in
    /// MD2-style table applies until the user rebinds something.
    #[serde(default)]
    pub keymap: KeymapSettings,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VisualsSettings {
    /// Warp mesh column count. MD2 caps at 192.
    pub mesh_cols: u32,
    /// Warp mesh row count. MD2 caps at 96.
    pub mesh_rows: u32,
    /// VSync on at boot (changing this requires surface reconfigure;
    /// V1.0 honours it at startup only — flagged "restart" in the UI).
    pub vsync: bool,
    /// Frame-rate cap. `0` = unlimited. Honoured by the renderer's
    /// `RenderConfig::target_fps`. Currently advisory — the frame loop
    /// doesn't gate on it yet, but it gets persisted for V1.1.
    pub target_fps: u32,
    /// MSAA sample count. Pipeline-bound, requires restart in V1.0.
    pub msaa_samples: u32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EngineSettings {
    /// Mirror of `EngineConfig::enable_per_frame`. Hot-toggleable.
    pub enable_per_frame: bool,
    /// Mirror of `EngineConfig::enable_per_pixel`. Hot-toggleable but
    /// expensive — applied on the next preset load in practice.
    pub enable_per_pixel: bool,
    /// Mirror of `EngineConfig::transition_duration_s`. `0` = instant
    /// cut. MD2 default is 2.7s.
    pub transition_duration_s: f32,
    /// Mirror of `EngineConfig::profile`. Off in production; on enables
    /// the per-phase timing logger.
    pub profile: bool,
}

impl Default for VisualsSettings {
    fn default() -> Self {
        // 48×36 ("Medium" quality) matches RenderConfig::default().
        Self {
            mesh_cols: 48,
            mesh_rows: 36,
            vsync: true,
            target_fps: 60,
            msaa_samples: 1,
        }
    }
}

impl Default for EngineSettings {
    fn default() -> Self {
        Self {
            enable_per_frame: true,
            enable_per_pixel: false,
            transition_duration_s: 2.7,
            profile: false,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PlaybackSettings {
    /// Beat detection mode by name — `Off`, `HardCut1`..`HardCut6`.
    /// Stored as a string so we don't have to take a serde dep on the
    /// engine just for this enum.
    pub beat_detection_mode: String,
}

impl Default for PlaybackSettings {
    fn default() -> Self {
        Self {
            beat_detection_mode: "Off".to_string(),
        }
    }
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct AudioSettings {
    /// Preferred input device name, as reported by cpal's `name()`.
    /// `None` = use the OS default input device. If the named device
    /// disappears (unplugged, renamed) the GUI falls back to default
    /// with a warning logged.
    #[serde(default)]
    pub input_device: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WindowSettings {
    /// Render a corner HUD (FPS + preset name) over the visuals.
    pub hud: bool,
    /// Hide the mouse cursor after this many seconds of inactivity.
    /// `0` disables auto-hide.
    pub cursor_auto_hide_secs: f32,
}

impl Default for WindowSettings {
    fn default() -> Self {
        Self {
            hud: true,
            cursor_auto_hide_secs: 3.0,
        }
    }
}

/// Preset library settings — the bits of MD2's behaviour that survive
/// across launches.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresetsSettings {
    /// `random` → pick the next preset by weighted random;
    /// `sequential` → walk the queue in order. Cycled by `R`.
    pub mode: PresetSelectionMode,
    /// History ring depth (back-stack size). MD2's default is 64.
    pub history_size: usize,
    /// `true` → preset changes are blocked by the user (Scroll Lock).
    /// Persisted so a locked session survives a restart.
    pub locked: bool,
}

/// Random / sequential selection — what `R` toggles between.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum PresetSelectionMode {
    Random,
    Sequential,
}

impl Default for PresetsSettings {
    fn default() -> Self {
        Self {
            mode: PresetSelectionMode::Random,
            history_size: 64,
            locked: false,
        }
    }
}

/// Per-action keybind overrides, keyed by canonical action name
/// (see `onedrop-gui::keymap::Action::as_str`). Each value is a
/// human-readable binding string like `"Ctrl+Shift+K"` parsed by the
/// keymap loader. Unrecognised actions are ignored; unbound actions
/// inherit the GUI's built-in defaults.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct KeymapSettings {
    #[serde(default)]
    pub bindings: std::collections::BTreeMap<String, String>,
}

/// Resolve `${XDG_DATA_HOME:-~/.local/share}/onedrop/`. Returns
/// `None` only in stripped-down sandboxes that don't expose a data
/// dir. Callers should treat `None` as "don't persist" and keep going.
pub fn data_dir() -> Option<PathBuf> {
    dirs::data_dir().map(|p| p.join("onedrop"))
}

/// Resolve a leaf file inside [`data_dir`]. Convenience for the
/// `ratings.toml` / `history.toml` callers so they don't all repeat
/// the `.map(|d| d.join(...))` chain.
pub fn data_path(leaf: &str) -> Option<PathBuf> {
    data_dir().map(|d| d.join(leaf))
}

impl Settings {
    /// Resolve `${XDG_CONFIG_HOME:-~/.config}/onedrop/settings.toml`.
    /// Returns `None` if the OS doesn't expose a config dir (rare —
    /// only happens in stripped-down sandboxes).
    pub fn config_path() -> Option<PathBuf> {
        dirs::config_dir().map(|p| p.join("onedrop").join("settings.toml"))
    }

    /// Load from disk. Missing file → defaults, no error (first launch
    /// always lands here). Parse errors are logged and also fall back
    /// to defaults so a corrupted file doesn't brick the GUI.
    pub fn load() -> Self {
        let Some(path) = Self::config_path() else {
            log::warn!("No config dir available, using default settings");
            return Self::default();
        };
        let text = match std::fs::read_to_string(&path) {
            Ok(b) => b,
            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
                log::info!("No settings file at {}, using defaults", path.display());
                return Self::default();
            }
            Err(e) => {
                log::warn!("Failed to read {}: {} — using defaults", path.display(), e);
                return Self::default();
            }
        };
        match toml::from_str::<Settings>(&text) {
            Ok(s) => {
                log::info!("Loaded settings from {}", path.display());
                s
            }
            Err(e) => {
                log::warn!("Failed to parse {}: {} — using defaults", path.display(), e);
                Self::default()
            }
        }
    }

    /// Best-effort serialize back to disk. Creates the parent dir if
    /// missing. Failures are logged but never propagate — a write
    /// failure shouldn't crash the visualiser mid-show.
    pub fn save(&self) {
        let Some(path) = Self::config_path() else {
            log::warn!("No config dir available, skipping settings save");
            return;
        };
        if let Some(parent) = path.parent()
            && let Err(e) = std::fs::create_dir_all(parent)
        {
            log::warn!(
                "Failed to create {}: {} — settings not saved",
                parent.display(),
                e
            );
            return;
        }
        match toml::to_string_pretty(self) {
            Ok(s) => {
                if let Err(e) = std::fs::write(&path, s) {
                    log::warn!("Failed to write {}: {}", path.display(), e);
                } else {
                    log::debug!("Saved settings to {}", path.display());
                }
            }
            Err(e) => log::warn!("Failed to serialize settings: {}", e),
        }
    }
}