Here is a possible implementation of an AVPlayer wrapper that includes the features you have requested:

Copy code
import AVFoundation

class AVPlayerWrapper {
  // Repository for storing and managing assets
  private var assets: [String: AVAsset] = [:]

  // AVPlayer for playing assets
  private let player = AVPlayer()

  // Keep track of total watch time for each asset
  private var watchTime: [String: TimeInterval] = [:]

  // Keep track of total stalls/buffers for each asset
  private var stalls: [String: Int] = [:]

  // Seek to a specific time in an asset
  func seek(to time: CMTime, asset: String) {
    guard let asset = assets[asset] else {
      // Asset not found, return
      return
    }

    // Pause the player before seeking
    player.pause()

    // Set the player's current time to the specified time
    player.currentTime = time

    // Create a new AVPlayerItem for the asset and seek to the specified time
    let item = AVPlayerItem(asset: asset)
    item.seek(to: time)

    // Replace the current item with the new item and seek to the specified time
    player.replaceCurrentItem(with: item)
    player.seek(to: time)

    // Start playing the asset again
    player.play()
  }

  // Composite multiple assets into a single playback asset
  func composite(assets: [AVAsset], name: String) {
    // Create a composition using the specified assets
    let composition = AVMutableComposition(asset: assets)

    // Store the composition in the repository
    self.assets[name] = composition
  }

  // Start playing an asset
  func play(asset: String) {
    guard let asset = assets[asset] else {
      // Asset not found, return
      return
    }

    // Create a new AVPlayerItem for the asset and start playing it
    let item = AVPlayerItem(asset: asset)
    player.replaceCurrentItem(with: item)
    player.play()

    // Start tracking watch time and stalls/buffers for the asset
    watchTime[asset] = 0
    stalls[asset] = 0

    // Observe the player's time to track watch time
    let timeObserver = player.addPeriodicTimeObserver(forInterval: CMTimeMake(value: 1, timescale: 1), queue: DispatchQueue.main) { [weak self] time in
      guard let self = self else { return }
      self.watchTime[asset] = time.seconds
    }

    // Observe the player's buffer to track stalls/buffers
    let bufferObserver = player.addBoundaryTimeObserver(forTimes: [NSValue(time: CMTimeMake(value: 1, timescale: 1))], queue: DispatchQueue.main) { [weak self] in
      guard let self = self else { return }
      self.stalls[asset] += 1
    }
  }

  // Stop playing the currently playing asset
  func stop() {
    player.pause()
    player.replaceCurrentItem(with: nil)
  }

  // Remove an asset from the repository
  func remove(asset: String) {
   

Copy code
  // Remove an asset from the repository
  func remove(asset: String) {
    assets[asset] = nil
    watchTime[asset] = nil
    stalls[asset] = nil
  }

  // Observe errors in an asset
  func observeErrors(for asset: String, handler: @escaping (Error) -> Void) {
    guard let asset = assets[asset] else {
      // Asset not found, return
      return
    }

    // Create a new AVPlayerItem for the asset and observe its errors
    let item = AVPlayerItem(asset: asset)
    item.addObserver(self, forKeyPath: "error", options: .new, context: nil) { [weak self] (item, _) in
      guard let error = item.error else { return }
      handler(error)
    }
  }

  // Query the total watch time for an asset
  func totalWatchTime(for asset: String) -> TimeInterval? {
    return watchTime[asset]
  }

  // Query the total number of stalls/buffers for an asset
  func totalStalls(for asset: String) -> Int? {
    return stalls[asset]
  }
}