package com.rgt.superr.business.ads.admob

import android.app.Activity
import android.content.Context
import com.rgt.superr.GlobalConfig
import com.rgt.superr.MyApplication
import com.rgt.superr.business.ads.AdEvent
import com.rgt.superr.business.ads.AdState
import com.rgt.superr.business.ads.AdsShowCallBack
import com.rgt.superr.business.ads.AdsType
import com.rgt.superr.business.ads.LimitUtils
import com.rgt.superr.utils.LogEx
import com.google.android.gms.ads.AdError
import com.google.android.gms.ads.AdRequest
import com.google.android.gms.ads.FullScreenContentCallback
import com.google.android.gms.ads.LoadAdError
import com.google.android.gms.ads.appopen.AppOpenAd
import com.rgt.superr.business.ads.AdsType.Companion.OPEN


/**
 * 开屏广告加载显示管理类
 */
class AdOpenMgr {

    private val TAG = "AdOpenMgr"
    private val adState = AdState<AppOpenAd>()
    private var showCallBack: AdsShowCallBack? = null

    //正在加载回调
    private var loadingCallBack: ((flag: Boolean) -> Unit)? = null

    fun show(
        activity: Activity,
        adEvent: AdEvent,
        showCallBack: AdsShowCallBack?
    ) {
        if (activity.isFinishing || activity.isDestroyed) {
            return
        }

        adState.currentAdEvent?.let { adEvent.reqId = it.reqId }

        if (!adEvent.isUnLimit) {
            if (!LimitUtils.isAdShow(AdsType.OPEN, adEvent)) {
                showCallBack?.failed()
                return
            }
            if (LimitUtils.isIntervalOpenLimit(adEvent)) {
                showCallBack?.failed()
                return
            }
        }

        val needLoad = adState.needLoad()
        this.showCallBack = showCallBack

        adEvent.adPrepareShow()
        if (needLoad) {
            if (!adState.loadingAd) {
                LogEx.logDebug(adEvent.TAG, "open adState !loadingAd")
                loadAd(activity, adEvent) {
                    if (it) {
                        showReadyAd(activity, adEvent)
                    } else {
                        showCallBack?.adFailed()
                    }
                }
            } else {
                LogEx.logDebug(adEvent.TAG, "open adState is loadingAd")
                loadingCallBack = {
                    if (it) {
                        showReadyAd(activity, adEvent)
                    } else {
                        showCallBack?.adFailed()
                    }
                }
            }
        } else {
            LogEx.logDebug(adEvent.TAG, "open ad ready")
            showReadyAd(activity, adEvent)
        }
    }

    private fun showReadyAd(ac: Activity, adEvent: AdEvent) {

        val admobEvent = (adEvent as AdmobEvent)

        if (ac.isFinishing || ac.isDestroyed || adState.currentAd == null) {
            LogEx.logDebug(adEvent.TAG, "open showReadyAd ac=null isFinishing isDestroyed")
            return
        }

        adState.currentAd?.run {


            fullScreenContentCallback = object : FullScreenContentCallback() {
                override fun onAdShowedFullScreenContent() {
                    adState.onAdDisplayed(OPEN)

                    showCallBack?.show()
                    //计数
                    LimitUtils.addDisplayNum()

                    admobEvent.showAd(this@run.responseInfo, ac)
                }

                override fun onAdFailedToShowFullScreenContent(adError: AdError) {
                    super.onAdFailedToShowFullScreenContent(adError)

                    showCallBack?.adFailed()
                    showCallBack = null
                    adState.onAdDisplayFailed()

                    admobEvent.adShowError(adError)

                }

                override fun onAdDismissedFullScreenContent() {
                    super.onAdDismissedFullScreenContent()

                    adState.onAdHidden(OPEN)

                    showCallBack?.close()
                    showCallBack = null

                    //预加载,“Timeout for show call succeed.”预加载的广告大概率,
                    loadAd(MyApplication.appContext, AdmobEvent("openAd", "preload"))
                }

                override fun onAdClicked() {
                    admobEvent.clickAd(this@run.responseInfo)
                    //计数
                    LimitUtils.addClickNum()
                }
            }
            show(ac)
        }
    }

    fun loadAd(
        context: Context,
        adEvent: AdEvent,
        loadCallBack: ((flag: Boolean) -> Unit)? = null
    ) {

        if (!adEvent.isUnLimit) {
            if (!LimitUtils.isAdShow(AdsType.OPEN, adEvent)) {
                this.showCallBack?.failed()
                this.showCallBack = null
                adState.onAdLoadFailed()
                return
            }
        }

        //避免无效预加载
        if (adState.loadingAd) {
            return
        }

        adEvent.adPulStart()
        adState.loadStart(adEvent)

        AppOpenAd.load(
            context,
            GlobalConfig.ID_ADMOB_OPEN,
            AdRequest.Builder().build(),
            object : AppOpenAd.AppOpenAdLoadCallback() {
                override fun onAdLoaded(appOpenAd: AppOpenAd) {
                    LogEx.logDebug(adEvent.TAG, "open onAdLoaded loadAd")

                    appOpenAd.onPaidEventListener = AdmobOnPaidEventListener(appOpenAd, adEvent.scope)
                    adState.onAdLoaded(appOpenAd)

                    loadCallBack?.invoke(true)
                    loadingCallBack?.invoke(true)
                    loadingCallBack = null

                    LimitUtils.addRequestNum()
                    (adEvent as AdmobEvent).pullAd(appOpenAd.responseInfo)
                }

                override fun onAdFailedToLoad(loadAdError: LoadAdError) {
                    LogEx.logDebug(adEvent.TAG, "open onAdFailedToLoad loadAd")
                    adState.onAdLoadFailed()

                    loadCallBack?.invoke(false)
                    loadingCallBack?.invoke(false)
                    loadingCallBack = null

                    (adEvent as AdmobEvent).pullAd(loadAdError.responseInfo, loadAdError)
                }
            }
        )
    }

}
