~ knotless Search/
↑↓ move↵ open⇧↵ all results

geesawra.industries/hydraulophone

An unofficial YouTube Music app for iPhone, iPad, and Mac.

0
0
main
833 lines · 24.6 KB Raw History
import HydraulophoneCore
import SwiftUI

@MainActor
final class CollectionTracksViewModel: ObservableObject {
  enum Source: Hashable, Sendable {
    case playlist(Playlist)
    case album(Album)

    var key: String {
      switch self {
      case .playlist(let playlist):
        return "playlist:\(playlist.routeIdentity)"
      case .album(let album):
        return "album:\(album.id)"
      }
    }

    var title: String {
      switch self {
      case .playlist(let playlist): return playlist.title
      case .album(let album): return album.title
      }
    }

    var subtitle: String? {
      switch self {
      case .playlist(let playlist): return playlist.subtitle
      case .album(let album): return album.subtitle
      }
    }

    var thumbnailURL: URL? {
      switch self {
      case .playlist(let playlist): return playlist.thumbnailURL
      case .album(let album): return album.thumbnailURL
      }
    }

    var showsTrackDetails: Bool { true }

    var showsTrackArtwork: Bool {
      if case .album = self { return false }
      return true
    }
  }

  let source: Source
  private let service: any MusicService
  private var fallbackAlbumArtworkURL: URL?
  private var requestTask: Task<Void, Never>?
  private var requestGeneration = UUID()
  private var continuation: PaginationToken?
  private var seenContinuationValues: Set<String> = []

  @Published private(set) var songs: [Song] = []
  @Published private(set) var header: CatalogPageHeader?
  @Published private(set) var isLoading = false
  @Published private(set) var isRefreshing = false
  @Published private(set) var isLoadingMore = false
  @Published private(set) var hasMore = false
  @Published var errorMessage: String?
  @Published private(set) var refreshErrorMessage: String?
  @Published private(set) var loadMoreErrorMessage: String?
  /// Changes only when a pagination request added at least one unique song.
  /// The view uses it to extend a queue created from this exact collection.
  @Published private(set) var appendGeneration = 0
  /// Changes after each successful first-page replacement. Queue tracking must
  /// be detached from a refreshed list, even when playback remains active.
  @Published private(set) var replacementGeneration = 0

  init(playlist: Playlist, service: any MusicService) {
    source = .playlist(playlist)
    self.service = service
  }

  init(album: Album, service: any MusicService) {
    source = .album(album)
    self.service = service
  }

  /// Browse headers supply artwork and credits missing from track navigation links.
  var displayAlbum: Album? {
    guard case .album(let album) = source else { return nil }
    return Album(
      browseID: album.browseID, playlistID: album.playlistID, title: album.title,
      subtitle: header?.subtitle ?? album.subtitle,
      thumbnailURL: header?.thumbnailURL ?? album.thumbnailURL
        ?? fallbackAlbumArtworkURL,
      artistReferences: header?.artistReferences ?? album.artistReferences, params: album.params)
  }

  deinit {
    requestTask?.cancel()
  }

  func clear() {
    requestTask?.cancel()
    requestTask = nil
    requestGeneration = UUID()
    songs = []
    header = nil
    fallbackAlbumArtworkURL = nil
    continuation = nil
    seenContinuationValues.removeAll()
    hasMore = false
    isLoading = false
    isRefreshing = false
    isLoadingMore = false
    errorMessage = nil
    refreshErrorMessage = nil
    loadMoreErrorMessage = nil
  }

  func load() async {
    guard !isLoading, !isRefreshing, !isLoadingMore else { return }
    requestTask?.cancel()
    let generation = UUID()
    requestGeneration = generation
    songs = []
    header = nil
    fallbackAlbumArtworkURL = nil
    continuation = nil
    seenContinuationValues.removeAll()
    hasMore = true
    isLoading = true
    errorMessage = nil
    refreshErrorMessage = nil
    loadMoreErrorMessage = nil

    let task = Task { [weak self] in
      guard let self else { return }
      await self.performInitialLoad(
        generation: generation,
        preserveContent: false,
        policy: .reload
      )
    }
    requestTask = task
    await withTaskCancellationHandler(
      operation: {
        await task.value
      },
      onCancel: {
        task.cancel()
      })
    if requestGeneration == generation {
      requestTask = nil
    }
  }

  func refresh() async {
    guard !isLoading, !isRefreshing, !isLoadingMore else { return }
    requestTask?.cancel()
    let generation = UUID()
    requestGeneration = generation
    isRefreshing = true
    refreshErrorMessage = nil
    loadMoreErrorMessage = nil

    let task = Task { [weak self] in
      guard let self else { return }
      await self.performInitialLoad(
        generation: generation,
        preserveContent: true,
        policy: .reload
      )
    }
    requestTask = task
    await withTaskCancellationHandler(
      operation: {
        await task.value
      },
      onCancel: {
        task.cancel()
      })
    if requestGeneration == generation {
      requestTask = nil
    }
  }

  func retry() async {
    if let loadMoreErrorMessage, !loadMoreErrorMessage.isEmpty {
      await loadMore()
    } else {
      await load()
    }
  }

  func loadMoreIfNeeded(index: Int) async {
    guard !songs.isEmpty, index >= max(songs.count - 4, 0) else { return }
    await loadMore()
  }

  func loadMore() async {
    guard hasMore, let continuation, !isLoading, !isRefreshing, !isLoadingMore else {
      return
    }
    let generation = requestGeneration
    isLoadingMore = true
    loadMoreErrorMessage = nil

    let task = Task { [weak self] in
      guard let self else { return }
      await self.performMoreLoad(continuation: continuation, generation: generation)
    }
    requestTask = task
    await withTaskCancellationHandler(
      operation: {
        await task.value
      },
      onCancel: {
        task.cancel()
      })
    if requestGeneration == generation {
      requestTask = nil
    }
  }

  func reloadAfterSessionTransition() async {
    await load()
  }

  private func performInitialLoad(
    generation: UUID,
    preserveContent: Bool,
    policy: CatalogLoadPolicy
  ) async {
    defer {
      if requestGeneration == generation {
        isLoading = false
        isRefreshing = false
      }
    }

    do {
      let page = try await loadPage(continuation: nil, policy: policy)
      guard requestGeneration == generation, !Task.isCancelled else { return }
      if case .album = source {
        fallbackAlbumArtworkURL =
          page.items.lazy.compactMap(\.thumbnailURL).first
          ?? fallbackAlbumArtworkURL
      }
      header = page.header?.fillingMissingValues(from: header) ?? header
      songs = uniqueSongs(page.items).map(applyingCollectionMetadata)
      replacementGeneration += 1
      continuation = nil
      seenContinuationValues.removeAll()
      hasMore = false
      if !page.items.isEmpty, let next = page.next,
        seenContinuationValues.insert(next.rawValue).inserted
      {
        continuation = next
        hasMore = true
      }
      if preserveContent {
        errorMessage = nil
        refreshErrorMessage = nil
      } else {
        errorMessage = nil
      }
    } catch is CancellationError {
      return
    } catch {
      guard requestGeneration == generation else { return }
      let message = (error as? LocalizedError)?.errorDescription ?? "Could not load songs."
      if preserveContent {
        refreshErrorMessage = message
      } else {
        songs = []
        continuation = nil
        hasMore = false
        errorMessage = message
      }
    }
  }

  private func performMoreLoad(
    continuation requestedContinuation: PaginationToken,
    generation: UUID
  ) async {
    defer {
      if requestGeneration == generation {
        isLoadingMore = false
      }
    }

    do {
      let page = try await loadPage(continuation: requestedContinuation, policy: .cacheFirst)
      guard requestGeneration == generation, !Task.isCancelled else { return }

      var existingIDs = Set(songs.map(\.id))
      var didAppend = false
      for song in page.items where existingIDs.insert(song.id).inserted {
        songs.append(applyingCollectionMetadata(to: song))
        didAppend = true
      }
      if didAppend {
        appendGeneration += 1
      }
      updateContinuation(after: page)
      loadMoreErrorMessage = nil
    } catch is CancellationError {
      return
    } catch {
      guard requestGeneration == generation else { return }
      loadMoreErrorMessage =
        (error as? LocalizedError)?.errorDescription ?? "Could not load more songs."
    }
  }

  private func loadPage(
    continuation: PaginationToken?,
    policy: CatalogLoadPolicy
  ) async throws -> Page<Song> {
    switch source {
    case .playlist(let playlist):
      if let paginatedService = service as? any PaginatedCatalogMusicService {
        return try await paginatedService.trackPage(
          in: playlist,
          continuation: continuation,
          policy: policy
        )
      }
      return Page(items: try await service.tracks(in: playlist))

    case .album(let album):
      if let paginatedService = service as? any PaginatedCatalogMusicService {
        return try await paginatedService.albumTrackPage(
          in: album,
          continuation: continuation,
          policy: policy
        )
      }
      // MusicService predates album collections. A fake can still provide
      // album data by exposing it through the same legacy track-array method.
      let legacyPlaylist = Playlist(
        id: album.playlistID ?? album.id,
        title: album.title,
        subtitle: album.subtitle,
        thumbnailURL: album.thumbnailURL
      )
      return Page(items: try await service.tracks(in: legacyPlaylist))
    }
  }

  private func uniqueSongs(_ values: [Song]) -> [Song] {
    var seenIDs: Set<String> = []
    return values.filter { seenIDs.insert($0.id).inserted }
  }

  private func applyingCollectionMetadata(to song: Song) -> Song {
    guard let album = displayAlbum else { return song }
    return CollectionTrackMetadata.applying(song, from: album)
  }

  private func updateContinuation(after page: Page<Song>) {
    guard !page.items.isEmpty, let next = page.next else {
      continuation = nil
      hasMore = false
      return
    }
    guard seenContinuationValues.insert(next.rawValue).inserted else {
      continuation = nil
      hasMore = false
      return
    }
    continuation = next
    hasMore = true
  }
}

enum CollectionTrackMetadata {
  static func applying(_ song: Song, from album: Album) -> Song {
    // Album rows can omit artwork already shown in the collection header.
    // Carry that context into the queue so every playback surface has it,
    // including tracks added by a later continuation page.
    let parsedArtist = song.artist.trimmingCharacters(in: .whitespacesAndNewlines)
    let linkedArtists = album.artistReferences?.map(\.title).filter { !$0.isEmpty }
      .joined(separator: ", ")
    let needsArtist =
      parsedArtist.isEmpty || parsedArtist.caseInsensitiveCompare("Unknown artist") == .orderedSame
    let albumArtistName =
      linkedArtists.flatMap { $0.isEmpty ? nil : $0 }
      ?? albumArtist(from: album.subtitle)
    let artist = needsArtist ? albumArtistName ?? song.artist : song.artist
    // A known guest credit must not navigate to the album's primary artist.
    let inheritsArtistReferences =
      needsArtist
      || parsedArtist.caseInsensitiveCompare(albumArtistName ?? "") == .orderedSame
    return Song(
      id: song.id,
      title: song.title,
      artist: artist,
      album: song.album ?? album.title,
      durationText: song.durationText,
      thumbnailURL: song.thumbnailURL ?? album.thumbnailURL,
      artistReferences: song.artistReferences
        ?? (inheritsArtistReferences ? album.artistReferences : nil),
      albumReference: song.albumReference ?? album
    )
  }

  private static func albumArtist(from subtitle: String?) -> String? {
    guard let subtitle else { return nil }
    let parts = subtitle.split(separator: "•").map {
      $0.trimmingCharacters(in: .whitespacesAndNewlines)
    }.filter { !$0.isEmpty }
    let artist: String
    if parts.count == 1 {
      artist = parts[0]
    } else if parts.count > 1,
      ["album", "ep", "single"].contains(parts[0].lowercased())
    {
      artist = parts[1]
    } else {
      return nil
    }
    guard artist.caseInsensitiveCompare("Unknown artist") != .orderedSame,
      !["album", "ep", "single"].contains(artist.lowercased()),
      Int(artist) == nil
    else { return nil }
    return artist
  }

}

/// App-facing constructor for playlist collections.
struct CollectionTracksView: View {
  private let source: CollectionTracksViewModel.Source
  private let injectedService: (any MusicService)?
  private let injectedPlayback: PlaybackController?
  @EnvironmentObject private var model: AppModel

  init(playlist: Playlist) {
    source = .playlist(playlist)
    injectedService = nil
    injectedPlayback = nil
  }

  init(album: Album) {
    source = .album(album)
    injectedService = nil
    injectedPlayback = nil
  }

  init(
    playlist: Playlist,
    service: any MusicService,
    playback: PlaybackController
  ) {
    source = .playlist(playlist)
    injectedService = service
    injectedPlayback = playback
  }

  init(
    album: Album,
    service: any MusicService,
    playback: PlaybackController
  ) {
    source = .album(album)
    injectedService = service
    injectedPlayback = playback
  }

  var body: some View {
    CollectionTracksContent(
      source: source,
      service: injectedService ?? model.musicService,
      playback: injectedPlayback ?? model.playback
    )
  }
}

/// Compatibility name retained for routes and callers from the first
/// collection implementation.
struct PlaylistTracksView: View {
  private let playlist: Playlist
  private let injectedService: (any MusicService)?
  private let injectedPlayback: PlaybackController?
  @EnvironmentObject private var model: AppModel

  init(playlist: Playlist) {
    self.playlist = playlist
    injectedService = nil
    injectedPlayback = nil
  }

  init(
    playlist: Playlist,
    service: any MusicService,
    playback: PlaybackController
  ) {
    self.playlist = playlist
    injectedService = service
    injectedPlayback = playback
  }

  var body: some View {
    CollectionTracksContent(
      source: .playlist(playlist),
      service: injectedService ?? model.musicService,
      playback: injectedPlayback ?? model.playback
    )
  }
}

private struct CollectionTracksContent: View {
  let source: CollectionTracksViewModel.Source
  let service: any MusicService
  @ObservedObject var playback: PlaybackController
  @EnvironmentObject private var model: AppModel
  @Environment(\.accessibilityReduceMotion) private var reduceMotion
  @StateObject private var viewModel: CollectionTracksViewModel
  @State private var queuedCollectionKey: String?
  @State private var queuedSongIDs: [String]?
  @State private var queuedReplacementGeneration: Int?
  @State private var handledAppendGeneration = 0
  @State private var handledReplacementGeneration = 0

  init(
    source: CollectionTracksViewModel.Source,
    service: any MusicService,
    playback: PlaybackController
  ) {
    self.source = source
    self.service = service
    _playback = ObservedObject(wrappedValue: playback)
    switch source {
    case .playlist(let playlist):
      _viewModel = StateObject(
        wrappedValue: CollectionTracksViewModel(playlist: playlist, service: service)
      )
    case .album(let album):
      _viewModel = StateObject(
        wrappedValue: CollectionTracksViewModel(album: album, service: service)
      )
    }
  }

  var body: some View {
    Group {
      if model.isRestoringSession || model.isSessionTransitioning {
        restoringState
      } else {
        collectionScrollView
      }
    }
    .background(HydraulophoneTheme.groupedBackground)
    .navigationTitle(viewModel.source.title)
    .navigationBarTitleDisplayMode(.inline)
    .toolbar {
      if let album = viewModel.displayAlbum {
        ToolbarItem(placement: .topBarTrailing) {
          AlbumDownloadButton(
            album: album, downloads: model.downloads, quality: model.settings.preferredQuality)
        }
      }
    }
    .task(id: model.catalogSessionID) {
      guard !model.isSessionTransitioning,
        !model.isRestoringSession
      else {
        viewModel.clear()
        clearQueueTracking()
        return
      }
      await viewModel.load()
    }
    .onChange(of: model.isSessionTransitioning) { _, isTransitioning in
      if isTransitioning {
        viewModel.clear()
        clearQueueTracking()
      } else if !model.isRestoringSession {
        Task { await viewModel.reloadAfterSessionTransition() }
      }
    }
    .onChange(of: model.session) { _, session in
      if session == nil {
        viewModel.clear()
        clearQueueTracking()
      }
    }
    .onChange(of: viewModel.appendGeneration) { _, generation in
      guard generation != handledAppendGeneration else { return }
      handledAppendGeneration = generation
      appendNewSongsToCurrentQueue()
    }
    .onChange(of: viewModel.replacementGeneration) { _, generation in
      guard generation != handledReplacementGeneration else { return }
      handledReplacementGeneration = generation
      clearQueueTracking()
    }
    .tint(HydraulophoneTheme.accent)
  }

  private var collectionScrollView: some View {
    ScrollView {
      VStack(alignment: .leading, spacing: 20) {
        collectionHeader
        collectionActions
        tracksContent
      }
      .padding(.horizontal, 20)
      .padding(.bottom, 24)
      .animation(reduceMotion ? nil : .easeInOut(duration: 0.2), value: viewModel.songs)
      .frame(maxWidth: 860)
      .frame(maxWidth: .infinity)
    }
    .refreshable {
      guard !model.isSessionTransitioning, !model.isRestoringSession else { return }
      await viewModel.refresh()
    }
  }

  private var collectionActions: some View {
    MusicPlaybackActions(
      isEnabled: !viewModel.songs.isEmpty,
      play: { playSong(at: 0, shuffle: false) },
      shuffle: { playSong(at: 0, shuffle: true) }
    )
  }

  private var restoringState: some View {
    VStack(spacing: 14) {
      ProgressView()
        .controlSize(.large)
      Text("Restoring your collection…")
        .font(.subheadline)
        .foregroundStyle(.secondary)
    }
    .frame(maxWidth: .infinity, minHeight: 260)
    .accessibilityElement(children: .combine)
    .accessibilityLabel("Restoring your collection")
  }

  @ViewBuilder
  private var collectionHeader: some View {
    if let album = viewModel.displayAlbum {
      AlbumDetailHeader(album: album)
    } else {
      playlistHeader
    }
  }

  private var playlistHeader: some View {
    HStack(alignment: .top, spacing: 16) {
      ArtworkView(
        url: viewModel.source.thumbnailURL,
        size: 128,
        cornerRadius: 14
      )
      VStack(alignment: .leading, spacing: 8) {
        Text(viewModel.source.title)
          .font(.title2.weight(.bold))
          .lineLimit(3)
        if let subtitle = viewModel.source.subtitle, !subtitle.isEmpty {
          Text(subtitle)
            .font(.subheadline)
            .foregroundStyle(.secondary)
            .lineLimit(2)
        }
        if !viewModel.songs.isEmpty {
          Text("\(viewModel.songs.count) songs")
            .font(.caption)
            .foregroundStyle(.secondary)
        }
      }
      .frame(maxWidth: .infinity, alignment: .leading)
    }
    .padding(.top, 12)
  }

  @ViewBuilder
  private var tracksContent: some View {
    if (viewModel.isLoading || viewModel.isRefreshing) && viewModel.songs.isEmpty {
      ProgressView("Loading songs…")
        .frame(maxWidth: .infinity, minHeight: 200)
    } else if let errorMessage = viewModel.errorMessage, viewModel.songs.isEmpty {
      HydraulophoneErrorState(
        title: "Could not load songs",
        message: errorMessage,
        retry: {
          Task { await viewModel.retry() }
        }
      )
      .frame(maxWidth: .infinity, minHeight: 220)
    } else if let refreshErrorMessage = viewModel.refreshErrorMessage,
      viewModel.songs.isEmpty
    {
      HydraulophoneErrorState(
        title: "Collection refresh failed",
        message: refreshErrorMessage,
        retry: {
          Task { await viewModel.refresh() }
        }
      )
      .frame(maxWidth: .infinity, minHeight: 220)
    } else if viewModel.songs.isEmpty {
      VStack(spacing: 12) {
        ContentUnavailableView("This collection is empty", systemImage: "music.note.list")
          .frame(maxWidth: .infinity, minHeight: 200)
        if viewModel.hasMore {
          collectionPaginationFooter
        }
      }
    } else {
      VStack(alignment: .leading, spacing: 12) {
        if let message = viewModel.refreshErrorMessage {
          CollectionRefreshErrorBanner(message: message) {
            Task { await viewModel.refresh() }
          }
        }
        LazyVStack(spacing: 0) {
          ForEach(Array(viewModel.songs.enumerated()), id: \.element.id) { index, song in
            SongRow(
              song: song,
              accessibilityIdentifier: HydraulophoneAccessibilityID.track(song.id),
              trackNumber: index + 1,
              showsDetails: viewModel.source.showsTrackDetails,
              showsArtwork: viewModel.source.showsTrackArtwork,
              playNext: { playback.enqueueNext(song) },
              addToQueue: { playback.enqueue(song) }
            ) {
              playSong(at: index)
            }
            .onAppear {
              Task { await viewModel.loadMoreIfNeeded(index: index) }
            }
            Divider()
          }
        }
        collectionPaginationFooter
      }
    }
  }

  @ViewBuilder
  private var collectionPaginationFooter: some View {
    if viewModel.isLoadingMore {
      ProgressView("Loading more songs…")
        .frame(maxWidth: .infinity)
        .padding(.vertical, 10)
        .accessibilityElement(children: .combine)
    } else if let message = viewModel.loadMoreErrorMessage {
      HStack(spacing: 10) {
        Text(message)
          .font(.footnote)
          .foregroundStyle(.secondary)
          .frame(maxWidth: .infinity, alignment: .leading)
        Button("Retry") {
          Task { await viewModel.loadMore() }
        }
        .frame(minHeight: 44)
      }
      .padding(.vertical, 4)
      .accessibilityElement(children: .contain)
    } else if viewModel.hasMore && !viewModel.isLoading && !viewModel.isRefreshing {
      Button("Load more") {
        Task { await viewModel.loadMore() }
      }
      .frame(maxWidth: .infinity, minHeight: 44)
      .padding(.vertical, 4)
    } else if !viewModel.hasMore {
      Text("End of songs")
        .font(.footnote)
        .foregroundStyle(.secondary)
        .frame(maxWidth: .infinity)
        .padding(.vertical, 10)
        .accessibilityLabel("End of songs")
    }
  }

  private func playSong(at index: Int, shuffle: Bool? = nil) {
    let songs = viewModel.songs
    guard songs.indices.contains(index) else { return }
    playback.setQueue(songs, startAt: index, shuffle: shuffle)
    queuedCollectionKey = viewModel.source.key
    queuedSongIDs = songs.map(\.id)
    queuedReplacementGeneration = viewModel.replacementGeneration
  }

  private func appendNewSongsToCurrentQueue() {
    guard queuedCollectionKey == viewModel.source.key,
      let queuedSongIDs,
      queuedReplacementGeneration == viewModel.replacementGeneration,
      playback.currentSong != nil,
      playback.queue.map(\.id) == queuedSongIDs
    else {
      return
    }

    let additions = viewModel.songs.filter { !queuedSongIDs.contains($0.id) }
    guard !additions.isEmpty else { return }
    for song in additions {
      playback.enqueue(song)
    }
    self.queuedSongIDs = queuedSongIDs + additions.map(\.id)
  }

  private func clearQueueTracking() {
    queuedCollectionKey = nil
    queuedSongIDs = nil
    queuedReplacementGeneration = nil
    handledAppendGeneration = viewModel.appendGeneration
    handledReplacementGeneration = viewModel.replacementGeneration
  }
}

private struct CollectionRefreshErrorBanner: View {
  let message: String
  let retry: () -> Void

  var body: some View {
    HStack(alignment: .top, spacing: 10) {
      Image(systemName: "exclamationmark.triangle.fill")
        .foregroundStyle(.orange)
      Text("Refresh failed: \(message)")
        .font(.footnote)
        .foregroundStyle(.secondary)
        .frame(maxWidth: .infinity, alignment: .leading)
      Button("Retry", action: retry)
        .font(.footnote.weight(.semibold))
        .frame(minHeight: 44)
    }
    .padding(.horizontal, 12)
    .padding(.vertical, 8)
    .background(.regularMaterial, in: RoundedRectangle(cornerRadius: 10))
    .accessibilityElement(children: .combine)
    .accessibilityLabel("Collection refresh failed. \(message)")
  }
}