Trusted Arbiter

private var nextWinner: CloudXArbiterResult? = null

// Runs as soon as the candidates have loaded, ahead of the placement.
private fun prepareWinner() {
    val configuration = CloudXArbiterConfiguration.builder(bids).build()
    CloudX.arbiter(configuration, object : CloudXArbiterListener {
        override fun onCompleted(result: CloudXArbiterResult) {
            nextWinner = result
        }
    })
}

// Runs at the placement. No network call here.
fun showInterstitial(activity: Activity) {
    when (nextWinner?.platform) {
        CloudXArbiterPlatform.CLOUDX -> cloudXInterstitial.show(activity)
        CloudXArbiterPlatform.LEVELPLAY -> levelPlayInterstitial.showAd(activity)
        else -> { } // no winner prepared; continue without an ad
    }
    nextWinner = null
}

// cloudXAd is the CloudXAd from a CloudX onAdLoaded callback.
// levelPlayAdInfo is the Unity LevelPlay ad info object.
// pobBid is the PubMatic/OpenWrap bid object.
val bids = listOf(
    CloudXArbiterBid.cloudX(cloudXAd),
    CloudXArbiterBid.levelPlay(
        networkName = levelPlayAdInfo.adNetwork,
        revenue = levelPlayAdInfo.revenue,
        precision = levelPlayAdInfo.precision,
    ),
    CloudXArbiterBid.pubmatic(
        price = pobBid.price,
        partnerName = pobBid.partnerName,
    )
)

val configuration = CloudXArbiterConfiguration.builder(bids).build()

CloudX.arbiter(configuration, object : CloudXArbiterListener {
    override fun onCompleted(result: CloudXArbiterResult) {
        Log.d("CloudX", "Selected platform: ${result.platform.name}")
    }
})

private fun Int.toCloudXRevenuePrecision(): CloudXRevenuePrecision = when (this) {
    AdValue.PrecisionType.PRECISE -> CloudXRevenuePrecision.EXACT
    AdValue.PrecisionType.ESTIMATED -> CloudXRevenuePrecision.ESTIMATED
    AdValue.PrecisionType.PUBLISHER_PROVIDED -> CloudXRevenuePrecision.PUBLISHER_DEFINED
    else -> CloudXRevenuePrecision.UNDEFINED
}

private fun reportGooglePaidEvent(
    platform: CloudXRevenuePlatform,
    adValue: AdValue,
    adFormat: String,
    adUnitId: String,
    responseInfo: ResponseInfo?,
): Boolean {
    val servedBy = responseInfo?.loadedAdapterResponseInfo

    return CloudX.reportRevenueData(
        CloudXRevenueData.builder(
            platform = platform,
            revenue = adValue.valueMicros / 1_000_000.0,
            adFormat = adFormat,
        )
            .currencyCode(adValue.currencyCode)
            .precision(adValue.precisionType.toCloudXRevenuePrecision())
            .networkName(servedBy?.adSourceName)
            .adUnitId(adUnitId)
            .thirdPartyAdPlacementId(servedBy?.adSourceInstanceName)
            .build(),
    )
}

// Attach the listener to the arbitrated Google ad before you show it.
adMobInterstitial.setOnPaidEventListener { adValue ->
    reportGooglePaidEvent(
        platform = CloudXRevenuePlatform.ADMOB,
        adValue = adValue,
        adFormat = "interstitial",
        adUnitId = adMobAdUnitId,
        responseInfo = adMobInterstitial.responseInfo,
    )
}

// An Ad Manager ad reports the same way, with the GAM platform.
adManagerInterstitial.setOnPaidEventListener { adValue ->
    reportGooglePaidEvent(
        platform = CloudXRevenuePlatform.GAM,
        adValue = adValue,
        adFormat = "interstitial",
        adUnitId = adManagerAdUnitId,
        responseInfo = adManagerInterstitial.responseInfo,
    )
}

// networkName is optional; pass the winning ad source when you know it, e.g.
// responseInfo?.loadedAdapterResponseInfo?.adSourceName.
val adMobBid = CloudXArbiterBid.adMob(
    adUnitId = adMobAdUnitId,
    networkName = adMobNetworkName ?: "admob",
    manualRevenuePerImpressionUSD = null,
    extras = emptyMap(),
)

// An Ad Manager ad unit id takes the form /NNNNNNN/placement/name.
val adManagerBid = CloudXArbiterBid.gam(
    adUnitId = "/21775744923/example/interstitial",
    networkName = "gam",
    manualRevenuePerImpressionUSD = null,
    extras = emptyMap(),
)

val configuration = CloudXArbiterConfiguration.builder(
    listOf(CloudXArbiterBid.cloudX(cloudXAd), adMobBid, adManagerBid)
).build()

// Runs once the candidates have loaded, ahead of the placement. Store the winner.
CloudX.arbiter(configuration, object : CloudXArbiterListener {
    override fun onCompleted(result: CloudXArbiterResult) {
        nextWinner = result
    }
})

// Runs at the placement. No arbiter call here.
fun showInterstitial(activity: Activity) {
    when (nextWinner?.platform) {
        CloudXArbiterPlatform.CLOUDX -> cloudXInterstitial.show(activity)
        CloudXArbiterPlatform.ADMOB -> adMobInterstitial.show(activity)
        CloudXArbiterPlatform.GAM -> adManagerInterstitial.show(activity)
        else -> { } // no winner prepared; continue without an ad
    }
    nextWinner = null
}

val adMobBid = CloudXArbiterBid.adMob(
    adUnitId = adMobAdUnitId,
    networkName = adMobNetworkName ?: "admob",
    // valueMicros is in micros: 1,000,000 micros is one currency unit.
    // Do not also divide by 1,000 — this is already a per-impression value, not a CPM.
    manualRevenuePerImpressionUSD = preBidAdValue.valueMicros / 1_000_000.0,
    extras = emptyMap(),
)

/**
 * Prepares a Trusted Arbiter winner ahead of time so an interstitial can be shown
 * instantly when a placement is reached.
 *
 * Loads [cloudXInterstitial] and [levelPlayInterstitial] in parallel, waits until both
 * have finished loading or failing, submits the loaded candidates to [CloudX.arbiter],
 * and caches the selected [CloudXArbiterPlatform] in [nextWinner].
 */
class ArbiterInterstitialController(
    private val cloudXInterstitial: CloudXInterstitialAd,
    private val levelPlayInterstitial: LevelPlayInterstitialAd,
) {
    /** Receives the arbitration outcome once a winner has been prepared. */
    interface Listener {
        /** Called when the arbiter has selected [platform] for the next show. */
        fun onWinnerPrepared(platform: CloudXArbiterPlatform)
    }

    /** Set to observe [Listener.onWinnerPrepared] callbacks. */
    var listener: Listener? = null
    private var cloudXAd: CloudXAd? = null
    private var cloudXLoadDone = false
    private var levelPlayAdInfo: LevelPlayAdInfo? = null
    private var levelPlayLoadDone = false
    private var nextWinner: CloudXArbiterPlatform? = null

    init {
        cloudXInterstitial.listener = createCloudXListener()
        levelPlayInterstitial.setListener(createLevelPlayListener())
    }

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

    /**
     * Shows the prepared winner on [activity], 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.
     */
    fun showAtPlacement(activity: Activity): Boolean {
        return when (nextWinner) {
            CloudXArbiterPlatform.CLOUDX -> showCloudX(activity)
            CloudXArbiterPlatform.LEVELPLAY -> showLevelPlay(activity)
            else -> 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 [CloudX.arbiter].
     */
    private fun maybePrepareWinner() {
        if (!cloudXLoadDone || !levelPlayLoadDone) return

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

        val bids = listOfNotNull(
            cloudXAd?.let { CloudXArbiterBid.cloudX(it) },
            levelPlayAdInfo?.let { adInfo ->
                CloudXArbiterBid.levelPlay(
                    networkName = adInfo.adNetwork,
                    revenue = adInfo.revenue,
                    precision = adInfo.precision,
                )
            }
        )

        CloudX.arbiter(
            configuration = CloudXArbiterConfiguration.builder(bids).build(),
            listener = object : CloudXArbiterListener {
                override fun onCompleted(result: CloudXArbiterResult) {
                    nextWinner = result.platform
                    listener?.onWinnerPrepared(result.platform)
                }
            }
        )
    }

    private fun showCloudX(activity: Activity): Boolean {
        if (cloudXInterstitial.isAdReady) {
            cloudXInterstitial.show(activity)
            return true
        }

        clearCloudXAndLoadMissingAds()
        return false
    }

    private fun showLevelPlay(activity: Activity): Boolean {
        if (levelPlayInterstitial.isAdReady) {
            levelPlayInterstitial.showAd(activity)
            return true
        }

        clearLevelPlayAndLoadMissingAds()
        return false
    }

    private fun clearCloudXAndLoadMissingAds() {
        cloudXAd = null
        cloudXLoadDone = false
        nextWinner = null
        loadMissingAds()
    }

    private fun clearLevelPlayAndLoadMissingAds() {
        levelPlayAdInfo = null
        levelPlayLoadDone = false
        nextWinner = null
        loadMissingAds()
    }

    private fun createCloudXListener() = object : CloudXInterstitialListener {
        override fun onAdLoaded(cloudXAd: CloudXAd) {
            this@ArbiterInterstitialController.cloudXAd = cloudXAd
            cloudXLoadDone = true
            maybePrepareWinner()
        }

        override fun onAdLoadFailed(adUnitId: String, cloudXError: CloudXError) {
            cloudXAd = null
            cloudXLoadDone = true
            maybePrepareWinner()
        }

        override fun onAdDisplayed(cloudXAd: CloudXAd) = Unit

        override fun onAdDisplayFailed(cloudXAd: CloudXAd, cloudXError: CloudXError) {
            clearCloudXAndLoadMissingAds()
        }

        override fun onAdHidden(cloudXAd: CloudXAd) {
            clearCloudXAndLoadMissingAds()
        }

        override fun onAdClicked(cloudXAd: CloudXAd) = Unit
    }

    private fun createLevelPlayListener() = object : LevelPlayInterstitialAdListener {
        override fun onAdLoaded(levelPlayAdInfo: LevelPlayAdInfo) {
            this@ArbiterInterstitialController.levelPlayAdInfo = levelPlayAdInfo
            levelPlayLoadDone = true
            maybePrepareWinner()
        }

        override fun onAdLoadFailed(levelPlayAdError: LevelPlayAdError) {
            levelPlayAdInfo = null
            levelPlayLoadDone = true
            maybePrepareWinner()
        }

        override fun onAdInfoChanged(levelPlayAdInfo: LevelPlayAdInfo) {
            this@ArbiterInterstitialController.levelPlayAdInfo = levelPlayAdInfo
        }

        override fun onAdDisplayed(levelPlayAdInfo: LevelPlayAdInfo) = Unit

        override fun onAdDisplayFailed(
            levelPlayAdError: LevelPlayAdError,
            levelPlayAdInfo: LevelPlayAdInfo
        ) {
            clearLevelPlayAndLoadMissingAds()
        }

        override fun onAdClosed(levelPlayAdInfo: LevelPlayAdInfo) {
            clearLevelPlayAndLoadMissingAds()
        }

        override fun onAdClicked(levelPlayAdInfo: LevelPlayAdInfo) = Unit
    }
}

/**
 * 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] only shows a result that was stored earlier.
 */
class ArbiterAppOpenController(
    private val context: Context,
    cloudXAdUnitId: String,
    private val adMobAdUnitId: String,
) {
    /** Receives the arbitration outcome once a winner has been prepared. */
    interface Listener {
        /** Called when the arbiter has selected [platform] for the next foreground show. */
        fun onWinnerPrepared(platform: CloudXArbiterPlatform)
    }

    /** Set to observe [Listener.onWinnerPrepared] callbacks. */
    var listener: Listener? = null
    private val cloudXAppOpen: CloudXAppOpenAd = CloudX.createAppOpen(context, cloudXAdUnitId)
    private var cloudXAd: CloudXAd? = null
    private var cloudXLoadDone = false
    private var adMobAppOpen: AppOpenAd? = null
    /** The ad that is presenting, or presented last. Held so a late paid event still has an ad. */
    private var presentedAdMobAd: AppOpenAd? = null
    private var adMobLoadDone = false
    private var cloudXLoadInFlight = false
    private var adMobLoadInFlight = false
    private var nextWinner: CloudXArbiterPlatform? = null
    private var isShowingAd = false

    init {
        cloudXAppOpen.listener = createCloudXListener()
    }

    /**
     * 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.
     */
    fun loadMissingAds() {
        if (cloudXAd == null && !cloudXLoadInFlight) {
            cloudXLoadInFlight = true
            cloudXLoadDone = false
            cloudXAppOpen.load()
        }

        if (adMobAppOpen == null && !adMobLoadInFlight) {
            adMobLoadInFlight = true
            adMobLoadDone = false
            loadAdMob()
        }
    }

    /**
     * Shows the prepared winner on [activity], 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.
     */
    fun showOnForeground(activity: Activity): Boolean {
        if (isShowingAd) return false

        return when (nextWinner) {
            CloudXArbiterPlatform.CLOUDX -> showCloudX(activity)
            CloudXArbiterPlatform.ADMOB -> showAdMob(activity)
            CloudXArbiterPlatform.NONE -> {
                // 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()
                false
            }
            // nextWinner is null — a cycle is still in flight. Leave it alone.
            else -> false
        }
    }

    /** Releases both platforms' ads. Call this from the owning component's teardown. */
    fun destroy() {
        cloudXAppOpen.destroy()
        adMobAppOpen = null
        presentedAdMobAd = null
    }

    /**
     * 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 [CloudX.arbiter].
     */
    private fun maybePrepareWinner() {
        if (!cloudXLoadDone || !adMobLoadDone) return

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

        val bids = listOfNotNull(
            cloudXAd?.let { CloudXArbiterBid.cloudX(it) },
            adMobAppOpen?.let { CloudXArbiterBid.adMob(adUnitId = adMobAdUnitId) },
        )

        CloudX.arbiter(
            configuration = CloudXArbiterConfiguration.builder(bids).build(),
            listener = object : CloudXArbiterListener {
                override fun onCompleted(result: CloudXArbiterResult) {
                    nextWinner = result.platform
                    listener?.onWinnerPrepared(result.platform)
                }
            }
        )
    }

    private fun showCloudX(activity: Activity): Boolean {
        if (cloudXAppOpen.isAdReady) {
            isShowingAd = true
            cloudXAppOpen.show(activity, "app_foreground")
            return true
        }

        clearCloudXAndLoadMissingAds()
        return false
    }

    private fun showAdMob(activity: Activity): Boolean {
        val ad = adMobAppOpen
        if (ad == null) {
            clearAdMobAndLoadMissingAds()
            return false
        }

        ad.fullScreenContentCallback = object : FullScreenContentCallback() {
            override fun onAdDismissedFullScreenContent() {
                clearAdMobAndLoadMissingAds()
            }

            override fun onAdFailedToShowFullScreenContent(adError: AdError) {
                Log.e("CloudX", "AdMob App Open failed to show: ${adError.message}")
                clearAdMobAndLoadMissingAds()
            }
        }

        // An AppOpenAd is single-use: show() 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 = null
        isShowingAd = true
        ad.show(activity)
        return true
    }

    private fun loadAdMob() {
        AppOpenAd.load(
            context,
            adMobAdUnitId,
            AdRequest.Builder().build(),
            object : AppOpenAd.AppOpenAdLoadCallback() {
                override fun onAdLoaded(ad: AppOpenAd) {
                    ad.setOnPaidEventListener { adValue -> reportAdMobPaidEvent(ad, adValue) }
                    adMobAppOpen = ad
                    adMobLoadInFlight = false
                    adMobLoadDone = true
                    maybePrepareWinner()
                }

                override fun onAdFailedToLoad(error: LoadAdError) {
                    Log.w("CloudX", "AdMob App Open failed to load: ${error.message}")
                    adMobAppOpen = null
                    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.
     *
     * toCloudXRevenuePrecision() is the mapping shown in
     * "Report Google paid events back to CloudX" above.
     */
    private fun reportAdMobPaidEvent(ad: AppOpenAd, adValue: AdValue) {
        val servedBy = ad.responseInfo.loadedAdapterResponseInfo

        val accepted = CloudX.reportRevenueData(
            CloudXRevenueData.builder(
                platform = CloudXRevenuePlatform.ADMOB,
                revenue = adValue.valueMicros / 1_000_000.0,
                adFormat = "app_open",
            )
                .currencyCode(adValue.currencyCode)
                .precision(adValue.precisionType.toCloudXRevenuePrecision())
                .networkName(servedBy?.adSourceName)
                .adUnitId(adMobAdUnitId)
                .thirdPartyAdPlacementId(servedBy?.adSourceInstanceName)
                .build(),
        )

        if (!accepted) {
            Log.w("CloudX", "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 fun discardCandidatesAndReload() {
        cloudXAd = null
        adMobAppOpen = null
        cloudXLoadDone = false
        adMobLoadDone = false
        nextWinner = null
        loadMissingAds()
    }

    private fun clearCloudXAndLoadMissingAds() {
        cloudXAd = null
        cloudXLoadDone = false
        nextWinner = null
        isShowingAd = false
        loadMissingAds()
    }

    private fun clearAdMobAndLoadMissingAds() {
        adMobAppOpen = null
        adMobLoadDone = false
        nextWinner = null
        isShowingAd = false
        loadMissingAds()
    }

    private fun createCloudXListener() = object : CloudXAppOpenListener {
        override fun onAdLoaded(cloudXAd: CloudXAd) {
            this@ArbiterAppOpenController.cloudXAd = cloudXAd
            cloudXLoadInFlight = false
            cloudXLoadDone = true
            maybePrepareWinner()
        }

        override fun onAdLoadFailed(adUnitId: String, cloudXError: CloudXError) {
            Log.w("CloudX", "CloudX App Open failed to load: ${cloudXError.message}")
            cloudXAd = null
            cloudXLoadInFlight = false
            cloudXLoadDone = true
            maybePrepareWinner()
        }

        override fun onAdDisplayed(cloudXAd: CloudXAd) = Unit

        override fun onAdDisplayFailed(cloudXAd: CloudXAd, cloudXError: CloudXError) {
            Log.e("CloudX", "CloudX App Open failed to display: ${cloudXError.message}")
            clearCloudXAndLoadMissingAds()
        }

        override fun onAdHidden(cloudXAd: CloudXAd) {
            clearCloudXAndLoadMissingAds()
        }

        override fun onAdClicked(cloudXAd: CloudXAd) = Unit
    }
}

// In the class that owns the controller, for example your Application subclass:
private val controller = ArbiterAppOpenController(context, cloudXAdUnitId, adMobAdUnitId)

ProcessLifecycleOwner.get().lifecycle.addObserver(object : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        currentActivity?.let { controller.showOnForeground(it) }
    }
})

/**
 * Drives Trusted Arbiter for a banner placement: loads [cloudXBanner] and
 * [levelPlayBanner] in parallel, arbitrates between whichever candidates filled,
 * attaches the winning view to [container], and refreshes on [refreshIntervalMs].
 *
 * Auto-refresh must be disabled on both networks (dashboard setting for CloudX,
 * `stopAutoRefresh()` here, and the equivalent LevelPlay setting) — this controller
 * owns the refresh cycle instead.
 */
class ArbiterBannerController(
    private val cloudXBanner: CloudXAdView,
    private val levelPlayBanner: LevelPlayBannerAdView,
    private val container: ViewGroup,
    private val refreshIntervalMs: Long = 25_000L,
) {
    private val handler = Handler(Looper.getMainLooper())
    private var cloudXAd: CloudXAd? = null
    private var cloudXFilled = false
    private var cloudXLoadDone = false
    private var levelPlayAdInfo: LevelPlayAdInfo? = null
    private var levelPlayFilled = false
    private var levelPlayLoadDone = false
    private var currentWinner: CloudXArbiterPlatform? = null

    private val refreshRunnable = Runnable { runArbitrationRound() }

    init {
        cloudXBanner.stopAutoRefresh()
        cloudXBanner.listener = createCloudXListener()
        cloudXBanner.revenueListener = createCloudXRevenueListener()
        levelPlayBanner.bannerListener = createLevelPlayListener()
    }

    /** Starts the first round: loads every network that isn't already holding a fill. */
    fun start() {
        loadMissingAds()
    }

    fun stop() {
        handler.removeCallbacks(refreshRunnable)
    }

    private fun loadMissingAds() {
        if (!cloudXFilled) cloudXBanner.load()
        if (!levelPlayFilled) levelPlayBanner.loadAd()
    }

    /** Runs once both networks have settled (filled or failed); re-arbitrates only pending candidates. */
    private fun maybeArbitrate() {
        if (!cloudXLoadDone || !levelPlayLoadDone) return

        val bids = listOfNotNull(
            cloudXAd?.let { CloudXArbiterBid.cloudX(it) },
            levelPlayAdInfo?.let { info ->
                CloudXArbiterBid.levelPlay(
                    networkName = info.adNetwork,
                    revenue = info.revenue,
                    precision = info.precision,
                )
            },
        )

        if (bids.isEmpty()) {
            loadMissingAds()
            return
        }

        CloudX.arbiter(
            configuration = CloudXArbiterConfiguration.builder(bids).build(),
            listener = object : CloudXArbiterListener {
                override fun onCompleted(result: CloudXArbiterResult) {
                    showWinner(result.platform)
                }
            }
        )
    }

    private fun runArbitrationRound() {
        maybeArbitrate()
    }

    /** Attaches only the winning view; the losing view is never added to [container]. */
    private fun showWinner(platform: CloudXArbiterPlatform) {
        currentWinner = platform
        container.removeAllViews()

        when (platform) {
            CloudXArbiterPlatform.CLOUDX -> container.addView(cloudXBanner)
            CloudXArbiterPlatform.LEVELPLAY -> container.addView(levelPlayBanner)
            else -> return // CloudXArbiterPlatform.NONE — no winner; leave container empty
        }

        handler.removeCallbacks(refreshRunnable)
        handler.postDelayed(refreshRunnable, refreshIntervalMs)
    }

    /** Starts the winning network's next load immediately after its impression fires. */
    private fun onWinnerImpression(platform: CloudXArbiterPlatform) {
        when (platform) {
            CloudXArbiterPlatform.CLOUDX -> {
                cloudXFilled = false
                cloudXLoadDone = false
                cloudXBanner.load()
            }
            CloudXArbiterPlatform.LEVELPLAY -> {
                levelPlayFilled = false
                levelPlayLoadDone = false
                levelPlayBanner.loadAd()
            }
            else -> Unit
        }
    }

    private fun createCloudXListener() = object : CloudXAdViewListener {
        override fun onAdLoaded(cloudXAd: CloudXAd) {
            this@ArbiterBannerController.cloudXAd = cloudXAd
            cloudXFilled = true
            cloudXLoadDone = true
            maybeArbitrate()
        }

        override fun onAdLoadFailed(adUnitId: String, cloudXError: CloudXError) {
            cloudXAd = null
            cloudXFilled = false
            cloudXLoadDone = true
            maybeArbitrate()
        }

        override fun onAdClicked(cloudXAd: CloudXAd) = Unit
        override fun onAdExpanded(cloudXAd: CloudXAd) = Unit
        override fun onAdCollapsed(cloudXAd: CloudXAd) = Unit
    }

    private fun createCloudXRevenueListener() = object : CloudXAdRevenueListener {
        override fun onAdRevenuePaid(cloudXAd: CloudXAd) {
            // onAdRevenuePaid fires at CloudX impression time; only act on it while CloudX is showing.
            if (currentWinner == CloudXArbiterPlatform.CLOUDX) {
                onWinnerImpression(CloudXArbiterPlatform.CLOUDX)
            }
        }
    }

    private fun createLevelPlayListener() = object : LevelPlayBannerAdViewListener {
        override fun onAdLoaded(levelPlayAdInfo: LevelPlayAdInfo) {
            this@ArbiterBannerController.levelPlayAdInfo = levelPlayAdInfo
            levelPlayFilled = true
            levelPlayLoadDone = true
            maybeArbitrate()
        }

        override fun onAdLoadFailed(levelPlayAdError: LevelPlayAdError) {
            levelPlayAdInfo = null
            levelPlayFilled = false
            levelPlayLoadDone = true
            maybeArbitrate()
        }

        override fun onAdDisplayed(levelPlayAdInfo: LevelPlayAdInfo) {
            if (currentWinner == CloudXArbiterPlatform.LEVELPLAY) {
                onWinnerImpression(CloudXArbiterPlatform.LEVELPLAY)
            }
        }

        override fun onAdClicked(levelPlayAdInfo: LevelPlayAdInfo) = Unit
    }
}

/**
 * Arbitrates a CloudX native ad against an AdMob native ad and renders only the winner
 * into [container].
 *
 * Both platforms load without a view: [CloudXNativeAdLoader.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.
 */
class ArbiterNativeController(
    private val context: Context,
    private val container: ViewGroup,
    private val binder: CloudXNativeAdViewBinder,
    cloudXAdUnitId: String,
    private val adMobAdUnitId: String,
) {
    private val cloudXLoader: CloudXNativeAdLoader =
        CloudX.createNativeAdLoader(context, cloudXAdUnitId)
    private var cloudXAd: CloudXAd? = null
    private var cloudXLoadDone = false
    private var adMobNativeAd: NativeAd? = null
    private var adMobLoadDone = false
    private var cloudXLoadInFlight = false
    private var adMobLoadInFlight = false
    private var renderedPlatform: CloudXArbiterPlatform? = null
    private var renderedAdView: View? = null
    // 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: CloudXAd? = null
    private var renderedAdMobAd: NativeAd? = null

    init {
        cloudXLoader.nativeAdListener = createCloudXListener()
        cloudXLoader.revenueListener = createCloudXRevenueListener()
    }

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

    /** Releases both platforms' ads and detaches the rendered view. */
    fun destroy() {
        // detachRenderedAd() releases the rendered AdMob ad; only destroy the candidate here
        // when it is a different, never-rendered instance.
        val unrenderedAdMobAd = adMobNativeAd.takeIf { it !== renderedAdMobAd }
        detachRenderedAd()
        cloudXLoader.destroy()
        unrenderedAdMobAd?.destroy()
        adMobNativeAd = null
    }

    /**
     * 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 fun loadMissingAds() {
        // loadAd() with no ad view defers rendering. Never use loadAd(adView) here: that
        // renders the CloudX ad at load time, before the arbiter has chosen a winner.
        if (cloudXAd == null && !cloudXLoadInFlight) {
            cloudXLoadInFlight = true
            cloudXLoadDone = false
            cloudXLoader.loadAd()
        }

        if (adMobNativeAd == null && !adMobLoadInFlight) {
            adMobLoadInFlight = true
            adMobLoadDone = false
            loadAdMob()
        }
    }

    /** Runs once both platforms have settled (filled or failed), then renders the winner. */
    private fun maybeArbitrate() {
        if (!cloudXLoadDone || !adMobLoadDone) return

        val bids = listOfNotNull(
            cloudXAd?.let { CloudXArbiterBid.cloudX(it) },
            adMobNativeAd?.let { CloudXArbiterBid.adMob(adUnitId = adMobAdUnitId) },
        )

        if (bids.isEmpty()) {
            loadMissingAds()
            return
        }

        CloudX.arbiter(
            configuration = CloudXArbiterConfiguration.builder(bids).build(),
            listener = object : CloudXArbiterListener {
                override fun onCompleted(result: CloudXArbiterResult) {
                    renderWinner(result.platform)
                }
            }
        )
    }

    /** Renders only the winning platform's assets; the loser stays unrendered and unattached. */
    private fun renderWinner(platform: CloudXArbiterPlatform) {
        // 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.
        if (isAlreadyRendered(platform)) return

        if (platform == CloudXArbiterPlatform.NONE) {
            // 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()

        when (platform) {
            CloudXArbiterPlatform.CLOUDX -> renderCloudX()
            CloudXArbiterPlatform.ADMOB -> renderAdMob()
            else -> Unit
        }
    }

    /** True when this platform's current candidate is the ad already attached to the container. */
    private fun isAlreadyRendered(platform: CloudXArbiterPlatform): Boolean = when (platform) {
        CloudXArbiterPlatform.CLOUDX -> cloudXAd != null && cloudXAd === renderedCloudXAd
        CloudXArbiterPlatform.ADMOB -> adMobNativeAd != null && adMobNativeAd === renderedAdMobAd
        else -> false
    }

    /** Drops every candidate that is not currently rendered, then starts a new cycle. */
    private fun discardUnrenderedCandidatesAndReload() {
        if (renderedPlatform != CloudXArbiterPlatform.CLOUDX) {
            cloudXAd = null
            cloudXLoadDone = false
        }

        if (renderedPlatform != CloudXArbiterPlatform.ADMOB) {
            adMobNativeAd = null
            adMobLoadDone = false
        }

        loadMissingAds()
    }

    /**
     * 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 fun detachRenderedAd() {
        renderedAdView?.let { container.removeView(it) }
        renderedAdView = null
        renderedPlatform = null

        renderedCloudXAd?.let { cloudXLoader.destroy(it) }
        renderedCloudXAd = null
        renderedAdMobAd?.destroy()
        renderedAdMobAd = null
    }

    private fun renderCloudX() {
        val ad = cloudXAd ?: return
        val adView = CloudXNativeAdView(context, binder)
        cloudXLoader.render(adView, ad)
        container.addView(adView)
        renderedAdView = adView
        renderedPlatform = CloudXArbiterPlatform.CLOUDX
        renderedCloudXAd = ad
    }

    private fun renderAdMob() {
        val ad = adMobNativeAd ?: return
        // Inflate your own NativeAdView layout and assign its asset views, exactly as you
        // would in a non-arbitrated AdMob native integration.
        val adView = LayoutInflater.from(context)
            .inflate(R.layout.admob_native_ad_layout, container, false) as NativeAdView
        adView.setNativeAd(ad)
        container.addView(adView)
        renderedAdView = adView
        renderedPlatform = CloudXArbiterPlatform.ADMOB
        renderedAdMobAd = ad
    }

    private fun loadAdMob() {
        AdLoader.Builder(context, adMobAdUnitId)
            .forNativeAd { nativeAd ->
                nativeAd.setOnPaidEventListener { adValue ->
                    reportAdMobPaidEvent(nativeAd, adValue)
                }
                adMobNativeAd = nativeAd
                adMobLoadInFlight = false
                adMobLoadDone = true
                maybeArbitrate()
            }
            .withAdListener(object : AdListener() {
                override fun onAdFailedToLoad(error: LoadAdError) {
                    Log.w("CloudX", "AdMob native ad failed to load: ${error.message}")
                    adMobNativeAd = null
                    adMobLoadInFlight = false
                    adMobLoadDone = true
                    maybeArbitrate()
                }

                // 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.
                override fun onAdImpression() {
                    if (renderedPlatform == CloudXArbiterPlatform.ADMOB) {
                        onWinnerImpression(CloudXArbiterPlatform.ADMOB)
                    }
                }
            })
            .build()
            .loadAd(AdRequest.Builder().build())
    }

    /**
     * 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.
     *
     * toCloudXRevenuePrecision() is the mapping shown in
     * "Report Google paid events back to CloudX" above.
     */
    private fun reportAdMobPaidEvent(ad: NativeAd, adValue: AdValue) {
        val servedBy = ad.responseInfo?.loadedAdapterResponseInfo

        val accepted = CloudX.reportRevenueData(
            CloudXRevenueData.builder(
                platform = CloudXRevenuePlatform.ADMOB,
                revenue = adValue.valueMicros / 1_000_000.0,
                adFormat = "native",
            )
                .currencyCode(adValue.currencyCode)
                .precision(adValue.precisionType.toCloudXRevenuePrecision())
                .networkName(servedBy?.adSourceName)
                .adUnitId(adMobAdUnitId)
                .thirdPartyAdPlacementId(servedBy?.adSourceInstanceName)
                .build(),
        )

        if (!accepted) {
            Log.w("CloudX", "AdMob native paid event was not accepted by the CloudX SDK")
        }
    }

    private fun createCloudXListener() = object : CloudXNativeAdListener {
        // adView is null here because loadAd() was called without one. The ad is rendered
        // later, and only if it wins.
        override fun onNativeAdLoaded(adView: CloudXNativeAdView?, ad: CloudXAd) {
            cloudXAd = ad
            cloudXLoadInFlight = false
            cloudXLoadDone = true
            maybeArbitrate()
        }

        override fun onNativeAdLoadFailed(adUnitId: String, error: CloudXError) {
            Log.w("CloudX", "CloudX native ad failed to load: ${error.message}")
            cloudXAd = null
            cloudXLoadInFlight = false
            cloudXLoadDone = true
            maybeArbitrate()
        }

        override fun onNativeAdClicked(ad: CloudXAd) = Unit

        override fun onNativeAdExpired(ad: CloudXAd) {
            // detachRenderedAd() releases the rendered ad, so hand it this one instead of
            // destroying it twice.
            if (renderedCloudXAd !== ad) cloudXLoader.destroy(ad)
            clearCloudXAndReload()
        }

        override fun onNativeAdClosed(ad: CloudXAd) {
            if (renderedCloudXAd !== ad) cloudXLoader.destroy(ad)
            clearCloudXAndReload()
        }
    }

    private fun createCloudXRevenueListener() = object : CloudXAdRevenueListener {
        override fun onAdRevenuePaid(cloudXAd: CloudXAd) {
            // onAdRevenuePaid fires at CloudX impression time; only act on it while CloudX is
            // the platform on screen.
            if (renderedPlatform == CloudXArbiterPlatform.CLOUDX) {
                onWinnerImpression(CloudXArbiterPlatform.CLOUDX)
            }
        }
    }

    /**
     * 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 fun onWinnerImpression(platform: CloudXArbiterPlatform) {
        when (platform) {
            CloudXArbiterPlatform.CLOUDX -> {
                cloudXAd = null
                cloudXLoadDone = false
                cloudXLoadInFlight = false
            }
            CloudXArbiterPlatform.ADMOB -> {
                adMobNativeAd = null
                adMobLoadDone = false
                adMobLoadInFlight = false
            }
            else -> return
        }

        loadMissingAds()
    }

    /** Drops the CloudX candidate, detaching it first if it is the one on screen. */
    private fun clearCloudXAndReload() {
        if (renderedPlatform == CloudXArbiterPlatform.CLOUDX) {
            detachRenderedAd()
        }

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

val customBid = CloudXArbiterBid.custom(
    platformName = "my_mediation_platform",
    networkName = "winning_demand_source",
    revenuePerImpressionUSD = 0.00125,
    precision = CloudXArbiterPrecision.EXACT,
    extras = mapOf("ad_unit" to "third-party-ad-unit-id"),
)

val configuration = CloudXArbiterConfiguration.builder(
    listOf(CloudXArbiterBid.cloudX(cloudXAd), customBid)
).build()