package csdk.gluads.max;

import android.text.TextUtils;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.applovin.mediation.MaxAd;
import com.applovin.mediation.MaxAdListener;
import com.applovin.mediation.MaxError;
import com.applovin.mediation.ads.MaxInterstitialAd;
import com.applovin.sdk.AppLovinSdk;
import com.applovin.sdk.AppLovinSdkSettings;
import csdk.gluads.Consts;
import csdk.gluads.max.EAMaxManagerBase;
import csdk.gluads.util.Common;
import csdk.gluads.util.ConfigUtil;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/* loaded from: classes4.dex */
public class EAMaxInterstitialManager extends EAMaxManagerBase {
    private final Map<String, MaxInterstitialAd> mAds;
    private boolean mIsLoadedIgnoreFrequencyCapping;
    private boolean mSendImpressionData;

    @Override // csdk.gluads.max.EAMaxManagerBase
    public String adType() {
        return "interstitial";
    }

    public class EAMaxInterstitialListener extends EAMaxManagerBase.EAMaxListener implements MaxAdListener {
        public EAMaxInterstitialListener() {
            super();
        }

        @Override // com.applovin.mediation.MaxAdListener
        public void onAdLoaded(MaxAd maxAd) {
            sendLoadPlacementEvent(Consts.PLACEMENT_STATUS_LOAD_FINISHED, null);
            clearLoadingPlacements();
        }

        @Override // com.applovin.mediation.MaxAdListener
        public void onAdDisplayed(MaxAd maxAd) {
            EAMaxInterstitialManager.this.getCrossPromos().remove(maxAd.getPlacement());
        }

        @Override // com.applovin.mediation.MaxAdListener
        public void onAdHidden(MaxAd maxAd) {
            EAMaxInterstitialManager.this.frequencyController().increaseCount(EAMaxInterstitialManager.this.isCrossPromo(maxAd.getAdUnitId()), showingPlacement());
            sendSinglePlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_SHOW_FINISHED, null);
        }

        @Override // com.applovin.mediation.MaxAdListener
        public void onAdClicked(MaxAd maxAd) {
            Map<String, Object> createMap = Common.createMap();
            createMap.putAll(this.mExtra);
            if (EAMaxInterstitialManager.this.isCrossPromo(maxAd.getAdUnitId())) {
                createMap.put(Consts.IS_CROSS_PROMO, 1);
                Map<String, Object> map = ConfigUtil.getMap(EAMaxInterstitialManager.this.getImpressionMapping(), maxAd.getAdUnitId());
                if (map != null) {
                    createMap.putAll(map);
                }
            }
            sendSinglePlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_CLICKED, null, createMap);
        }

        @Override // com.applovin.mediation.MaxAdListener
        public void onAdLoadFailed(String str, MaxError maxError) {
            sendLoadPlacementEvent(Consts.PLACEMENT_STATUS_LOAD_FINISHED, new IllegalStateException("Failed to load ad: " + maxError.toString()));
            clearLoadingPlacements();
        }

        @Override // com.applovin.mediation.MaxAdListener
        public void onAdDisplayFailed(MaxAd maxAd, MaxError maxError) {
            sendSinglePlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_SHOW_FINISHED, new IllegalStateException("Failed to show ad: " + String.format("{code:%s, msg:%s, waterfall:%s}", Integer.valueOf(maxError.getCode()), maxError.getMessage(), maxError.getWaterfall())));
        }
    }

    public EAMaxInterstitialManager(@NonNull AppLovinSdk appLovinSdk, EAMaxManagerBase eAMaxManagerBase, boolean z, boolean z2) {
        super(appLovinSdk, eAMaxManagerBase);
        this.mAds = new ConcurrentHashMap();
        this.mSendImpressionData = z;
        this.mIsLoadedIgnoreFrequencyCapping = z2;
    }

    public MaxInterstitialAd getAdForAdUnitID(String str) {
        if (str == null) {
            return null;
        }
        return this.mAds.get(str);
    }

    public void setAdForAdUnitID(String str, MaxInterstitialAd maxInterstitialAd) {
        EAMaxInterstitialListener eAMaxInterstitialListener = new EAMaxInterstitialListener();
        maxInterstitialAd.setListener(eAMaxInterstitialListener);
        addListenerForAdUnitId(eAMaxInterstitialListener, str);
        synchronized (this.mAds) {
            this.mAds.put(str, maxInterstitialAd);
        }
    }

    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
        MaxInterstitialAd adForAdUnitID = getAdForAdUnitID(getAdUnitId(str2, false));
        if (adForAdUnitID == null || !adForAdUnitID.isReady()) {
            return false;
        }
        return this.mIsLoadedIgnoreFrequencyCapping || !isCapped(str2);
    }

    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
    public void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
        if (TextUtils.equals(str2, Consts.DEBUG_PLACEMENT)) {
            getSdk().showMediationDebugger();
            return;
        }
        String adUnitId = getAdUnitId(str2);
        if (TextUtils.isEmpty(adUnitId)) {
            sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_LOAD_FINISHED, new IllegalArgumentException("No mapping for " + str2 + Consts.STRING_PERIOD), map);
            return;
        }
        if (crossPromoMappingContains(adUnitId).booleanValue()) {
            loadAdOnCrossPromoTargetAppCheck(str2, ConfigUtil.getString(ConfigUtil.getMap(getImpressionMapping(), adUnitId), "campaign_name"), map);
        } else {
            directLoad(str2, map);
        }
    }

    @Override // csdk.gluads.eventbus.GluAdsManagerEventHandler
    public void directLoad(String str, @NonNull Map<String, Object> map) {
        if (TextUtils.equals(str, Consts.DEBUG_PLACEMENT)) {
            getSdk().showMediationDebugger();
            return;
        }
        String adUnitId = getAdUnitId(str);
        MaxInterstitialAd adForAdUnitID = getAdForAdUnitID(adUnitId);
        if (adForAdUnitID == null) {
            adForAdUnitID = new MaxInterstitialAd(adUnitId, getSdk(), getActivity());
            setAdForAdUnitID(adUnitId, adForAdUnitID);
        } else if (adForAdUnitID.isReady()) {
            sendPlacementEvent(str, Consts.PLACEMENT_STATUS_LOAD_FINISHED, null, map);
            return;
        }
        if (crossPromoMappingContains(adUnitId).booleanValue()) {
            setCrossPromoLoaded(adUnitId);
        }
        EAMaxManagerBase.EAMaxListener listenerForAdUnitId = getListenerForAdUnitId(adUnitId);
        if (listenerForAdUnitId != null) {
            listenerForAdUnitId.addLoadingPlacement(str);
        }
        AppLovinSdkSettings settings = getSdk().getSettings();
        String string = ConfigUtil.getString(map, Consts.MAX_TEST_MODE_NETWORK);
        if (string != null) {
            settings.setExtraParameter(Consts.MAX_TEST_MODE_NETWORK, string);
        } else if (isTestPlacement(str)) {
            settings.setExtraParameter(Consts.MAX_TEST_MODE_NETWORK, getTestNetwork(str));
        }
        adForAdUnitID.loadAd();
    }

    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
    public void show(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
        if (TextUtils.equals(str2, Consts.DEBUG_PLACEMENT)) {
            getSdk().showMediationDebugger();
            return;
        }
        if (isLoaded(str, str2, map)) {
            String adUnitId = getAdUnitId(str2);
            MaxInterstitialAd adForAdUnitID = getAdForAdUnitID(adUnitId);
            ((EAMaxManagerBase) this).mLog.d("INTERSTITIAL.SHOW", Consts.KEY_TAPJOY_USER_ID_VERSION, str2, "l", "max");
            EAMaxManagerBase.EAMaxListener listenerForAdUnitId = getListenerForAdUnitId(adUnitId);
            if (listenerForAdUnitId != null) {
                listenerForAdUnitId.setShowingPlacement(str2);
            }
            if (isCrossPromo(adUnitId)) {
                ((EAMaxManagerBase) this).mLog.d("INTERSTITIAL.LOAD", Consts.KEY_TAPJOY_USER_ID_VERSION, str2, "placement", adUnitId, "adUnitID", "max");
            }
            adForAdUnitID.setRevenueListener(makeRevenueListener(str2, map, this.mSendImpressionData));
            adForAdUnitID.showAd(str2);
            return;
        }
        sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_STARTED, new IllegalStateException("Not ready"), map);
    }
}