package csdk.gluads.max;

import android.app.Activity;
import android.text.TextUtils;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.webkit.ProxyConfig;
import com.applovin.mediation.MaxAd;
import com.applovin.mediation.MaxAdRevenueListener;
import com.applovin.sdk.AppLovinSdk;
import com.ironsource.nb;
import com.tapjoy.TapjoyConstants;
import csdk.gluads.Consts;
import csdk.gluads.FrequencyController;
import csdk.gluads.IAdvertising;
import csdk.gluads.IAdvertisingListener;
import csdk.gluads.PlacementEvent;
import csdk.gluads.PrivacyStatus;
import csdk.gluads.Reward;
import csdk.gluads.eventbus.GluAdsManagerEventHandler;
import csdk.gluads.impl.NullAdvertisingListener;
import csdk.gluads.util.Common;
import csdk.gluads.util.ConfigUtil;
import csdk.gluads.util.log.YLogger;
import csdk.gluads.util.log.YLoggerFactory;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicReference;

/* loaded from: classes4.dex */
public class EAMaxManagerBase extends GluAdsManagerEventHandler implements IAdvertising {
    static final String CROSSPROMO_PROVIDER = "APPLOVIN_DIRECTSOLD";
    private final Activity mActivity;
    private final Map<String, EAMaxListener> mAdUnitIdToListener;
    private Set<String> mCrossPromoLoaded;
    private final Map<String, String> mCrossPromotions;
    private final AtomicReference<String> mDefaultAddUnitId;
    private final AtomicReference<FrequencyController> mFrequencyController;
    private Map<String, Object> mImpressionMapping;
    protected boolean mIsDebug;
    private final AtomicReference<IAdvertisingListener> mListener;
    protected final YLogger mLog;
    private final Map<String, String> mPlacementToAdUnitId;
    private AppLovinSdk mSdk;
    final Set<String> testPlacementNames;

    public String adType() {
        return null;
    }

    @Override // csdk.gluads.IAdvertising
    public void destroy() {
    }

    @Override // csdk.gluads.IAdvertising
    public void discard(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
    }

    public Activity getActivity() {
        return this.mActivity;
    }

    @NonNull
    public Map<String, String> getCrossPromos() {
        return this.mCrossPromotions;
    }

    @NonNull
    public Map<String, Object> getImpressionMapping() {
        return this.mImpressionMapping;
    }

    @Override // csdk.gluads.IAdvertising
    public Reward getReward(@NonNull String str, @NonNull String str2) {
        return null;
    }

    @NonNull
    public AppLovinSdk getSdk() {
        return this.mSdk;
    }

    @Override // csdk.gluads.IAdvertising
    public void internal_setGemsData(@Nullable String str, @Nullable Map<String, Object> map) {
    }

    @Override // csdk.gluads.IAdvertising
    public void internal_updatePrivacyStatus(PrivacyStatus privacyStatus) {
    }

    @Override // csdk.gluads.IAdvertising
    public void internal_updateRewardList(@NonNull Map<String, Object> map) {
    }

    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
        return false;
    }

    public void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
    }

    @Override // csdk.gluads.IAdvertising
    public void onAdvertisementClick(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
    }

    @Override // csdk.gluads.IAdvertising
    public void onAdvertisementImpression(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
    }

    @Override // csdk.gluads.IAdvertising
    public void onPause() {
    }

    @Override // csdk.gluads.IAdvertising
    public void onResume() {
    }

    @Override // csdk.gluads.IAdvertising
    public void setCustomProperties(@Nullable Map<String, Object> map) {
    }

    @Override // csdk.gluads.IAdvertising
    public void setUserIdentifier(@Nullable String str, @Nullable Map<String, Object> map) {
    }

    public void show(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
    }

    public class EAMaxListener extends EAPlacementListener {
        final Map<String, Object> mExtra;
        private final List<String> mLoadingPlacements;

        public EAMaxListener() {
            Map<String, Object> createMap = Common.createMap();
            this.mExtra = createMap;
            createMap.put(Consts.MEDIATION_NETWORK, "max");
            this.mLoadingPlacements = new ArrayList();
        }

        public void addLoadingPlacement(String str) {
            synchronized (this.mLoadingPlacements) {
                try {
                    if (!this.mLoadingPlacements.contains(str)) {
                        this.mLoadingPlacements.add(str);
                    }
                } catch (Throwable th) {
                    throw th;
                }
            }
        }

        public void clearLoadingPlacements() {
            synchronized (this.mLoadingPlacements) {
                this.mLoadingPlacements.clear();
            }
        }

        public void sendLoadPlacementEvent(String str, Throwable th) {
            sendLoadPlacementEvent(str, th, null);
        }

        public void sendLoadPlacementEvent(String str, Throwable th, Map<String, Object> map) {
            synchronized (this.mLoadingPlacements) {
                try {
                    Iterator<String> it = this.mLoadingPlacements.iterator();
                    while (it.hasNext()) {
                        sendSinglePlacementEvent(it.next(), str, th, map);
                    }
                } catch (Throwable th2) {
                    throw th2;
                }
            }
        }

        public void sendSinglePlacementEvent(String str, String str2, Throwable th) {
            sendSinglePlacementEvent(str, str2, th, this.mExtra);
        }

        public void sendSinglePlacementEvent(String str, String str2, Throwable th, Map<String, Object> map) {
            EAMaxManagerBase.this.sendPlacementEvent(str, str2, th, map);
        }
    }

    public EAMaxManagerBase(String str, Callable<Activity> callable, Map<String, String> map, Map<String, Object> map2, boolean z) {
        super(str);
        this.testPlacementNames = new HashSet(Arrays.asList("admob", "applovin", "fyber", "facebook", "fan", "googleadmanager", "gam", "ironsource", Consts.SDK_MINTEGRAL, Consts.SDK_TAPJOY, TapjoyConstants.TJC_PLUGIN_UNITY, Consts.SDK_VUNGLE));
        this.mLog = YLoggerFactory.getLogger(getClass());
        this.mIsDebug = false;
        Activity activity = (Activity) Common.call(callable);
        this.mActivity = activity;
        this.mListener = new AtomicReference<>(NullAdvertisingListener.INSTANCE);
        this.mFrequencyController = new AtomicReference<>(new FrequencyController(str, activity.getApplicationContext(), map2));
        ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap();
        this.mPlacementToAdUnitId = concurrentHashMap;
        this.mAdUnitIdToListener = new ConcurrentHashMap();
        AtomicReference<String> atomicReference = new AtomicReference<>();
        this.mDefaultAddUnitId = atomicReference;
        this.mIsDebug = z;
        if (map != null) {
            String remove = map.remove(ProxyConfig.MATCH_ALL_SCHEMES);
            if (!TextUtils.isEmpty(remove)) {
                atomicReference.set(remove);
            }
            synchronized (concurrentHashMap) {
                concurrentHashMap.putAll(map);
            }
        }
        this.mImpressionMapping = new ConcurrentHashMap();
        this.mCrossPromotions = Collections.synchronizedMap(Common.createMap());
        this.mCrossPromoLoaded = Collections.newSetFromMap(new ConcurrentHashMap());
    }

    public EAMaxManagerBase(EAMaxManagerBase eAMaxManagerBase) {
        super(eAMaxManagerBase.adType());
        this.testPlacementNames = new HashSet(Arrays.asList("admob", "applovin", "fyber", "facebook", "fan", "googleadmanager", "gam", "ironsource", Consts.SDK_MINTEGRAL, Consts.SDK_TAPJOY, TapjoyConstants.TJC_PLUGIN_UNITY, Consts.SDK_VUNGLE));
        this.mLog = YLoggerFactory.getLogger(getClass());
        this.mIsDebug = false;
        this.mActivity = eAMaxManagerBase.mActivity;
        this.mListener = eAMaxManagerBase.mListener;
        this.mFrequencyController = eAMaxManagerBase.mFrequencyController;
        this.mPlacementToAdUnitId = eAMaxManagerBase.mPlacementToAdUnitId;
        this.mAdUnitIdToListener = eAMaxManagerBase.mAdUnitIdToListener;
        this.mDefaultAddUnitId = eAMaxManagerBase.mDefaultAddUnitId;
        this.mImpressionMapping = eAMaxManagerBase.mImpressionMapping;
        this.mCrossPromotions = eAMaxManagerBase.mCrossPromotions;
        this.mCrossPromoLoaded = eAMaxManagerBase.mCrossPromoLoaded;
    }

    public EAMaxManagerBase(@NonNull AppLovinSdk appLovinSdk, EAMaxManagerBase eAMaxManagerBase) {
        this(eAMaxManagerBase);
        this.mSdk = appLovinSdk;
    }

    public boolean isCapped(@NonNull String str) {
        return frequencyController().isLimitReached(str);
    }

    public void addListenerForAdUnitId(EAMaxListener eAMaxListener, String str) {
        synchronized (this.mAdUnitIdToListener) {
            this.mAdUnitIdToListener.put(str, eAMaxListener);
        }
    }

    public EAMaxListener getListenerForAdUnitId(String str) {
        EAMaxListener eAMaxListener;
        synchronized (this.mAdUnitIdToListener) {
            eAMaxListener = this.mAdUnitIdToListener.get(str);
        }
        return eAMaxListener;
    }

    public Boolean crossPromoMappingContains(String str) {
        return Boolean.valueOf(this.mCrossPromotions.values().contains(str));
    }

    public IAdvertisingListener listener() {
        return this.mListener.get();
    }

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

    public void setCrossPromoLoaded(String str) {
        this.mCrossPromoLoaded.add(str);
    }

    public boolean isCrossPromo(String str) {
        return this.mCrossPromoLoaded.contains(str);
    }

    public String getAdUnitId(String str, boolean z) {
        if (getCrossPromos().containsKey(str) && (!z || !isCrossPromoBlocked(str))) {
            String str2 = getCrossPromos().get(str);
            if (frequencyController().shouldShowCrossPromo(str) && !str2.isEmpty()) {
                return str2;
            }
        }
        String str3 = this.mPlacementToAdUnitId.get(str);
        return TextUtils.isEmpty(str3) ? this.mDefaultAddUnitId.get() : str3;
    }

    public String getAdUnitId(String str) {
        return getAdUnitId(str, true);
    }

    public MaxAdRevenueListener makeRevenueListener(final String str, @Nullable final Map<String, Object> map, final boolean z) {
        return new MaxAdRevenueListener() { // from class: csdk.gluads.max.EAMaxManagerBase.1
            @Override // com.applovin.mediation.MaxAdRevenueListener
            public void onAdRevenuePaid(MaxAd maxAd) {
                sendImpressionInternal(str, map, maxAd);
                sendImpressionSingular(str, maxAd);
            }

            private void sendImpressionInternal(String str2, @Nullable Map<String, Object> map2, MaxAd maxAd) {
                Map<String, Object> createMap = Common.createMap();
                if (map2 != null) {
                    createMap.putAll(map2);
                }
                if (z) {
                    createMap.put(Consts.SERVED_BY_NETWORK, maxAd.getNetworkName());
                    createMap.put(Consts.KEY_NAME_PUB_REVENUE, Double.valueOf(maxAd.getRevenue()));
                    createMap.put("precision", maxAd.getRevenuePrecision());
                    createMap.put("max_show_placement", maxAd.getPlacement());
                    if (!TextUtils.isEmpty(maxAd.getCreativeId())) {
                        createMap.put(Consts.CREATIVE_ID, maxAd.getCreativeId());
                    }
                    if (!TextUtils.isEmpty(maxAd.getAdUnitId())) {
                        createMap.put("adUnit", maxAd.getAdUnitId());
                    }
                    if (EAMaxManagerBase.this.isCrossPromo(maxAd.getAdUnitId())) {
                        if (!TextUtils.equals(maxAd.getNetworkName(), EAMaxManagerBase.CROSSPROMO_PROVIDER)) {
                            EAMaxManagerBase.this.mLog.d("Failed to load a cross promo, marking as regular ad", maxAd.getAdUnitId(), str2, "l", "max");
                            EAMaxManagerBase.this.mCrossPromoLoaded.remove(maxAd.getAdUnitId());
                        } else {
                            createMap.put(Consts.IS_CROSS_PROMO, 1);
                            Map<String, Object> map3 = ConfigUtil.getMap(EAMaxManagerBase.this.getImpressionMapping(), maxAd.getAdUnitId());
                            if (map3 != null) {
                                createMap.putAll(map3);
                            }
                        }
                    }
                }
                EAMaxManagerBase.this.sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_STARTED, null, createMap);
            }

            private void sendImpressionSingular(String str2, MaxAd maxAd) {
                if (z) {
                    Map<String, Object> createMap = Common.createMap();
                    createMap.put("ad_platform", "AppLovin");
                    createMap.put("ad_currency", "USD");
                    createMap.put("ad_revenue", Double.valueOf(maxAd.getRevenue()));
                    createMap.put("withAdUnitId", maxAd.getAdUnitId());
                    createMap.put("withNetworkName", maxAd.getNetworkName());
                    createMap.put("withAdType", maxAd.getFormat().getLabel());
                    EAMaxManagerBase.this.sendPlacementEvent(str2, Consts.SINGULAR_AD_REVENUE_REPORT, null, createMap);
                }
            }
        };
    }

    public void sendPlacementEvent(String str, String str2, Throwable th, Map<String, Object> map) {
        if (th == null && str2 == Consts.PLACEMENT_STATUS_LOAD_FINISHED && isCapped(str)) {
            th = new IllegalArgumentException("FrequencyCap limit.");
            if (frequencyController().isFreqCountRefreshRequired(str)) {
                if (map == null) {
                    map = Common.createMap();
                }
                map.put(Consts.KEY_NAME_FREQUENCY_REFRESH, new Boolean(true));
            }
        }
        internal_sendPlacementEvent(str, str2, th, map);
    }

    public void internal_sendPlacementEvent(String str, String str2, Throwable th, Map<String, Object> map) {
        if (th != null) {
            this.mLog.e(adType() + Consts.STRING_PERIOD + str2, nb.q, str, "l", "max", "error", th);
        } else {
            this.mLog.d(adType() + Consts.STRING_PERIOD + str2, nb.q, str, "l", "max", "extra", map);
        }
        if (map == null) {
            map = Common.createMap();
        }
        Map<String, Object> map2 = map;
        map2.put("network", "max");
        listener().onPlacementEvent(new PlacementEvent(adType(), str, str2, th, map2));
    }

    public boolean isTestPlacement(String str) {
        return this.testPlacementNames.contains(str.toLowerCase(Locale.US));
    }

    public String getTestNetwork(String str) {
        String lowerCase = str.toLowerCase(Locale.US);
        lowerCase.hashCode();
        switch (lowerCase) {
            case "googleadmanager":
            case "gam":
                return "GOOGLE_AD_MANAGER_NETWORK";
            case "ironsource":
                return "IRONSOURCE_NETWORK";
            case "tapjoy":
                return "TAPJOY_NETWORK";
            case "vungle":
                return "VUNGLE_NETWORK";
            case "fan":
            case "facebook":
                return "FACEBOOK_NETWORK";
            case "admob":
                return "ADMOB_NETWORK";
            case "fyber":
                return "FYBER_NETWORK";
            case "unity":
                return "UNITY_NETWORK";
            case "mintegral":
                return "MINTEGRAL_BIDDING";
            default:
                return "APPLOVIN_NETWORK";
        }
    }

    @Override // csdk.gluads.IAdvertising
    public void setAdvertisingListener(@Nullable IAdvertisingListener iAdvertisingListener) {
        AtomicReference<IAdvertisingListener> atomicReference = this.mListener;
        if (iAdvertisingListener == null) {
            iAdvertisingListener = NullAdvertisingListener.INSTANCE;
        }
        atomicReference.set(iAdvertisingListener);
    }

    @Override // csdk.gluads.IAdvertising
    public void internal_updateAdsFrequency(@NonNull Map<String, Object> map) {
        frequencyController().update(map);
    }

    @Override // csdk.gluads.IAdvertising
    public void internal_updateCrossPromotion(@NonNull String str, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2) {
        synchronized (this.mCrossPromotions) {
            this.mCrossPromotions.clear();
            this.mCrossPromotions.putAll(Common.mapSSFromConfig(map));
        }
        synchronized (this.mImpressionMapping) {
            try {
                this.mImpressionMapping.clear();
                Map<String, Object> map3 = this.mImpressionMapping;
                if (map3 != null) {
                    map3.putAll(map2);
                }
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    @Override // csdk.gluads.IAdvertising
    public void internal_onNewSession() {
        frequencyController().onNewSession();
    }
}