onedrop_engine/

preset_manager.rs

//! Preset management and transitions.

use std::collections::{HashMap, VecDeque};
use std::path::{Path, PathBuf};

use crate::history::History;

/// Random / sequential selection. Cycled by the GUI's `R` key.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SelectionMode {
    Random,
    Sequential,
}

/// Preset manager handling library navigation, mode/lock/ratings,
/// and crossfade transitions.
pub struct PresetManager {
    /// Library queue — populated at startup by walking the preset dir.
    preset_queue: VecDeque<PathBuf>,

    /// Cursor into `preset_queue`. Sequential navigation walks this;
    /// random navigation rewrites it before reading.
    current_index: usize,

    /// Crossfade transition state.
    transition: TransitionState,

    /// History ring — records every preset actually loaded via
    /// [`advance`] (and friends) so `Backspace` can walk back through
    /// what the user has seen, not just the queue order.
    history: History<PathBuf>,

    /// Scroll Lock state. When `true`, [`advance`] / [`retreat`] return
    /// `None` so the engine keeps showing the current preset.
    locked: bool,

    /// Random vs sequential selection mode.
    mode: SelectionMode,

    /// Per-preset rating in `[0, 5]`. Unrated entries fall back to the
    /// default 3 when sampling. Sampling weight is `2^rating`.
    ratings: HashMap<PathBuf, u8>,

    /// Where ratings persist. `None` disables persistence (tests).
    ratings_path: Option<PathBuf>,
}

/// Transition state between presets.
#[derive(Debug, Clone)]
pub enum TransitionState {
    /// No transition in progress
    None,

    /// Transitioning between presets
    Transitioning {
        /// Progress (0.0 to 1.0)
        progress: f32,

        /// Duration in seconds
        duration: f32,

        /// Elapsed time
        elapsed: f32,
    },
}

/// Default rating for an unrated preset. Picked at the middle of the
/// `[0, 5]` window so unrated presets sit between user-disliked (0–2)
/// and user-liked (4–5) when weighted-random sampling.
pub const DEFAULT_RATING: u8 = 3;

/// Cap for the history ring. Matches MilkDrop's default.
pub const DEFAULT_HISTORY_SIZE: usize = 64;

impl PresetManager {
    /// Create a new preset manager with no persistence.
    pub fn new() -> Self {
        Self::with_history_size(DEFAULT_HISTORY_SIZE)
    }

    /// Create a new preset manager with a specific history cap.
    pub fn with_history_size(history_size: usize) -> Self {
        Self {
            preset_queue: VecDeque::new(),
            current_index: 0,
            transition: TransitionState::None,
            history: History::new(history_size.max(1)),
            locked: false,
            mode: SelectionMode::Random,
            ratings: HashMap::new(),
            ratings_path: None,
        }
    }

    /// Point the manager at a TOML file for persisted ratings and load
    /// whatever's already on disk. Missing / unreadable / unparseable
    /// files fall back to "no ratings" — the call never fails.
    pub fn attach_ratings_file(&mut self, path: PathBuf) {
        self.ratings = load_ratings(&path);
        self.ratings_path = Some(path);
    }

    /// Add a preset to the queue.
    pub fn add_preset<P: AsRef<Path>>(&mut self, path: P) {
        self.preset_queue.push_back(path.as_ref().to_path_buf());
    }

    /// Add multiple presets to the queue.
    pub fn add_presets<P: AsRef<Path>>(&mut self, paths: &[P]) {
        for path in paths {
            self.add_preset(path);
        }
    }

    /// Get the next preset path (sequential walk, ignores mode / lock).
    pub fn next_preset(&mut self) -> Option<&Path> {
        if self.preset_queue.is_empty() {
            return None;
        }

        self.current_index = (self.current_index + 1) % self.preset_queue.len();
        self.preset_queue
            .get(self.current_index)
            .map(|p| p.as_path())
    }

    /// Get the previous preset path (sequential walk, ignores mode / lock).
    pub fn prev_preset(&mut self) -> Option<&Path> {
        if self.preset_queue.is_empty() {
            return None;
        }

        if self.current_index == 0 {
            self.current_index = self.preset_queue.len() - 1;
        } else {
            self.current_index -= 1;
        }

        self.preset_queue
            .get(self.current_index)
            .map(|p| p.as_path())
    }

    /// Get the current preset path.
    pub fn current_preset(&self) -> Option<&Path> {
        self.preset_queue
            .get(self.current_index)
            .map(|p| p.as_path())
    }

    /// Pick a uniformly-random preset (ignores ratings, mode, lock).
    /// Used by the beat detector for forced cuts where the user has
    /// asked for randomness independent of selection mode.
    pub fn random_preset(&mut self) -> Option<&Path> {
        if self.preset_queue.is_empty() {
            return None;
        }
        let pick = quick_random_seed() % self.preset_queue.len();
        self.current_index = pick;
        self.preset_queue
            .get(self.current_index)
            .map(|p| p.as_path())
    }

    /// Pick a rating-weighted random preset. Probability of selecting
    /// a preset is proportional to `2^rating(preset)` — a rating-5
    /// preset is 32× more likely than a rating-0 one. Unrated presets
    /// use [`DEFAULT_RATING`].
    pub fn random_weighted_by_rating(&mut self) -> Option<&Path> {
        if self.preset_queue.is_empty() {
            return None;
        }

        let weights: Vec<u64> = self
            .preset_queue
            .iter()
            .map(|p| {
                let r = self.ratings.get(p).copied().unwrap_or(DEFAULT_RATING);
                1u64 << r.min(5)
            })
            .collect();
        let total: u64 = weights.iter().sum();
        if total == 0 {
            return self.random_preset();
        }
        let mut pick = (quick_random_seed() as u64) % total;
        for (i, &w) in weights.iter().enumerate() {
            if pick < w {
                self.current_index = i;
                return self.preset_queue.get(i).map(|p| p.as_path());
            }
            pick -= w;
        }
        // Floating-point of sorts — should never reach here with integer
        // weights, but fall back to last entry just in case.
        self.current_index = self.preset_queue.len() - 1;
        self.preset_queue
            .get(self.current_index)
            .map(|p| p.as_path())
    }

    /// High-level "user pressed Space / Right arrow": respect lock,
    /// dispatch on mode, record the result in history. Returns
    /// `None` when locked, when the queue is empty, or when the
    /// current implementation can't produce a candidate.
    pub fn advance(&mut self) -> Option<PathBuf> {
        if self.locked {
            return None;
        }
        let picked = match self.mode {
            SelectionMode::Random => self.random_weighted_by_rating().map(Path::to_path_buf),
            SelectionMode::Sequential => self.next_preset().map(Path::to_path_buf),
        };
        if let Some(ref p) = picked {
            self.history.push(p.clone());
        }
        picked
    }

    /// History-aware "Backspace": walks the history ring back one
    /// entry and returns it. Falls back to the sequential
    /// [`prev_preset`] when the history has no prior entry. Honours
    /// the lock.
    pub fn retreat(&mut self) -> Option<PathBuf> {
        if self.locked {
            return None;
        }
        // History::back() returns the entry one step before the
        // current cursor when possible. The very first call (cursor
        // at None) jumps to the tail — which is the just-pushed
        // current preset — so we shift one more step back to skip it.
        if self.history.can_go_back() {
            let back = self.history.back().cloned();
            // If we landed on the same preset as current, step once more.
            if let Some(b) = &back
                && self.current_preset().map(Path::to_path_buf).as_ref() == Some(b)
                && self.history.can_go_back()
            {
                return self.history.back().cloned();
            }
            return back;
        }
        self.prev_preset().map(Path::to_path_buf)
    }

    // ----- Lock --------------------------------------------------------

    /// True when preset changes are blocked.
    pub fn is_locked(&self) -> bool {
        self.locked
    }

    /// Set the lock state outright (used by Scroll Lock keybind and by
    /// the GUI's startup hydration from `Settings::presets.locked`).
    pub fn set_locked(&mut self, locked: bool) {
        self.locked = locked;
    }

    /// Flip the lock state and return the new value.
    pub fn toggle_lock(&mut self) -> bool {
        self.locked = !self.locked;
        self.locked
    }

    // ----- Mode --------------------------------------------------------

    pub fn mode(&self) -> SelectionMode {
        self.mode
    }

    pub fn set_mode(&mut self, mode: SelectionMode) {
        self.mode = mode;
    }

    /// `R` keybind: cycle Random ↔ Sequential and return the new mode.
    pub fn cycle_mode(&mut self) -> SelectionMode {
        self.mode = match self.mode {
            SelectionMode::Random => SelectionMode::Sequential,
            SelectionMode::Sequential => SelectionMode::Random,
        };
        self.mode
    }

    // ----- Ratings -----------------------------------------------------

    /// Rating of an arbitrary preset path. Unrated → [`DEFAULT_RATING`].
    pub fn rating(&self, path: &Path) -> u8 {
        self.ratings.get(path).copied().unwrap_or(DEFAULT_RATING)
    }

    /// Rating of the currently-cursor'd preset.
    pub fn current_rating(&self) -> Option<u8> {
        self.current_preset().map(|p| self.rating(p))
    }

    /// Set a preset's rating (clamped to `[0, 5]`) and persist.
    pub fn set_rating(&mut self, path: &Path, rating: u8) {
        let clamped = rating.min(5);
        self.ratings.insert(path.to_path_buf(), clamped);
        self.persist_ratings();
    }

    /// Nudge the current preset's rating by `delta` (+/-), clamped to
    /// `[0, 5]`. Returns the new rating, or `None` if no current preset.
    pub fn nudge_current_rating(&mut self, delta: i32) -> Option<u8> {
        let path = self.current_preset()?.to_path_buf();
        let cur = self.rating(&path) as i32;
        let next = (cur + delta).clamp(0, 5) as u8;
        self.ratings.insert(path, next);
        self.persist_ratings();
        Some(next)
    }

    fn persist_ratings(&self) {
        let Some(path) = self.ratings_path.as_ref() else {
            return;
        };
        save_ratings(path, &self.ratings);
    }

    // ----- Transitions (unchanged) ------------------------------------

    /// Start a transition to the next preset.
    pub fn start_transition(&mut self, duration: f32) {
        self.transition = TransitionState::Transitioning {
            progress: 0.0,
            duration,
            elapsed: 0.0,
        };
    }

    /// Update transition state.
    pub fn update_transition(&mut self, delta_time: f32) -> bool {
        match &mut self.transition {
            TransitionState::Transitioning {
                progress,
                duration,
                elapsed,
            } => {
                *elapsed += delta_time;
                *progress = (*elapsed / *duration).min(1.0);

                if *progress >= 1.0 {
                    self.transition = TransitionState::None;
                    true // Transition complete
                } else {
                    false
                }
            }
            TransitionState::None => true,
        }
    }

    /// Get transition progress (0.0 to 1.0).
    pub fn transition_progress(&self) -> f32 {
        match &self.transition {
            TransitionState::Transitioning { progress, .. } => *progress,
            TransitionState::None => 1.0,
        }
    }

    /// Check if transitioning.
    pub fn is_transitioning(&self) -> bool {
        matches!(self.transition, TransitionState::Transitioning { .. })
    }

    /// Clear all presets.
    pub fn clear(&mut self) {
        self.preset_queue.clear();
        self.current_index = 0;
        self.transition = TransitionState::None;
        self.history.clear();
    }

    /// Get number of presets in queue.
    pub fn preset_count(&self) -> usize {
        self.preset_queue.len()
    }

    /// Shuffle presets.
    pub fn shuffle(&mut self) {
        if self.preset_queue.len() <= 1 {
            return;
        }
        let seed = quick_random_seed();
        let mut indices: Vec<usize> = (0..self.preset_queue.len()).collect();
        // Fisher-Yates
        for i in (1..indices.len()).rev() {
            let j = (seed.wrapping_add(i)) % (i + 1);
            indices.swap(i, j);
        }
        let mut new_queue = VecDeque::with_capacity(self.preset_queue.len());
        for idx in indices {
            if let Some(preset) = self.preset_queue.get(idx) {
                new_queue.push_back(preset.clone());
            }
        }
        self.preset_queue = new_queue;
        self.current_index = 0;
    }
}

impl Default for PresetManager {
    fn default() -> Self {
        Self::new()
    }
}

/// Simple wall-clock seed for the navigation RNG. The visualiser doesn't
/// need cryptographic randomness — frame-to-frame variation from the
/// nanosecond clock is plenty for preset shuffling.
fn quick_random_seed() -> usize {
    use std::time::{SystemTime, UNIX_EPOCH};
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map(|d| d.as_nanos() as usize)
        .unwrap_or(0)
}

/// On-disk format for ratings: a flat `[ratings]` table of path →
/// integer. Stored as a `String`-keyed map so paths with non-UTF8
/// bytes degrade gracefully (skipped, never panic).
#[derive(Debug, Default, serde::Serialize, serde::Deserialize)]
struct RatingsFile {
    #[serde(default)]
    ratings: HashMap<String, u8>,
}

fn load_ratings(path: &Path) -> HashMap<PathBuf, u8> {
    let text = match std::fs::read_to_string(path) {
        Ok(s) => s,
        Err(_) => return HashMap::new(),
    };
    let parsed: RatingsFile = match toml::from_str(&text) {
        Ok(r) => r,
        Err(e) => {
            log::warn!(
                "Failed to parse ratings file {}: {} — starting fresh",
                path.display(),
                e
            );
            return HashMap::new();
        }
    };
    parsed
        .ratings
        .into_iter()
        .map(|(k, v)| (PathBuf::from(k), v.min(5)))
        .collect()
}

fn save_ratings(path: &Path, ratings: &HashMap<PathBuf, u8>) {
    if let Some(parent) = path.parent()
        && let Err(e) = std::fs::create_dir_all(parent)
    {
        log::warn!(
            "Failed to create {} for ratings save: {}",
            parent.display(),
            e
        );
        return;
    }
    let file = RatingsFile {
        ratings: ratings
            .iter()
            .filter_map(|(k, v)| k.to_str().map(|s| (s.to_string(), *v)))
            .collect(),
    };
    match toml::to_string_pretty(&file) {
        Ok(s) => {
            if let Err(e) = std::fs::write(path, s) {
                log::warn!("Failed to write ratings to {}: {}", path.display(), e);
            }
        }
        Err(e) => log::warn!("Failed to serialise ratings: {}", e),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_preset_manager_creation() {
        let manager = PresetManager::new();
        assert_eq!(manager.preset_count(), 0);
    }

    #[test]
    fn test_add_presets() {
        let mut manager = PresetManager::new();

        manager.add_preset("preset1.milk");
        manager.add_preset("preset2.milk");
        manager.add_preset("preset3.milk");

        assert_eq!(manager.preset_count(), 3);
    }

    #[test]
    fn test_navigation() {
        let mut manager = PresetManager::new();

        manager.add_preset("preset1.milk");
        manager.add_preset("preset2.milk");
        manager.add_preset("preset3.milk");

        // Current should be first
        assert_eq!(
            manager.current_preset().unwrap().to_str().unwrap(),
            "preset1.milk"
        );

        // Next
        manager.next_preset();
        assert_eq!(
            manager.current_preset().unwrap().to_str().unwrap(),
            "preset2.milk"
        );

        // Next again
        manager.next_preset();
        assert_eq!(
            manager.current_preset().unwrap().to_str().unwrap(),
            "preset3.milk"
        );

        // Wrap around
        manager.next_preset();
        assert_eq!(
            manager.current_preset().unwrap().to_str().unwrap(),
            "preset1.milk"
        );

        // Previous
        manager.prev_preset();
        assert_eq!(
            manager.current_preset().unwrap().to_str().unwrap(),
            "preset3.milk"
        );
    }

    #[test]
    fn test_transition() {
        let mut manager = PresetManager::new();

        manager.start_transition(1.0);
        assert!(manager.is_transitioning());
        assert_eq!(manager.transition_progress(), 0.0);

        // Update halfway
        manager.update_transition(0.5);
        assert!(manager.is_transitioning());
        assert!((manager.transition_progress() - 0.5).abs() < 0.01);

        // Complete transition
        manager.update_transition(0.5);
        assert!(!manager.is_transitioning());
        assert_eq!(manager.transition_progress(), 1.0);
    }

    #[test]
    fn test_shuffle() {
        let mut manager = PresetManager::new();

        for i in 0..10 {
            manager.add_preset(format!("preset{}.milk", i));
        }

        let _original_first = manager.current_preset().unwrap().to_path_buf();

        manager.shuffle();

        // After shuffle, should still have same count
        assert_eq!(manager.preset_count(), 10);

        // First preset might be different (not guaranteed, but likely)
        // Just check that we can still navigate
        assert!(manager.current_preset().is_some());
    }

    #[test]
    fn lock_blocks_advance_and_retreat() {
        let mut m = PresetManager::new();
        m.add_preset("a.milk");
        m.add_preset("b.milk");
        m.set_locked(true);
        assert!(m.advance().is_none(), "advance must respect lock");
        assert!(m.retreat().is_none(), "retreat must respect lock");
        m.toggle_lock();
        assert!(!m.is_locked());
        assert!(m.advance().is_some(), "advance must work once unlocked");
    }

    #[test]
    fn cycle_mode_alternates_random_and_sequential() {
        let mut m = PresetManager::new();
        assert_eq!(m.mode(), SelectionMode::Random);
        assert_eq!(m.cycle_mode(), SelectionMode::Sequential);
        assert_eq!(m.cycle_mode(), SelectionMode::Random);
    }

    #[test]
    fn ratings_clamp_to_zero_through_five() {
        let mut m = PresetManager::new();
        m.add_preset("a.milk");
        let path = m.current_preset().unwrap().to_path_buf();
        m.set_rating(&path, 99);
        assert_eq!(m.rating(&path), 5);
        m.set_rating(&path, 0);
        assert_eq!(m.rating(&path), 0);
    }

    #[test]
    fn nudge_current_rating_walks_within_range() {
        let mut m = PresetManager::new();
        m.add_preset("a.milk");
        assert_eq!(m.nudge_current_rating(1), Some(DEFAULT_RATING + 1));
        assert_eq!(m.nudge_current_rating(-10), Some(0));
        assert_eq!(m.nudge_current_rating(99), Some(5));
    }

    #[test]
    fn sequential_advance_walks_history_forward() {
        let mut m = PresetManager::new();
        m.add_preset("a.milk");
        m.add_preset("b.milk");
        m.add_preset("c.milk");
        m.set_mode(SelectionMode::Sequential);
        let first = m.advance().unwrap();
        assert_eq!(first.to_str().unwrap(), "b.milk");
        let second = m.advance().unwrap();
        assert_eq!(second.to_str().unwrap(), "c.milk");
        // retreat walks back through history (one before current tail)
        let back = m.retreat().unwrap();
        assert_eq!(back.to_str().unwrap(), "b.milk");
    }

    #[test]
    fn weighted_random_falls_back_to_uniform_with_empty_ratings() {
        let mut m = PresetManager::new();
        m.add_preset("a.milk");
        m.add_preset("b.milk");
        // Without ratings every preset uses DEFAULT_RATING, so weights
        // are equal — picking just returns *some* preset, not None.
        assert!(m.random_weighted_by_rating().is_some());
    }

    #[test]
    fn ratings_roundtrip_through_file() {
        let tmp =
            std::env::temp_dir().join(format!("onedrop-test-ratings-{}.toml", quick_random_seed()));
        // Setup: rate a preset, persist.
        {
            let mut m = PresetManager::new();
            m.attach_ratings_file(tmp.clone());
            m.add_preset("/abs/path/a.milk");
            m.set_rating(Path::new("/abs/path/a.milk"), 4);
        }
        // Reload: rating must be there.
        let mut m2 = PresetManager::new();
        m2.attach_ratings_file(tmp.clone());
        assert_eq!(m2.rating(Path::new("/abs/path/a.milk")), 4);
        let _ = std::fs::remove_file(tmp);
    }
}