implement playlist queue for room server

Author: kluvin

lib/pling/rooms/room/impl.ex

@@ -18,11 +18,10 @@ defmodule Pling.Rooms.Room.Impl do
         %{
           initial_state
           | playlists: updated_playlists,
-            selection: %{playlist: playlist.spotify_id, track: track}
+            selection: %{playlist: playlist.spotify_id, track: track, queue: []}
         }
       else
-        initial_state = %{initial_state | playlists: playlists}
-        update_track(initial_state)
+        %{initial_state | playlists: playlists}
       end
 
     update_track(state)
@@ -42,20 +41,36 @@ defmodule Pling.Rooms.Room.Impl do
   end
 
   def update_track(state) do
-    track = select_track(state)
-    %{state | selection: %{playlist: state.selection.playlist, track: track}}
+    {track, queue} = select_track(state)
+    %{state |
+      selection: %{
+        playlist: state.selection.playlist,
+        track: track,
+        queue: [track | queue]
+      }
+    }
   end
 
-  defp select_track(%{playlists: playlists} = state) do
-    MusicLibrary.select_track(playlists, state.selection.playlist)
+  defp select_track(%{playlists: playlists, selection: %{queue: []}} = state) do
+    tracks = MusicLibrary.get_tracks(state.selection.playlist, playlists)
+    shuffled = Enum.shuffle(tracks)
+    {hd(shuffled), tl(shuffled)}
+  end
+
+  defp select_track(%{selection: %{queue: [_current | remaining]}} = _state) do
+    {hd(remaining), tl(remaining)}
   end
 
   def set_playlist(state, playlist_id) do
     playlists = MusicLibrary.load_playlists()
 
     state
     |> Map.put(:playlists, playlists)
-    |> Map.put(:selection, %{playlist: playlist_id, track: nil})
+    |> Map.put(:selection, %{
+      playlist: playlist_id,
+      track: nil,
+      queue: []
+    })
     |> update_track()
     |> reset_playback()
   end

lib/pling/rooms/room_state.ex

@@ -25,7 +25,8 @@ defmodule Pling.Rooms.RoomState do
       recent_plings: [],
       selection: %{
         playlist: @default_playlist_id,
-        track: nil
+        track: nil,
+        queue: []  # First item is always the current track
       }
     }
   end

test/pling/rooms/room/impl_test.exs

@@ -0,0 +1,146 @@
+defmodule Pling.Rooms.Room.ImplTest do
+  use Pling.DataCase
+  alias Pling.Rooms.Room.Impl
+  alias Pling.Playlists.{Playlist, Track}
+
+  @default_playlist_id "6ZSeHvrhmEH4erjxudpULB"
+
+  setup do
+    :meck.unload()
+    :meck.new(Pling.Playlists.MusicLibrary, [:passthrough])
+
+    tracks = [
+      %Track{uri: "track1", title: "Track 1"},
+      %Track{uri: "track2", title: "Track 2"},
+      %Track{uri: "track3", title: "Track 3"},
+      %Track{uri: "track4", title: "Track 4"}
+    ]
+
+    playlist = %Playlist{
+      spotify_id: "test_playlist",
+      name: "Test Playlist",
+      tracks: tracks
+    }
+
+    default_playlist = %Playlist{
+      spotify_id: @default_playlist_id,
+      name: "Default Playlist",
+      tracks: tracks
+    }
+
+    playlists = %{
+      playlist.spotify_id => playlist,
+      @default_playlist_id => default_playlist
+    }
+
+    :meck.expect(Pling.Playlists.MusicLibrary, :load_playlists, fn -> playlists end)
+    :meck.expect(Pling.Playlists.MusicLibrary, :get_tracks, fn playlist_id, _playlists ->
+      case playlist_id do
+        @default_playlist_id -> tracks
+        "test_playlist" -> tracks
+        _ -> []
+      end
+    end)
+
+    on_exit(fn -> :meck.unload() end)
+
+    {:ok, %{playlist: playlist, tracks: tracks}}
+  end
+
+  describe "initialize/4" do
+    test "initializes room with default playlist", %{tracks: tracks} do
+      state = Impl.initialize("room1", "vs", "leader1")
+
+      assert state.room_code == "room1"
+      assert state.game_mode == "vs"
+      assert state.leader_id == "leader1"
+      assert state.playing? == false
+      assert Map.has_key?(state.playlists, @default_playlist_id)
+      assert state.selection.track in tracks
+      assert state.selection.queue != nil
+      assert length(state.selection.queue) > 0
+      assert length(state.selection.queue) == length(tracks)
+    end
+
+    test "initializes room with provided playlist", %{playlist: playlist, tracks: tracks} do
+      state = Impl.initialize("room1", "vs", "leader1", playlist)
+
+      assert state.selection.playlist == playlist.spotify_id
+      assert state.selection.track in tracks
+      assert is_list(state.selection.queue)
+      assert length(state.selection.queue) == length(tracks)
+      assert state.selection.queue != tracks
+    end
+  end
+
+  describe "play/1 and pause/1" do
+    test "transitions between playing states", %{tracks: tracks} do
+      initial_state = Impl.initialize("room1", "vs", "leader1")
+
+      assert initial_state.selection.track in tracks
+
+      played_state = Impl.play(initial_state)
+      assert played_state.playing? == true
+      assert played_state.countdown != nil
+      assert played_state.timer_ref != nil
+
+      paused_state = Impl.pause(played_state)
+      assert paused_state.playing? == false
+      assert paused_state.countdown == nil
+      assert paused_state.timer_ref == nil
+    end
+  end
+
+  describe "update_track/1" do
+    test "updates track and maintains queue order", %{tracks: tracks} do
+      state = Impl.initialize("room1", "vs", "leader1")
+      initial_track = state.selection.track
+
+      # First update - should take next track from queue
+      updated_state = Impl.update_track(state)
+      assert updated_state.selection.track != initial_track
+      assert updated_state.selection.track in tracks
+      assert hd(updated_state.selection.queue) == updated_state.selection.track
+
+      # Second update - should take next track
+      second_update = Impl.update_track(updated_state)
+      assert second_update.selection.track != updated_state.selection.track
+      assert second_update.selection.track in tracks
+      assert hd(second_update.selection.queue) == second_update.selection.track
+    end
+
+    test "reshuffles with all tracks when queue is empty", %{tracks: tracks} do
+      state = Impl.initialize("room1", "vs", "leader1")
+
+      # Empty the queue
+      empty_state = %{state | selection: %{state.selection | queue: []}}
+
+      # Update should trigger reshuffle
+      new_state = Impl.update_track(empty_state)
+      assert new_state.selection.track in tracks
+      assert length(new_state.selection.queue) == length(tracks)
+      assert hd(new_state.selection.queue) == new_state.selection.track
+      assert Enum.sort(new_state.selection.queue) == Enum.sort(tracks)
+    end
+
+    test "maintains unique tracks in queue until reshuffle", %{tracks: tracks} do
+      state = Impl.initialize("room1", "vs", "leader1")
+
+      # Track all updates until we've seen all tracks
+      {_final_state, seen_tracks} =
+        Enum.reduce_while(1..10, {state, MapSet.new([state.selection.track])}, fn _, {current_state, seen} ->
+          new_state = Impl.update_track(current_state)
+          new_seen = MapSet.put(seen, new_state.selection.track)
+
+          if MapSet.size(new_seen) == length(tracks) do
+            {:halt, {new_state, new_seen}}
+          else
+            {:cont, {new_state, new_seen}}
+          end
+        end)
+
+      assert MapSet.size(seen_tracks) == length(tracks)
+      assert MapSet.to_list(seen_tracks) |> Enum.sort() == Enum.sort(tracks)
+    end
+  end
+end