public func fetchVAST(_ remoteURL: URL,
                          _ statusHandler: @escaping (_ message: String) -> (),
                          _ completionHandler: @escaping (_ videoAdURL: URL, 
                                                          _ captionsURL: URL,
                                                          _ verificationURL: String, 
                                                          _ verificationParameters: String, 
                                                          _ vendorKey: String, 
                                                          _ tracking: Dictionary<String, URL>) -> (),
                          _ errorHandler: @escaping (_ message: String) -> ()) {
    DispatchQueue.main.async {
        statusHandler("Fetching VAST...");
    }

    print("Fetching VAST from '\(remoteURL)'.")
    self.VASTDownloadTask = URLSession.shared.downloadTask(with: remoteURL) {
        (fileURL, response, error) in
        guard let fileURL = fileURL else {
            DispatchQueue.main.async {
                errorHandler("Unable to fetch VAST from remote URL: \(remoteURL)")
            }
            return
        }
        
        do {
            let fileData = try Data(contentsOf: fileURL)
            
            // Process the file data as needed
            let mediaFile = self.evaluateXPath(xmlString: fileData, xpath: "//MediaFile/text()");
            let captions = self.evaluateXPath(xmlString: fileData, xpath: "//ClosedCaptionFile/text()");
            let verifScript = self.evaluateXPath(xmlString: fileData, 
                                                 xpath: "//Verification[@vendor='criteo.com-omid']/JavaScriptResource/text()");
            let verifParameters = self.evaluateXPath(xmlString: fileData, 
                                                     xpath: "//Verification[@vendor='criteo.com-omid']/VerificationParameters/text()");
            
            // Retrieve VAST tracking URLs
            var tracking: Dictionary<String, URL> = Dictionary(minimumCapacity: 15);
            let events = self.evaluateXPath(xmlString: fileData, xpath: "//Linear/TrackingEvents/Tracking/@event");
            events.forEach {
                let url = self.evaluateXPath(xmlString: fileData, xpath: "//Linear/TrackingEvents/Tracking[@event='"+$0+"']");
                tracking[$0] = URL(string: url[0]);
            }
            tracking["impression"] = URL( string: self.evaluateXPath(xmlString: fileData, xpath: "//Impression")[0]);
            tracking["error"] = URL(string: self.evaluateXPath(xmlString: fileData, xpath: "//Error")[0]);
            tracking["click"] = URL(string: self.evaluateXPath(xmlString: fileData, xpath: "//VideoClicks/ClickTracking/text()")[0]);
            
            // create URLs
            let videoAdURL = URL(string: mediaFile[0])!;
            let captionsURL = URL(string: captions[0])!;
            let verificationURL = verifScript[0];            
            DispatchQueue.main.async {
                completionHandler(videoAdURL, captionsURL, verificationURL, verifParameters[0], "criteo", tracking)
            }
        } catch {
            DispatchQueue.main.async {
                errorHandler("Unable to read file content: \(error.localizedDescription)")
            }
        }
    }

    self.VASTDownloadTask?.resume()
}

private func evaluateXPath(xmlString: Data, xpath: String) -> [String] {
  var results: [String] = [];

  // Convert the XML string to a C string
  let bytes = UnsafeMutablePointer<UInt8>.allocate(capacity: xmlString.count + 1)
  defer { bytes.deallocate() }
  xmlString.copyBytes(to: bytes, count: xmlString.count)
  bytes[xmlString.count] = 0;
  let xmlCString = UnsafeRawPointer(bytes).assumingMemoryBound(to: CChar.self)

  // Parse the XML
  let xmlDoc = xmlParseDoc(xmlCString)
  guard let doc = xmlDoc else { return results }

  // Create an XPath context
  let xpathCtx = xmlXPathNewContext(doc)
  guard let context = xpathCtx else {
    xmlFreeDoc(doc)
    return results
  }

  // Evaluate the XPath expression
  let xpathObj = xmlXPathEvalExpression(xpath, context)
  guard let xpathObject = xpathObj else {
    xmlXPathFreeContext(context)
    xmlFreeDoc(doc)
    return results
  }

  // Extract the nodes
  let nodes = xpathObject.pointee.nodesetval
  if let nodeSet = nodes {
    for i in 0..<nodeSet.pointee.nodeNr {
      if let node = nodeSet.pointee.nodeTab[Int(i)] {
        if let content = xmlNodeGetContent(node) {
          let cString = content.withMemoryRebound(to: CChar.self, capacity: 1) { $0 }
          if let result = String(cString: cString, encoding: .utf8) {
            results.append(result)
          }
          xmlFree(content)
        }
      }
    }
  }

  // Clean up
  xmlXPathFreeObject(xpathObject)
  xmlXPathFreeContext(context)
  xmlFreeDoc(doc)

  return results
}

func createMediaPlayer(withAsset asset: AVAsset) {
		let player = AVQueuePlayer()
    let looper = AVPlayerLooper(player: player, templateItem: AVPlayerItem(asset: asset!))

    player.isMuted = true
    self.attachUnMuteButtonImage()

    guard let videoView = playerView else {
      fatalError("VideoView is not initialized")
    }

    let videoPlayerLayer = AVPlayerLayer(player: player)
    videoPlayerLayer.bounds = videoView.bounds
    videoPlayerLayer.frame = videoView.bounds
    videoPlayerLayer.videoGravity = AVLayerVideoGravity.resizeAspect;
    videoPlayerLayer.player?.volume = 1.0;

    videoView.layer.insertSublayer(videoPlayerLayer, at: 0)
}

private static func createAdSession(adView: UIView?, vendorKey:String, verificationScriptURL: String, verificationParameters: String) -> OMIDCriteoAdSession {
    // ensure OMID has been already activated
    guard OMIDCriteoSDK.shared.isActive else {
        fatalError("OMID is not active")
    }

    // Obtain ad session context. See below
    let context = createAdSessionContext(withPartner: partner, adView: adView, vendorKey: vendorKey, verificationScriptURL: verificationScriptURL, verificationParameters: verificationParameters)

    // Obtain ad session configuration. See below
    let configuration = createAdSessionConfiguration()

    do {
        // Create ad session
        let session = try OMIDCriteoAdSession(configuration: configuration, adSessionContext: context)

        print("Session created")

        // Provide main ad view for measurement
        guard let adView = adView else {
            fatalError("Ad View is not initialized")
        }
        session.mainAdView = adView
        return session
    } catch {
        fatalError("Unable to instantiate ad session: \(error)")
    }

}
    
private static func createAdSessionContext(withPartner partner: OMIDCriteoPartner, adView: UIView?, vendorKey: String, verificationScriptURL: String, verificationParameters: String) -> OMIDCriteoAdSessionContext {
    do {  
        // Create verification resource using the values provided in the ad response
        guard let verificationResource = createVerificationScriptResource(vendorKey: vendorKey,
                                                                          verificationScriptURL: verificationScriptURL,
                                                                          parameters: verificationParameters)
        else {
            fatalError("Unable to instantiate session context: verification resource cannot be nil")
        }
    
    
        return try OMIDCriteoAdSessionContext(partner: partner,
                                        script: omidJSService,
                                        resources: [verificationResource],
                                        contentUrl: nil,
                                        customReferenceIdentifier: nil)
    
    } catch {
        fatalError("Unable to create ad session context: \(error)")
    }
}

private static func createAdSessionConfiguration() -> OMIDCriteoAdSessionConfiguration {
    do {
        return try OMIDCriteoAdSessionConfiguration(creativeType: .video,
                                                  impressionType: .beginToRender,
                                                  impressionOwner: .nativeOwner,
                                                  mediaEventsOwner: .nativeOwner,
                                                  isolateVerificationScripts: false)
    
    } catch {
        fatalError("Unable to create ad session configuration: \(error)")
    }
}

func startSession() {
    print("Starting session for \(adSession.debugDescription)")

    createAdEventsPublisher()
    createMediaEventsPublisher()

    adSession.start()
}

private func createAdEventsPublisher() {
    // Create event publisher before starting the session
    do {
        self.adEvents = try OMIDCriteoAdEvents(adSession: adSession)
    } catch {
        fatalError("Unable to instantiate OMIDAdEvents: \(error)")
    }
}

private func createMediaEventsPublisher() {
    do {
        self.mediaEvents = try OMIDCriteoMediaEvents(adSession: adSession)
    } catch {
        fatalError("Unable to instantiate OMIDMediaEvents: \(error)")
    }
}

func didFinishFetchingCreative() {
  sessionInteractor?.startSession()

  // Report VAST properties to OMID
  let VASTProperties = OMIDCriteoVASTProperties(autoPlay: true, position: .standalone)
  sessionInteractor?.fireAdLoaded(vastProperties: VASTProperties)

  // get the player ready and attach listeners
  createMediaPlayer(withAsset: getVideoAndCaptions()!)
  addQuartileTrackingToVideoPlayer()
  attachPauseButtonImage()
  presentAd()
}

func emitBeacon(type: Beacon) {        
  let task = URLSession.shared.dataTask(with: self.tracking![type.rawValue]!);
  task.resume()
}

func didPresentAd() {
   emitBeacon(type: .impression);
   sessionInteractor?.fireImpression()
 }

func addQuartileTrackingToVideoPlayer() {
  guard let player = player else { return }
  player.addPeriodicTimeObserver(forInterval: CMTimeMakeWithSeconds(1, preferredTimescale: 10),
                                 queue: DispatchQueue.main) { [weak self] _ in
    guard let self = self else { return }
    self.recordQuartileChange()
  }
  currentQuartile = .tracking
}

func recordQuartileChange() {
  guard let quartile = currentQuartile,
  let currentItem = player?.currentItem
  else {
    return
  }

  let currentTime = currentItem.currentTime().seconds
  let duration = currentItem.duration.seconds
  guard duration > 0 else { return }

  let progress = currentTime / duration
  switch quartile {
    case .tracking:
    if (progress > 0) {
      emitBeacon(type: .start);

      sessionInteractor?.getMediaEventsPublisher().start(withDuration: CGFloat(duration),
                                                         mediaPlayerVolume: playerVolume())
      currentQuartile = .start
    }
    case .start:
    if (progress > 0.25) {
      emitBeacon(type: .firstQuartile);

      sessionInteractor?.getMediaEventsPublisher().firstQuartile()
      currentQuartile = .firstQuartile
    }
    case .firstQuartile:
    if (progress > 0.5) {
      emitBeacon(type: .midpoint);

      sessionInteractor?.getMediaEventsPublisher().midpoint()
      currentQuartile = .midpoint
    }
    case .midpoint:
    if (progress > 0.75) {
      emitBeacon(type: .thirdQuartile);

      sessionInteractor?.getMediaEventsPublisher().thirdQuartile()
      currentQuartile = .thirdQuartile
    }
    case .thirdQuartile:
    if (progress >= 1.0) {
      emitBeacon(type: .complete);

      sessionInteractor?.getMediaEventsPublisher().complete()
      currentQuartile = .complete
    }
    case .complete:
    break
  }
}

@IBAction func tappedPlayingControl() {
  changePlayingControls()
}

func changePlayingControls() {
  if let player = player, player.rate == 0 {
    play()
    attachPauseButtonImage()
    sessionInteractor?.getMediaEventsPublisher().resume()
    emitBeacon(type: .resume)
  } else {
    pause()
    attachPlayButtonImage()
    sessionInteractor?.getMediaEventsPublisher().pause()
    emitBeacon(type: .pause)
  }
}

@IBAction func handleClick() {
  let clickThroughURL = self.tracking![Beacon.click.rawValue];

  if((clickThroughURL) != nil) {
    sessionInteractor?.getMediaEventsPublisher().adUserInteraction(withType: .click)
    emitBeacon(type: .click)

    UIApplication.shared.open(clickThroughURL!)
  } else {
    changePlayingControls();
  }
}

@IBAction func toggleMute() {
  player.isMuted = !player.isMuted
  player.isMuted ? attachUnMuteButtonImage() : attachMuteButtonImage();

  sessionInteractor?.getMediaEventsPublisher().volumeChange(to: playerVolume())
  emitBeacon(type: player.isMuted ? .mute : .unmute);
}

func willDismissAd() {
    // Finish measurement
    print("Ending measurement session now")
    sessionInteractor?.stopSession()
}

func didDismissAd() {
    // Destroy the ad
    destroyAd()
}

/**
  Releases any resources that the ad may still be using after dismissal.
  */
func destroyAd() {
    hidePlayerControls()

    guard let videoPlayerLayer = playerLayer else { return }
    videoPlayerLayer.player = nil
    videoPlayerLayer.removeFromSuperlayer()
    try? FileManager.default.removeItem(at: localAssetURL)
}