PlayolaStationPlayer.swift

//
//  PlayolaPlayer.swift
//  PlayolaPlayer
//
//  Created by Brian D Keane on 12/29/24.
//

import AVFAudio
import Combine
import Foundation
@_exported import PlayolaCore
import os.log

/// Errors specific to the station player
public enum StationPlayerError: Error, LocalizedError {
  case networkError(String)
  case scheduleError(String)
  case playbackError(String)
  case invalidStationId(String)
  case fileDownloadError(String)

  public var errorDescription: String? {
    switch self {
    case .networkError(let message):
      return "Network error: \(message)"
    case .scheduleError(let message):
      return "Schedule error: \(message)"
    case .playbackError(let message):
      return "Playback error: \(message)"
    case .invalidStationId(let id):
      return "Invalid station ID: \(id)"
    case .fileDownloadError(let message):
      return "File download error: \(message)"
    }
  }
}

/// A player for Playola stations that manages audio playback, scheduling, and stream management.
///
/// `PlayolaStationPlayer` is the main entry point for apps integrating with the Playola platform.
/// It handles:
/// - Loading and playing audio from Playola stations
/// - Scheduling upcoming audio content
/// - Managing the audio session and playback state
/// - Reporting listening sessions to Playola analytics
///
/// ## Usage Example:
/// ```
/// // Play a specific station
/// try await PlayolaStationPlayer.shared.play(stationId: "station-id-here")
///
/// // Stop playback
/// PlayolaStationPlayer.shared.stop()
///
/// // Observe state changes
/// player.$state.sink { state in
///    // Handle state changes
/// }
/// ```
@MainActor
final public class PlayolaStationPlayer: ObservableObject {
  var baseUrl = URL(string: "https://admin-api.playola.fm")!
  @Published public var stationId: String?
  private var interruptedStationId: String?
  var currentSchedule: Schedule?
  let fileDownloadManager: FileDownloadManaging
  var listeningSessionReporter: ListeningSessionReporter?
  private let errorReporter = PlayolaErrorReporter.shared
  private var authProvider: PlayolaAuthenticationProvider?

  /// Time offset for playing station from a different point in time
  private var scheduleOffset: TimeInterval?

  private var activeDownloadIds: [String: UUID] = [:]

  private var schedulingTask: Task<Void, Never>?
  private var playTask: Task<Void, Error>?

  // Audio interruption state
  private var isSuspended = false
  private var wasPlayingBeforeInterruption = false

  public weak var delegate: PlayolaStationPlayerDelegate?

  // Thread-safe access to spin players - all access must be on main actor
  private var _spinPlayers: [SpinPlayer] = []

  /// Thread-safe access to spin players array
  private var spinPlayers: [SpinPlayer] {
    get {
      MainActor.assumeIsolated {
        return _spinPlayers
      }
    }
    set {
      MainActor.assumeIsolated {
        _spinPlayers = newValue
      }
    }
  }
  public static let shared = PlayolaStationPlayer()

  /// Configure this instance with authentication provider
  /// - Parameters:
  ///   - authProvider: Provider for JWT tokens
  ///   - baseURL: Base URL for API endpoints. Defaults to production URL.
  public func configure(
    authProvider: PlayolaAuthenticationProvider,
    baseURL: URL = URL(string: "https://admin-api.playola.fm")!
  ) {
    self.authProvider = authProvider
    self.listeningSessionReporter = ListeningSessionReporter(
      stationPlayer: self, authProvider: authProvider, baseURL: baseURL)
    self.baseUrl = baseURL
  }

  public enum State: Sendable {
    case loading(Float)
    case playing(Spin)
    case idle
  }

  @Published public var state: PlayolaStationPlayer.State = .idle {
    didSet {
      delegate?.player(self, playerStateDidChange: state)
    }
  }

  public var isPlaying: Bool {
    switch state {
    case .playing:
      return true
    default:
      return false
    }
  }

  @MainActor
  internal init(fileDownloadManager: FileDownloadManaging? = nil) {
    self.fileDownloadManager = fileDownloadManager ?? FileDownloadManagerAsync.shared
    self.authProvider = nil
    self.listeningSessionReporter = ListeningSessionReporter(stationPlayer: self, authProvider: nil)

    #if os(iOS) || os(tvOS)
      NotificationCenter.default.addObserver(
        self,
        selector: #selector(handleAudioSessionInterruption(_:)),
        name: AVAudioSession.interruptionNotification,
        object: nil
      )

      NotificationCenter.default.addObserver(
        self,
        selector: #selector(handleAudioRouteChange(_:)),
        name: AVAudioSession.routeChangeNotification,
        object: nil
      )

      NotificationCenter.default.addObserver(
        self,
        selector: #selector(handleAudioEngineConfigurationChange(_:)),
        name: .AVAudioEngineConfigurationChange,
        object: PlayolaMainMixer.shared.engine
      )
    #endif
  }

  private static let logger = OSLog(
    subsystem: "PlayolaPlayer",
    category: "PlayolaStationPlayer")

  private func getAvailableSpinPlayer() -> SpinPlayer {
    let availablePlayers = _spinPlayers.filter({ $0.state == .available })
    if let available = availablePlayers.first { return available }

    let newPlayer = SpinPlayer(delegate: self)
    _spinPlayers.append(newPlayer)
    return newPlayer
  }

  @MainActor
  private func scheduleSpin(spin: Spin, showProgress: Bool = false, retryCount: Int = 0)
    async throws
  {
    os_log(
      "📅 Scheduling spin: %@ - Retry: %d", log: PlayolaStationPlayer.logger, type: .info, spin.id,
      retryCount)

    try validateSpinForScheduling(spin)
    let spinPlayer = getAvailableSpinPlayer()
    cancelExistingDownload(for: spin.id)

    do {
      let result = await loadSpinWithProgress(spin, spinPlayer, showProgress)
      try await handleLoadResult(
        result, spin: spin, showProgress: showProgress, retryCount: retryCount)
    } catch {
      try await handleSchedulingError(
        error, spin: spin, showProgress: showProgress, retryCount: retryCount)
    }
  }

  private func validateSpinForScheduling(_ spin: Spin) throws {
    guard spin.audioBlock.downloadUrl != nil else {
      let error = StationPlayerError.playbackError("Invalid audio file URL in spin")
      let spinDetails = createSpinDetailsString(spin)
      Task {
        await errorReporter.reportError(
          error,
          context: "Invalid or missing download URL for spin | \(spinDetails)",
          level: .error)
      }
      throw error
    }
  }

  private func createSpinDetailsString(_ spin: Spin) -> String {
    return """
        Spin ID: \(spin.id)
        Audio Block ID: \(spin.audioBlock.id)
        Audio Block Title: \(spin.audioBlock.title)
        Audio Block Artist: \(spin.audioBlock.artist)
        Download URL: \(spin.audioBlock.downloadUrl?.absoluteString ?? "nil")
      """
  }

  private func cancelExistingDownload(for spinId: String) {
    if let existingDownloadId = activeDownloadIds[spinId] {
      _ = fileDownloadManager.cancelDownload(id: existingDownloadId)
      activeDownloadIds.removeValue(forKey: spinId)
    }
  }

  private func loadSpinWithProgress(
    _ spin: Spin, _ spinPlayer: SpinPlayer, _ showProgress: Bool
  ) async -> Result<URL, Error> {
    return await spinPlayer.load(
      spin,
      onDownloadProgress: { [weak self] progress in
        guard let self = self, showProgress else { return }
        self.state = .loading(progress)
      }
    )
  }

  private func handleLoadResult(
    _ result: Result<URL, Error>, spin: Spin, showProgress: Bool,
    retryCount: Int
  ) async throws {
    switch result {
    case .success:
      if showProgress {
        self.state = .playing(spin)
      }
    case .failure(let error):
      try await handleLoadFailure(
        error, spin: spin, showProgress: showProgress, retryCount: retryCount)
    }
  }

  private func handleLoadFailure(_ error: Error, spin: Spin, showProgress: Bool, retryCount: Int)
    async throws
  {
    if shouldSkipRetry(for: error) {
      throw error
    }

    let stationError = convertToStationError(error)
    Task {
      await self.errorReporter.reportError(stationError, level: .error)
    }

    try await retryIfPossible(
      spin: spin, showProgress: showProgress, retryCount: retryCount, fallbackError: error)
  }

  private func handleSchedulingError(
    _ error: Error, spin: Spin, showProgress: Bool, retryCount: Int
  ) async throws {
    if shouldSkipRetry(for: error) {
      throw error
    }

    try await retryIfPossible(
      spin: spin, showProgress: showProgress, retryCount: retryCount, fallbackError: error)
  }

  private func shouldSkipRetry(for error: Error) -> Bool {
    if let urlError = error as? URLError, urlError.code == .cancelled {
      return true
    }
    if let fileDownloadError = error as? FileDownloadError,
      case .downloadCancelled = fileDownloadError
    {
      return true
    }
    return false
  }

  private func convertToStationError(_ error: Error) -> Error {
    return error is FileDownloadError
      ? error
      : StationPlayerError.fileDownloadError(error.localizedDescription)
  }

  private func retryIfPossible(
    spin: Spin, showProgress: Bool, retryCount: Int, fallbackError: Error
  ) async throws {
    let maxRetries = 3
    if retryCount < maxRetries {
      let delay = TimeInterval(0.5 * pow(2.0, Double(retryCount)))
      try await Task.sleep(for: .seconds(delay))
      try await self.scheduleSpin(
        spin: spin, showProgress: showProgress, retryCount: retryCount + 1)
    } else {
      let finalError =
        fallbackError is StationPlayerError
        ? fallbackError
        : StationPlayerError.fileDownloadError(fallbackError.localizedDescription)
      Task {
        await errorReporter.reportError(finalError, level: .error)
      }
      throw fallbackError
    }
  }

  @MainActor
  private func isScheduled(spin: Spin) -> Bool {
    return _spinPlayers.contains { $0.spin?.id == spin.id }
  }

  private let schedulePollingInterval: UInt64 = 20_000_000_000  // 20 seconds in nanoseconds

  @MainActor
  private func scheduleUpcomingSpins() async {
    guard let stationId else {
      let error = StationPlayerError.invalidStationId("No station ID available")
      Task { await errorReporter.reportError(error, level: .warning) }
      return
    }

    while !Task.isCancelled {
      do {
        try await performScheduleUpdate(stationId: stationId)
      } catch is CancellationError {
        os_log("📛 Schedule update cancelled", log: PlayolaStationPlayer.logger, type: .info)
        return
      } catch {
        Task {
          await errorReporter.reportError(
            error, context: "Failed to schedule upcoming spins", level: .error)
        }
        os_log(
          "Schedule update failed: %@", log: PlayolaStationPlayer.logger, type: .error,
          error.localizedDescription)
      }

      do {
        try await Task.sleep(nanoseconds: schedulePollingInterval)
      } catch {
        return
      }
    }
  }

  @MainActor
  private func performScheduleUpdate(stationId: String) async throws {
    let updatedSchedule = try await getUpdatedSchedule(stationId: stationId)

    os_log(
      "Retrieved schedule: %d total, %d current", log: PlayolaStationPlayer.logger, type: .info,
      updatedSchedule.spins.count,
      updatedSchedule.current(offsetTimeInterval: scheduleOffset).count)

    // Server returns only locked-in spins via lockedIn=true param.
    // This filter is a client-side safety net to prevent scheduling spins too far out.
    let spinsToLoad = updatedSchedule.current(offsetTimeInterval: scheduleOffset).filter {
      $0.airtime < .now + TimeInterval(600)
    }

    os_log(
      "Loading %d upcoming spins", log: PlayolaStationPlayer.logger, type: .info,
      spinsToLoad.count)

    for spin in spinsToLoad {
      try Task.checkCancellation()
      if !isScheduled(spin: spin) {
        os_log(
          "Scheduling new spin: %@ at %@", log: PlayolaStationPlayer.logger, type: .info,
          spin.id, ISO8601DateFormatter().string(from: spin.airtime))
        try await scheduleSpin(spin: spin)
      }
    }

    let scheduledSpinsCount = _spinPlayers.filter { $0.spin != nil }.count
    os_log(
      "Total scheduled spins: %d", log: PlayolaStationPlayer.logger, type: .info,
      scheduledSpinsCount)
  }

  private func getUpdatedSchedule(stationId: String) async throws -> Schedule {
    let url = createScheduleURL(for: stationId)

    do {
      let (data, response) = try await URLSession.shared.data(from: url)
      let httpResponse = try validateHTTPResponse(response, url: url)
      try await validateStatusCode(httpResponse, data: data, stationId: stationId)

      return try await decodeSchedule(from: data, stationId: stationId)
    } catch {
      await reportScheduleFetchError(error, stationId: stationId)
      throw error
    }
  }

  private func createScheduleURL(for stationId: String) -> URL {
    return baseUrl.appending(path: "/v1/stations/\(stationId)/schedule")
      .appending(queryItems: [
        URLQueryItem(name: "includeRelatedTexts", value: "true"),
        URLQueryItem(name: "lockedIn", value: "true"),
      ])
  }

  private func validateHTTPResponse(_ response: URLResponse, url: URL) throws -> HTTPURLResponse {
    guard let httpResponse = response as? HTTPURLResponse else {
      let error = StationPlayerError.networkError("Invalid response type")
      Task {
        await errorReporter.reportError(
          error,
          context: "Non-HTTP response received from schedule endpoint: \(url.absoluteString)",
          level: .error)
      }
      throw error
    }
    return httpResponse
  }

  private func validateStatusCode(_ httpResponse: HTTPURLResponse, data: Data, stationId: String)
    async throws
  {
    guard (200...299).contains(httpResponse.statusCode) else {
      let responseText = String(data: data, encoding: .utf8) ?? "Unable to decode response"
      let error = StationPlayerError.networkError("HTTP error: \(httpResponse.statusCode)")

      await reportHTTPError(
        error, statusCode: httpResponse.statusCode, stationId: stationId, responseText: responseText
      )
      throw error
    }
  }

  private func reportHTTPError(
    _ error: StationPlayerError, statusCode: Int, stationId: String, responseText: String
  ) async {
    if statusCode == 404 {
      Task {
        await errorReporter.reportError(
          error,
          context: "Station not found: \(stationId) | Response: \(responseText.prefix(100))",
          level: .error)
      }
    } else {
      Task {
        await errorReporter.reportError(
          error,
          context:
            "HTTP \(statusCode) error getting schedule for station: \(stationId) | "
            + "Response: \(responseText.prefix(100))",
          level: .error)
      }
    }
  }

  private func decodeSchedule(from data: Data, stationId: String) async throws -> Schedule {
    let decoder = JSONDecoderWithIsoFull()

    do {
      let spins = try decoder.decode([Spin].self, from: data)
      guard !spins.isEmpty else {
        let error = StationPlayerError.scheduleError(
          "No spins returned in schedule for station ID: \(stationId)")
        Task {
          await errorReporter.reportError(error, level: .error)
        }
        throw error
      }
      return Schedule(stationId: spins[0].stationId, spins: spins)
    } catch let decodingError as DecodingError {
      let context = await reportDecodingError(decodingError)
      throw StationPlayerError.scheduleError("Invalid schedule data: \(context)")
    }
  }

  private func reportDecodingError(_ decodingError: DecodingError) async -> String {
    let context: String
    switch decodingError {
    case .dataCorrupted(let reportedContext):
      context = "Corrupted data: \(reportedContext.debugDescription)"
    case .keyNotFound(let key, _):
      context = "Missing key: \(key)"
    case .typeMismatch(let type, _):
      context = "Type mismatch for: \(type)"
    default:
      context = "Unknown decoding error"
    }

    Task {
      await errorReporter.reportError(
        decodingError, context: "Failed to decode schedule: \(context)", level: .error)
    }

    return context
  }

  private func reportScheduleFetchError(_ error: Error, stationId: String) async {
    Task {
      await errorReporter.reportError(
        error, context: "Failed to fetch schedule for station: \(stationId)", level: .error)
    }
  }

  /// Begins playback of the specified Playola station.
  ///
  /// This method:
  /// 1. Fetches the station's schedule from the Playola API
  /// 2. Loads and prepares the current audio block for playback
  /// 3. Schedules upcoming audio blocks to ensure smooth transitions
  /// 4. Reports the listening session to Playola analytics
  ///
  /// - Parameters:
  ///   - stationId: The unique identifier of the station to play
  ///   - atDate: Optional date to play from. If provided, the station will play as if it were that date/time.
  ///             For example, passing a date 1 hour ago will play the station from 1 hour ago.
  /// - Throws: `StationPlayerError` if playback cannot be started due to:
  ///   - Network errors when fetching the schedule
  ///   - Invalid station ID
  ///   - Missing audio content in the schedule
  ///   - File download failures
  public func play(stationId: String, atDate: Date? = nil) async throws {
    // Reset any stale interruption state when explicitly starting playback.
    // This ensures CarPlay and other external callers always get a clean start.
    isSuspended = false
    wasPlayingBeforeInterruption = false
    interruptedStationId = nil

    // Cancel any existing play task
    playTask?.cancel()

    // Calculate schedule offset if atDate is provided
    self.scheduleOffset = atDate?.timeIntervalSinceNow

    self.stationId = stationId

    // Get the schedule
    self.currentSchedule = try await getUpdatedSchedule(stationId: stationId)

    guard let spinToPlay = currentSchedule?.current(offsetTimeInterval: scheduleOffset).first else {
      let error = StationPlayerError.scheduleError("No available spins to play")
      Task {
        await errorReporter.reportError(
          error,
          context:
            "Schedule for station \(stationId) contains no current spins | "
            + "Total spins: \(currentSchedule?.spins.count ?? 0)",
          level: .error)
      }
      throw error
    }

    // Log success with context
    os_log(
      "Starting playback for station: %@", log: PlayolaStationPlayer.logger, type: .info, stationId)

    // Schedule the first spin with progress shown
    try await scheduleSpin(spin: spinToPlay, showProgress: true)

    // Schedule upcoming spins
    schedulingTask?.cancel()
    schedulingTask = Task {
      await scheduleUpcomingSpins()
    }
  }

  /// Stops the current playback and releases associated resources.
  ///
  /// This method:
  /// 1. Stops all playing audio
  /// 2. Cancels pending downloads
  /// 3. Clears the current schedule
  /// 4. Reports the end of the listening session
  public func stop() {
    os_log("🛑 STOP called", log: PlayolaStationPlayer.logger, type: .info)

    // Log current state before stopping
    os_log(
      "Current state: %d players, %d downloads", log: PlayolaStationPlayer.logger, type: .info,
      _spinPlayers.count, activeDownloadIds.count)

    // Cancel any active async tasks first
    if schedulingTask != nil {
      os_log("Cancelling scheduling task", log: PlayolaStationPlayer.logger, type: .info)
      schedulingTask?.cancel()
      schedulingTask = nil
    }

    if playTask != nil {
      os_log("Cancelling play task", log: PlayolaStationPlayer.logger, type: .info)
      playTask?.cancel()
      playTask = nil
    }

    // Stop all players (this will cancel their individual downloads)
    os_log("Stopping %d players", log: PlayolaStationPlayer.logger, type: .info, _spinPlayers.count)

    for (index, player) in _spinPlayers.enumerated() {
      os_log(
        "Stopping player %d/%d", log: PlayolaStationPlayer.logger, type: .info, index + 1,
        _spinPlayers.count)
      player.stop()
    }

    // Cancel any downloads tracked at this level
    os_log(
      "Cancelling %d downloads", log: PlayolaStationPlayer.logger, type: .info,
      activeDownloadIds.count)

    for (spinId, downloadId) in activeDownloadIds {
      os_log("Cancelling download: %@", log: PlayolaStationPlayer.logger, type: .info, spinId)
      _ = fileDownloadManager.cancelDownload(id: downloadId)
    }
    activeDownloadIds.removeAll()

    self.stationId = nil
    self.currentSchedule = nil
    self.state = .idle

    os_log("✅ STOP completed", log: PlayolaStationPlayer.logger, type: .info)
  }

  #if os(iOS) || os(tvOS)
    @objc public func handleAudioRouteChange(_ notification: Notification) {
      guard let userInfo = notification.userInfo,
        let reasonValue = userInfo[AVAudioSessionRouteChangeReasonKey] as? UInt,
        let reason = AVAudioSession.RouteChangeReason(rawValue: reasonValue)
      else {
        return
      }

      switch reason {
      case .newDeviceAvailable:
        os_log("New audio route device available", log: PlayolaStationPlayer.logger, type: .info)

      case .oldDeviceUnavailable:
        os_log("Audio route device disconnected", log: PlayolaStationPlayer.logger, type: .info)
        guard
          let previousRoute = userInfo[AVAudioSessionRouteChangePreviousRouteKey]
            as? AVAudioSessionRouteDescription
        else { return }

        let wasUsingHeadphones = previousRoute.outputs.contains {
          [.headphones, .bluetoothA2DP, .bluetoothHFP, .bluetoothLE].contains($0.portType)
        }

        if wasUsingHeadphones && isPlaying {
          os_log(
            "Headphones disconnected while playing - pausing", log: PlayolaStationPlayer.logger,
            type: .info)
          interruptedStationId = stationId
          wasPlayingBeforeInterruption = true
          stop()
        }

      default:
        os_log(
          "Audio route changed for reason: %d", log: PlayolaStationPlayer.logger, type: .info,
          reasonValue)
      }
    }

    @objc public func handleAudioSessionInterruption(_ notification: Notification) {
      guard let userInfo = notification.userInfo,
        let typeValue = userInfo[AVAudioSessionInterruptionTypeKey] as? UInt,
        let type = AVAudioSession.InterruptionType(rawValue: typeValue)
      else {
        return
      }

      switch type {
      case .began:
        os_log(
          "Audio session interrupted - suspending", log: PlayolaStationPlayer.logger, type: .info)
        isSuspended = true
        wasPlayingBeforeInterruption = isPlaying
        interruptedStationId = stationId

        // Cancel scheduling to prevent grabbing audio back from other apps
        schedulingTask?.cancel()
        schedulingTask = nil

      case .ended:
        os_log("Audio session interruption ended", log: PlayolaStationPlayer.logger, type: .info)
        isSuspended = false

        guard let optionsValue = userInfo[AVAudioSessionInterruptionOptionKey] as? UInt else {
          return
        }
        let options = AVAudioSession.InterruptionOptions(rawValue: optionsValue)

        if options.contains(.shouldResume) && wasPlayingBeforeInterruption {
          resumeAfterInterruption()
        }

      @unknown default:
        os_log(
          "Unknown audio session interruption type: %d", log: PlayolaStationPlayer.logger,
          type: .error, typeValue)
      }
    }

    @objc public func handleAudioEngineConfigurationChange(_ notification: Notification) {
      os_log("Audio engine configuration changed", log: PlayolaStationPlayer.logger, type: .info)

      guard !isSuspended else {
        os_log(
          "Ignoring config change while suspended", log: PlayolaStationPlayer.logger, type: .info)
        return
      }

      if wasPlayingBeforeInterruption {
        resumeAfterInterruption()
      }
    }

    private func resumeAfterInterruption() {
      guard let stationToResume = interruptedStationId else { return }

      os_log("Resuming playback after interruption", log: PlayolaStationPlayer.logger, type: .info)

      Task { @MainActor in
        do {
          try await PlayolaMainMixer.shared.audioSessionManager.activate()
          try PlayolaMainMixer.shared.restartEngine()
          try await self.play(stationId: stationToResume)
        } catch {
          os_log(
            "Failed to resume after interruption: %@",
            log: PlayolaStationPlayer.logger, type: .error,
            error.localizedDescription)
          await errorReporter.reportError(
            error, context: "Failed to resume playback after interruption", level: .error)
        }

        self.interruptedStationId = nil
        self.wasPlayingBeforeInterruption = false
      }
    }
  #endif

  deinit {
    fileDownloadManager.cancelAllDownloads()
  }
}

extension PlayolaStationPlayer: SpinPlayerDelegate {
  public func player(_ player: SpinPlayer, startedPlaying spin: Spin) {
    os_log("Started playing: %@", log: PlayolaStationPlayer.logger, type: .info, spin.id)

    self.state = .playing(spin)

    schedulingTask?.cancel()
    schedulingTask = Task {
      do {
        await self.scheduleUpcomingSpins()

        // Get a list of active file paths to exclude from pruning
        let activePaths = self._spinPlayers
          .compactMap { $0.localUrl?.path }

        // Use the new pruning method with proper error handling
        try self.fileDownloadManager.pruneCache(maxSize: nil, excludeFilepaths: activePaths)
      } catch {
        Task {
          await errorReporter.reportError(
            error, context: "Error during cache pruning after starting playback", level: .warning)
        }
      }
    }
  }

  nonisolated public func player(
    _ player: SpinPlayer,
    didPlayFile file: AVAudioFile,
    atTime time: TimeInterval,
    withBuffer buffer: AVAudioPCMBuffer
  ) {
  }

  public func player(_ player: SpinPlayer, didChangeState state: SpinPlayer.State) {
    os_log(
      "Player state: %@", log: PlayolaStationPlayer.logger, type: .info, String(describing: state))
  }
}

public protocol PlayolaStationPlayerDelegate: AnyObject {
  func player(
    _ player: PlayolaStationPlayer,
    playerStateDidChange state: PlayolaStationPlayer.State)
}