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.MaxError;
import com.applovin.mediation.MaxReward;
import com.applovin.mediation.MaxRewardedAdListener;
import com.applovin.mediation.ads.MaxRewardedAd;
import com.applovin.sdk.AppLovinSdk;
import com.applovin.sdk.AppLovinSdkSettings;
import com.facebook.share.internal.ShareConstants;
import com.ironsource.nb;
import csdk.gluads.Consts;
import csdk.gluads.GemsDataUtil;
import csdk.gluads.Reward;
import csdk.gluads.max.EAMaxManagerBase;
import csdk.gluads.util.Common;
import csdk.gluads.util.ConfigUtil;
import csdk.gluads.util.JsonUtil;
import csdk.gluads.util.PlacementInfo;
import csdk.gluads.util.RewardUtil;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicReference;
import org.json.JSONException;

/* loaded from: classes4.dex */
public class EAMaxRVManager extends EAMaxManagerBase {
    private boolean mHasUserID;
    private boolean mIsLoadedIgnoreFrequencyCapping;
    private final AtomicReference<String> mRewardSource;
    private final Map<String, Object> mRewards;
    private final Map<String, Object> mSdkData;
    private boolean mSendImpressionData;
    private final String mSeparator;
    private boolean mShouldIgnoreGlobalFrequencyCapping;

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

    public class EAMaxRVListener extends EAMaxManagerBase.EAMaxListener implements MaxRewardedAdListener {
        public EAMaxRVListener() {
            super();
        }

        @Override // com.applovin.mediation.MaxRewardedAdListener
        public void onUserRewarded(MaxAd maxAd, MaxReward maxReward) {
            int amount = maxReward.getAmount();
            String label = maxReward.getLabel();
            String[] split = maxAd.getPlacement().split(EAMaxRVManager.this.mSeparator);
            if (split.length > 1) {
                label = split[0];
                amount = Integer.parseInt(split[1]);
            }
            if (amount <= 0) {
                EAMaxRVManager eAMaxRVManager = EAMaxRVManager.this;
                Reward reward = eAMaxRVManager.getReward(eAMaxRVManager.adType(), "defaultReward");
                if (reward != null) {
                    label = reward.item;
                    amount = reward.amount;
                }
            }
            int i = amount;
            if (i <= 0) {
                ((EAMaxManagerBase) EAMaxRVManager.this).mLog.e("REWARDED_INTERSTITIAL.REWARD", nb.q, showingPlacement(), "Skipping reward callback because no valid reward amount can be determined");
                return;
            }
            ((EAMaxManagerBase) EAMaxRVManager.this).mLog.d("REWARDED_INTERSTITIAL.REWARD", nb.q, showingPlacement(), "reward", label, "amount", Integer.valueOf(i));
            EAMaxRVManager.this.listener().onRewardReceived(new Reward(Common.uuid(), showingPlacement(), "max", EAMaxRVManager.this.adType(), label, i));
        }

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

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

        @Override // com.applovin.mediation.MaxAdListener
        public void onAdHidden(MaxAd maxAd) {
            EAMaxRVManager.this.frequencyController().increaseCount(EAMaxRVManager.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 (EAMaxRVManager.this.isCrossPromo(maxAd.getAdUnitId())) {
                createMap.put(Consts.IS_CROSS_PROMO, 1);
                Map<String, Object> map = ConfigUtil.getMap(EAMaxRVManager.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 show ad: " + String.format("{code:%s, msg:%s, waterfall:%s}", Integer.valueOf(maxError.getCode()), maxError.getMessage(), maxError.getWaterfall()), new Throwable(String.valueOf(maxError.getCode()))));
            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: " + maxError.toString()));
        }
    }

    public EAMaxRVManager(@NonNull AppLovinSdk appLovinSdk, EAMaxManagerBase eAMaxManagerBase, String str, Map<String, Object> map, boolean z, boolean z2, boolean z3) {
        super(appLovinSdk, eAMaxManagerBase);
        this.mHasUserID = false;
        this.mSeparator = str;
        AtomicReference<String> atomicReference = new AtomicReference<>("DEFAULT");
        this.mRewardSource = atomicReference;
        ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap();
        this.mRewards = concurrentHashMap;
        this.mSdkData = Common.createMap();
        if (map != null) {
            synchronized (concurrentHashMap) {
                concurrentHashMap.putAll(map);
            }
            atomicReference.set(map.isEmpty() ? "DEFAULT" : "SDK (client)");
        }
        this.mSendImpressionData = z;
        this.mIsLoadedIgnoreFrequencyCapping = z2;
        this.mShouldIgnoreGlobalFrequencyCapping = z3;
        if (z3) {
            return;
        }
        frequencyController().enableGlobalFrequencyCapping();
    }

    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
    public void setUserIdentifier(@Nullable String str, @Nullable Map<String, Object> map) {
        ((EAMaxManagerBase) this).mLog.d("REWARDED_INTERSTITIAL.SET.USERID", Consts.KEY_TAPJOY_USER_ID_VERSION, str, "l", "max");
        if (TextUtils.isEmpty(str)) {
            return;
        }
        getSdk().setUserIdentifier(str);
        this.mHasUserID = true;
    }

    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
    public void internal_setGemsData(@Nullable String str, @Nullable Map<String, Object> map) {
        ((EAMaxManagerBase) this).mLog.d("REWARDED_INTERSTITIAL.SET.GEMSDATA", Consts.KEY_TAPJOY_USER_ID_VERSION, str, "l", "max");
        if (TextUtils.isEmpty(str)) {
            return;
        }
        try {
            Map<String, Object> parseJsonObject = JsonUtil.parseJsonObject(str);
            String string = ConfigUtil.getString(parseJsonObject, "sessionId");
            if (!TextUtils.isEmpty(string)) {
                parseJsonObject.remove("sessionId");
                this.mSdkData.put("sessionId", string);
            }
            getSdk().setUserIdentifier(GemsDataUtil.base64EncodeMap(parseJsonObject));
            this.mHasUserID = true;
        } catch (JSONException e) {
            ((EAMaxManagerBase) this).mLog.d("REWARDED_INTERSTITIAL.SET.GEMSDATA", "e", e, "l", "max");
        }
    }

    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
        MaxRewardedAd maxRewardedAd;
        if (!this.mHasUserID) {
            return false;
        }
        String adUnitId = getAdUnitId(str2);
        if (TextUtils.isEmpty(adUnitId) || (maxRewardedAd = MaxRewardedAd.getInstance(adUnitId, getSdk(), getActivity())) == null || !maxRewardedAd.isReady()) {
            return false;
        }
        return this.mIsLoadedIgnoreFrequencyCapping || !isCapped(str2);
    }

    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
    public Reward getReward(@NonNull String str, @NonNull String str2) {
        Object obj;
        synchronized (this.mRewards) {
            obj = this.mRewards.get(str2);
        }
        if (obj == null || !(obj instanceof Map)) {
            return null;
        }
        return RewardUtil.toReward(str2, obj);
    }

    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
    public void internal_updateRewardList(@NonNull Map<String, Object> map) {
        synchronized (this.mRewards) {
            this.mRewards.clear();
            this.mRewards.putAll(map);
        }
    }

    @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;
        }
        if (!this.mHasUserID) {
            sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_LOAD_STARTED, new IllegalArgumentException("UserId is empty."), map);
            return;
        }
        String adUnitId = getAdUnitId(str2, false);
        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);
        MaxRewardedAd maxRewardedAd = MaxRewardedAd.getInstance(adUnitId, getSdk(), getActivity());
        if (maxRewardedAd == null) {
            sendPlacementEvent(str, Consts.PLACEMENT_STATUS_LOAD_FINISHED, new IllegalArgumentException("Not able to get instance for ad unit ID" + adUnitId + Consts.STRING_PERIOD), map);
            return;
        }
        if (maxRewardedAd.isReady()) {
            sendPlacementEvent(str, Consts.PLACEMENT_STATUS_LOAD_FINISHED, null, map);
            return;
        }
        if (crossPromoMappingContains(adUnitId).booleanValue()) {
            setCrossPromoLoaded(adUnitId);
        }
        EAMaxManagerBase.EAMaxListener listenerForAdUnitId = getListenerForAdUnitId(adUnitId);
        EAMaxManagerBase.EAMaxListener eAMaxListener = listenerForAdUnitId;
        if (listenerForAdUnitId == null) {
            EAMaxRVListener eAMaxRVListener = new EAMaxRVListener();
            addListenerForAdUnitId(eAMaxRVListener, adUnitId);
            maxRewardedAd.setListener(eAMaxRVListener);
            eAMaxListener = eAMaxRVListener;
        }
        eAMaxListener.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));
        }
        maxRewardedAd.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 str3 = null;
            sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_ATTEMPT, null, map);
            String adUnitId = getAdUnitId(str2);
            MaxRewardedAd maxRewardedAd = MaxRewardedAd.getInstance(adUnitId, getSdk(), getActivity());
            PlacementInfo placement = RewardUtil.getPlacement(new PlacementInfo(this.mRewardSource.get(), str2), this.mRewards, map, this.mSeparator);
            String str4 = placement.mName;
            ((EAMaxManagerBase) this).mLog.d("REWARDED_INTERSTITIAL.SHOW", Consts.KEY_TAPJOY_USER_ID_VERSION, str4, ShareConstants.FEED_SOURCE_PARAM, placement.mSource, "l", "max");
            Map createMap = Common.createMap();
            if (map != null) {
                String string = ConfigUtil.getString(map, Consts.MEDIATION_CUSTOM_DATA);
                if (!TextUtils.isEmpty(string)) {
                    createMap.put(Consts.KEY_NAME_GAMEDATA, string);
                }
            }
            if (!this.mSdkData.isEmpty()) {
                createMap.put(Consts.MEDIATION_CUSTOM_DATA, JsonUtil.toJson(this.mSdkData));
            }
            if (!createMap.isEmpty()) {
                str3 = GemsDataUtil.base64EncodeMap(createMap);
                ((EAMaxManagerBase) this).mLog.d("REWARDED_INTERSTITIAL.SHOW", nb.q, str2, "customParams", JsonUtil.toJson(createMap));
            }
            EAMaxManagerBase.EAMaxListener listenerForAdUnitId = getListenerForAdUnitId(adUnitId);
            if (listenerForAdUnitId != null) {
                listenerForAdUnitId.setShowingPlacement(str2);
            }
            if (isCrossPromo(adUnitId)) {
                ((EAMaxManagerBase) this).mLog.d("REWARDED_INTERSTITIAL.LOAD", Consts.KEY_TAPJOY_USER_ID_VERSION, str2, "placement", adUnitId, "adUnitID", "max");
            }
            maxRewardedAd.setRevenueListener(makeRevenueListener(str2, map, this.mSendImpressionData));
            maxRewardedAd.showAd(str4, str3);
            return;
        }
        sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_STARTED, new IllegalStateException("Not ready"), map);
    }
}