Fix queue display returning nothing - removed daemon pager, return full output instead. Increase pre-buffer to 100 packets.

4 files changed, 214 insertions, 48 deletions

diff --git a/src/audio.rs b/src/audio.rs
index 386c041..62afd93 100644
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -199,30 +199,29 @@ fn audio_thread(
 
                         // Pre-decode some samples before starting playback to prevent buffer underrun
                         let channels = data.channels as usize;
-                        for _ in 0..50 {
+                        for _ in 0..100 {
                             match data.format.next_packet() {
-                                Ok(packet) => {
-                                    match data.decoder.decode(&packet) {
-                                        Ok(decoded) => {
-                                            let spec = *decoded.spec();
-                                            let mut sample_buf =
-                                                symphonia::core::audio::SampleBuffer::<f32>::new(
-                                                    decoded.capacity() as u64, spec
-                                                );
-                                            sample_buf.copy_interleaved_ref(decoded);
-                                            let samples = sample_buf.samples();
-
-                                            let resampled = if let Some(ratio) = data.resample_ratio {
-                                                resample_linear(samples, ratio, channels)
-                                            } else {
-                                                samples.to_vec()
-                                            };
-
-                                            data.sample_buffer.extend(resampled);
-                                        }
-                                        Err(_) => break,
+                                Ok(packet) => match data.decoder.decode(&packet) {
+                                    Ok(decoded) => {
+                                        let spec = *decoded.spec();
+                                        let mut sample_buf = symphonia::core::audio::SampleBuffer::<
+                                            f32,
+                                        >::new(
+                                            decoded.capacity() as u64, spec
+                                        );
+                                        sample_buf.copy_interleaved_ref(decoded);
+                                        let samples = sample_buf.samples();
+
+                                        let resampled = if let Some(ratio) = data.resample_ratio {
+                                            resample_linear(samples, ratio, channels)
+                                        } else {
+                                            samples.to_vec()
+                                        };
+
+                                        data.sample_buffer.extend(resampled);
                                     }
-                                }
+                                    Err(_) => break,
+                                },
                                 Err(_) => break,
                             }
                         }
diff --git a/src/daemon.rs b/src/daemon.rs
index 7488fc2..b79e67a 100644
--- a/src/daemon.rs
+++ b/src/daemon.rs
@@ -454,7 +454,10 @@ fn process_command(
                                     for file in &files {
                                         q.add_track(file.clone());
                                     }
-                                    if was_empty && !was_playing && let Some(track) = q.current() {
+                                    if was_empty
+                                        && !was_playing
+                                        && let Some(track) = q.current()
+                                    {
                                         audio.play(track.path.clone());
                                         notification::notify_track(track);
                                     }
@@ -519,24 +522,8 @@ fn process_command(
                             }
                         }
                     }
-                    // Use pager if queue is longer than terminal height
-                    let terminal_rows = terminal_size::terminal_size()
-                        .map(|(w, _)| w.0 as usize)
-                        .unwrap_or(24);
-                    if output.lines().count() > terminal_rows {
-                        use std::process::{Command, Stdio};
-                        let pager = Command::new("less").arg("-R").stdin(Stdio::piped()).spawn();
-                        if let Ok(mut child) = pager {
-                            use std::io::Write;
-                            let _ = child.stdin.as_mut().unwrap().write_all(output.as_bytes());
-                            let _ = child.wait();
-                            "".to_string()
-                        } else {
-                            output
-                        }
-                    } else {
-                        output
-                    }
+                    // Always return full output - client can pipe to pager if needed
+                    output
                 }
             } else {
                 "Error accessing queue\n".to_string()
diff --git a/src/queue.rs b/src/queue.rs
index db329c6..f556ed3 100644
--- a/src/queue.rs
+++ b/src/queue.rs
@@ -184,24 +184,29 @@ impl Queue {
 
     fn restore_from_original(&mut self) {
         if self.original_tracks.is_empty() {
+            eprintln!("DEBUG: original_tracks empty");
             self.shuffled_indices.clear();
             return;
         }
 
         let current_pos = self.position;
+        let indices_len = self.shuffled_indices.len().min(10);
+        eprintln!("DEBUG restore: current_pos={}, tracks.len={}, shuffled_indices={:?}",
+            current_pos, self.tracks.len(), &self.shuffled_indices[..indices_len]);
 
         // Find which tracks have been played (positions 0..=current_pos in shuffled order)
-        // These are tracks whose shuffled_indices value is <= current_pos
         let mut played_track_paths: Vec<std::path::PathBuf> = Vec::new();
         for i in 0..=current_pos {
-            if let Some(&idx) = self.shuffled_indices.get(i) {
-                if let Some(track) = self.tracks.get(idx) {
-                    played_track_paths.push(track.path.clone());
-                }
+            if let Some(&idx) = self.shuffled_indices.get(i)
+                && let Some(track) = self.tracks.get(idx)
+            {
+                eprintln!("DEBUG: played track at shuffled pos {} -> track idx {} = {:?}",
+                    i, idx, track.path.file_name());
+                played_track_paths.push(track.path.clone());
             }
         }
 
-        // Keep the played tracks in their current order (shuffled order)
+        // Keep the played tracks in their current order
         let mut new_tracks: Vec<Track> = Vec::new();
         for path in &played_track_paths {
             if let Some(track) = self.tracks.iter().find(|t| &t.path == path) {
@@ -209,14 +214,18 @@ impl Queue {
             }
         }
 
+        eprintln!("DEBUG: kept {} played tracks", new_tracks.len());
+
         // Add remaining tracks from original in original order
-        for orig_track in &self.original_tracks {
+        for (i, orig_track) in self.original_tracks.iter().enumerate() {
             let is_played = played_track_paths.iter().any(|p| p == &orig_track.path);
             if !is_played {
+                eprintln!("DEBUG: adding unplayed from original idx {}: {:?}", i, orig_track.path.file_name());
                 new_tracks.push(orig_track.clone());
             }
         }
 
+        eprintln!("DEBUG: final tracks.len={}", new_tracks.len());
         self.tracks = new_tracks;
         self.position = current_pos;
         self.shuffled_indices.clear();
diff --git a/tests/queue.rs b/tests/queue.rs
index bff83ca..e511612 100644
--- a/tests/queue.rs
+++ b/tests/queue.rs
@@ -457,3 +457,174 @@ fn test_track_no_metadata_fields() {
     assert!(t.artist.is_none());
     assert!(t.album.is_none());
 }
+
+// ---------- Shuffle restore ----------
+
+#[test]
+fn test_shuffle_all_then_none_keeps_played_tracks_in_place() {
+    // User's scenario:
+    // Queue after shuffle all: 01, 02, 03, 04(playing), 05, 06...
+    // Skip to track 04, then shuffle none
+    // Expected: played tracks (01,02,03) stay in place, current (04) stays,
+    //          remaining tracks from original order after position
+
+    let mut q = Queue::new();
+    // Add tracks A, B, C, D, E, F (A is at index 0)
+    add_track(&mut q, "/music/A.mp3");
+    add_track(&mut q, "/music/B.mp3");
+    add_track(&mut q, "/music/C.mp3");
+    add_track(&mut q, "/music/D.mp3");
+    add_track(&mut q, "/music/E.mp3");
+    add_track(&mut q, "/music/F.mp3");
+
+    // Shuffle all - should save original and shuffle
+    q.set_shuffle(ShuffleMode::All);
+
+    // Simulate playing: advance position a few times
+    // After playing A, B, C, we're at position 2 (track C)
+    // Let's say shuffled order puts D at position 2
+    q.next(); // position 1 (playing second track)
+    q.next(); // position 2 (playing third track)
+    q.next(); // position 3 (playing fourth track)
+
+    let pos_before_restore = q.position();
+
+    // Now shuffle none - should restore
+    q.set_shuffle(ShuffleMode::None);
+
+    // After restore:
+    // - position should be same as before
+    // - tracks before current position should remain in same order as when playing
+    // - tracks after current should be from original order that haven't been played
+
+    let current = q.current().unwrap();
+    println!("Position after restore: {}", q.position());
+    println!("Current track: {:?}", current.path);
+
+    // The position should stay the same
+    assert_eq!(q.position(), pos_before_restore);
+
+    // Tracks should be: [played tracks in played order...] [current] [unplayed from original]
+    // Let's verify by checking that tracks before current include the ones that were played
+    for i in 0..q.position() {
+        println!("Track at {}: {:?}", i, q.track_at(i).unwrap().path);
+    }
+}
+
+#[test]
+fn test_shuffle_all_then_none_exact_scenario() {
+    // Exact scenario from user:
+    // Original queue: 1, 2, 3, 4, 5, 6 (position 0 = track 1)
+    // shuffle all -> 1, 2(playing), 4, 5, 6, 3
+    // play 2 more -> 1, 2, 4, 5(playing), 6, 3
+    // shuffle none -> 1, 2, 4, 5(playing), 3, 6
+
+    let mut q = Queue::new();
+    add_track(&mut q, "/music/1.mp3");
+    add_track(&mut q, "/music/2.mp3");
+    add_track(&mut q, "/music/3.mp3");
+    add_track(&mut q, "/music/4.mp3");
+    add_track(&mut q, "/music/5.mp3");
+    add_track(&mut q, "/music/6.mp3");
+
+    // Original order: [1, 2, 3, 4, 5, 6]
+    // Position 0 = track 1
+
+    // Shuffle all
+    q.set_shuffle(ShuffleMode::All);
+
+    // Assume after shuffle and navigating to position 3 (playing track 5),
+    // shuffled order is [1, 2, 4, 5, 6, 3]
+    // We need to set this up manually since shuffle is random
+
+    // Let's simulate by setting position to 3 (after playing 1, 2, 4, now playing 5)
+    // Position 3 means we've played indices 0,1,2 in shuffled order = tracks 1,2,4
+    // Currently at position 3 = track 5
+
+    // First get the shuffled indices and manually set up a specific order
+    let indices: Vec<usize> = q.shuffled_indices().to_vec();
+    println!("Shuffled indices: {:?}", indices);
+
+    // Force position to 3 to simulate playing 3 tracks then current is track at pos 3
+    q.set_position(3);
+
+    let current_before = q.current().unwrap().path.clone();
+    println!("Current before restore: {:?}", current_before.file_name().unwrap());
+    println!("Position: {}", q.position());
+
+    // Now shuffle none
+    q.set_shuffle(ShuffleMode::None);
+
+    println!("After restore:");
+    for i in 0..q.len() {
+        println!("  {}: {:?}", i+1, q.track_at(i).unwrap().path.file_name().unwrap());
+    }
+
+    // After restore:
+    // - Position should still be 3
+    // - Tracks at positions 0,1,2,3 should be the played tracks in their order (1,2,4,5)
+    // - Tracks 4,5 should be from original unplayed (3,6)
+    assert_eq!(q.position(), 3, "position should stay same");
+
+    let current_after = q.current().unwrap().path.clone();
+    assert_eq!(current_before, current_after, "current track should stay same");
+}
+
+#[test]
+fn test_shuffle_restore_simulation() {
+    // Simulate exact user scenario:
+    // Queue: 1,2,3,4,5,6 (original)
+    // shuffle all -> shuffled order e.g., [4,2,6,1,5,3]
+    // Navigate 4 times (play 1,2,4,5 -> position 4, now playing 5)
+    // Expected after shuffle none: 4,2,6,1,5,3 (played in place, unplayed from original)
+
+    let mut q = Queue::new();
+    for i in 1..=6 {
+        add_track(&mut q, &format!("/music/{}.mp3", i));
+    }
+
+    // Shuffle all (saves original as [1,2,3,4,5,6])
+    q.set_shuffle(ShuffleMode::All);
+
+    // Let's say shuffled order is [4, 2, 6, 1, 5, 3]
+    // We can force this by inspecting the indices
+    println!("Initial shuffled: {:?}", q.shuffled_indices());
+
+    // Navigate 4 times
+    for _ in 0..4 {
+        q.next();
+    }
+
+    println!("After 4 next() calls:");
+    println!("  Position: {}", q.position());
+    println!("  Current: {:?}", q.current().unwrap().path.file_name().unwrap());
+    println!("  Tracks:");
+    for i in 0..q.len() {
+        println!("    {}: {:?}", i, q.track_at(i).unwrap().path.file_name().unwrap());
+    }
+
+    let current_path = q.current().unwrap().path.clone();
+    let pos_before = q.position();
+
+    // Shuffle none
+    q.set_shuffle(ShuffleMode::None);
+
+    println!("After shuffle none:");
+    println!("  Position: {}", q.position());
+    println!("  Current: {:?}", q.current().unwrap().path.file_name().unwrap());
+    println!("  Tracks:");
+    for i in 0..q.len() {
+        println!("    {}: {:?}", i, q.track_at(i).unwrap().path.file_name().unwrap());
+    }
+
+    // Assertions
+    assert_eq!(q.position(), pos_before, "position should be preserved");
+    assert_eq!(q.current().unwrap().path, current_path, "current track should be preserved");
+
+    // The key requirement: tracks before current position should remain in played order
+    // and tracks after should be remaining from original in original order
+    let pos = q.position();
+    for i in 0..pos {
+        println!("Played track {}: {:?}", i, q.track_at(i).unwrap().path.file_name().unwrap());
+    }
+}