deep link

Author: kluvin

lib/pling/playlists/music_library.ex

@@ -4,6 +4,7 @@ defmodule Pling.Playlists.MusicLibrary do
   Playlists are organized by decades, with tracks associated to each playlist.
   """
   import Ecto.Query
+  require Logger
   alias Pling.Repo
   alias Pling.Playlists.{Playlist, Track}
 
@@ -56,46 +57,104 @@ defmodule Pling.Playlists.MusicLibrary do
 
   @doc """
   Gets a playlist by Spotify ID, fetching it from Spotify if it doesn't exist locally.
+  Returns the playlist as soon as it has basic info and at least one track.
   """
-  def get_or_fetch_playlist(spotify_id) do
+  def get_or_fetch_playlist(spotify_id, timeout \\ 5000) do
     case Repo.get(Playlist, spotify_id) do
       nil ->
-        # Fetch from Spotify and save
-        case Pling.Services.Spotify.get_playlist(spotify_id) do
-          {:ok, %{playlist_info: info, tracks: tracks}} ->
-            # Create and save the playlist
+        # Create a reference we can use to receive a message when the first track arrives
+        ref = make_ref()
+        parent = self()
+
+        callback = fn
+          %{"playlist_info" => info} ->
             playlist = %Playlist{
               spotify_id: spotify_id,
-              name: info.name,
-              owner: info.owner,
-              image_url: info.image_url,
+              name: info["name"],
+              owner: info["owner"],
+              image_url: get_first_image_url(info["images"]),
               official: false
             }
 
             {:ok, saved_playlist} = Repo.insert(playlist)
+            saved_playlist
 
-            # Save all tracks
-            Enum.each(tracks, fn track_data ->
-              %Track{
-                spotify_id: track_data.spotify_id,
-                title: track_data.title,
-                artists: track_data.artists,
-                uri: track_data.uri,
-                popularity: track_data.popularity,
-                album: track_data.album,
-                playlist_spotify_id: spotify_id
-              }
-              |> Repo.insert(on_conflict: :nothing)
-            end)
+          %{"track" => track} ->
+            track_entry = %Track{
+              spotify_id: track["id"],
+              title: track["name"],
+              artists: Enum.map(track["artists"], & &1["name"]),
+              uri: track["uri"],
+              popularity: track["popularity"],
+              album: track["album"]["name"],
+              playlist_spotify_id: spotify_id
+            }
 
-            saved_playlist
+            {:ok, saved_track} = Repo.insert(track_entry, on_conflict: :nothing)
+
+            # Notify parent process of first track
+            if not Process.get({:notified_first_track, ref}) do
+              Process.put({:notified_first_track, ref}, true)
+              send(parent, {:first_track_saved, ref})
+            end
+
+            saved_track
+        end
+
+        # Start streaming in the background
+        Task.start(fn ->
+          case Pling.Services.Spotify.stream_playlist(spotify_id, callback) do
+            :ok ->
+              :ok
+
+            {:error, reason} ->
+              Logger.error("Failed to fetch complete playlist: #{inspect(reason)}")
+              # Notify parent in case of immediate error
+              send(parent, {:playlist_error, ref, reason})
+          end
+        end)
 
-          {:error, reason} ->
+        # Wait for either first track or timeout
+        receive do
+          {:first_track_saved, ^ref} ->
+            case Repo.get(Playlist, spotify_id) do
+              nil -> {:error, :playlist_fetch_failed}
+              playlist -> playlist
+            end
+
+          {:playlist_error, ^ref, reason} ->
             {:error, reason}
+        after
+          timeout ->
+            case Repo.get(Playlist, spotify_id) do
+              nil -> {:error, :playlist_fetch_timeout}
+              playlist -> playlist
+            end
         end
 
       playlist ->
         playlist
     end
   end
+
+  @doc """
+  Returns a callback that just outputs the streaming data.
+  Useful for debugging or monitoring the stream.
+  """
+  def debug_callback do
+    fn
+      %{"playlist_info" => info} ->
+        IO.puts("Playlist Info:")
+        IO.inspect(info, pretty: true)
+        :ok
+
+      %{"track" => track} ->
+        IO.puts("\nTrack:")
+        IO.inspect(track, pretty: true)
+        :ok
+    end
+  end
+
+  defp get_first_image_url([%{"url" => url} | _]), do: url
+  defp get_first_image_url(_), do: nil
 end

lib/pling/rooms/room/impl.ex

@@ -8,17 +8,19 @@ defmodule Pling.Rooms.Room.Impl do
 
   def initialize(room_code, game_mode, leader_id, playlist \\ nil) do
     initial_state = RoomState.initialize(room_code, game_mode, leader_id)
+    playlists = MusicLibrary.load_playlists()
 
     state =
       if playlist do
+        # Merge the custom playlist with existing playlists
+        updated_playlists = Map.put(playlists, playlist.spotify_id, playlist)
+
         %{
           initial_state
-          | playlists: %{"custom" => playlist},
-            selection: %{playlist: "custom", track: nil}
+          | playlists: updated_playlists,
+            selection: %{playlist: playlist.spotify_id, track: nil}
         }
       else
-        playlists = MusicLibrary.load_playlists()
-
         if Enum.empty?(playlists) do
           Logger.warning("No playlists found in database, room may not function correctly")
 

lib/pling/services/spotify.ex

@@ -4,7 +4,9 @@ defmodule Pling.Services.Spotify do
   @base_url "https://playlist-fetcher-1031294514094.europe-north1.run.app"
   @api_key "1367a6ef2cb6f3cd2bfb3f73978292fdae3bc9a5e885ca7632d4eb3fc15eb4d4"
 
-  def get_playlist(playlist_id) do
+  def stream_playlist(playlist_id, callback) when is_function(callback, 1) do
+    Logger.info("Starting playlist stream", playlist_id: playlist_id)
+
     req =
       Req.new(
         base_url: @base_url,
@@ -13,44 +15,42 @@ defmodule Pling.Services.Spotify do
 
     case Req.get(req,
            url: "/playlist/#{playlist_id}",
-           params: [stream: false]
+           params: [stream: true],
+           into: fn {:data, data}, {req, resp} ->
+             String.split(data, "\n", trim: true)
+             |> Enum.each(fn line ->
+               case Jason.decode(line) do
+                 {:ok, decoded} ->
+                   Logger.debug("Processing playlist item",
+                     playlist_id: playlist_id,
+                     track_id: decoded["id"]
+                   )
+
+                   callback.(decoded)
+
+                 {:error, error} ->
+                   Logger.error("Failed to decode chunk",
+                     playlist_id: playlist_id,
+                     error: inspect(error),
+                     chunk: line
+                   )
+               end
+             end)
+
+             {:cont, {req, resp}}
+           end
          ) do
-      {:ok, %{body: %{"tracks" => tracks, "playlist_info" => playlist_info}}} ->
-        {:ok,
-         %{
-           tracks: Enum.map(tracks, &map_to_track/1),
-           playlist_info: map_to_playlist_info(playlist_info)
-         }}
+      {:ok, _response} ->
+        Logger.info("Completed playlist stream", playlist_id: playlist_id)
+        :ok
 
       {:error, error} ->
-        {:error, error}
+        Logger.error("Failed to stream playlist",
+          playlist_id: playlist_id,
+          error: inspect(error)
+        )
 
-      unexpected ->
-        Logger.error("Unexpected response from Spotify service: #{inspect(unexpected)}")
-        {:error, :invalid_response}
+        {:error, error}
     end
   end
-
-  defp map_to_track(%{"track" => track}) do
-    %Pling.Playlists.Track{
-      spotify_id: track["id"],
-      title: track["name"],
-      artists: Enum.map(track["artists"], & &1["name"]),
-      uri: track["uri"],
-      popularity: track["popularity"],
-      album: track["album"]["name"]
-    }
-  end
-
-  defp map_to_playlist_info(playlist_info) do
-    %{
-      name: playlist_info["name"],
-      owner: playlist_info["owner"],
-      uri: playlist_info["uri"],
-      image_url: get_first_image_url(playlist_info["images"])
-    }
-  end
-
-  defp get_first_image_url([%{"url" => url} | _]), do: url
-  defp get_first_image_url(_), do: nil
 end

lib/pling_web/live/room_live.ex

@@ -18,8 +18,15 @@ defmodule PlingWeb.RoomLive do
         case params do
           %{"playlist_id" => playlist_id} ->
             # Ensure playlist exists or fetch it
-            playlist = Pling.Playlists.MusicLibrary.get_or_fetch_playlist(playlist_id)
-            Rooms.join_room(room_code, user_id, self(), game_mode, playlist)
+            case Pling.Playlists.MusicLibrary.get_or_fetch_playlist(playlist_id) do
+              {:error, reason} ->
+                # If playlist fetch fails, fall back to default behavior
+                socket = put_flash(socket, :error, "Failed to load playlist: #{reason}")
+                Rooms.join_room(room_code, user_id, self(), game_mode)
+
+              playlist when is_struct(playlist) ->
+                Rooms.join_room(room_code, user_id, self(), game_mode, playlist)
+            end
 
           _ ->
             Rooms.join_room(room_code, user_id, self(), game_mode)
@@ -36,8 +43,14 @@ defmodule PlingWeb.RoomLive do
       {:ok, state} =
         case params do
           %{"playlist_id" => playlist_id} ->
-            playlist = Pling.Playlists.MusicLibrary.get_or_fetch_playlist(playlist_id)
-            Rooms.join_room(room_code, user_id, self(), game_mode, playlist)
+            case Pling.Playlists.MusicLibrary.get_or_fetch_playlist(playlist_id) do
+              {:error, reason} ->
+                socket = put_flash(socket, :error, "Failed to load playlist: #{reason}")
+                Rooms.join_room(room_code, user_id, self(), game_mode)
+
+              playlist when is_struct(playlist) ->
+                Rooms.join_room(room_code, user_id, self(), game_mode, playlist)
+            end
 
           _ ->
             Rooms.join_room(room_code, user_id, self(), game_mode)
@@ -64,6 +77,7 @@ defmodule PlingWeb.RoomLive do
       leader?: false,
       users: [],
       selection: %{playlist: nil, track: nil},
+      # This will be populated from room state
       playlists: nil
     )
   end
@@ -225,7 +239,7 @@ defmodule PlingWeb.RoomLive do
   end
 
   def pling_button(assigns) do
-    assigns = assign(assigns, :disabled?, !assigns.leader? && !assigns.playing?)
+    assigns = assign(assigns, :disabled?, !assigns.playing? && !assigns.leader?)
 
     ~H"""
     <div id="start" phx-hook="PlingButton" class="flex place-content-center w-full">