Untitled

package com.astraler.android.landparcels.ui.ads

import android.app.Activity
import android.os.Bundle
import android.util.Log
import com.appsflyer.adrevenue.AppsFlyerAdRevenue
import com.appsflyer.adrevenue.adnetworks.generic.MediationNetwork
import com.appsflyer.adrevenue.adnetworks.generic.Scheme
import com.astraler.android.landparcels.BuildConfig
import com.astraler.android.landparcels.ui.paywall.PaywallManager
import com.astraler.android.landparcels.utils.SingletonHolder
import com.astraler.android.landparcels.utils.remote.RemoteConfigManager
import com.google.android.gms.ads.AdError
import com.google.android.gms.ads.AdRequest
import com.google.android.gms.ads.AdValue
import com.google.android.gms.ads.FullScreenContentCallback
import com.google.android.gms.ads.LoadAdError
import com.google.android.gms.ads.OnPaidEventListener
import com.google.android.gms.ads.ResponseInfo
import com.google.android.gms.ads.rewarded.RewardedAd
import com.google.android.gms.ads.rewarded.RewardedAdLoadCallback
import com.google.firebase.analytics.FirebaseAnalytics
import java.util.Currency

class RewardAds(private val activity: Activity) {

    companion object : SingletonHolder<RewardAds, Activity>(::RewardAds) {
        private const val TAG = "RewardAds"
    }

    private var isShowingAd = false

    private var rewardedAd: RewardedAd? = null
    private var firebaseAnalytics: FirebaseAnalytics =
        FirebaseAnalytics.getInstance(activity.applicationContext)

    /**
     * Request an ad
     */
    internal fun fetchAd(onAdLoaded: () -> Unit = {}) {
        if (isAdAvailable() && !isConditionConfigAvailable()) {
            onAdLoaded.invoke()
            return
        }

        val loadCallback = object : RewardedAdLoadCallback() {
            override fun onAdLoaded(ad: RewardedAd) {
                Log.i(TAG, "fetchAd: onAdLoaded")
                rewardedAd = ad
                onAdLoaded.invoke()
            }

            override fun onAdFailedToLoad(loadAdError: LoadAdError) {
                Log.e(TAG, "failed to load: ${loadAdError.message}")
                onAdLoaded.invoke()
            }
        }
        val request = AdRequest.Builder().build()
        val adUnitId = if (BuildConfig.DEBUG) {
            BuildConfig.ADS_REWARD_ID
        } else {
            RemoteConfigManager.getInstance()?.getAdmobConfig()?.reward?.adUnitId
                ?: BuildConfig.ADS_REWARD_ID
        }
        activity.application?.let {
            RewardedAd.load(it, adUnitId, request, loadCallback)
        }
    }

    internal fun showAdIfAvailable(onAdsClosedListener: () -> Unit = {}) {
        Log.i(TAG, "showAdIfAvailable $rewardedAd")
        if (!isShowingAd && isConditionConfigAvailable() && rewardedAd != null) {
            rewardedAd?.fullScreenContentCallback = object : FullScreenContentCallback() {
                override fun onAdDismissedFullScreenContent() {
                    Log.i(TAG, "showAdIfAvailable: onAdDismissedFullScreenContent")
                    rewardedAd = null
                    isShowingAd = false
                    fetchAd()
                    onAdsClosedListener.invoke()
                }

                override fun onAdFailedToShowFullScreenContent(adError: AdError) {
                    Log.e(TAG, "onAdFailedToShowFullScreenContent: ${adError.message}")
                    onAdsClosedListener.invoke()
                }

                override fun onAdShowedFullScreenContent() {
                    Log.i(TAG, "showAdIfAvailable: onAdShowedFullScreenContent")
                    isShowingAd = true
                }
            }
            rewardedAd?.onPaidEventListener = OnPaidEventListener { adValue ->
                rewardedAd?.responseInfo?.let {
                    trackingAdImpression(adValue, it)
                    trackingAppsFlyerAdRevenue(adValue)
                }
            }
            rewardedAd?.show(activity) {
                Log.d(TAG, "showAdIfAvailable: ")
            }
        } else {
            onAdsClosedListener.invoke()
        }
    }

    /**
     * Utility method that checks if ad exists and can be shown.
     */
    private fun isAdAvailable() = rewardedAd != null

    private fun isConditionConfigAvailable(): Boolean {
        RemoteConfigManager.getInstance()?.getAdmobConfig()?.reward?.let { config ->
            val isPurchased = PaywallManager.getInstance()?.hasPurchased() == true
            return !isPurchased && config.hasShow == true
        }
        return true
    }

    private fun trackingAdImpression(adValue: AdValue, responseInfo: ResponseInfo) {
        firebaseAnalytics.logEvent(FirebaseAnalytics.Event.AD_IMPRESSION, Bundle().apply {
            putString(FirebaseAnalytics.Param.AD_PLATFORM, "Admob")
            putString(
                FirebaseAnalytics.Param.AD_UNIT_NAME,
                responseInfo.loadedAdapterResponseInfo?.adSourceInstanceName ?: ""
            )
            putString(FirebaseAnalytics.Param.AD_FORMAT, "Reward")
            putString(
                FirebaseAnalytics.Param.AD_SOURCE,
                responseInfo.loadedAdapterResponseInfo?.adSourceName ?: ""
            )
            val eventRevenue = adValue.valueMicros.toDouble() / 1000000
            putDouble(FirebaseAnalytics.Param.VALUE, eventRevenue)
            putString(FirebaseAnalytics.Param.CURRENCY, adValue.currencyCode)
        })
    }

    private fun trackingAppsFlyerAdRevenue(adValue: AdValue) {
        Log.i(TAG, "trackingAppsFlyerAdRevenue: ")
        val customParams: MutableMap<String, String> = HashMap()
        customParams[Scheme.COUNTRY] = "US"
        val adUnitId =
            RemoteConfigManager.getInstance()?.getAdmobConfig()?.reward?.adUnitId
                ?: BuildConfig.ADS_INTERSTITIAL_ID
        customParams[Scheme.AD_UNIT] = adUnitId
        customParams[Scheme.AD_TYPE] = "Reward"
        customParams[Scheme.PLACEMENT] = "adPlacement"
        customParams[Scheme.ECPM_PAYLOAD] = "encrypt"
        val eventRevenue = adValue.valueMicros.toDouble() / 1000000
        AppsFlyerAdRevenue.logAdRevenue(
            "googleAdMob",
            MediationNetwork.googleadmob,
            Currency.getInstance(adValue.currencyCode),
            eventRevenue,
            customParams
        )
    }
}