package csdk.gluads.ironsource;

import android.app.Activity;
import android.text.TextUtils;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.facebook.share.internal.ShareConstants;
import com.ironsource.mediationsdk.IronSource;
import com.ironsource.mediationsdk.adunit.adapter.utility.AdInfo;
import com.ironsource.mediationsdk.logger.IronSourceError;
import com.ironsource.mediationsdk.model.Placement;
import com.ironsource.mediationsdk.sdk.LevelPlayRewardedVideoListener;
import com.ironsource.nb;
import csdk.gluads.Consts;
import csdk.gluads.FrequencyController;
import csdk.gluads.GemsDataUtil;
import csdk.gluads.Reward;
import csdk.gluads.max.EAPlacementListener;
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.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicReference;

/* loaded from: classes4.dex */
public class EAIronSourceRVManager extends EAIronSourceManagerBase {
    private AtomicReference<String> mEncodedUserID;
    private AtomicReference<String> mGemsData;
    private boolean mIsLoadedIgnoreFrequencyCapping;
    private AtomicReference<RVListener> mListener;
    private final AtomicReference<String> mRewardSource;
    private final Map<String, Object> mRewards;
    private final String mSeparator;
    private boolean mShouldIgnoreGlobalFrequencyCapping;

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

    public class RVListener extends EAPlacementListener implements LevelPlayRewardedVideoListener {
        private final AtomicReference<FrequencyController> mFrequencyController;

        @Override // com.ironsource.mediationsdk.sdk.LevelPlayRewardedVideoListener
        public void onAdAvailable(AdInfo adInfo) {
        }

        @Override // com.ironsource.mediationsdk.sdk.LevelPlayRewardedVideoBaseListener
        public void onAdOpened(AdInfo adInfo) {
        }

        @Override // com.ironsource.mediationsdk.sdk.LevelPlayRewardedVideoListener
        public void onAdUnavailable() {
        }

        public RVListener(FrequencyController frequencyController) {
            this.mFrequencyController = new AtomicReference<>(frequencyController);
        }

        private FrequencyController frequencyController() {
            return this.mFrequencyController.get();
        }

        @Override // com.ironsource.mediationsdk.sdk.LevelPlayRewardedVideoBaseListener
        public void onAdClosed(AdInfo adInfo) {
            frequencyController().increaseCount(false, showingPlacement());
            EAIronSourceRVManager.this.sendPlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_SHOW_FINISHED, null, null);
            setShowingPlacement("");
        }

        @Override // com.ironsource.mediationsdk.sdk.LevelPlayRewardedVideoBaseListener
        public void onAdRewarded(Placement placement, AdInfo adInfo) {
            EAIronSourceRVManager.this.mLog.d("REWARDED_INTERSTITIAL.REWARD", nb.q, showingPlacement(), "reward", placement);
            if (placement == null) {
                EAIronSourceRVManager.this.sendReward("unknown", 0, showingPlacement());
            } else {
                EAIronSourceRVManager.this.sendReward(placement.getRewardName(), placement.getRewardAmount(), showingPlacement());
            }
        }

        @Override // com.ironsource.mediationsdk.sdk.LevelPlayRewardedVideoBaseListener
        public void onAdShowFailed(IronSourceError ironSourceError, AdInfo adInfo) {
            EAIronSourceRVManager.this.sendPlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_SHOW_FINISHED, new IllegalStateException("Failed to show ad: " + ironSourceError.toString()), null);
            setShowingPlacement("");
        }

        @Override // com.ironsource.mediationsdk.sdk.LevelPlayRewardedVideoBaseListener
        public void onAdClicked(Placement placement, AdInfo adInfo) {
            EAIronSourceRVManager.this.sendPlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_CLICKED, null, null);
        }
    }

    public EAIronSourceRVManager(Callable<Activity> callable, Map<String, String> map, Map<String, Object> map2, String str, Map<String, Object> map3, boolean z, boolean z2, boolean z3) {
        super(callable, map, map2, z);
        this.mGemsData = new AtomicReference<>();
        this.mEncodedUserID = new AtomicReference<>();
        this.mSeparator = str;
        ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap();
        this.mRewards = concurrentHashMap;
        AtomicReference<String> atomicReference = new AtomicReference<>("DEFAULT");
        this.mRewardSource = atomicReference;
        if (map3 != null) {
            synchronized (concurrentHashMap) {
                concurrentHashMap.putAll(map3);
            }
            atomicReference.set(map3.isEmpty() ? "DEFAULT" : "SDK (client)");
        }
        AtomicReference<RVListener> atomicReference2 = new AtomicReference<>(new RVListener(frequencyController()));
        this.mListener = atomicReference2;
        IronSource.setLevelPlayRewardedVideoListener(atomicReference2.get());
        this.mIsLoadedIgnoreFrequencyCapping = z2;
        this.mShouldIgnoreGlobalFrequencyCapping = z3;
        if (z3) {
            return;
        }
        frequencyController().enableGlobalFrequencyCapping();
    }

    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase
    public void setShowingPlacement(String str) {
        RVListener rVListener = this.mListener.get();
        if (rVListener != null) {
            rVListener.setShowingPlacement(str);
        }
        super.setShowingPlacement(str);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void sendReward(String str, int i, String str2) {
        listener().onRewardReceived(new Reward(Common.uuid(), str2, Consts.SDK_IRONSOURCE, adType(), str, i));
    }

    private boolean isCapped(@NonNull String str) {
        return frequencyController().isLimitReached(str) || IronSource.isRewardedVideoPlacementCapped(str);
    }

    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
    public void destroy() {
        IronSource.setLevelPlayRewardedVideoListener(null);
        super.destroy();
    }

    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, 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.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
        return IronSource.isRewardedVideoAvailable() && !TextUtils.isEmpty(this.mGemsData.get()) && (this.mIsLoadedIgnoreFrequencyCapping || !isCapped(str2));
    }

    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, 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.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
    public void internal_setGemsData(@Nullable String str, @Nullable Map<String, Object> map) {
        this.mLog.d("REWARDED_INTERSTITIAL.SET.GEMSDATA", Consts.KEY_TAPJOY_USER_ID_VERSION, str, "l", Consts.SDK_IRONSOURCE);
        if (str != null) {
            this.mGemsData.set(GemsDataUtil.base64Encode(str));
            String tryGetPlayerId = tryGetPlayerId(str);
            if (TextUtils.isEmpty(tryGetPlayerId)) {
                EAIronSource.setAdQualityUserID(str);
                return;
            }
            EAIronSource.setAdQualityUserID(tryGetPlayerId);
            Map createMap = Common.createMap();
            createMap.put("playerId", tryGetPlayerId);
            this.mEncodedUserID.set(GemsDataUtil.base64Encode(JsonUtil.toJson(createMap)));
        }
    }

    private String tryGetPlayerId(String str) {
        try {
            Map<String, Object> parseJsonObject = JsonUtil.parseJsonObject(str);
            if (parseJsonObject != null) {
                String string = ConfigUtil.getString(parseJsonObject, "playerId", "");
                if (!TextUtils.isEmpty(string)) {
                    return string;
                }
            }
        } catch (Throwable th) {
            this.mLog.d("REWARDED_INTERSTITIAL.TRYGETPLAYERID", "e", th, "l", Consts.SDK_IRONSOURCE);
        }
        return "";
    }

    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
    public void setUserIdentifier(@Nullable String str, @Nullable Map<String, Object> map) {
        if (TextUtils.isEmpty(str)) {
            return;
        }
        this.mGemsData.set(str);
        this.mEncodedUserID.set(str);
        String tryGetPlayerId = tryGetPlayerId(str);
        if (!TextUtils.isEmpty(tryGetPlayerId)) {
            str = tryGetPlayerId;
        }
        EAIronSource.setAdQualityUserID(str);
    }

    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
    public void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
        IllegalArgumentException illegalArgumentException;
        if (str2.equals("IS_debugger")) {
            IronSource.launchTestSuite(this.mActivity.getApplicationContext());
            return;
        }
        if (frequencyController().isLimitReached(str2)) {
            illegalArgumentException = new IllegalArgumentException("FrequencyCap limit.");
            if (frequencyController().isFreqCountRefreshRequired(str2)) {
                if (map == null) {
                    map = Common.createMap();
                }
                map.put(Consts.KEY_NAME_FREQUENCY_REFRESH, new Boolean(true));
            }
        } else {
            illegalArgumentException = TextUtils.isEmpty(this.mGemsData.get()) ? new IllegalArgumentException("GemsData is empty.") : !isLoaded(str, str2, map) ? new IllegalArgumentException("No ads available.") : null;
        }
        sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_LOAD_FINISHED, illegalArgumentException, map);
    }

    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
    public void show(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
        if (str2.equals("IS_debugger")) {
            IronSource.launchTestSuite(this.mActivity.getApplicationContext());
            return;
        }
        if (frequencyController().isLimitReached(str2)) {
            sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_STARTED, new IllegalArgumentException("FrequencyCap limit."), null);
            return;
        }
        if (!isLoaded(adType(), str2, map)) {
            sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_STARTED, new IllegalStateException("Not ready"), null);
            return;
        }
        Map createMap = Common.createMap();
        AtomicReference<String> atomicReference = this.mGemsData;
        if (atomicReference != null) {
            createMap.put(Consts.KEY_NAME_GEMSDATA, atomicReference.get());
        }
        if (map != null) {
            String string = ConfigUtil.getString(map, Consts.MEDIATION_CUSTOM_DATA);
            if (!TextUtils.isEmpty(string)) {
                createMap.put(Consts.KEY_NAME_GAMEDATA, GemsDataUtil.base64Encode(string));
            }
        }
        IronSource.clearRewardedVideoServerParameters();
        IronSource.setRewardedVideoServerParameters(createMap);
        String str3 = this.mEncodedUserID.get();
        if (str3.length() < 128) {
            IronSource.setDynamicUserId(str3);
        } else {
            this.mLog.d("REWARDED_INTERSTITIAL.SHOW", "e", "Dynamic user ID exceeds max length.", "l", Consts.SDK_IRONSOURCE);
        }
        sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_ATTEMPT, null, map);
        setShowingPlacement(str2);
        PlacementInfo placement = RewardUtil.getPlacement(new PlacementInfo(this.mRewardSource.get(), str2), this.mRewards, map, this.mSeparator);
        String str4 = placement.mName;
        this.mLog.d("REWARDED_INTERSTITIAL.SHOW", Consts.KEY_TAPJOY_USER_ID_VERSION, str4, ShareConstants.FEED_SOURCE_PARAM, placement.mSource, "l", Consts.SDK_IRONSOURCE);
        if (IronSource.getRewardedVideoPlacementInfo(str4) == null) {
            Exception exc = new Exception("No reward");
            this.mLog.e("REWARDED_INTERSTITIAL.SHOW.ERROR", nb.q, str2, "l", Consts.SDK_IRONSOURCE, "e", exc);
            sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_STARTED, exc, map);
        } else {
            this.mLog.d("REWARDED_INTERSTITIAL.SHOW", Consts.KEY_TAPJOY_USER_ID_VERSION, str4, "l", Consts.SDK_IRONSOURCE);
            IronSource.showRewardedVideo(str4);
        }
    }
}