seek: jump within the current track from the CLI and over MPRIS

`rsp seek 1:30`, `rsp seek +15`, `rsp seek -30` and `rsp seek` (print the
position) drive a new AudioCommand that seeks the format reader, resets the
decoder and drops the buffered samples, so the cpal stream keeps running and
playback continues from the new spot.

MPRIS gets a working Seek/SetPosition, reports CanSeek, and the state watcher
now emits Seeked when the playhead jumps (not just on track changes), which is
what clients need to move their progress bar after an external seek.

`rsp status` also reports the position (and duration when known) and says
Paused instead of Stopped when a track is loaded but not playing.

1 files changed, 127 insertions, 13 deletions

diff --git a/src/daemon.rs b/src/daemon.rs
index 8f470c1..4f95820 100644
--- a/src/daemon.rs
+++ b/src/daemon.rs
@@ -954,6 +954,49 @@ fn resume_queue_track(
     true
 }
 
+/// Parse a seek argument into an absolute position in seconds.
+///
+/// Accepts `90`, `1:30`, `1:02:03`, and relative offsets `+15` / `-30`.
+fn parse_seek(arg: &str, current: f64) -> Option<f64> {
+    let (sign, body) = match arg.as_bytes().first()? {
+        b'+' => (1.0, &arg[1..]),
+        b'-' => (-1.0, &arg[1..]),
+        _ => (0.0, arg),
+    };
+    let value = parse_time(body)?;
+    Some(if sign == 0.0 {
+        value
+    } else {
+        (current + sign * value).max(0.0)
+    })
+}
+
+/// Parse `SS`, `MM:SS`, or `HH:MM:SS` (fractions allowed) into seconds.
+fn parse_time(text: &str) -> Option<f64> {
+    let mut total = 0.0f64;
+    let mut parts = 0usize;
+    for part in text.split(':') {
+        let value: f64 = part.trim().parse().ok()?;
+        if value < 0.0 {
+            return None;
+        }
+        total = total * 60.0 + value;
+        parts += 1;
+    }
+    (1..=3).contains(&parts).then_some(total)
+}
+
+/// `83.4` -> `1:23`, `3723` -> `1:02:03`
+fn format_time(seconds: f64) -> String {
+    let secs = seconds.max(0.0) as u64;
+    let (hours, minutes, secs) = (secs / 3600, (secs % 3600) / 60, secs % 60);
+    if hours > 0 {
+        format!("{}:{:02}:{:02}", hours, minutes, secs)
+    } else {
+        format!("{}:{:02}", minutes, secs)
+    }
+}
+
 fn process_command(
     cmd: &str,
     audio: &AudioEngine,
@@ -964,20 +1007,38 @@ fn process_command(
 ) -> String {
     match cmd {
         "status" => {
-            if audio.is_playing() {
-                if let Some(track_path) = audio.current_track() {
-                    let track = Track::from_path(track_path);
-                    let fmt = Config::load().ok().and_then(|c| c.display_format.clone());
-                    let track_str = match fmt.as_deref() {
-                        Some(f) => track.format(f),
-                        None => track.display_string(0, 1),
-                    };
-                    format!("Playing\nTrack: {}\n", track_str)
-                } else {
-                    "Playing\n".to_string()
-                }
+            let current = audio.current_track().or_else(|| {
+                queue
+                    .lock()
+                    .ok()
+                    .and_then(|q| q.current().map(|t| t.path.clone()))
+            });
+            let Some(track_path) = current else {
+                return "Stopped\n".to_string();
+            };
+            let state = if audio.is_playing() {
+                "Playing"
             } else {
-                "Stopped\n".to_string()
+                "Paused"
+            };
+            let track = Track::from_path(track_path);
+            let fmt = Config::load().ok().and_then(|c| c.display_format.clone());
+            let track_str = match fmt.as_deref() {
+                Some(f) => track.format(f),
+                None => track.display_string(0, 1),
+            };
+            let position = format_time(audio.position());
+            match track.duration_secs {
+                Some(duration) if duration > 0.0 => {
+                    format!(
+                        "{}\nTrack: {}\nPosition: {} / {}\n",
+                        state,
+                        track_str,
+                        position,
+                        format_time(duration)
+                    )
+                }
+                _ => format!("{}\nTrack: {}\nPosition: {}\n", state, track_str, position),
             }
         }
         "pause" => {
@@ -1014,6 +1075,20 @@ fn process_command(
             notification::notify_change("Stopped");
             "Stopped\n".to_string()
         }
+        _ if cmd == "seek" || cmd.starts_with("seek ") => {
+            let current = audio.position();
+            let arg = cmd[4..].trim();
+            if arg.is_empty() {
+                return format!("Position: {}\n", format_time(current));
+            }
+            match parse_seek(arg, current) {
+                Some(target) => {
+                    audio.seek(target);
+                    format!("Seeking to {}\n", format_time(target))
+                }
+                None => "Usage: rsp seek <seconds|MM:SS|[+|-]seconds>\n".to_string(),
+            }
+        }
         "stop_daemon" => {
             shutdown_flag.store(true, Ordering::SeqCst);
             "Shutting down\n".to_string()
@@ -1834,3 +1909,42 @@ fn cleanup_daemon(socket_path: &std::path::Path, pid_path: &std::path::Path) {
     std::fs::remove_file(socket_path).ok();
     std::fs::remove_file(pid_path).ok();
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_absolute_seek_positions() {
+        assert_eq!(parse_seek("90", 10.0), Some(90.0));
+        assert_eq!(parse_seek("1:30", 10.0), Some(90.0));
+        assert_eq!(parse_seek("1:02:03", 0.0), Some(3723.0));
+        assert_eq!(parse_seek("83.5", 0.0), Some(83.5));
+    }
+
+    #[test]
+    fn parses_relative_seek_offsets() {
+        assert_eq!(parse_seek("+15", 60.0), Some(75.0));
+        assert_eq!(parse_seek("-15", 60.0), Some(45.0));
+        assert_eq!(
+            parse_seek("-60", 30.0),
+            Some(0.0),
+            "relative seeks never go below the start"
+        );
+    }
+
+    #[test]
+    fn rejects_bad_seek_positions() {
+        assert_eq!(parse_seek("abc", 0.0), None);
+        assert_eq!(parse_seek("", 0.0), None);
+        assert_eq!(parse_seek("-", 0.0), None);
+        assert_eq!(parse_seek("1:2:3:4", 0.0), None, "at most hours:min:sec");
+    }
+
+    #[test]
+    fn formats_positions_for_status() {
+        assert_eq!(format_time(0.0), "0:00");
+        assert_eq!(format_time(83.4), "1:23");
+        assert_eq!(format_time(3723.0), "1:02:03");
+    }
+}