Trusted Arbiter

/// 提前准备好 Trusted Arbiter 的获胜平台，以便在到达广告位时立即展示插屏广告。
///
/// 并行加载 CloudX 和 LevelPlay 插屏广告，等待两者都加载完成或加载失败，
/// 将已加载的候选项提交给 CloudXCore.shared.arbiter，并将选中的
/// CLXArbiterPlatform 缓存到 nextWinner 中。
final class ArbiterInterstitialController: NSObject {
    protocol Listener: AnyObject {
        /// 当仲裁器为下一次展示选出平台后调用。
        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)
    }

    /// 为每个当前没有缓存广告的平台启动加载。
    func loadMissingAds() {
        if cloudXAd == nil { cloudXInterstitial.load() }
        if levelPlayAdInfo == nil { levelPlayInterstitial.loadAd() }
    }

    /// 展示已准备好的获胜广告，仅当确实发起了展示调用时返回 true。
    ///
    /// 当没有准备好获胜平台或缓存的广告已不可用时返回 false，
    /// 此时会启动一次新的加载周期。
    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
    }

    /// 在两个平台都完成后运行仲裁器，然后缓存获胜平台。
    ///
    /// 在两个加载都完成之前提前返回。如果两个平台都没有加载成功，则重启加载周期；
    /// 否则将已加载的候选项提交给 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) {}
}

/// 在 CloudX 开屏广告与 AdMob 开屏广告之间进行仲裁，并在下一次前台切换时展示获胜方。
///
/// 开屏广告没有用户触发的展示动作，因此当用户返回应用时，获胜方必须已经选定。
/// loadMissingAds() 会启动两个平台的加载，仲裁器会在两者都已确定结果后立即运行，
/// 而 showOnForeground(from:) 只会展示此前已经存储好的结果。
final class ArbiterAppOpenController: NSObject {
    private let cloudXAppOpen: CLXAppOpen?
    private let adMobAdUnitId: String
    private var cloudXAd: CLXAd?
    private var cloudXLoadDone = false
    private var adMobAppOpen: GADAppOpenAd?
    /// 正在展示或最近展示过的广告。保留它，好让迟到的付费事件仍能找到对应的广告。
    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
    }

    /// 为既没有缓存广告、也没有进行中请求的平台启动加载。
    ///
    /// 每次启动加载时都会清除该平台的 `LoadDone` 标志，因此只有当本轮发起的所有请求都返回后
    /// 才会进行仲裁。如果不重置，上一轮加载失败的平台在重试时会遇到仍为 true 的标志，
    /// 仲裁就会基于只有一个候选的快照运行。
    func loadMissingAds() {
        if cloudXAd == nil, !cloudXLoadInFlight {
            cloudXLoadInFlight = true
            cloudXLoadDone = false
            cloudXAppOpen?.load()
        }

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

    /// 展示已准备好的获胜广告，仅在实际调用了展示方法时返回 true。
    ///
    /// 请从前台观察者中调用该方法。它绝不会拖慢应用返回前台的流程：如果已有广告在屏幕上展示，
    /// 或者还没有准备好获胜方，它会返回 false，并启动下一个加载周期。
    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:
            // 仲裁器判定没有获胜方，因此两个缓存的广告都不可用，需要丢弃：
            // loadMissingAds() 只会为空槽位发起请求，如果不丢弃，这两个候选会一直留在原处，
            // 后续任何一轮都无法再运行。
            discardCandidatesAndReload()
            return false
        default:
            // nextWinner 为 nil —— 仲裁周期仍在进行中，不要干预。
            return false
        }
    }

    /// 释放两个平台的广告。请在所属对象销毁时调用该方法。
    func destroy() {
        cloudXAppOpen?.destroy()
        adMobAppOpen = nil
        presentedAdMobAd = nil
    }

    /// 在两个平台都完成加载后运行仲裁器，然后缓存获胜平台。
    ///
    /// 在两个加载都完成之前会提前返回。如果两个平台都未加载成功，则重新启动加载周期；
    /// 否则将已加载的候选项提交给 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
        // GADAppOpenAd 是一次性的：present 会消耗它。现在就把它移到一边，这样在展示过程中
        // 返回的加载结果就不会让一个已消耗的广告参与仲裁。它会继续存活在 presentedAdMobAd 中，
        // 因为 AdMob 可能在广告已被关闭之后才投递付费事件，而这笔收入正是下一个 AdMob
        // 出价的定价依据。
        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()
        }
    }

    /// 将 AdMob 的实际收益转发给 CloudX。这是集成中必需的环节，而不是可选的分析附加项：
    /// CloudX 会根据你回传的数据为未来的 AdMob 出价定价。
    ///
    /// revenuePrecision(from:) 就是上文"将 Google 付费事件回传给 CloudX（必需）"
    /// 一节中展示的映射方式。
    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 返回 false。CloudX 会根据你在这里
        // 上报的数据为后续 AdMob 出价定价，因此静默的 false 值得记录下来。
        if !CloudXCore.shared.reportRevenueData(data) {
            print("AdMob App Open paid event was not accepted by the CloudX SDK")
        }
    }

    /// 丢弃两个候选并开始新一轮周期。用于仲裁器判定没有获胜方的情况。
    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()
    }
}

// 在持有该控制器的类型中，例如你的 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)
}

/// 在 CloudX 原生广告与 AdMob 原生广告之间进行仲裁，只将获胜方渲染到容器视图中。
///
/// 两个平台都以不带视图的方式加载：CLXNativeAdLoader.loadAd() 在调用时不传入广告视图，
/// 因此加载时不会渲染任何内容，AdMob 广告也会保持未渲染状态。落选出价的素材永远不会被
/// 渲染或附加，因此也不会触发展示事件。
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?
    /// 已附加视图背后的广告。它们的生命周期长于各自的候选状态：已渲染的广告在展示事件触发后
    /// 仍会留在屏幕上，直到替换它的广告被附加为止。
    private var renderedCloudXAd: CLXAd?
    private var renderedAdMobAd: GADNativeAd?

    /// - Parameter makeAdMobAdView: 为已加载的 AdMob 广告构建并填充你自己的 GADNativeAdView，
    ///   方式与非仲裁场景下的 AdMob 原生广告集成完全相同。该闭包只会在 AdMob 出价
    ///   获胜时才会被调用。
    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
    }

    /// 启动第一轮：为尚未持有填充广告的每个平台发起加载。
    func start() {
        loadMissingAds()
    }

    /// 释放两个平台的广告并清空容器。
    func destroy() {
        detachRenderedAd()
        cloudXLoader.destroy()
        adMobNativeAd = nil
        adMobAdLoader = nil
    }

    /// 为既没有填充广告、也没有进行中请求的平台启动加载。
    ///
    /// 每次启动加载时都会清除该平台的 `LoadDone` 标志，因此只有当本轮发起的所有请求
    /// 都返回后才会进行仲裁。
    private func loadMissingAds() {
        // 不带广告视图调用 loadAd() 可以推迟渲染。此处绝不能使用 loadAd(into:)：
        // 那样会在加载时就渲染 CloudX 广告，而此时仲裁器还没有选出获胜方。
        if cloudXAd == nil, !cloudXLoadInFlight {
            cloudXLoadInFlight = true
            cloudXLoadDone = false
            cloudXLoader.loadAd()
        }

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

    /// 仅在两个平台都已结束加载（无论填充还是失败）后运行，并渲染获胜方。
    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)
        }
    }

    /// 只渲染获胜平台的素材；落选方保持未渲染、未附加的状态。
    private func renderWinner(_ platform: CLXArbiterPlatform) {
        // 渲染本身就会触发展示事件，因此绝不能把同一个广告渲染两次。每当落选候选重新加载时
        // maybeArbitrate() 都会再次运行，同一个平台在那一轮再次获胜是完全正常的结果——但那时
        // 已展示过的广告早已不再是候选，所以再次获胜的一定是新广告，会正常渲染。
        guard !isAlreadyRendered(platform) else { return }

        guard platform.name != CLXArbiterPlatform.none.name else {
            // 没有获胜方。保留当前屏幕上的广告——在这里移除会丢掉一个完全有效的广告——
            // 并且只丢弃落选的候选，好让下一轮有新的对象可以比较。
            discardUnrenderedCandidatesAndReload()
            return
        }

        detachRenderedAd()

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

    /// 当该平台的当前候选广告就是已附加到容器中的那一个时返回 true。
    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
        }
    }

    /// 丢弃当前未被渲染的所有候选广告，然后开始新一轮周期。
    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())
    }

    /// 将 AdMob 的实际收益转发给 CloudX。这是集成中必需的环节，而不是可选的分析附加项：
    /// CloudX 会根据你回传的数据为未来的 AdMob 出价定价。
    ///
    /// revenuePrecision(from:) 就是上文"将 Google 付费事件回传给 CloudX（必需）"
    /// 一节中展示的映射方式。
    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 返回 false。CloudX 会根据你在这里
        // 上报的数据为后续 AdMob 出价定价，因此静默的 false 值得记录下来。
        if !CloudXCore.shared.reportRevenueData(data) {
            print("AdMob native paid event was not accepted by the CloudX SDK")
        }
    }

    /// 只移除该控制器自己添加的广告视图，这样发布商放在容器中的其他内容——
    /// 占位图、加载指示器、文本标签——都能在本轮中保留下来。
    ///
    /// 这里也是唯一释放已渲染广告的地方。只要广告还在屏幕上，它就会一直存活；直到替换它的
    /// 广告被附加，或者控制器被销毁时才会被释放。
    private func detachRenderedAd() {
        renderedAdView?.removeFromSuperview()
        renderedAdView = nil
        renderedPlatformName = nil

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

    /// 丢弃 CloudX 候选广告，如果它当前正在屏幕上展示，则先将其移除。
    private func clearCloudXAndReload() {
        if renderedPlatformName == CLXArbiterPlatform.cloudX.name {
            detachRenderedAd()
        }

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

    /// 在获胜方的展示事件触发后开始下一轮周期。
    ///
    /// 已渲染的视图会留在屏幕上，其背后的广告也继续存活。原生广告位没有任何可回退的内容，
    /// 因此在广告刚计费时就把它移除，会让广告位在下一轮完成之前一直空白。这里只丢弃候选状态，
    /// 所以已消耗的广告不会再次参与出价或被重新渲染；广告本身会在 detachRenderedAd() 中、
    /// 即替换它的广告出现时才被释放。这与横幅广告控制器遵循的规则相同。
    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 为 nil，因为调用 loadAd() 时没有传入视图。该广告只有在
    // 赢得仲裁后才会被渲染。
    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() 会释放已渲染的广告，因此把它交给那里处理，避免销毁两次。
        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 的展示信号。已渲染的广告作为候选即被消耗，因此在这里请求下一个——
    /// 与横幅广告控制器遵循的规则相同。
    func didPayRevenue(for ad: CLXAd) {
        guard renderedPlatformName == CLXArbiterPlatform.cloudX.name else { return }
        onWinnerImpression(CLXArbiterPlatform.cloudX.name)
    }
}

extension ArbiterNativeController: GADNativeAdDelegate {
    /// 获胜的 AdMob 广告在展示事件触发的瞬间即被消耗，因此在这里请求下一个。
    /// 如果没有这一步，该控制器会在整个会话期间持续用一个已消耗的广告参与出价。
    func nativeAdDidRecordImpression(_ nativeAd: GADNativeAd) {
        guard renderedPlatformName == CLXArbiterPlatform.adMob.name else { return }
        onWinnerImpression(CLXArbiterPlatform.adMob.name)
    }
}