package com.vungle.ads;

import android.annotation.SuppressLint;
import android.os.Build;
import androidx.annotation.VisibleForTesting;
import androidx.annotation.WorkerThread;
import com.ironsource.v8;
import com.vungle.ads.internal.executor.VungleThreadPoolExecutor;
import com.vungle.ads.internal.network.VungleApiClient;
import com.vungle.ads.internal.protos.Sdk;
import com.vungle.ads.internal.signals.SignalManager;
import com.vungle.ads.internal.util.ActivityManager;
import com.vungle.ads.internal.util.Logger;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import kotlin.jvm.internal.DefaultConstructorMarker;
import kotlin.jvm.internal.Intrinsics;

/* loaded from: classes4.dex */
public final class AnalyticsClient {
    public static final AnalyticsClient INSTANCE = new AnalyticsClient();
    private static final String TAG;
    private static final BlockingQueue<Sdk.SDKError.Builder> errors;
    private static VungleThreadPoolExecutor executor = null;
    private static LogLevel logLevel = null;
    private static final int maxBatchSize = 20;
    private static final BlockingQueue<Sdk.SDKMetric.Builder> metrics;
    private static boolean metricsEnabled = false;
    private static boolean paused = false;
    private static final BlockingQueue<Sdk.SDKError.Builder> pendingErrors;
    private static final BlockingQueue<Sdk.SDKMetric.Builder> pendingMetrics;
    private static boolean refreshEnabled = false;
    private static final long refreshTimeMillis = 5000;

    @SuppressLint({"StaticFieldLeak"})
    private static SignalManager signalManager;
    private static VungleApiClient vungleApiClient;

    public interface RequestListener {
        void onFailure();

        void onSuccess();
    }

    @VisibleForTesting
    public static /* synthetic */ void getErrors$vungle_ads_release$annotations() {
    }

    @VisibleForTesting
    public static /* synthetic */ void getExecutor$vungle_ads_release$annotations() {
    }

    @VisibleForTesting
    public static /* synthetic */ void getMetrics$vungle_ads_release$annotations() {
    }

    @VisibleForTesting
    public static /* synthetic */ void getMetricsEnabled$vungle_ads_release$annotations() {
    }

    @VisibleForTesting
    public static /* synthetic */ void getPendingErrors$vungle_ads_release$annotations() {
    }

    @VisibleForTesting
    public static /* synthetic */ void getPendingMetrics$vungle_ads_release$annotations() {
    }

    @VisibleForTesting
    public static /* synthetic */ void getRefreshEnabled$vungle_ads_release$annotations() {
    }

    @VisibleForTesting
    public static /* synthetic */ void getSignalManager$vungle_ads_release$annotations() {
    }

    @VisibleForTesting
    public static /* synthetic */ void getVungleApiClient$vungle_ads_release$annotations() {
    }

    public final BlockingQueue<Sdk.SDKError.Builder> getErrors$vungle_ads_release() {
        return errors;
    }

    public final VungleThreadPoolExecutor getExecutor$vungle_ads_release() {
        return executor;
    }

    public final BlockingQueue<Sdk.SDKMetric.Builder> getMetrics$vungle_ads_release() {
        return metrics;
    }

    public final boolean getMetricsEnabled$vungle_ads_release() {
        return metricsEnabled;
    }

    public final BlockingQueue<Sdk.SDKError.Builder> getPendingErrors$vungle_ads_release() {
        return pendingErrors;
    }

    public final BlockingQueue<Sdk.SDKMetric.Builder> getPendingMetrics$vungle_ads_release() {
        return pendingMetrics;
    }

    public final boolean getRefreshEnabled$vungle_ads_release() {
        return refreshEnabled;
    }

    public final SignalManager getSignalManager$vungle_ads_release() {
        return signalManager;
    }

    public final VungleApiClient getVungleApiClient$vungle_ads_release() {
        return vungleApiClient;
    }

    public final void pause() {
        paused = true;
    }

    public final void resume() {
        paused = false;
    }

    public final void setExecutor$vungle_ads_release(VungleThreadPoolExecutor vungleThreadPoolExecutor) {
        executor = vungleThreadPoolExecutor;
    }

    public final void setMetricsEnabled$vungle_ads_release(boolean z) {
        metricsEnabled = z;
    }

    public final void setRefreshEnabled$vungle_ads_release(boolean z) {
        refreshEnabled = z;
    }

    public final void setSignalManager$vungle_ads_release(SignalManager signalManager2) {
        signalManager = signalManager2;
    }

    public final void setVungleApiClient$vungle_ads_release(VungleApiClient vungleApiClient2) {
        vungleApiClient = vungleApiClient2;
    }

    private AnalyticsClient() {
    }

    public enum LogLevel {
        ERROR_LOG_LEVEL_OFF(0),
        ERROR_LOG_LEVEL_ERROR(1),
        ERROR_LOG_LEVEL_DEBUG(2);

        public static final Companion Companion = new Companion(null);
        private final int level;

        public final int getLevel() {
            return this.level;
        }

        LogLevel(int i) {
            this.level = i;
        }

        public static final class Companion {
            public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
                this();
            }

            private Companion() {
            }

            public final LogLevel fromValue(int i) {
                LogLevel logLevel = LogLevel.ERROR_LOG_LEVEL_DEBUG;
                if (i == logLevel.getLevel()) {
                    return logLevel;
                }
                LogLevel logLevel2 = LogLevel.ERROR_LOG_LEVEL_ERROR;
                if (i == logLevel2.getLevel()) {
                    return logLevel2;
                }
                LogLevel logLevel3 = LogLevel.ERROR_LOG_LEVEL_OFF;
                return i == logLevel3.getLevel() ? logLevel3 : logLevel2;
            }
        }
    }

    static {
        String simpleName = AnalyticsClient.class.getSimpleName();
        Intrinsics.checkNotNullExpressionValue(simpleName, "AnalyticsClient::class.java.simpleName");
        TAG = simpleName;
        errors = new LinkedBlockingQueue();
        metrics = new LinkedBlockingQueue();
        pendingErrors = new LinkedBlockingQueue();
        pendingMetrics = new LinkedBlockingQueue();
        logLevel = LogLevel.ERROR_LOG_LEVEL_ERROR;
        refreshEnabled = true;
    }

    public final void init$vungle_ads_release(VungleApiClient vungleApiClient2, final VungleThreadPoolExecutor executor2, int i, boolean z, SignalManager signalManager2) {
        Intrinsics.checkNotNullParameter(vungleApiClient2, "vungleApiClient");
        Intrinsics.checkNotNullParameter(executor2, "executor");
        Intrinsics.checkNotNullParameter(signalManager2, "signalManager");
        signalManager = signalManager2;
        executor = executor2;
        vungleApiClient = vungleApiClient2;
        try {
            BlockingQueue<Sdk.SDKError.Builder> blockingQueue = pendingErrors;
            if (!blockingQueue.isEmpty()) {
                blockingQueue.drainTo(errors);
            }
        } catch (Exception e) {
            Logger.Companion.e(TAG, "Failed to add pendingErrors to errors queue.", e);
        }
        try {
            BlockingQueue<Sdk.SDKMetric.Builder> blockingQueue2 = pendingMetrics;
            if (!blockingQueue2.isEmpty()) {
                blockingQueue2.drainTo(metrics);
            }
        } catch (Exception e2) {
            Logger.Companion.e(TAG, "Failed to add pendingMetrics to metrics queue.", e2);
        }
        if (refreshEnabled) {
            Executors.newSingleThreadScheduledExecutor().scheduleWithFixedDelay(new Runnable() { // from class: com.vungle.ads.AnalyticsClient$$ExternalSyntheticLambda1
                @Override // java.lang.Runnable
                public final void run() {
                    AnalyticsClient.m3780init$lambda1(VungleThreadPoolExecutor.this);
                }
            }, 0L, 5000L, TimeUnit.MILLISECONDS);
        }
        updateErrorLevelAndMetricEnabled$vungle_ads_release(i, z);
        if (i == LogLevel.ERROR_LOG_LEVEL_DEBUG.getLevel()) {
            Logger.Companion.enable(true);
        } else if (i == LogLevel.ERROR_LOG_LEVEL_ERROR.getLevel()) {
            Logger.Companion.enable(false);
        } else if (i == LogLevel.ERROR_LOG_LEVEL_OFF.getLevel()) {
            Logger.Companion.enable(false);
        }
        ActivityManager.Companion.addLifecycleListener(new ActivityManager.LifeCycleCallback() { // from class: com.vungle.ads.AnalyticsClient$init$2
            @Override // com.vungle.ads.internal.util.ActivityManager.LifeCycleCallback
            public void onResume() {
                super.onResume();
                AnalyticsClient.INSTANCE.resume();
            }

            @Override // com.vungle.ads.internal.util.ActivityManager.LifeCycleCallback
            public void onPause() {
                super.onPause();
                AnalyticsClient.INSTANCE.pause();
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* renamed from: init$lambda-1, reason: not valid java name */
    public static final void m3780init$lambda1(VungleThreadPoolExecutor executor2) {
        Intrinsics.checkNotNullParameter(executor2, "$executor");
        executor2.execute(new Runnable() { // from class: com.vungle.ads.AnalyticsClient$$ExternalSyntheticLambda0
            @Override // java.lang.Runnable
            public final void run() {
                AnalyticsClient.m3781init$lambda1$lambda0();
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* renamed from: init$lambda-1$lambda-0, reason: not valid java name */
    public static final void m3781init$lambda1$lambda0() {
        INSTANCE.report();
    }

    public final synchronized void updateErrorLevelAndMetricEnabled$vungle_ads_release(int i, boolean z) {
        logLevel = LogLevel.Companion.fromValue(i);
        metricsEnabled = z;
    }

    public final synchronized void logError$vungle_ads_release(final Sdk.SDKError.Reason reason, final String message, final String str, final String str2, final String str3) {
        VungleThreadPoolExecutor vungleThreadPoolExecutor;
        Intrinsics.checkNotNullParameter(reason, "reason");
        Intrinsics.checkNotNullParameter(message, "message");
        try {
            vungleThreadPoolExecutor = executor;
        } catch (Exception e) {
            Logger.Companion.e(TAG, "Cannot logError " + reason + ", " + message + ", " + str + ", " + str2 + ',' + str3, e);
        }
        if (vungleThreadPoolExecutor == null) {
            pendingErrors.put(genSDKError(reason, message, str, str2, str3));
        } else {
            if (vungleThreadPoolExecutor != null) {
                vungleThreadPoolExecutor.execute(new Runnable() { // from class: com.vungle.ads.AnalyticsClient$$ExternalSyntheticLambda2
                    @Override // java.lang.Runnable
                    public final void run() {
                        AnalyticsClient.m3782logError$lambda2(Sdk.SDKError.Reason.this, message, str, str2, str3);
                    }
                });
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* renamed from: logError$lambda-2, reason: not valid java name */
    public static final void m3782logError$lambda2(Sdk.SDKError.Reason reason, String message, String str, String str2, String str3) {
        Intrinsics.checkNotNullParameter(reason, "$reason");
        Intrinsics.checkNotNullParameter(message, "$message");
        INSTANCE.logErrorInSameThread(reason, message, str, str2, str3);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final Sdk.SDKError.Builder genSDKError(Sdk.SDKError.Reason reason, String str, String str2, String str3, String str4) {
        String uuid;
        Sdk.SDKError.Builder at = Sdk.SDKError.newBuilder().setOs(v8.d).setOsVersion(String.valueOf(Build.VERSION.SDK_INT)).setMake(Build.MANUFACTURER).setModel(Build.MODEL).setReason(reason).setMessage(str).setAt(System.currentTimeMillis());
        String str5 = "";
        if (str2 == null) {
            str2 = "";
        }
        Sdk.SDKError.Builder placementReferenceId = at.setPlacementReferenceId(str2);
        if (str3 == null) {
            str3 = "";
        }
        Sdk.SDKError.Builder creativeId = placementReferenceId.setCreativeId(str3);
        if (str4 == null) {
            str4 = "";
        }
        Sdk.SDKError.Builder eventId = creativeId.setEventId(str4);
        SignalManager signalManager2 = signalManager;
        if (signalManager2 != null && (uuid = signalManager2.getUuid()) != null) {
            str5 = uuid;
        }
        Sdk.SDKError.Builder sessionId = eventId.setSessionId(str5);
        Intrinsics.checkNotNullExpressionValue(sessionId, "newBuilder()\n           …ignalManager?.uuid ?: \"\")");
        return sessionId;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final synchronized void logErrorInSameThread(Sdk.SDKError.Reason reason, String str, String str2, String str3, String str4) {
        if (logLevel == LogLevel.ERROR_LOG_LEVEL_OFF) {
            return;
        }
        try {
            Sdk.SDKError.Builder genSDKError = genSDKError(reason, str, str2, str3, str4);
            BlockingQueue<Sdk.SDKError.Builder> blockingQueue = errors;
            blockingQueue.put(genSDKError);
            Logger.Companion.w(TAG, "Logging error: " + reason + " with message: " + str);
            if (blockingQueue.size() >= 20) {
                report();
            }
        } catch (Exception e) {
            Logger.Companion.e(TAG, "Cannot logError", e);
        }
    }

    public final synchronized void logError$vungle_ads_release(int i, String message, String str, String str2, String str3) {
        Intrinsics.checkNotNullParameter(message, "message");
        Sdk.SDKError.Reason forNumber = Sdk.SDKError.Reason.forNumber(i);
        Intrinsics.checkNotNullExpressionValue(forNumber, "forNumber(reasonCode)");
        logError$vungle_ads_release(forNumber, message, str, str2, str3);
    }

    public final synchronized void logMetric$vungle_ads_release(final Sdk.SDKMetric.SDKMetricType metricType, final long j, final String str, final String str2, final String str3, final String str4) {
        VungleThreadPoolExecutor vungleThreadPoolExecutor;
        Intrinsics.checkNotNullParameter(metricType, "metricType");
        try {
            vungleThreadPoolExecutor = executor;
        } catch (Exception e) {
            Logger.Companion.e(TAG, "Cannot logMetric " + metricType + ", " + j + ", " + str + ", " + str2 + ',' + str3 + ", " + str4, e);
        }
        if (vungleThreadPoolExecutor == null) {
            pendingMetrics.put(genMetric(metricType, j, str, str2, str3, str4));
        } else {
            if (vungleThreadPoolExecutor != null) {
                vungleThreadPoolExecutor.execute(new Runnable() { // from class: com.vungle.ads.AnalyticsClient$$ExternalSyntheticLambda3
                    @Override // java.lang.Runnable
                    public final void run() {
                        AnalyticsClient.m3783logMetric$lambda3(Sdk.SDKMetric.SDKMetricType.this, j, str, str2, str3, str4);
                    }
                });
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* renamed from: logMetric$lambda-3, reason: not valid java name */
    public static final void m3783logMetric$lambda3(Sdk.SDKMetric.SDKMetricType metricType, long j, String str, String str2, String str3, String str4) {
        Intrinsics.checkNotNullParameter(metricType, "$metricType");
        INSTANCE.logMetricInSameThread(metricType, j, str, str2, str3, str4);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final Sdk.SDKMetric.Builder genMetric(Sdk.SDKMetric.SDKMetricType sDKMetricType, long j, String str, String str2, String str3, String str4) {
        String uuid;
        Sdk.SDKMetric.Builder osVersion = Sdk.SDKMetric.newBuilder().setType(sDKMetricType).setValue(j).setMake(Build.MANUFACTURER).setModel(Build.MODEL).setOs(v8.d).setOsVersion(String.valueOf(Build.VERSION.SDK_INT));
        String str5 = "";
        if (str == null) {
            str = "";
        }
        Sdk.SDKMetric.Builder placementReferenceId = osVersion.setPlacementReferenceId(str);
        if (str2 == null) {
            str2 = "";
        }
        Sdk.SDKMetric.Builder creativeId = placementReferenceId.setCreativeId(str2);
        if (str3 == null) {
            str3 = "";
        }
        Sdk.SDKMetric.Builder eventId = creativeId.setEventId(str3);
        if (str4 == null) {
            str4 = "";
        }
        Sdk.SDKMetric.Builder meta = eventId.setMeta(str4);
        SignalManager signalManager2 = signalManager;
        if (signalManager2 != null && (uuid = signalManager2.getUuid()) != null) {
            str5 = uuid;
        }
        Sdk.SDKMetric.Builder sessionId = meta.setSessionId(str5);
        Intrinsics.checkNotNullExpressionValue(sessionId, "newBuilder()\n           …ignalManager?.uuid ?: \"\")");
        return sessionId;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final synchronized void logMetricInSameThread(Sdk.SDKMetric.SDKMetricType sDKMetricType, long j, String str, String str2, String str3, String str4) {
        if (metricsEnabled) {
            try {
                Sdk.SDKMetric.Builder genMetric = genMetric(sDKMetricType, j, str, str2, str3, str4);
                BlockingQueue<Sdk.SDKMetric.Builder> blockingQueue = metrics;
                blockingQueue.put(genMetric);
                Logger.Companion.d(TAG, "Logging Metric " + sDKMetricType + " with value " + j + " for placement " + str);
                if (blockingQueue.size() >= 20) {
                    report();
                }
            } catch (Exception e) {
                Logger.Companion.e(TAG, "Cannot logMetrics", e);
            }
        }
    }

    public final synchronized void logMetric$vungle_ads_release(Metric metric, String str, String str2, String str3, String str4) {
        try {
            Intrinsics.checkNotNullParameter(metric, "metric");
            Sdk.SDKMetric.SDKMetricType metricType = metric.getMetricType();
            long value = metric.getValue();
            if (str4 == null) {
                str4 = metric.getMeta();
            }
            logMetric$vungle_ads_release(metricType, value, str, str2, str3, str4);
        } catch (Throwable th) {
            throw th;
        }
    }

    public final synchronized void logMetric$vungle_ads_release(SingleValueMetric singleValueMetric, String str, String str2, String str3, String str4) {
        Intrinsics.checkNotNullParameter(singleValueMetric, "singleValueMetric");
        logMetric$vungle_ads_release((Metric) singleValueMetric, str, str2, str3, str4);
    }

    public static /* synthetic */ void logMetric$vungle_ads_release$default(AnalyticsClient analyticsClient, TimeIntervalMetric timeIntervalMetric, String str, String str2, String str3, String str4, int i, Object obj) {
        String str5 = (i & 2) != 0 ? null : str;
        String str6 = (i & 4) != 0 ? null : str2;
        String str7 = (i & 8) != 0 ? null : str3;
        if ((i & 16) != 0) {
            str4 = timeIntervalMetric.getMeta();
        }
        analyticsClient.logMetric$vungle_ads_release(timeIntervalMetric, str5, str6, str7, str4);
    }

    public final synchronized void logMetric$vungle_ads_release(TimeIntervalMetric timeIntervalMetric, String str, String str2, String str3, String str4) {
        Intrinsics.checkNotNullParameter(timeIntervalMetric, "timeIntervalMetric");
        logMetric$vungle_ads_release((Metric) timeIntervalMetric, str, str2, str3, str4);
    }

    public final synchronized void logMetric$vungle_ads_release(OneShotTimeIntervalMetric oneShotTimeIntervalMetric, String str, String str2, String str3, String str4) {
        Intrinsics.checkNotNullParameter(oneShotTimeIntervalMetric, "oneShotTimeIntervalMetric");
        if (!oneShotTimeIntervalMetric.isLogged()) {
            logMetric$vungle_ads_release((TimeIntervalMetric) oneShotTimeIntervalMetric, str, str2, str3, str4);
            oneShotTimeIntervalMetric.markLogged();
        }
    }

    private final synchronized void report() {
        try {
            if (paused) {
                return;
            }
            if (logLevel != LogLevel.ERROR_LOG_LEVEL_OFF && errors.size() > 0) {
                flushErrors();
            }
            if (metricsEnabled && metrics.size() > 0) {
                flushMetrics();
            }
        } catch (Throwable th) {
            throw th;
        }
    }

    @WorkerThread
    private final void flushMetrics() {
        VungleApiClient vungleApiClient2;
        Logger.Companion companion = Logger.Companion;
        String str = TAG;
        StringBuilder sb = new StringBuilder();
        sb.append("Sending ");
        BlockingQueue<Sdk.SDKMetric.Builder> blockingQueue = metrics;
        sb.append(blockingQueue.size());
        sb.append(" metrics");
        companion.d(str, sb.toString());
        final LinkedBlockingQueue linkedBlockingQueue = new LinkedBlockingQueue();
        blockingQueue.drainTo(linkedBlockingQueue);
        if (linkedBlockingQueue.isEmpty() || (vungleApiClient2 = vungleApiClient) == null) {
            return;
        }
        vungleApiClient2.reportMetrics(linkedBlockingQueue, new RequestListener() { // from class: com.vungle.ads.AnalyticsClient$flushMetrics$1
            @Override // com.vungle.ads.AnalyticsClient.RequestListener
            public void onSuccess() {
                String str2;
                Logger.Companion companion2 = Logger.Companion;
                str2 = AnalyticsClient.TAG;
                companion2.d(str2, "Sent " + linkedBlockingQueue.size() + " metrics");
            }

            @Override // com.vungle.ads.AnalyticsClient.RequestListener
            public void onFailure() {
                String str2;
                Logger.Companion companion2 = Logger.Companion;
                str2 = AnalyticsClient.TAG;
                companion2.d(str2, "Failed to send " + linkedBlockingQueue.size() + " metrics");
                AnalyticsClient.INSTANCE.getMetrics$vungle_ads_release().addAll(linkedBlockingQueue);
            }
        });
    }

    @WorkerThread
    private final void flushErrors() {
        VungleApiClient vungleApiClient2;
        Logger.Companion companion = Logger.Companion;
        String str = TAG;
        StringBuilder sb = new StringBuilder();
        sb.append("Sending ");
        BlockingQueue<Sdk.SDKError.Builder> blockingQueue = errors;
        sb.append(blockingQueue.size());
        sb.append(" errors");
        companion.d(str, sb.toString());
        final LinkedBlockingQueue linkedBlockingQueue = new LinkedBlockingQueue();
        blockingQueue.drainTo(linkedBlockingQueue);
        if (linkedBlockingQueue.isEmpty() || (vungleApiClient2 = vungleApiClient) == null) {
            return;
        }
        vungleApiClient2.reportErrors(linkedBlockingQueue, new RequestListener() { // from class: com.vungle.ads.AnalyticsClient$flushErrors$1
            @Override // com.vungle.ads.AnalyticsClient.RequestListener
            public void onSuccess() {
                String str2;
                Logger.Companion companion2 = Logger.Companion;
                str2 = AnalyticsClient.TAG;
                companion2.d(str2, "Sent " + linkedBlockingQueue.size() + " errors");
            }

            @Override // com.vungle.ads.AnalyticsClient.RequestListener
            public void onFailure() {
                String str2;
                Logger.Companion companion2 = Logger.Companion;
                str2 = AnalyticsClient.TAG;
                companion2.d(str2, "Failed to send " + linkedBlockingQueue.size() + " errors");
                AnalyticsClient.INSTANCE.getErrors$vungle_ads_release().addAll(linkedBlockingQueue);
            }
        });
    }
}