Trusted Arbiter

/// Prepares a Trusted Arbiter winner ahead of time so an interstitial can be shown
/// instantly when a placement is reached.
///
/// Loads the CloudX and LevelPlay interstitials in parallel, waits until both have
/// finished loading or failing, submits the loaded candidates to CloudXCore.shared.arbiter,
/// and caches the selected CLXArbiterPlatform in nextWinner.
final class ArbiterInterstitialController: NSObject {
    protocol Listener: AnyObject {
        /// Called when the arbiter has selected a platform for the next show.
        func arbiterInterstitialController(
            _ controller: ArbiterInterstitialController,
            didPrepareWinner platform: CLXArbiterPlatform
        )
    }

    weak var listener: Listener?

    private let cloudXInterstitial: CLXInterstitial
    private let levelPlayInterstitial: LPMInterstitialAd
    private var cloudXAd: CLXAd?
    private var cloudXLoadDone = false
    private var levelPlayAdInfo: LPMAdInfo?
    private var levelPlayLoadDone = false
    private var nextWinner: CLXArbiterPlatform?

    init(cloudXInterstitial: CLXInterstitial, levelPlayInterstitial: LPMInterstitialAd) {
        self.cloudXInterstitial = cloudXInterstitial
        self.levelPlayInterstitial = levelPlayInterstitial
        super.init()
        self.cloudXInterstitial.delegate = self
        self.levelPlayInterstitial.setDelegate(self)
    }

    /// Starts a load for each platform that does not currently hold a cached ad.
    func loadMissingAds() {
        if cloudXAd == nil { cloudXInterstitial.load() }
        if levelPlayAdInfo == nil { levelPlayInterstitial.loadAd() }
    }

    /// Shows the prepared winner, returning true only when a show call was made.
    ///
    /// Returns false when no winner is ready or the cached ad is no longer available, in which
    /// case a fresh load cycle is started.
    func showAtPlacement(from viewController: UIViewController, placementName: String? = nil) -> Bool {
        guard let platformName = nextWinner?.name else { return false }

        if platformName == CLXArbiterPlatform.cloudX.name {
            return showCloudX(from: viewController, placementName: placementName)
        }

        if platformName == CLXArbiterPlatform.levelPlay.name {
            return showLevelPlay(from: viewController, placementName: placementName)
        }

        return false
    }

    /// Runs the arbiter once both platforms have settled, then caches the winning platform.
    ///
    /// Returns early until both loads complete. If neither platform loaded, it restarts the
    /// load cycle; otherwise it submits the loaded candidates to CloudXCore.shared.arbiter.
    private func maybePrepareWinner() {
        guard cloudXLoadDone, levelPlayLoadDone else { return }

        if cloudXAd == nil && levelPlayAdInfo == nil {
            cloudXLoadDone = false
            levelPlayLoadDone = false
            loadMissingAds()
            return
        }

        var bids: [CLXArbiterBid] = []
        if let cloudXAd {
            bids.append(CLXArbiterBid.cloudX(ad: cloudXAd))
        }

        if let levelPlayAdInfo {
            bids.append(CLXArbiterBid.levelPlay(
                networkName: levelPlayAdInfo.adNetwork,
                revenue: levelPlayAdInfo.revenue?.doubleValue ?? 0,
                precision: levelPlayAdInfo.precision
            ))
        }

        let configuration = CLXArbiterConfiguration.configuration(bids: bids, builderBlock: nil)
        CloudXCore.shared.arbiter(with: configuration) { [weak self] result in
            guard let self else { return }
            nextWinner = result.platform
            listener?.arbiterInterstitialController(self, didPrepareWinner: result.platform)
        }
    }

    private func showCloudX(from viewController: UIViewController, placementName: String?) -> Bool {
        if cloudXInterstitial.isReady {
            if let placementName {
                cloudXInterstitial.show(from: viewController, placement: placementName, customData: nil)
            } else {
                cloudXInterstitial.show(from: viewController)
            }
            return true
        }

        clearCloudXAndLoadMissingAds()
        return false
    }

    private func showLevelPlay(from viewController: UIViewController, placementName: String?) -> Bool {
        if levelPlayInterstitial.isAdReady() {
            levelPlayInterstitial.showAd(viewController: viewController, placementName: placementName)
            return true
        }

        clearLevelPlayAndLoadMissingAds()
        return false
    }

    private func clearCloudXAndLoadMissingAds() {
        cloudXAd = nil
        cloudXLoadDone = false
        nextWinner = nil
        loadMissingAds()
    }

    private func clearLevelPlayAndLoadMissingAds() {
        levelPlayAdInfo = nil
        levelPlayLoadDone = false
        nextWinner = nil
        loadMissingAds()
    }
}

extension ArbiterInterstitialController: CLXInterstitialDelegate {
    func didLoad(_ ad: CLXAd) {
        cloudXAd = ad
        cloudXLoadDone = true
        maybePrepareWinner()
    }

    func didFailToLoadAd(_ adUnitId: String, error: CLXError) {
        cloudXAd = nil
        cloudXLoadDone = true
        maybePrepareWinner()
    }

    func didDisplay(_ ad: CLXAd) {}

    func didFailToDisplay(_ ad: CLXAd, error: CLXError) {
        clearCloudXAndLoadMissingAds()
    }

    func didHide(_ ad: CLXAd) {
        clearCloudXAndLoadMissingAds()
    }

    func didClick(_ ad: CLXAd) {}
}

extension ArbiterInterstitialController: LPMInterstitialAdDelegate {
    func didLoadAd(with adInfo: LPMAdInfo) {
        levelPlayAdInfo = adInfo
        levelPlayLoadDone = true
        maybePrepareWinner()
    }

    func didFailToLoadAd(withAdUnitId adUnitId: String, error: Error) {
        levelPlayAdInfo = nil
        levelPlayLoadDone = true
        maybePrepareWinner()
    }

    func didChangeAdInfo(_ adInfo: LPMAdInfo) {
        levelPlayAdInfo = adInfo
    }

    func didDisplayAd(with adInfo: LPMAdInfo) {}

    func didFailToDisplayAd(with adInfo: LPMAdInfo, error: Error) {
        clearLevelPlayAndLoadMissingAds()
    }

    func didCloseAd(with adInfo: LPMAdInfo) {
        clearLevelPlayAndLoadMissingAds()
    }

    func didClickAd(with adInfo: LPMAdInfo) {}
}

/// Arbitrates a CloudX App Open ad against an AdMob App Open ad and shows the winner on the
/// next foreground transition.
///
/// App Open has no user-initiated show, so the winner must already be chosen by the time the
/// user comes back. loadMissingAds() starts both loads, the arbiter runs as soon as both
/// platforms settle, and showOnForeground(from:) only shows a result that was stored earlier.
final class ArbiterAppOpenController: NSObject {
    private let cloudXAppOpen: CLXAppOpen?
    private let adMobAdUnitId: String
    private var cloudXAd: CLXAd?
    private var cloudXLoadDone = false
    private var adMobAppOpen: GADAppOpenAd?
    /// The ad that is presenting, or presented last. Held so a late paid event still has an ad.
    private var presentedAdMobAd: GADAppOpenAd?
    private var adMobLoadDone = false
    private var cloudXLoadInFlight = false
    private var adMobLoadInFlight = false
    private var nextWinner: CLXArbiterPlatform?
    private var isShowingAd = false

    init(cloudXAdUnitId: String, adMobAdUnitId: String) {
        cloudXAppOpen = CloudXCore.shared.createAppOpen(adUnitId: cloudXAdUnitId)
        self.adMobAdUnitId = adMobAdUnitId
        super.init()
        cloudXAppOpen?.delegate = self
    }

    /// Starts a load for each platform that holds neither a cached ad nor a request in flight.
    ///
    /// Each load it starts clears that platform's `LoadDone` flag, so a round only arbitrates
    /// once every request it started has come back. Without that reset, a retry for the platform
    /// that failed last round lands against a flag still set from the previous round, and the
    /// arbiter runs on a one-candidate snapshot.
    func loadMissingAds() {
        if cloudXAd == nil, !cloudXLoadInFlight {
            cloudXLoadInFlight = true
            cloudXLoadDone = false
            cloudXAppOpen?.load()
        }

        if adMobAppOpen == nil, !adMobLoadInFlight {
            adMobLoadInFlight = true
            adMobLoadDone = false
            loadAdMob()
        }
    }

    /// Shows the prepared winner, returning true only when a show call was made.
    ///
    /// Call this from a foreground observer. It never holds up the return to the app: with an ad
    /// already on screen, or no winner prepared, it returns false and starts the next load cycle.
    func showOnForeground(from viewController: UIViewController) -> Bool {
        guard !isShowingAd else { return false }

        switch nextWinner?.name {
        case CLXArbiterPlatform.cloudX.name:
            return showCloudX(from: viewController)
        case CLXArbiterPlatform.adMob.name:
            return showAdMob(from: viewController)
        case CLXArbiterPlatform.none.name:
            // The arbiter settled on no winner, so both cached ads are unusable. Drop them:
            // loadMissingAds() only requests a platform whose slot is empty, so without this
            // the same two candidates would sit there and no later round could ever run.
            discardCandidatesAndReload()
            return false
        default:
            // nextWinner is nil — a cycle is still in flight. Leave it alone.
            return false
        }
    }

    /// Releases both platforms' ads. Call this from the owning object's teardown.
    func destroy() {
        cloudXAppOpen?.destroy()
        adMobAppOpen = nil
        presentedAdMobAd = nil
    }

    /// Runs the arbiter once both platforms have settled, then caches the winning platform.
    ///
    /// Returns early until both loads complete. If neither platform loaded, it restarts the
    /// load cycle; otherwise it submits the loaded candidates to CloudXCore.shared.arbiter.
    private func maybePrepareWinner() {
        guard cloudXLoadDone, adMobLoadDone else { return }

        if cloudXAd == nil && adMobAppOpen == nil {
            loadMissingAds()
            return
        }

        var bids: [CLXArbiterBid] = []
        if let cloudXAd {
            bids.append(CLXArbiterBid.cloudX(ad: cloudXAd))
        }
        if adMobAppOpen != nil {
            bids.append(CLXArbiterBid.adMob(adUnitId: adMobAdUnitId))
        }

        let configuration = CLXArbiterConfiguration.configuration(bids: bids, builderBlock: nil)
        CloudXCore.shared.arbiter(with: configuration) { [weak self] result in
            self?.nextWinner = result.platform
        }
    }

    private func showCloudX(from viewController: UIViewController) -> Bool {
        guard let cloudXAppOpen, cloudXAppOpen.isReady else {
            clearCloudXAndLoadMissingAds()
            return false
        }

        isShowingAd = true
        cloudXAppOpen.show(from: viewController, placement: "app_foreground", customData: nil)
        return true
    }

    private func showAdMob(from viewController: UIViewController) -> Bool {
        guard let ad = adMobAppOpen else {
            clearAdMobAndLoadMissingAds()
            return false
        }

        ad.fullScreenContentDelegate = self
        // A GADAppOpenAd is single-use: present consumes it. Move it aside now, so a load that
        // lands mid-show cannot arbitrate a spent ad. It stays alive in presentedAdMobAd
        // because AdMob can deliver the paid event after the ad has already been dismissed,
        // and that revenue is what prices the next AdMob bid.
        presentedAdMobAd = ad
        adMobAppOpen = nil
        isShowingAd = true
        ad.present(fromRootViewController: viewController)
        return true
    }

    private func loadAdMob() {
        GADAppOpenAd.load(withAdUnitID: adMobAdUnitId, request: GADRequest()) { [weak self] ad, error in
            guard let self else { return }

            if let error {
                print("AdMob App Open failed to load: \(error.localizedDescription)")
                adMobAppOpen = nil
            } else {
                ad?.paidEventHandler = { [weak self, weak ad] adValue in
                    self?.reportAdMobPaidEvent(ad, adValue: adValue)
                }
                adMobAppOpen = ad
            }

            adMobLoadInFlight = false
            adMobLoadDone = true
            maybePrepareWinner()
        }
    }

    /// Forwards AdMob's realized revenue to CloudX. This is a required part of the integration,
    /// not optional analytics: CloudX prices future AdMob bids from what you report back.
    ///
    /// revenuePrecision(from:) is the mapping shown in
    /// "Report Google paid events back to CloudX" above.
    private func reportAdMobPaidEvent(_ ad: GADAppOpenAd?, adValue: GADAdValue) {
        let servedBy = ad?.responseInfo.loadedAdNetworkResponseInfo
        let data = CLXRevenueData.revenueData(
            platform: .adMob,
            revenue: adValue.value.doubleValue,
            adFormat: "app_open"
        ) { builder in
            builder.currencyCode = adValue.currencyCode
            builder.precision = revenuePrecision(from: adValue.precision)
            builder.networkName = servedBy?.adSourceName
            builder.adUnitId = self.adMobAdUnitId
            builder.thirdPartyAdPlacementId = servedBy?.adSourceInstanceName
        }

        // reportRevenueData returns false when nothing consumed the event. CloudX prices future
        // AdMob bids from what you report here, so a silent false is worth surfacing.
        if !CloudXCore.shared.reportRevenueData(data) {
            print("AdMob App Open paid event was not accepted by the CloudX SDK")
        }
    }

    /// Drops both candidates and starts a new cycle. Used when the arbiter reports no winner.
    private func discardCandidatesAndReload() {
        cloudXAd = nil
        adMobAppOpen = nil
        cloudXLoadDone = false
        adMobLoadDone = false
        nextWinner = nil
        loadMissingAds()
    }

    private func clearCloudXAndLoadMissingAds() {
        cloudXAd = nil
        cloudXLoadDone = false
        nextWinner = nil
        isShowingAd = false
        loadMissingAds()
    }

    private func clearAdMobAndLoadMissingAds() {
        adMobAppOpen = nil
        adMobLoadDone = false
        nextWinner = nil
        isShowingAd = false
        loadMissingAds()
    }
}

extension ArbiterAppOpenController: CLXAppOpenDelegate {
    func didLoad(_ ad: CLXAd) {
        cloudXAd = ad
        cloudXLoadInFlight = false
        cloudXLoadDone = true
        maybePrepareWinner()
    }

    func didFailToLoadAd(_ adUnitId: String, error: CLXError) {
        print("CloudX App Open failed to load: \(error.localizedDescription)")
        cloudXAd = nil
        cloudXLoadInFlight = false
        cloudXLoadDone = true
        maybePrepareWinner()
    }

    func didDisplay(_ ad: CLXAd) {}

    func didFailToDisplay(_ ad: CLXAd, error: CLXError) {
        print("CloudX App Open failed to display: \(error.localizedDescription)")
        clearCloudXAndLoadMissingAds()
    }

    func didHide(_ ad: CLXAd) {
        clearCloudXAndLoadMissingAds()
    }

    func didClick(_ ad: CLXAd) {}
}

extension ArbiterAppOpenController: GADFullScreenContentDelegate {
    func adDidDismissFullScreenContent(_ ad: GADFullScreenPresentingAd) {
        clearAdMobAndLoadMissingAds()
    }

    func ad(_ ad: GADFullScreenPresentingAd, didFailToPresentFullScreenContentWithError error: Error) {
        print("AdMob App Open failed to show: \(error.localizedDescription)")
        clearAdMobAndLoadMissingAds()
    }
}

// In the type that owns the controller, for example your scene delegate:
let controller = ArbiterAppOpenController(cloudXAdUnitId: "…", adMobAdUnitId: "…")

NotificationCenter.default.addObserver(
    forName: UIApplication.willEnterForegroundNotification,
    object: nil,
    queue: .main
) { [weak self] _ in
    guard let self, let viewController = self.topViewController() else { return }
    _ = self.controller.showOnForeground(from: viewController)
}

/// Arbitrates a CloudX native ad against an AdMob native ad and renders only the winner into
/// the container view.
///
/// Both platforms load without a view: CLXNativeAdLoader.loadAd() is called with no ad view so
/// nothing is rendered at load time, and the AdMob ad is held unrendered. The losing bid's
/// assets are never rendered or attached, so they never fire an impression.
final class ArbiterNativeController: NSObject {
    private weak var containerView: UIView?
    private let cloudXLoader: CLXNativeAdLoader
    private let adMobAdUnitId: String
    private let makeAdMobAdView: (GADNativeAd) -> GADNativeAdView
    private var cloudXAd: CLXAd?
    private var cloudXLoadDone = false
    private var adMobNativeAd: GADNativeAd?
    private var adMobLoadDone = false
    private var adMobAdLoader: GADAdLoader?
    private var cloudXLoadInFlight = false
    private var adMobLoadInFlight = false
    private var renderedPlatformName: String?
    private var renderedAdView: UIView?
    /// The ads behind the attached view. They outlive their own candidate state: a rendered ad
    /// stays on screen after its impression, until its replacement is attached.
    private var renderedCloudXAd: CLXAd?
    private var renderedAdMobAd: GADNativeAd?

    /// - Parameter makeAdMobAdView: builds and populates your own GADNativeAdView for a loaded
    ///   AdMob ad, exactly as in a non-arbitrated AdMob native integration. It is called only
    ///   for a winning AdMob bid.
    init(
        containerView: UIView,
        cloudXAdUnitId: String,
        adMobAdUnitId: String,
        makeAdMobAdView: @escaping (GADNativeAd) -> GADNativeAdView
    ) {
        self.containerView = containerView
        cloudXLoader = CloudXCore.shared.createNativeAdLoader(adUnitIdentifier: cloudXAdUnitId)
        self.adMobAdUnitId = adMobAdUnitId
        self.makeAdMobAdView = makeAdMobAdView
        super.init()
        cloudXLoader.nativeAdDelegate = self
        cloudXLoader.revenueDelegate = self
    }

    /// Starts the first round: loads every platform that is not already holding a fill.
    func start() {
        loadMissingAds()
    }

    /// Releases both platforms' ads and clears the container.
    func destroy() {
        detachRenderedAd()
        cloudXLoader.destroy()
        adMobNativeAd = nil
        adMobAdLoader = nil
    }

    /// Starts a load for each platform that holds neither a filled ad nor a request in flight.
    ///
    /// Each load it starts clears that platform's `LoadDone` flag, so a round only arbitrates
    /// once every request it started has come back.
    private func loadMissingAds() {
        // loadAd() with no ad view defers rendering. Never use loadAd(into:) here: that renders
        // the CloudX ad at load time, before the arbiter has chosen a winner.
        if cloudXAd == nil, !cloudXLoadInFlight {
            cloudXLoadInFlight = true
            cloudXLoadDone = false
            cloudXLoader.loadAd()
        }

        if adMobNativeAd == nil, !adMobLoadInFlight {
            adMobLoadInFlight = true
            adMobLoadDone = false
            loadAdMob()
        }
    }

    /// Runs once both platforms have settled (filled or failed), then renders the winner.
    private func maybeArbitrate() {
        guard cloudXLoadDone, adMobLoadDone else { return }

        var bids: [CLXArbiterBid] = []
        if let cloudXAd {
            bids.append(CLXArbiterBid.cloudX(ad: cloudXAd))
        }
        if adMobNativeAd != nil {
            bids.append(CLXArbiterBid.adMob(adUnitId: adMobAdUnitId))
        }

        guard !bids.isEmpty else {
            loadMissingAds()
            return
        }

        let configuration = CLXArbiterConfiguration.configuration(bids: bids, builderBlock: nil)
        CloudXCore.shared.arbiter(with: configuration) { [weak self] result in
            self?.renderWinner(result.platform)
        }
    }

    /// Renders only the winning platform's assets; the loser stays unrendered and unattached.
    private func renderWinner(_ platform: CLXArbiterPlatform) {
        // Rendering is what fires the impression, so never render the same ad twice.
        // maybeArbitrate() runs again whenever the losing candidate reloads, and the same
        // platform winning that round is a normal outcome — but by then the served ad has been
        // dropped as a candidate, so a repeat win is always a new ad and does render.
        guard !isAlreadyRendered(platform) else { return }

        guard platform.name != CLXArbiterPlatform.none.name else {
            // No winner. Keep whatever is already on screen — detaching it here would drop a
            // perfectly good ad — and drop only the candidates that lost, so the next round
            // has something new to compare.
            discardUnrenderedCandidatesAndReload()
            return
        }

        detachRenderedAd()

        switch platform.name {
        case CLXArbiterPlatform.cloudX.name:
            renderCloudX()
        case CLXArbiterPlatform.adMob.name:
            renderAdMob()
        default:
            break
        }
    }

    /// True when this platform's current candidate is the ad already attached to the container.
    private func isAlreadyRendered(_ platform: CLXArbiterPlatform) -> Bool {
        switch platform.name {
        case CLXArbiterPlatform.cloudX.name:
            return cloudXAd != nil && cloudXAd === renderedCloudXAd
        case CLXArbiterPlatform.adMob.name:
            return adMobNativeAd != nil && adMobNativeAd === renderedAdMobAd
        default:
            return false
        }
    }

    /// Drops every candidate that is not currently rendered, then starts a new cycle.
    private func discardUnrenderedCandidatesAndReload() {
        if renderedPlatformName != CLXArbiterPlatform.cloudX.name {
            cloudXAd = nil
            cloudXLoadDone = false
        }

        if renderedPlatformName != CLXArbiterPlatform.adMob.name {
            adMobNativeAd = nil
            adMobLoadDone = false
        }

        loadMissingAds()
    }

    private func renderCloudX() {
        guard let cloudXAd, let containerView else { return }

        let adView = CLXNativeAdView()
        adView.bindViews(with: nativeAdViewBinder())

        guard cloudXLoader.renderNativeAdView(adView, with: cloudXAd) else {
            print("CloudX native ad could not be rendered; skipping this round")
            clearCloudXAndReload()
            return
        }

        adView.frame = containerView.bounds
        adView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        containerView.addSubview(adView)
        renderedAdView = adView
        renderedPlatformName = CLXArbiterPlatform.cloudX.name
        renderedCloudXAd = cloudXAd
    }

    private func renderAdMob() {
        guard let adMobNativeAd, let containerView else { return }

        let adView = makeAdMobAdView(adMobNativeAd)
        adView.frame = containerView.bounds
        adView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        containerView.addSubview(adView)
        renderedAdView = adView
        renderedPlatformName = CLXArbiterPlatform.adMob.name
        renderedAdMobAd = adMobNativeAd
    }

    private func loadAdMob() {
        let loader = GADAdLoader(
            adUnitID: adMobAdUnitId,
            rootViewController: nil,
            adTypes: [.native],
            options: nil
        )
        loader.delegate = self
        adMobAdLoader = loader
        loader.load(GADRequest())
    }

    /// Forwards AdMob's realized revenue to CloudX. This is a required part of the integration,
    /// not optional analytics: CloudX prices future AdMob bids from what you report back.
    ///
    /// revenuePrecision(from:) is the mapping shown in
    /// "Report Google paid events back to CloudX" above.
    private func reportAdMobPaidEvent(_ ad: GADNativeAd?, adValue: GADAdValue) {
        let servedBy = ad?.responseInfo.loadedAdNetworkResponseInfo
        let data = CLXRevenueData.revenueData(
            platform: .adMob,
            revenue: adValue.value.doubleValue,
            adFormat: "native"
        ) { builder in
            builder.currencyCode = adValue.currencyCode
            builder.precision = revenuePrecision(from: adValue.precision)
            builder.networkName = servedBy?.adSourceName
            builder.adUnitId = self.adMobAdUnitId
            builder.thirdPartyAdPlacementId = servedBy?.adSourceInstanceName
        }

        // reportRevenueData returns false when nothing consumed the event. CloudX prices future
        // AdMob bids from what you report here, so a silent false is worth surfacing.
        if !CloudXCore.shared.reportRevenueData(data) {
            print("AdMob native paid event was not accepted by the CloudX SDK")
        }
    }

    /// Removes only the ad view this controller attached, so anything else the publisher keeps
    /// in the container — a placeholder, a spinner, a label — survives the round.
    ///
    /// This is also the only place a rendered ad is released. It stays alive for as long as it
    /// is on screen, and goes away when its replacement is attached or the controller is
    /// destroyed.
    private func detachRenderedAd() {
        renderedAdView?.removeFromSuperview()
        renderedAdView = nil
        renderedPlatformName = nil

        if let renderedCloudXAd { cloudXLoader.destroyAd(renderedCloudXAd) }
        renderedCloudXAd = nil
        renderedAdMobAd = nil
    }

    /// Drops the CloudX candidate, detaching it first if it is the one on screen.
    private func clearCloudXAndReload() {
        if renderedPlatformName == CLXArbiterPlatform.cloudX.name {
            detachRenderedAd()
        }

        cloudXAd = nil
        cloudXLoadDone = false
        cloudXLoadInFlight = false
        loadMissingAds()
    }

    /// Starts the next cycle once the winner's impression has fired.
    ///
    /// The rendered view stays on screen and the ad behind it stays alive. A native slot has
    /// nothing to fall back to, so detaching the ad the moment it is billed would leave the slot
    /// blank for as long as the next round takes. Only the candidate state is dropped, so the
    /// spent ad is never bid or rendered again; the ad itself is released in detachRenderedAd(),
    /// when its replacement goes up. This is the same rule the banner controller follows.
    private func onWinnerImpression(_ platformName: String) {
        switch platformName {
        case CLXArbiterPlatform.cloudX.name:
            cloudXAd = nil
            cloudXLoadDone = false
            cloudXLoadInFlight = false
        case CLXArbiterPlatform.adMob.name:
            adMobNativeAd = nil
            adMobLoadDone = false
            adMobLoadInFlight = false
        default:
            return
        }

        loadMissingAds()
    }

    private func nativeAdViewBinder() -> CLXNativeAdViewBinder {
        CLXNativeAdViewBinder { builder in
            builder.titleLabelTag = CLXNativeAdViewTagTitleLabel
            builder.bodyLabelTag = CLXNativeAdViewTagBodyLabel
            builder.iconImageViewTag = CLXNativeAdViewTagIconImageView
            builder.callToActionButtonTag = CLXNativeAdViewTagCallToActionButton
            builder.mediaContentViewTag = CLXNativeAdViewTagMediaViewContainer
            builder.optionsContentViewTag = CLXNativeAdViewTagOptionsContentView
            builder.advertiserLabelTag = CLXNativeAdViewTagAdvertiserLabel
        }
    }
}

extension ArbiterNativeController: CLXNativeAdDelegate {
    // nativeAdView is nil here because loadAd() was called without one. The ad is rendered
    // later, and only if it wins.
    func didLoadNativeAd(_ nativeAdView: CLXNativeAdView?, for ad: CLXAd) {
        cloudXAd = ad
        cloudXLoadInFlight = false
        cloudXLoadDone = true
        maybeArbitrate()
    }

    func didFailToLoadNativeAd(forAdUnitIdentifier adUnitId: String, error: CLXError) {
        print("CloudX native ad failed to load: \(error.localizedDescription)")
        cloudXAd = nil
        cloudXLoadInFlight = false
        cloudXLoadDone = true
        maybeArbitrate()
    }

    func didClickNativeAd(_ ad: CLXAd) {}

    func didExpireNativeAd(_ ad: CLXAd) {
        // detachRenderedAd() releases the rendered ad, so hand it this one instead of
        // destroying it twice.
        if ad !== renderedCloudXAd { cloudXLoader.destroyAd(ad) }
        clearCloudXAndReload()
    }

    func didCloseNativeAd(_ ad: CLXAd) {
        if ad !== renderedCloudXAd { cloudXLoader.destroyAd(ad) }
        clearCloudXAndReload()
    }
}

extension ArbiterNativeController: GADNativeAdLoaderDelegate {
    func adLoader(_ adLoader: GADAdLoader, didReceive nativeAd: GADNativeAd) {
        nativeAd.paidEventHandler = { [weak self, weak nativeAd] adValue in
            self?.reportAdMobPaidEvent(nativeAd, adValue: adValue)
        }
        nativeAd.delegate = self
        adMobNativeAd = nativeAd
        adMobLoadInFlight = false
        adMobLoadDone = true
        maybeArbitrate()
    }

    func adLoader(_ adLoader: GADAdLoader, didFailToReceiveAdWithError error: Error) {
        print("AdMob native ad failed to load: \(error.localizedDescription)")
        adMobNativeAd = nil
        adMobLoadInFlight = false
        adMobLoadDone = true
        maybeArbitrate()
    }
}

extension ArbiterNativeController: CLXAdRevenueDelegate {
    /// CloudX's impression signal. The rendered ad is spent as a candidate, so request the next
    /// one — the same rule the banner controller follows.
    func didPayRevenue(for ad: CLXAd) {
        guard renderedPlatformName == CLXArbiterPlatform.cloudX.name else { return }
        onWinnerImpression(CLXArbiterPlatform.cloudX.name)
    }
}

extension ArbiterNativeController: GADNativeAdDelegate {
    /// The winning AdMob ad is consumed the moment its impression fires, so request the next one
    /// here. Without this the controller keeps bidding a spent ad for the rest of the session.
    func nativeAdDidRecordImpression(_ nativeAd: GADNativeAd) {
        guard renderedPlatformName == CLXArbiterPlatform.adMob.name else { return }
        onWinnerImpression(CLXArbiterPlatform.adMob.name)
    }
}