package com.vungle.ads.internal;

import android.content.Context;
import androidx.annotation.VisibleForTesting;
import androidx.core.content.PermissionChecker;
import com.vungle.ads.AnalyticsClient;
import com.vungle.ads.InitializationListener;
import com.vungle.ads.InvalidAppId;
import com.vungle.ads.NetworkPermissionsNotGranted;
import com.vungle.ads.OutOfMemory;
import com.vungle.ads.SdkVersionTooLow;
import com.vungle.ads.ServiceLocator;
import com.vungle.ads.VungleError;
import com.vungle.ads.internal.downloader.Downloader;
import com.vungle.ads.internal.executor.Executors;
import com.vungle.ads.internal.load.MraidJsLoader;
import com.vungle.ads.internal.model.ConfigPayload;
import com.vungle.ads.internal.network.VungleApiClient;
import com.vungle.ads.internal.persistence.FilePreferences;
import com.vungle.ads.internal.platform.Platform;
import com.vungle.ads.internal.privacy.PrivacyManager;
import com.vungle.ads.internal.signals.SignalManager;
import com.vungle.ads.internal.task.CleanupJob;
import com.vungle.ads.internal.task.JobRunner;
import com.vungle.ads.internal.task.ResendTpatJob;
import com.vungle.ads.internal.util.ActivityManager;
import com.vungle.ads.internal.util.Logger;
import com.vungle.ads.internal.util.PathProvider;
import com.vungle.ads.internal.util.ThreadUtil;
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicBoolean;
import kotlin.Lazy;
import kotlin.LazyKt__LazyJVMKt;
import kotlin.LazyThreadSafetyMode;
import kotlin.Unit;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.DefaultConstructorMarker;
import kotlin.jvm.internal.Intrinsics;
import kotlin.text.StringsKt__StringsJVMKt;

/* loaded from: classes4.dex */
public final class VungleInitializer {
    public static final Companion Companion = new Companion(null);
    private static final String TAG = "VungleInitializer";
    private AtomicBoolean isInitialized = new AtomicBoolean(false);
    private final CopyOnWriteArrayList<InitializationListener> initializationCallbackArray = new CopyOnWriteArrayList<>();

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

    public final AtomicBoolean isInitialized$vungle_ads_release() {
        return this.isInitialized;
    }

    public final void setInitialized$vungle_ads_release(AtomicBoolean atomicBoolean) {
        Intrinsics.checkNotNullParameter(atomicBoolean, "<set-?>");
        this.isInitialized = atomicBoolean;
    }

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

        private Companion() {
        }
    }

    public final void init(final String appId, final Context context, final InitializationListener initializationCallback) {
        Lazy lazy;
        Lazy lazy2;
        final Lazy lazy3;
        Intrinsics.checkNotNullParameter(appId, "appId");
        Intrinsics.checkNotNullParameter(context, "context");
        Intrinsics.checkNotNullParameter(initializationCallback, "initializationCallback");
        this.initializationCallbackArray.add(initializationCallback);
        ActivityManager.Companion.init(context);
        if (isAppIdInvalid(appId)) {
            onInitError(new InvalidAppId().logError$vungle_ads_release());
            return;
        }
        ServiceLocator.Companion companion = ServiceLocator.Companion;
        LazyThreadSafetyMode lazyThreadSafetyMode = LazyThreadSafetyMode.SYNCHRONIZED;
        lazy = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.VungleInitializer$init$$inlined$inject$1
            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
            {
                super(0);
            }

            /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.platform.Platform, java.lang.Object] */
            @Override // kotlin.jvm.functions.Function0
            public final Platform invoke() {
                return ServiceLocator.Companion.getInstance(context).getService(Platform.class);
            }
        });
        if (!m3868init$lambda0(lazy).isAtLeastMinimumSDK()) {
            Logger.Companion.e(TAG, "SDK is supported only for API versions 21 and above");
            onInitError(new SdkVersionTooLow().logError$vungle_ads_release());
            return;
        }
        ConfigManager.INSTANCE.setAppId$vungle_ads_release(appId);
        if (this.isInitialized.get()) {
            Logger.Companion.d(TAG, "init already complete");
            onInitSuccess();
        } else if (PermissionChecker.checkCallingOrSelfPermission(context, "android.permission.ACCESS_NETWORK_STATE") != 0 || PermissionChecker.checkCallingOrSelfPermission(context, "android.permission.INTERNET") != 0) {
            Logger.Companion.e(TAG, "Network permissions not granted");
            onInitError(new NetworkPermissionsNotGranted());
        } else {
            lazy2 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.VungleInitializer$init$$inlined$inject$2
                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                {
                    super(0);
                }

                /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.executor.Executors, java.lang.Object] */
                @Override // kotlin.jvm.functions.Function0
                public final Executors invoke() {
                    return ServiceLocator.Companion.getInstance(context).getService(Executors.class);
                }
            });
            lazy3 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.VungleInitializer$init$$inlined$inject$3
                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                {
                    super(0);
                }

                /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.network.VungleApiClient, java.lang.Object] */
                @Override // kotlin.jvm.functions.Function0
                public final VungleApiClient invoke() {
                    return ServiceLocator.Companion.getInstance(context).getService(VungleApiClient.class);
                }
            });
            m3869init$lambda1(lazy2).getBackgroundExecutor().execute(new Runnable() { // from class: com.vungle.ads.internal.VungleInitializer$$ExternalSyntheticLambda0
                @Override // java.lang.Runnable
                public final void run() {
                    VungleInitializer.m3871init$lambda3(context, appId, this, initializationCallback, lazy3);
                }
            }, new Runnable() { // from class: com.vungle.ads.internal.VungleInitializer$$ExternalSyntheticLambda1
                @Override // java.lang.Runnable
                public final void run() {
                    VungleInitializer.m3872init$lambda4(VungleInitializer.this);
                }
            });
        }
    }

    /* renamed from: init$lambda-0, reason: not valid java name */
    private static final Platform m3868init$lambda0(Lazy lazy) {
        return (Platform) lazy.getValue();
    }

    /* renamed from: init$lambda-1, reason: not valid java name */
    private static final Executors m3869init$lambda1(Lazy lazy) {
        return (Executors) lazy.getValue();
    }

    /* renamed from: init$lambda-2, reason: not valid java name */
    private static final VungleApiClient m3870init$lambda2(Lazy lazy) {
        return (VungleApiClient) lazy.getValue();
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* renamed from: init$lambda-3, reason: not valid java name */
    public static final void m3871init$lambda3(Context context, String appId, VungleInitializer this$0, InitializationListener initializationCallback, Lazy vungleApiClient$delegate) {
        Intrinsics.checkNotNullParameter(context, "$context");
        Intrinsics.checkNotNullParameter(appId, "$appId");
        Intrinsics.checkNotNullParameter(this$0, "this$0");
        Intrinsics.checkNotNullParameter(initializationCallback, "$initializationCallback");
        Intrinsics.checkNotNullParameter(vungleApiClient$delegate, "$vungleApiClient$delegate");
        PrivacyManager.INSTANCE.init(context);
        m3870init$lambda2(vungleApiClient$delegate).initialize(appId);
        this$0.configure(context, appId, initializationCallback);
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* renamed from: init$lambda-4, reason: not valid java name */
    public static final void m3872init$lambda4(VungleInitializer this$0) {
        Intrinsics.checkNotNullParameter(this$0, "this$0");
        this$0.onInitError(new OutOfMemory("Config: Out of Memory").logError$vungle_ads_release());
    }

    private final boolean isAppIdInvalid(String str) {
        return StringsKt__StringsJVMKt.isBlank(str);
    }

    private final void configure(final Context context, String str, InitializationListener initializationListener) {
        Lazy lazy;
        Lazy lazy2;
        boolean z;
        final Lazy lazy3;
        Lazy lazy4;
        Lazy lazy5;
        ServiceLocator.Companion companion = ServiceLocator.Companion;
        LazyThreadSafetyMode lazyThreadSafetyMode = LazyThreadSafetyMode.SYNCHRONIZED;
        lazy = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.VungleInitializer$configure$$inlined$inject$1
            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
            {
                super(0);
            }

            /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.network.VungleApiClient, java.lang.Object] */
            @Override // kotlin.jvm.functions.Function0
            public final VungleApiClient invoke() {
                return ServiceLocator.Companion.getInstance(context).getService(VungleApiClient.class);
            }
        });
        try {
            lazy2 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.VungleInitializer$configure$$inlined$inject$2
                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                {
                    super(0);
                }

                /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.persistence.FilePreferences, java.lang.Object] */
                @Override // kotlin.jvm.functions.Function0
                public final FilePreferences invoke() {
                    return ServiceLocator.Companion.getInstance(context).getService(FilePreferences.class);
                }
            });
            ConfigManager configManager = ConfigManager.INSTANCE;
            ConfigPayload cachedConfig = configManager.getCachedConfig(m3864configure$lambda6(lazy2), str);
            if (cachedConfig != null) {
                ConfigManager.initWithConfig$vungle_ads_release$default(configManager, context, cachedConfig, true, null, 8, null);
                z = true;
            } else {
                z = false;
            }
            lazy3 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.VungleInitializer$configure$$inlined$inject$3
                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                {
                    super(0);
                }

                /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.executor.Executors, java.lang.Object] */
                @Override // kotlin.jvm.functions.Function0
                public final Executors invoke() {
                    return ServiceLocator.Companion.getInstance(context).getService(Executors.class);
                }
            });
            lazy4 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.VungleInitializer$configure$$inlined$inject$4
                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                {
                    super(0);
                }

                /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.signals.SignalManager, java.lang.Object] */
                @Override // kotlin.jvm.functions.Function0
                public final SignalManager invoke() {
                    return ServiceLocator.Companion.getInstance(context).getService(SignalManager.class);
                }
            });
            AnalyticsClient.INSTANCE.init$vungle_ads_release(m3863configure$lambda5(lazy), m3865configure$lambda7(lazy3).getLoggerExecutor(), configManager.getLogLevel(), configManager.getMetricsEnabled(), m3866configure$lambda8(lazy4));
            try {
                this.isInitialized.set(true);
                onInitSuccess();
                Logger.Companion.d(TAG, "Running cleanup and resend tpat jobs. " + Thread.currentThread().getId());
                lazy5 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.VungleInitializer$configure$$inlined$inject$5
                    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                    {
                        super(0);
                    }

                    /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.task.JobRunner, java.lang.Object] */
                    @Override // kotlin.jvm.functions.Function0
                    public final JobRunner invoke() {
                        return ServiceLocator.Companion.getInstance(context).getService(JobRunner.class);
                    }
                });
                m3867configure$lambda9(lazy5).execute(CleanupJob.Companion.makeJobInfo$default(CleanupJob.Companion, null, 1, null));
                m3867configure$lambda9(lazy5).execute(ResendTpatJob.Companion.makeJobInfo());
                if (z) {
                    return;
                }
                configManager.fetchConfigAsync$vungle_ads_release(context, new Function1() { // from class: com.vungle.ads.internal.VungleInitializer$configure$1
                    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                    {
                        super(1);
                    }

                    @Override // kotlin.jvm.functions.Function1
                    public /* bridge */ /* synthetic */ Object invoke(Object obj) {
                        invoke(((Boolean) obj).booleanValue());
                        return Unit.INSTANCE;
                    }

                    /* renamed from: invoke$lambda-0, reason: not valid java name */
                    private static final PathProvider m3875invoke$lambda0(Lazy lazy6) {
                        return (PathProvider) lazy6.getValue();
                    }

                    public final void invoke(boolean z2) {
                        Lazy lazy6;
                        Lazy lazy7;
                        Executors m3865configure$lambda7;
                        if (z2) {
                            ServiceLocator.Companion companion2 = ServiceLocator.Companion;
                            final Context context2 = context;
                            LazyThreadSafetyMode lazyThreadSafetyMode2 = LazyThreadSafetyMode.SYNCHRONIZED;
                            lazy6 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode2, new Function0() { // from class: com.vungle.ads.internal.VungleInitializer$configure$1$invoke$$inlined$inject$1
                                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                                {
                                    super(0);
                                }

                                /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.util.PathProvider, java.lang.Object] */
                                @Override // kotlin.jvm.functions.Function0
                                public final PathProvider invoke() {
                                    return ServiceLocator.Companion.getInstance(context2).getService(PathProvider.class);
                                }
                            });
                            final Context context3 = context;
                            lazy7 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode2, new Function0() { // from class: com.vungle.ads.internal.VungleInitializer$configure$1$invoke$$inlined$inject$2
                                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                                {
                                    super(0);
                                }

                                /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.downloader.Downloader, java.lang.Object] */
                                @Override // kotlin.jvm.functions.Function0
                                public final Downloader invoke() {
                                    return ServiceLocator.Companion.getInstance(context3).getService(Downloader.class);
                                }
                            });
                            MraidJsLoader mraidJsLoader = MraidJsLoader.INSTANCE;
                            PathProvider m3875invoke$lambda0 = m3875invoke$lambda0(lazy6);
                            Downloader m3876invoke$lambda1 = m3876invoke$lambda1(lazy7);
                            m3865configure$lambda7 = VungleInitializer.m3865configure$lambda7(lazy3);
                            MraidJsLoader.downloadJs$default(mraidJsLoader, m3875invoke$lambda0, m3876invoke$lambda1, m3865configure$lambda7.getBackgroundExecutor(), null, 8, null);
                        }
                    }

                    /* renamed from: invoke$lambda-1, reason: not valid java name */
                    private static final Downloader m3876invoke$lambda1(Lazy lazy6) {
                        return (Downloader) lazy6.getValue();
                    }
                });
            } catch (Throwable th) {
                th = th;
                Logger.Companion.e(TAG, "Cannot get config", th);
            }
        } catch (Throwable th2) {
            th = th2;
        }
    }

    /* renamed from: configure$lambda-5, reason: not valid java name */
    private static final VungleApiClient m3863configure$lambda5(Lazy lazy) {
        return (VungleApiClient) lazy.getValue();
    }

    /* renamed from: configure$lambda-6, reason: not valid java name */
    private static final FilePreferences m3864configure$lambda6(Lazy lazy) {
        return (FilePreferences) lazy.getValue();
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* renamed from: configure$lambda-7, reason: not valid java name */
    public static final Executors m3865configure$lambda7(Lazy lazy) {
        return (Executors) lazy.getValue();
    }

    /* renamed from: configure$lambda-8, reason: not valid java name */
    private static final SignalManager m3866configure$lambda8(Lazy lazy) {
        return (SignalManager) lazy.getValue();
    }

    /* renamed from: configure$lambda-9, reason: not valid java name */
    private static final JobRunner m3867configure$lambda9(Lazy lazy) {
        return (JobRunner) lazy.getValue();
    }

    private final void onInitError(final VungleError vungleError) {
        ThreadUtil.INSTANCE.runOnUiThread(new Runnable() { // from class: com.vungle.ads.internal.VungleInitializer$$ExternalSyntheticLambda3
            @Override // java.lang.Runnable
            public final void run() {
                VungleInitializer.m3873onInitError$lambda11(VungleInitializer.this, vungleError);
            }
        });
        String localizedMessage = vungleError.getLocalizedMessage();
        if (localizedMessage == null) {
            localizedMessage = "Exception code is " + vungleError.getCode();
        }
        Logger.Companion.e(TAG, localizedMessage);
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* renamed from: onInitError$lambda-11, reason: not valid java name */
    public static final void m3873onInitError$lambda11(VungleInitializer this$0, VungleError exception) {
        Intrinsics.checkNotNullParameter(this$0, "this$0");
        Intrinsics.checkNotNullParameter(exception, "$exception");
        Logger.Companion.e(TAG, "onError");
        Iterator<T> it = this$0.initializationCallbackArray.iterator();
        while (it.hasNext()) {
            ((InitializationListener) it.next()).onError(exception);
        }
        this$0.initializationCallbackArray.clear();
    }

    private final void onInitSuccess() {
        Logger.Companion.d(TAG, "onSuccess " + Thread.currentThread().getId());
        ThreadUtil.INSTANCE.runOnUiThread(new Runnable() { // from class: com.vungle.ads.internal.VungleInitializer$$ExternalSyntheticLambda2
            @Override // java.lang.Runnable
            public final void run() {
                VungleInitializer.m3874onInitSuccess$lambda13(VungleInitializer.this);
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* renamed from: onInitSuccess$lambda-13, reason: not valid java name */
    public static final void m3874onInitSuccess$lambda13(VungleInitializer this$0) {
        Intrinsics.checkNotNullParameter(this$0, "this$0");
        Iterator<T> it = this$0.initializationCallbackArray.iterator();
        while (it.hasNext()) {
            ((InitializationListener) it.next()).onSuccess();
        }
        this$0.initializationCallbackArray.clear();
    }

    public final boolean isInitialized() {
        return this.isInitialized.get();
    }

    public final void deInit$vungle_ads_release() {
        ServiceLocator.Companion.deInit();
        VungleApiClient.Companion.reset$vungle_ads_release();
        this.isInitialized.set(false);
    }
}