#if os(iOS)

  import AVFoundation
  import CryptoKit
  import Foundation
  import MediaPlayer
  import Models
  import SwiftUI
  import Utils

  public enum AudioControllerState {
    case stopped
    case paused
    case loading
    case playing
    case reachedEnd
  }

  public enum PlayerScrubState {
    case reset
    case scrubStarted
    case scrubEnded(TimeInterval)
  }

  enum DownloadPriority: String {
    case low
    case high
  }

  // swiftlint:disable all
  public class AudioController: NSObject, ObservableObject, AVAudioPlayerDelegate {
    @Published public var state: AudioControllerState = .stopped
    @Published public var currentAudioIndex: Int = 0
    @Published public var readText: String = ""
    @Published public var unreadText: String = ""
    @Published public var itemAudioProperties: LinkedItemAudioProperties?

    @Published public var timeElapsed: TimeInterval = 0
    @Published public var duration: TimeInterval = 0
    @Published public var timeElapsedString: String?
    @Published public var durationString: String?
    @Published public var voiceList: [VoiceItem]?
    @Published public var realisticVoiceList: [VoiceItem]?

    @Published public var textItems: [String]?

    @Published public var playbackError: Bool = false

    let dataService: DataService

    var timer: Timer?
    var player: AVQueuePlayer?
    var observer: Any?
    var document: SpeechDocument?
    var synthesizer: SpeechSynthesizer?
    var durations: [Double]?
    var lastReadUpdate = 0.0

    var samplePlayer: AVPlayer?

    public init(dataService: DataService) {
      self.dataService = dataService

      super.init()
      self.voiceList = generateVoiceList()
      self.realisticVoiceList = generateRealisticVoiceList()
      self._currentLanguage = defaultLanguage
    }

    deinit {
      player = nil
      observer = nil
    }

    public func play(itemAudioProperties: LinkedItemAudioProperties) {
      stop()

      self.itemAudioProperties = itemAudioProperties
      startAudio(atIndex: itemAudioProperties.startIndex, andOffset: itemAudioProperties.startOffset)

      EventTracker.track(
        .audioSessionStart(linkID: itemAudioProperties.itemID)
      )
    }

    public var offsets: [Double]? {
      if let durations = durations {
        var currentSum = 0.0
        return durations.map {
          currentSum += $0
          return currentSum
        }
      }
      return nil
    }

    public func stop() {
      let stoppedId = itemAudioProperties?.itemID
      let stoppedTimeElapsed = timeElapsed

      savePositionInfo(force: true)

      player?.pause()
      timer?.invalidate()

      clearNowPlayingInfo()

      player?.replaceCurrentItem(with: nil)
      player?.removeAllItems()

      document = nil
      textItems = nil

      timer = nil
      player = nil
      observer = nil
      synthesizer = nil
      lastReadUpdate = 0

      itemAudioProperties = nil
      state = .stopped
      timeElapsed = 0
      duration = 1
      durations = nil
      currentAudioIndex = 0

      if let stoppedId = stoppedId {
        EventTracker.track(
          .audioSessionEnd(linkID: stoppedId, timeElapsed: stoppedTimeElapsed)
        )
      }
    }

    public func stopWithError() {
      pause()
      playbackError = true

      timer?.invalidate()
      timer = nil
      if let player = player {
        player.removeAllItems()
      }
    }

    public func generateVoiceList() -> [VoiceItem] {
      Voices.Pairs.flatMap { voicePair in
        [
          VoiceItem(name: voicePair.firstName, key: voicePair.firstKey, category: voicePair.category, selected: voicePair.firstKey == currentVoice),
          VoiceItem(name: voicePair.secondName, key: voicePair.secondKey, category: voicePair.category, selected: voicePair.secondKey == currentVoice)
        ]
      }.sorted { $0.name.lowercased() < $1.name.lowercased() }
    }

    public func generateRealisticVoiceList() -> [VoiceItem] {
      Voices.UltraPairs.flatMap { voicePair in
        [
          VoiceItem(name: voicePair.firstName, key: voicePair.firstKey, category: voicePair.category, selected: voicePair.firstKey == currentVoice),
          VoiceItem(name: voicePair.secondName, key: voicePair.secondKey, category: voicePair.category, selected: voicePair.secondKey == currentVoice)
        ]
      }.sorted { $0.name.lowercased() < $1.name.lowercased() }
    }

    public func preload(itemIDs: [String], retryCount _: Int = 0) async -> Bool {
      for itemID in itemIDs {
        _ = try? await downloadSpeechFile(itemID: itemID, priority: .low)
      }
      return false
    }

    public func downloadForOffline(itemID: String) async -> Bool {
      if let document = try? await getSpeechFile(itemID: itemID, priority: .low) {
        let synthesizer = SpeechSynthesizer(appEnvironment: dataService.appEnvironment, networker: dataService.networker, document: document, speechAuthHeader: speechAuthHeader)
        for item in synthesizer.createPlayerItems(from: 0) {
          do {
            _ = try await SpeechSynthesizer.download(speechItem: item, redownloadCached: true)
          } catch {
            print("error downloading audio segment: ", error)
            return false
          }
        }
        return true
      }
      return false
    }

    public static func removeAudioFiles(itemID: String) {
      do {
        let audioDirectory = pathForAudioDirectory(itemID: itemID)
        try FileManager.default.removeItem(at: audioDirectory)
      } catch {
        // We don't need to throw here, as its likely the
        // directory just doesn't exist
        print("Error removing audio files", error)
      }
    }

    public var scrubState: PlayerScrubState = .reset {
      didSet {
        switch scrubState {
        case .reset:
          return
        case .scrubStarted:
          return
        case let .scrubEnded(seekTime):
          seek(to: seekTime)
        }
      }
    }

    func updateDuration(forItem item: SpeechItem, newDuration: TimeInterval) {
      if let durations = self.durations, item.audioIdx < durations.count {
        self.durations?[item.audioIdx] = (newDuration / playbackRate)
      }
    }

    public func seek(toUtterance: Int) {
      player?.pause()

      player?.removeAllItems()
      synthesizeFrom(start: toUtterance, playWhenReady: state == .playing, atOffset: 0.0)
      scrubState = .reset
      fireTimer()
    }

    public func seek(to: TimeInterval) {
      let position = max(0, to)

      // Always reset this state when seeking so we trigger a re-saving of positional info
      lastReadUpdate = 0

      // If we are in reachedEnd state, and seek back, we need to move to
      // paused state
      if to < duration, state == .reachedEnd {
        state = .paused
      }

      // First find the item that this interval is within
      // Not the most effecient, but these lists should be less than 500 items
      var sum = 0.0
      var foundIdx: Int?
      for (idx, duration) in (durations ?? []).enumerated() {
        if sum + duration > position {
          foundIdx = idx
          break
        }
        sum += duration
      }

      if let foundIdx = foundIdx {
        // Now figure out how far into this segment we need to seek to
        let before = durationBefore(playerIndex: foundIdx)
        let remainder = position - before

        // if the foundIdx happens to be the current item, we just set the position
        if let playerItem = player?.currentItem as? SpeechPlayerItem {
          if playerItem.speechItem.audioIdx == foundIdx {
            playerItem.seek(to: CMTimeMakeWithSeconds(remainder, preferredTimescale: 600), completionHandler: nil)
            scrubState = .reset
            fireTimer()
            return
          }
        }

        // Move the playback to the found index, we also seek by the remainder amount
        // before moving we pause the player so playback doesnt jump to a previous spot
        player?.pause()
        player?.removeAllItems()
        synthesizeFrom(start: foundIdx, playWhenReady: state == .playing, atOffset: remainder)
      } else {
        // There was no foundIdx, so we are probably trying to seek past the end, so
        // just seek to the last possible duration.
        if let durations = self.durations, let last = durations.last {
          lastReadUpdate = 0
          player?.removeAllItems()
          synthesizeFrom(start: durations.count - 1, playWhenReady: state == .playing, atOffset: last)
        }
      }

      scrubState = .reset
      fireTimer()
    }

    @AppStorage(UserDefaultKey.textToSpeechDefaultLanguage.rawValue) public var defaultLanguage = "en" {
      didSet {
        currentLanguage = defaultLanguage
      }
    }

    @AppStorage(UserDefaultKey.textToSpeechPlaybackRate.rawValue) public var playbackRate = 1.0 {
      didSet {
        updateDurations(oldPlayback: oldValue, newPlayback: playbackRate)
        unpause()
        fireTimer()
      }
    }

    @AppStorage(UserDefaultKey.textToSpeechPreloadEnabled.rawValue) public var preloadEnabled = false

    @AppStorage(UserDefaultKey.textToSpeechUseUltraRealisticVoices.rawValue) public var useUltraRealisticVoices = false

    @AppStorage(UserDefaultKey.textToSpeechUltraRealisticFeatureKey.rawValue) public var ultraRealisticFeatureKey: String = ""
    @AppStorage(UserDefaultKey.textToSpeechUltraRealisticFeatureRequested.rawValue) public var ultraRealisticFeatureRequested: Bool = false

    var speechAuthHeader: String? {
      if Voices.isUltraRealisticVoice(currentVoice), !ultraRealisticFeatureKey.isEmpty {
        return ultraRealisticFeatureKey
      }
      return nil
    }

    public var currentVoiceLanguage: VoiceLanguage {
      Voices.Languages.first(where: { $0.key == currentLanguage }) ?? Voices.English
    }

    private var _currentLanguage: String?
    public var currentLanguage: String {
      get {
        if let currentLanguage = _currentLanguage {
          return currentLanguage
        }
        if let itemLang = itemAudioProperties?.language, let lang = Voices.Languages.first(where: { $0.name == itemLang || $0.key == itemLang }) {
          return lang.key
        }
        return defaultLanguage
      }
      set {
        _currentLanguage = newValue

        let newVoice = getPreferredVoice(forLanguage: newValue)
        currentVoice = newVoice
      }
    }

    private var _currentVoice: String?
    public var currentVoice: String {
      get {
        if let currentVoice = _currentVoice {
          return currentVoice
        }

        if let currentVoice = UserDefaults.standard.string(forKey: "\(currentLanguage)-\(UserDefaultKey.textToSpeechPreferredVoice.rawValue)") {
          return currentVoice
        }

        return currentVoiceLanguage.defaultVoice
      }
      set {
        _currentVoice = newValue
        voiceList = generateVoiceList()
        realisticVoiceList = generateRealisticVoiceList()

        var currentIdx = 0
        var currentOffset = 0.0
        if let player = self.player, let item = self.player?.currentItem as? SpeechPlayerItem {
          currentIdx = item.speechItem.audioIdx
          currentOffset = CMTimeGetSeconds(player.currentTime())
        }
        player?.removeAllItems()

        downloadAndPlayFrom(currentIdx, currentOffset)
      }
    }

    public var currentVoicePair: VoicePair? {
      let voice = currentVoice
      if Voices.isUltraRealisticVoice(currentVoice) {
        let ultraPair = Voices.UltraPairs.first { $0.firstKey == currentVoice || $0.secondKey == currentVoice }
        if let ultraPair = ultraPair {
          return ultraPair
        }
      }
      return Voices.Pairs.first(where: { $0.firstKey == voice || $0.secondKey == voice })
    }

    struct TextNode: Codable {
      let to: String
      let from: String
      let heading: String
      let body: String
    }

    func setTextItems() {
      if let document = self.document {
        textItems = document.utterances.map { utterance in
          if let regex = try? NSRegularExpression(pattern: "<[^>]*>", options: .caseInsensitive) {
            let modString = regex.stringByReplacingMatches(in: utterance.text, options: [], range: NSRange(location: 0, length: utterance.text.count), withTemplate: "")
            return modString
          }
          return ""
        }
        currentAudioIndex = 0
      } else {
        textItems = nil
      }
    }

    func updateReadText() {
      if let item = player?.currentItem as? SpeechPlayerItem, let speechMarks = item.speechMarks {
        var currentItemOffset = 0
        for i in 0 ..< speechMarks.count {
          if speechMarks[i].time ?? 0 < 0 {
            continue
          }
          if (speechMarks[i].time ?? 0.0) > CMTimeGetSeconds(item.currentTime()) * 1000 {
            currentItemOffset = speechMarks[i].start ?? 0
            break
          }
        }
        // check to see if we are greater than all
        if let last = speechMarks.last, let lastTime = last.time {
          if CMTimeGetSeconds(item.currentTime()) * 1000 > lastTime {
            currentItemOffset = (last.start ?? 0) + (last.length ?? 0)
          }
        }

        // Sometimes we get negatives
        currentItemOffset = max(currentItemOffset, 0)

        let idx = currentAudioIndex // item.speechItem.audioIdx
        if idx < document?.utterances.count ?? 0 {
          let currentItem = document?.utterances[idx].text ?? ""
          let currentReadIndex = currentItem.index(currentItem.startIndex, offsetBy: min(currentItemOffset, currentItem.count))
          let lastItem = String(currentItem[..<currentReadIndex])
          let lastItemAfter = String(currentItem[currentReadIndex...])

          readText = lastItem
          unreadText = lastItemAfter
        }
      } else {
        readText = ""
      }
    }

    public func getPreferredVoice(forLanguage language: String) -> String {
      UserDefaults.standard.string(forKey: "\(language)-\(UserDefaultKey.textToSpeechPreferredVoice.rawValue)") ?? currentVoiceLanguage.defaultVoice
    }

    public func setPreferredVoice(_ voice: String, forLanguage language: String) {
      UserDefaults.standard.set(voice, forKey: "\(language)-\(UserDefaultKey.textToSpeechPreferredVoice.rawValue)")
    }

    private func downloadAndPlayFrom(_ currentIdx: Int, _ currentOffset: Double) {
      let desiredState = state

      pause()
      document = nil
      synthesizer = nil

      if let itemID = itemAudioProperties?.itemID {
        Task {
          let document = try? await self.getSpeechFile(itemID: itemID, priority: .high)

          DispatchQueue.main.async {
            if let document = document {
              let synthesizer = SpeechSynthesizer(appEnvironment: self.dataService.appEnvironment, networker: self.dataService.networker, document: document, speechAuthHeader: self.speechAuthHeader)

              self.setTextItems()
              self.durations = synthesizer.estimatedDurations(forSpeed: self.playbackRate)
              self.synthesizer = synthesizer

              self.state = desiredState
              self.synthesizeFrom(start: currentIdx, playWhenReady: self.state == .playing, atOffset: currentOffset)
            } else {
              print("error loading audio")
              // TODO: post error to SnackBar?
            }
          }
        }
      }
    }

    public var secondaryVoice: String {
      if let pair = currentVoicePair {
        if pair.firstKey == currentVoice {
          return pair.secondKey
        }
        if pair.secondKey == currentVoice {
          return pair.firstKey
        }
      }
      return "en-US-CoraNeural"
    }

    func previewVoiceURL(_ voice: String) -> URL? {
      URL(string: "https://storage.googleapis.com/omnivore_preview_bucket/tts-voice-previews/\(voice).mp3")
    }

    public func playVoiceSample(voice: String) {
      pause()

      if let url = previewVoiceURL(voice) {
        samplePlayer = AVPlayer(playerItem: AVPlayerItem(url: url))
        if let samplePlayer = samplePlayer {
          samplePlayer.play()
        }
      } else {
        NSNotification.operationFailed(message: "Error playing voice sample.")
      }
    }

    public func isPlayingSample(voice: String) -> Bool {
      if let samplePlayer = self.samplePlayer, let url = previewVoiceURL(voice) {
        if let urlAsset = samplePlayer.currentItem?.asset as? AVURLAsset {
          return urlAsset.url == url && samplePlayer.timeControlStatus == .playing
        }
        return false
      }
      return false
    }

    public func stopVoiceSample() {
      if let samplePlayer = self.samplePlayer {
        samplePlayer.pause()
        self.samplePlayer = nil
      }
    }

    private func updateDurations(oldPlayback: Double, newPlayback: Double) {
      if let oldDurations = durations {
        durations = oldDurations.map { $0 * oldPlayback / newPlayback }
      }
    }

    public var isLoading: Bool {
      if state == .reachedEnd {
        return false
      }
      return (state == .loading || player?.currentItem == nil || player?.currentItem?.status == .unknown)
    }

    public var isPlaying: Bool {
      state == .playing
    }

    public func isLoadingItem(itemID: String) -> Bool {
      if state == .reachedEnd {
        return false
      }
      return itemAudioProperties?.itemID == itemID && isLoading
    }

    public func isPlayingItem(itemID: String) -> Bool {
      itemAudioProperties?.itemID == itemID && isPlaying
    }

    public func skipForward(seconds: Double) {
      seek(to: timeElapsed + seconds)
    }

    public func skipBackwards(seconds: Double) {
      seek(to: timeElapsed - seconds)
    }

    public func fileNameForAudioFile(_ itemID: String) -> String {
      itemID + "-" + currentVoice + ".mp3"
    }

    public static func pathForAudioDirectory(itemID: String) -> URL {
      URL.om_documentsDirectory
        .appendingPathComponent("audio-\(itemID)/")
    }

    public func pathForSpeechFile(itemID: String) -> URL {
      Self.pathForAudioDirectory(itemID: itemID)
        .appendingPathComponent("speech-\(currentVoice).json")
    }

    public func startAudio(atIndex index: Int, andOffset offset: Double) {
      state = .loading
      setupNotifications()

      if let itemID = itemAudioProperties?.itemID {
        Task {
          let document = try? await getSpeechFile(itemID: itemID, priority: .high)

          DispatchQueue.main.async {
            self.setTextItems()
            if let document = document {
              // Don't attempt to seek past the end, restart from beginning if we are
              // past the max utterances in the document.
              let startIndex = index < document.utterances.count ? index : 0
              let startOffset = index < document.utterances.count ? offset : 0.0
              self.startStreamingAudio(itemID: itemID, document: document, atIndex: startIndex, andOffset: startOffset)
            } else {
              self.stopWithError()
            }
          }
        }
      }
    }

    // swiftlint:disable all
    private func startStreamingAudio(itemID _: String, document: SpeechDocument, atIndex index: Int, andOffset offset: Double) {
      do {
        try AVAudioSession.sharedInstance().setCategory(.playback, mode: .default, options: [])
      } catch {
        print("error playing MP3 file", error)
        // try? FileManager.default.removeItem(atPath: audioUrl.path)
        state = .stopped
      }

      player = AVQueuePlayer(items: [])
      if let player = player {
        observer = player.observe(\.currentItem, options: [.new]) { _, _ in
          self.currentAudioIndex = (player.currentItem as? SpeechPlayerItem)?.speechItem.audioIdx ?? 0
          self.updateReadText()
        }
      }

      let synthesizer = SpeechSynthesizer(appEnvironment: dataService.appEnvironment, networker: dataService.networker, document: document, speechAuthHeader: speechAuthHeader)
      durations = synthesizer.estimatedDurations(forSpeed: playbackRate)
      self.synthesizer = synthesizer

      synthesizeFrom(start: index, playWhenReady: true, atOffset: offset)
    }

    func synthesizeFrom(start: Int, playWhenReady: Bool, atOffset: Double = 0.0) {
      if let synthesizer = self.synthesizer, let items = self.synthesizer?.createPlayerItems(from: start) {
        let prefetchQueue = OperationQueue()
        prefetchQueue.maxConcurrentOperationCount = 5

        for speechItem in items {
          let isLast = speechItem.audioIdx == synthesizer.document.utterances.count - 1
          let playerItem = SpeechPlayerItem(session: self, prefetchQueue: prefetchQueue, speechItem: speechItem) {
            if isLast {
              self.player?.pause()
              self.state = .reachedEnd
            }
          }
          player?.insert(playerItem, after: nil)
          if player?.items().count == 1, atOffset > 0.0 {
            playerItem.seek(to: CMTimeMakeWithSeconds(atOffset, preferredTimescale: 600)) { success in
              print("success seeking to time: ", success)
              self.fireTimer()
            }
          }
          if playWhenReady, player?.items().count == 1 {
            startTimer()
            unpause()
            setupRemoteControl()
          }
        }
        if items.count < 1 {
          state = .reachedEnd
        }
      }
    }

    public func pause() {
      if let player = player {
        player.pause()
        state = .paused
        savePositionInfo(force: true)
      }
    }

    public func unpause() {
      stopVoiceSample()
      if let player = player {
        player.rate = Float(playbackRate)
        state = .playing
      }
    }

    func formatTimeInterval(_ time: TimeInterval) -> String? {
      let componentFormatter = DateComponentsFormatter()
      componentFormatter.unitsStyle = .positional
      componentFormatter.allowedUnits = time >= 3600 ? [.second, .minute, .hour] : [.second, .minute]
      componentFormatter.zeroFormattingBehavior = .pad
      return componentFormatter.string(from: time)
    }

    // What we need is an array of all items in a document, either Utterances if unloaded or AVPlayerItems
    // if they have been loaded, then for each one we can calculate a duration
    func durationBefore(playerIndex: Int) -> TimeInterval {
      let result = durations?.prefix(playerIndex).reduce(0, +) ?? 0
      return result
    }

    func startTimer() {
      if timer == nil {
        lastReadUpdate = 0
        timer = Timer.scheduledTimer(timeInterval: 0.2, target: self, selector: #selector(fireTimer), userInfo: nil, repeats: true)
        timer?.fire()
      }
    }

    // Every second, get the current playing time of the player and refresh the status of the player progressslider
    @objc func fireTimer() {
      if let player = player {
        if player.error != nil || player.currentItem?.error != nil {
          stopWithError()
        }

        if let durations = durations {
          duration = durations.reduce(0, +)
          durationString = formatTimeInterval(duration)
        }

        updateReadText()
      }

      if let player = player {
        switch scrubState {
        case .reset:
          if let playerItem = player.currentItem as? SpeechPlayerItem {
            let itemElapsed = playerItem.status == .readyToPlay ? CMTimeGetSeconds(playerItem.currentTime()) : 0
            if itemElapsed >= CMTimeGetSeconds(playerItem.duration) + 0.5 {
              // Occasionally AV wont send an event for a new item starting for ~3s, if this
              // happens we can try to manually update the time
              if playerItem.speechItem.audioIdx + 1 < (document?.utterances.count ?? 0) {
                currentAudioIndex = playerItem.speechItem.audioIdx + 1
              }
            }

            timeElapsed = durationBefore(playerIndex: playerItem.speechItem.audioIdx) + itemElapsed
            timeElapsedString = formatTimeInterval(timeElapsed)

            if var nowPlaying = MPNowPlayingInfoCenter.default().nowPlayingInfo {
              nowPlaying[MPMediaItemPropertyPlaybackDuration] = NSNumber(value: duration)
              nowPlaying[MPNowPlayingInfoPropertyElapsedPlaybackTime] = NSNumber(value: timeElapsed)
              MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlaying
            }
          }
        case .scrubStarted:
          break
        case let .scrubEnded(seekTime):
          timeElapsed = seekTime
          timeElapsedString = formatTimeInterval(timeElapsed)
          if var nowPlaying = MPNowPlayingInfoCenter.default().nowPlayingInfo {
            nowPlaying[MPMediaItemPropertyPlaybackDuration] = NSNumber(value: duration)
            nowPlaying[MPNowPlayingInfoPropertyElapsedPlaybackTime] = NSNumber(value: timeElapsed)
            MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlaying
          }
        }
      }

      savePositionInfo()
    }

    func savePositionInfo(force: Bool = false) {
      if force || (timeElapsed - 10 > lastReadUpdate) {
        let percentProgress = timeElapsed / duration
        let speechIndex = (player?.currentItem as? SpeechPlayerItem)?.speechItem.audioIdx ?? 0
        let anchorIndex = Int((player?.currentItem as? SpeechPlayerItem)?.speechItem.htmlIdx ?? "") ?? 0

        if let itemID = itemAudioProperties?.itemID {
          dataService.updateLinkReadingProgress(itemID: itemID, readingProgress: percentProgress, anchorIndex: anchorIndex, force: true)
        }

        if let itemID = itemAudioProperties?.itemID, let player = player, let currentItem = player.currentItem {
          let currentOffset = CMTimeGetSeconds(currentItem.currentTime())
          print("updating listening info: ", speechIndex, currentOffset, timeElapsed)

          dataService.updateLinkListeningProgress(itemID: itemID,
                                                  listenIndex: speechIndex,
                                                  listenOffset: currentOffset,
                                                  listenTime: timeElapsed)
        }

        lastReadUpdate = timeElapsed
      }
    }

    func clearNowPlayingInfo() {
      MPNowPlayingInfoCenter.default().nowPlayingInfo = [:]
    }

    func downloadAndSetArtwork() async {
      if let pageId = itemAudioProperties?.itemID, let imageURL = itemAudioProperties?.imageURL {
        if let result = try? await URLSession.shared.data(from: imageURL) {
          if let downloadedImage = UIImage(data: result.0) {
            let artwork = MPMediaItemArtwork(boundsSize: downloadedImage.size, requestHandler: { _ -> UIImage in
              downloadedImage
            })
            DispatchQueue.main.async {
              if pageId == self.itemAudioProperties?.itemID {
                if var nowPlaying = MPNowPlayingInfoCenter.default().nowPlayingInfo {
                  nowPlaying[MPMediaItemPropertyArtwork] = artwork
                  MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlaying
                }
              }
            }
          }
        }
      }
    }

    func setupRemoteControl() {
      UIApplication.shared.beginReceivingRemoteControlEvents()

      if let itemAudioProperties = itemAudioProperties {
        MPNowPlayingInfoCenter.default().nowPlayingInfo = [
          MPMediaItemPropertyTitle: NSString(string: itemAudioProperties.title),
          MPMediaItemPropertyArtist: NSString(string: itemAudioProperties.byline ?? "Omnivore"),
          MPMediaItemPropertyPlaybackDuration: NSNumber(value: duration),
          MPNowPlayingInfoPropertyElapsedPlaybackTime: NSNumber(value: timeElapsed)
        ]
      }

      let commandCenter = MPRemoteCommandCenter.shared()

      commandCenter.playCommand.isEnabled = true
      commandCenter.playCommand.addTarget { _ -> MPRemoteCommandHandlerStatus in
        self.unpause()
        return .success
      }

      commandCenter.pauseCommand.isEnabled = true
      commandCenter.pauseCommand.addTarget { _ -> MPRemoteCommandHandlerStatus in
        self.pause()
        return .success
      }

      commandCenter.skipForwardCommand.isEnabled = true
      commandCenter.skipForwardCommand.preferredIntervals = [15, 30, 60]
      commandCenter.skipForwardCommand.addTarget { event -> MPRemoteCommandHandlerStatus in
        if let event = event as? MPSkipIntervalCommandEvent {
          self.skipForward(seconds: event.interval)
          return .success
        }
        return .commandFailed
      }

      commandCenter.skipBackwardCommand.isEnabled = true
      commandCenter.skipBackwardCommand.preferredIntervals = [15, 30, 60]
      commandCenter.skipBackwardCommand.addTarget { event -> MPRemoteCommandHandlerStatus in
        if let event = event as? MPSkipIntervalCommandEvent {
          self.skipBackwards(seconds: event.interval)
          return .success
        }
        return .commandFailed
      }

      commandCenter.changePlaybackPositionCommand.isEnabled = true
      commandCenter.changePlaybackPositionCommand.addTarget { event -> MPRemoteCommandHandlerStatus in
        if let event = event as? MPChangePlaybackPositionCommandEvent {
          self.seek(to: event.positionTime)
          return .success
        }
        return .commandFailed
      }

      Task {
        await downloadAndSetArtwork()
      }
    }

    func isoLangForCurrentVoice() -> String {
      // currentVoicePair should not ever be nil but if it is we return an empty string
      if let isoLang = currentVoicePair?.language {
        return "&language=\(isoLang)"
      }
      return ""
    }

    func downloadSpeechFile(itemID: String, priority: DownloadPriority) async throws -> SpeechDocument? {
      let decoder = JSONDecoder()
      let speechFileUrl = pathForSpeechFile(itemID: itemID)

      if FileManager.default.fileExists(atPath: speechFileUrl.path) {
        let data = try Data(contentsOf: speechFileUrl)
        document = try decoder.decode(SpeechDocument.self, from: data)
        // If we can't load it from disk we make the API call
        if let document = document {
          return document
        }
      }

      let path = "/api/article/\(itemID)/speech?voice=\(currentVoice)&secondaryVoice=\(secondaryVoice)&priority=\(priority)\(isoLangForCurrentVoice())"
      guard let url = URL(string: path, relativeTo: dataService.appEnvironment.serverBaseURL) else {
        throw BasicError.message(messageText: "Invalid audio URL")
      }

      var request = URLRequest(url: url)
      request.httpMethod = "GET"
      for (header, value) in dataService.networker.defaultHeaders {
        request.setValue(value, forHTTPHeaderField: header)
      }

      let result: (Data, URLResponse)? = try? await URLSession.shared.data(for: request)
      guard let httpResponse = result?.1 as? HTTPURLResponse, 200 ..< 300 ~= httpResponse.statusCode else {
        throw BasicError.message(messageText: "audioFetch failed. no response or bad status code.")
      }

      guard let data = result?.0 else {
        throw BasicError.message(messageText: "audioFetch failed. no data received.")
      }

      let str = String(decoding: data, as: UTF8.self)
      print("result speech file: ", str)

      if let document = try? JSONDecoder().decode(SpeechDocument.self, from: data) {
        do {
          try? FileManager.default.createDirectory(at: document.audioDirectory, withIntermediateDirectories: true)
          try data.write(to: speechFileUrl)
          return document
        } catch {
          print("error writing file", error)
        }
      }

      return nil
    }

    func getSpeechFile(itemID: String, priority: DownloadPriority) async throws -> SpeechDocument? {
      document = try await downloadSpeechFile(itemID: itemID, priority: priority)
      return document
    }

    public func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully _: Bool) {
      if player == self.player {
        pause()
        player.currentTime = 0
      }
    }

    func setupNotifications() {
      NotificationCenter.default.removeObserver(self, name: AVAudioSession.interruptionNotification, object: AVAudioSession.sharedInstance())
      NotificationCenter.default.addObserver(self,
                                             selector: #selector(handleInterruption),
                                             name: AVAudioSession.interruptionNotification,
                                             object: AVAudioSession.sharedInstance())
    }

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

      // Switch over the interruption type.
      switch type {
      case .began:
        // An interruption began. Update the UI as necessary.
        pause()
      case .ended:
        // An interruption ended. Resume playback, if appropriate.

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

#endif