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");
+    }
+}