path: root/src/queue.rs

/*
 * This file is a part of RSPlayer
 * Licensed under the GPL-3.0 License
 * Copyright (C) 2026 Salmonik @ salmonik@tuta.io
 * https://codeberg.org/salmonik/RSPlayer
*/

use rand::SeedableRng;
use rand::rngs::StdRng;
use rand::seq::SliceRandom;
use std::path::{Path, PathBuf};

#[derive(Debug, Clone, PartialEq)]
pub enum ShuffleMode {
    None,
    All,
    Album,
    Albums,
}

#[derive(Debug, Default, Clone)]
pub struct AudioMetadata {
    pub title: Option<String>,
    pub artist: Option<String>,
    pub album: Option<String>,
    pub track_number: Option<i32>,
    pub duration_secs: Option<f64>,
}

pub fn extract_metadata(path: &Path) -> Option<AudioMetadata> {
    use symphonia::core::formats::probe::Hint;
    use symphonia::core::io::MediaSourceStream;
    use symphonia::core::meta::StandardTag;

    let file = std::fs::File::open(path).ok()?;
    let mss = MediaSourceStream::new(Box::new(file), Default::default());

    let hint = Hint::new();
    let mut probed = symphonia::default::get_probe()
        .probe(&hint, mss, Default::default(), Default::default())
        .ok()?;

    // Extract duration from track's num_frames and time_base
    let duration_secs = probed
        .tracks()
        .iter()
        .find(|t| t.num_frames.is_some() && t.time_base.is_some())
        .and_then(|t| {
            let n_frames = t.num_frames?;
            let tb = t.time_base?;
            Some(n_frames as f64 * tb.numer.get() as f64 / tb.denom.get() as f64)
        });

    let mut metadata = AudioMetadata {
        duration_secs,
        ..Default::default()
    };

    {
        let mut meta = probed.metadata();
        if let Some(rev) = meta.skip_to_latest() {
            for tag in &rev.media.tags {
                match &tag.std {
                    Some(StandardTag::TrackTitle(value)) => {
                        metadata.title = Some(value.to_string());
                    }
                    Some(StandardTag::Artist(value)) => {
                        metadata.artist = Some(value.to_string());
                    }
                    Some(StandardTag::AlbumArtist(value)) => {
                        metadata.artist = Some(value.to_string());
                    }
                    Some(StandardTag::Album(value)) => {
                        metadata.album = Some(value.to_string());
                    }
                    Some(StandardTag::TrackNumber(value)) => {
                        metadata.track_number = value.to_string().parse().ok();
                    }
                    _ => {}
                }
            }
        }
    }

    if metadata.title.is_some()
        || metadata.artist.is_some()
        || metadata.album.is_some()
        || metadata.track_number.is_some()
        || metadata.duration_secs.is_some()
    {
        Some(metadata)
    } else {
        None
    }
}

#[derive(Debug, Clone)]
pub struct Track {
    pub path: PathBuf,
    pub title: Option<String>,
    pub artist: Option<String>,
    pub album: Option<String>,
    pub track_number: Option<i32>,
    pub duration_secs: Option<f64>,
    pub is_stream: bool,
}

impl Track {
    pub fn from_path(path: PathBuf) -> Self {
        let path_str = path.to_string_lossy();
        if path_str.starts_with("http://") || path_str.starts_with("https://") {
            return Track::from_url(&path_str);
        }
        let metadata = extract_metadata(&path);
        let metadata = metadata.as_ref();
        Track {
            path,
            title: metadata.and_then(|m| m.title.clone()),
            artist: metadata.and_then(|m| m.artist.clone()),
            album: metadata.and_then(|m| m.album.clone()),
            track_number: metadata.and_then(|m| m.track_number),
            duration_secs: metadata.and_then(|m| m.duration_secs),
            is_stream: false,
        }
    }

    pub fn from_url(url: &str) -> Self {
        let clean_url = url.split('?').next().unwrap_or(url);
        let url_path = Path::new(clean_url);
        let title = url_path
            .file_stem()
            .and_then(|s| s.to_str())
            .map(|s| s.to_string())
            .or_else(|| {
                url_path
                    .file_name()
                    .and_then(|s| s.to_str())
                    .map(|s| s.to_string())
            })
            .unwrap_or_else(|| url.to_string());
        Track {
            path: PathBuf::from(url),
            title: Some(title),
            artist: None,
            album: None,
            track_number: None,
            duration_secs: None,
            is_stream: true,
        }
    }

    pub fn display_string(&self, index: usize, total: usize) -> String {
        let album_artist = self
            .artist
            .clone()
            .or_else(|| self.album.clone())
            .unwrap_or_default();
        let title = self.title.clone().unwrap_or_else(|| {
            self.path
                .file_name()
                .and_then(|n| n.to_str())
                .unwrap_or("Unknown")
                .to_string()
        });
        let width = total.to_string().len();

        if album_artist.is_empty() {
            format!("{:0width$}. {}", index + 1, title)
        } else {
            format!("{:0width$}. {} - {}", index + 1, album_artist, title)
        }
    }

    pub fn format(&self, format_str: &str) -> String {
        let has_metadata = self.artist.as_ref().is_some_and(|a| !a.is_empty())
            || self.album.as_ref().is_some_and(|a| !a.is_empty());
        if !has_metadata {
            return self.title.clone().unwrap_or_else(|| {
                self.path
                    .file_name()
                    .and_then(|n| n.to_str())
                    .unwrap_or("Unknown")
                    .to_string()
            });
        }
        let artist = self.artist.clone().unwrap_or_default();
        let album = self.album.clone().unwrap_or_default();
        let title = self.title.clone().unwrap_or_else(|| {
            self.path
                .file_name()
                .and_then(|n| n.to_str())
                .unwrap_or("Unknown")
                .to_string()
        });
        format_str
            .replace("$ARTIST", &artist)
            .replace("$ALBUM", &album)
            .replace("$TRACK", &title)
    }
}

pub struct Queue {
    tracks: Vec<Track>,
    position: usize,
    shuffle: ShuffleMode,
    shuffled_indices: Vec<usize>,
    rng: StdRng,
}

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

impl Queue {
    pub fn new() -> Self {
        Queue {
            tracks: Vec::new(),
            position: 0,
            shuffle: ShuffleMode::None,
            shuffled_indices: Vec::new(),
            rng: rand::make_rng(),
        }
    }

    /// Construct a queue with a fixed RNG seed, making shuffle order fully
    /// reproducible. Used by tests and handy for debugging a specific order.
    #[allow(dead_code)] // used only by integration tests (bin crate does not link the lib)
    pub fn with_seed(seed: u64) -> Self {
        Queue {
            tracks: Vec::new(),
            position: 0,
            shuffle: ShuffleMode::None,
            shuffled_indices: Vec::new(),
            rng: StdRng::seed_from_u64(seed),
        }
    }

    pub fn add_track(&mut self, path: PathBuf) {
        self.tracks.push(Track::from_path(path));
        self.update_shuffle_indices();
    }

    pub fn push_track(&mut self, track: Track) {
        self.tracks.push(track);
        self.update_shuffle_indices();
    }

    pub fn insert_after_current(&mut self, path: PathBuf) {
        if self.tracks.is_empty() {
            self.tracks.push(Track::from_path(path));
            self.update_shuffle_indices();
            return;
        }
        let insert_idx = self.position + 1;
        self.tracks.insert(insert_idx, Track::from_path(path));
        if self.shuffle == ShuffleMode::None {
            self.update_shuffle_indices();
            return;
        }
        // Under shuffle, splice the new entry into the play order right after
        // the current slot instead of re-shuffling the tail: the inserted
        // track deterministically occupies slot `position + 1`, so "play
        // now/next" is meaningful and `current()` agrees with what the daemon
        // starts playing. The remaining play order is preserved (indices that
        // shifted right in `tracks` are bumped), not re-randomized.
        for v in self.shuffled_indices.iter_mut() {
            if *v >= insert_idx {
                *v += 1;
            }
        }
        self.shuffled_indices.insert(self.position + 1, insert_idx);
    }

    pub fn track_at(&self, idx: usize) -> Option<&Track> {
        self.tracks.get(idx)
    }

    pub fn set_shuffle(&mut self, mode: ShuffleMode) {
        self.shuffle = mode;
        match self.shuffle {
            ShuffleMode::None => {
                self.restore_from_original();
            }
            ShuffleMode::All => {
                self.update_shuffle_indices();
            }
            ShuffleMode::Album => {
                self.update_shuffle_indices_album();
            }
            ShuffleMode::Albums => {
                self.update_shuffle_indices_albums();
            }
        }
    }

    fn restore_from_original(&mut self) {
        // Restore linear (unshuffled) order. `tracks` is never reordered by
        // shuffle — only `shuffled_indices` is a permutation — so the live
        // list already carries the original insertion order. Keep the played
        // segment (positions 0..=current in shuffled order) in the order it
        // was played, then append the unplayed entries in original order.
        // Entries are tracked by identity, so duplicate paths are preserved
        // and entries added during shuffle survive.
        if self.tracks.is_empty() {
            self.position = 0;
            self.shuffled_indices.clear();
            return;
        }

        let current_pos = self.position.min(self.tracks.len().saturating_sub(1));

        // Played entries, in played order (positions 0..=current_pos in shuffled order).
        let mut played: Vec<Track> = Vec::new();
        let mut played_idx: Vec<usize> = Vec::new();
        for i in 0..=current_pos {
            if let Some(&idx) = self.shuffled_indices.get(i)
                && let Some(track) = self.tracks.get(idx)
            {
                played.push(track.clone());
                played_idx.push(idx);
            }
        }

        // Unplayed entries keep their original (insertion) order.
        let mut new_tracks = played;
        for (idx, track) in self.tracks.iter().enumerate() {
            if !played_idx.contains(&idx) {
                new_tracks.push(track.clone());
            }
        }

        self.tracks = new_tracks;
        self.position = current_pos;
        self.shuffled_indices.clear();
    }

    fn update_shuffle_indices(&mut self) {
        let len = self.tracks.len();
        self.shuffled_indices = (0..len).collect();
        match self.shuffle {
            ShuffleMode::All => {
                let pos = self.position.min(len.saturating_sub(1));
                if pos + 1 < len {
                    self.shuffled_indices[pos + 1..].shuffle(&mut self.rng);
                }
            }
            ShuffleMode::Album => {
                self.update_shuffle_indices_album();
            }
            ShuffleMode::Albums => {
                self.update_shuffle_indices_albums();
            }
            ShuffleMode::None => {}
        }
    }

    fn update_shuffle_indices_album(&mut self) {
        let len = self.tracks.len();
        self.shuffled_indices = (0..len).collect();

        if len > 1 {
            let pos = self.position.min(len.saturating_sub(1));
            if pos + 1 < len {
                Self::shuffle_album_range(
                    &self.tracks,
                    &mut self.shuffled_indices,
                    pos + 1..len,
                    &mut self.rng,
                );
            }
        }
    }

    fn update_shuffle_indices_albums(&mut self) {
        let len = self.tracks.len();
        self.shuffled_indices = (0..len).collect();

        if len <= 1 {
            return;
        }

        let pos = self.position.min(len.saturating_sub(1));
        if pos + 1 >= len {
            return;
        }

        let range_start = pos + 1;

        // Build album groups within the range, shuffling tracks within each group
        let mut groups: Vec<Vec<usize>> = Vec::new();
        let mut current_group: Vec<usize> = Vec::new();
        let mut current_album: Option<&str> = None;

        for i in range_start..len {
            let album = self.tracks.get(i).and_then(|t| t.album.as_deref());

            if current_group.is_empty() {
                current_group.push(i);
                current_album = album;
            } else if album != current_album {
                // Shuffle tracks within this album group before adding it
                if current_group.len() > 1 {
                    current_group.shuffle(&mut self.rng);
                }
                groups.push(std::mem::take(&mut current_group));
                current_group.push(i);
                current_album = album;
            } else {
                current_group.push(i);
            }
        }
        if !current_group.is_empty() {
            if current_group.len() > 1 {
                current_group.shuffle(&mut self.rng);
            }
            groups.push(current_group);
        }

        // Shuffle the album group order
        groups.shuffle(&mut self.rng);

        let mut new_indices: Vec<usize> = self.shuffled_indices[..=pos].to_vec();
        for group in &groups {
            new_indices.extend(group);
        }
        self.shuffled_indices = new_indices;
    }

    fn shuffle_album_range(
        tracks: &[Track],
        indices: &mut [usize],
        range: std::ops::Range<usize>,
        rng: &mut impl rand::Rng,
    ) {
        if range.start >= range.end {
            return;
        }

        let mut album_ranges: Vec<(usize, usize)> = Vec::new();
        let mut current_album: Option<&str> = None;
        let mut range_start: Option<usize> = None;

        for i in range.clone() {
            let album = tracks.get(i).and_then(|t| t.album.as_deref());
            match (current_album, range_start) {
                (None, None) => {
                    current_album = album;
                    range_start = Some(i);
                }
                (Some(_), Some(start)) if album != current_album => {
                    album_ranges.push((start, i));
                    current_album = album;
                    range_start = Some(i);
                }
                _ => {}
            }
        }
        if let Some(start) = range_start {
            album_ranges.push((start, range.end));
        }

        for (start, end) in album_ranges {
            if start + 1 < end {
                indices[start..end].shuffle(rng);
            }
        }
    }

    pub fn current(&self) -> Option<&Track> {
        if self.tracks.is_empty() {
            None
        } else if self.shuffle == ShuffleMode::All {
            self.shuffled_indices
                .get(self.position)
                .and_then(|&idx| self.tracks.get(idx))
        } else if self.shuffle == ShuffleMode::Album || self.shuffle == ShuffleMode::Albums {
            self.shuffled_indices
                .get(self.position)
                .and_then(|&idx| self.tracks.get(idx))
        } else {
            self.tracks.get(self.position)
        }
    }

    #[allow(clippy::should_implement_trait)]
    pub fn next(&mut self) -> Option<PathBuf> {
        let max_pos = self.tracks.len().saturating_sub(1);
        if self.position < max_pos {
            self.position += 1;
            self.current().map(|t| t.path.clone())
        } else {
            None
        }
    }

    pub fn previous(&mut self) -> Option<PathBuf> {
        if self.position > 0 {
            self.position -= 1;
            self.current().map(|t| t.path.clone())
        } else {
            None
        }
    }

    pub fn is_empty(&self) -> bool {
        self.tracks.is_empty()
    }

    pub fn len(&self) -> usize {
        self.tracks.len()
    }

    pub fn position(&self) -> usize {
        self.position
    }

    pub fn set_position(&mut self, pos: usize) {
        self.position = pos;
    }

    #[allow(dead_code)]
    pub fn tracks(&self) -> &[Track] {
        &self.tracks
    }

    pub fn shuffle_mode(&self) -> &ShuffleMode {
        &self.shuffle
    }

    pub fn shuffled_indices(&self) -> &[usize] {
        &self.shuffled_indices
    }

    pub fn shuffle_initial(&mut self) {
        if self.position != 0 || self.tracks.len() <= 1 {
            return;
        }
        match self.shuffle {
            ShuffleMode::All => {
                self.shuffled_indices.shuffle(&mut self.rng);
            }
            ShuffleMode::Album => {
                Self::shuffle_album_range(
                    &self.tracks,
                    &mut self.shuffled_indices,
                    0..self.tracks.len(),
                    &mut self.rng,
                );
            }
            ShuffleMode::Albums => {
                let mut groups: Vec<Vec<usize>> = Vec::new();
                let mut current_group: Vec<usize> = Vec::new();
                let mut current_album: Option<&str> = None;

                for i in 0..self.tracks.len() {
                    let album = self.tracks.get(i).and_then(|t| t.album.as_deref());

                    if current_group.is_empty() {
                        current_group.push(i);
                        current_album = album;
                    } else if album != current_album {
                        if current_group.len() > 1 {
                            current_group.shuffle(&mut self.rng);
                        }
                        groups.push(std::mem::take(&mut current_group));
                        current_group.push(i);
                        current_album = album;
                    } else {
                        current_group.push(i);
                    }
                }
                if !current_group.is_empty() {
                    if current_group.len() > 1 {
                        current_group.shuffle(&mut self.rng);
                    }
                    groups.push(current_group);
                }

                groups.shuffle(&mut self.rng);

                self.shuffled_indices = groups.concat();
            }
            ShuffleMode::None => {}
        }
    }

    pub fn clear(&mut self) {
        self.tracks.clear();
        self.position = 0;
        self.shuffled_indices.clear();
    }
}