package com.vungle.ads.internal;

import android.content.Context;
import com.vungle.ads.AdExpiredError;
import com.vungle.ads.AdExpiredOnPlayError;
import com.vungle.ads.AdMarkupInvalidError;
import com.vungle.ads.AdNotLoadedCantPlay;
import com.vungle.ads.AnalyticsClient;
import com.vungle.ads.ConcurrentPlaybackUnsupported;
import com.vungle.ads.InternalError;
import com.vungle.ads.InvalidAdStateError;
import com.vungle.ads.InvalidWaterfallPlacementError;
import com.vungle.ads.PlacementAdTypeMismatchError;
import com.vungle.ads.PlacementNotFoundError;
import com.vungle.ads.SdkNotInitialized;
import com.vungle.ads.ServiceLocator;
import com.vungle.ads.TimeIntervalMetric;
import com.vungle.ads.VungleAdSize;
import com.vungle.ads.VungleAds;
import com.vungle.ads.VungleError;
import com.vungle.ads.internal.AdInternal;
import com.vungle.ads.internal.downloader.Downloader;
import com.vungle.ads.internal.executor.SDKExecutors;
import com.vungle.ads.internal.load.AdLoaderCallback;
import com.vungle.ads.internal.load.AdRequest;
import com.vungle.ads.internal.load.BaseAdLoader;
import com.vungle.ads.internal.load.DefaultAdLoader;
import com.vungle.ads.internal.load.RealtimeAdLoader;
import com.vungle.ads.internal.model.AdPayload;
import com.vungle.ads.internal.model.BidPayload;
import com.vungle.ads.internal.model.Placement;
import com.vungle.ads.internal.network.TpatSender;
import com.vungle.ads.internal.network.VungleApiClient;
import com.vungle.ads.internal.omsdk.OMInjector;
import com.vungle.ads.internal.presenter.AdEventListener;
import com.vungle.ads.internal.presenter.AdPlayCallback;
import com.vungle.ads.internal.presenter.AdPlayCallbackWrapper;
import com.vungle.ads.internal.protos.Sdk;
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.ui.AdActivity;
import com.vungle.ads.internal.util.ActivityManager;
import com.vungle.ads.internal.util.Logger;
import com.vungle.ads.internal.util.PathProvider;
import java.lang.ref.WeakReference;
import java.util.List;
import kotlin.Lazy;
import kotlin.LazyKt__LazyJVMKt;
import kotlin.LazyThreadSafetyMode;
import kotlin.NoWhenBranchMatchedException;
import kotlin.NotImplementedError;
import kotlin.Unit;
import kotlin.collections.CollectionsKt__CollectionsKt;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.DefaultConstructorMarker;
import kotlin.jvm.internal.Intrinsics;
import kotlin.jvm.internal.Reflection;
import kotlinx.serialization.DeserializationStrategy;
import kotlinx.serialization.SerializersKt;
import kotlinx.serialization.StringFormat;
import kotlinx.serialization.json.Json;
import kotlinx.serialization.json.JsonBuilder;
import kotlinx.serialization.json.JsonKt;

/* loaded from: classes4.dex */
public abstract class AdInternal implements AdLoaderCallback {
    private static final String TAG = "AdInternal";
    private static final boolean THROW_ON_ILLEGAL_TRANSITION = false;
    private AdLoaderCallback adLoaderCallback;
    private AdState adState;
    private AdPayload advertisement;
    private BaseAdLoader baseAdLoader;
    private BidPayload bidPayload;
    private final Context context;
    private Placement placement;
    private WeakReference<Context> playContext;
    private TimeIntervalMetric requestMetric;
    private final Lazy signalManager$delegate;
    private final Lazy vungleApiClient$delegate;
    public static final Companion Companion = new Companion(null);
    private static final Json json = JsonKt.Json$default((Json) null, new Function1() { // from class: com.vungle.ads.internal.AdInternal$Companion$json$1
        @Override // kotlin.jvm.functions.Function1
        public /* bridge */ /* synthetic */ Object invoke(Object obj) {
            invoke((JsonBuilder) obj);
            return Unit.INSTANCE;
        }

        public final void invoke(JsonBuilder Json) {
            Intrinsics.checkNotNullParameter(Json, "$this$Json");
            Json.setIgnoreUnknownKeys(true);
            Json.setEncodeDefaults(true);
            Json.setExplicitNulls(false);
        }
    }, 1, (Object) null);

    public /* synthetic */ class WhenMappings {
        public static final /* synthetic */ int[] $EnumSwitchMapping$0;

        static {
            int[] iArr = new int[AdState.values().length];
            iArr[AdState.NEW.ordinal()] = 1;
            iArr[AdState.LOADING.ordinal()] = 2;
            iArr[AdState.READY.ordinal()] = 3;
            iArr[AdState.PLAYING.ordinal()] = 4;
            iArr[AdState.FINISHED.ordinal()] = 5;
            iArr[AdState.ERROR.ordinal()] = 6;
            $EnumSwitchMapping$0 = iArr;
        }
    }

    public void adLoadedAndUpdateConfigure$vungle_ads_release(AdPayload advertisement) {
        Intrinsics.checkNotNullParameter(advertisement, "advertisement");
    }

    public abstract VungleAdSize getAdSizeForAdRequest();

    public final AdState getAdState() {
        return this.adState;
    }

    public final AdPayload getAdvertisement() {
        return this.advertisement;
    }

    public final BidPayload getBidPayload() {
        return this.bidPayload;
    }

    public final Context getContext() {
        return this.context;
    }

    public final Placement getPlacement() {
        return this.placement;
    }

    public abstract boolean isValidAdSize(VungleAdSize vungleAdSize);

    public abstract boolean isValidAdTypeForPlacement(Placement placement);

    public final void setAdvertisement(AdPayload adPayload) {
        this.advertisement = adPayload;
    }

    public final void setBidPayload(BidPayload bidPayload) {
        this.bidPayload = bidPayload;
    }

    public final void setPlacement(Placement placement) {
        this.placement = placement;
    }

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

        private static /* synthetic */ void getJson$annotations() {
        }

        private Companion() {
        }
    }

    public AdInternal(final Context context) {
        Lazy lazy;
        Lazy lazy2;
        Intrinsics.checkNotNullParameter(context, "context");
        this.context = context;
        this.adState = AdState.NEW;
        ServiceLocator.Companion companion = ServiceLocator.Companion;
        LazyThreadSafetyMode lazyThreadSafetyMode = LazyThreadSafetyMode.SYNCHRONIZED;
        lazy = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.AdInternal$special$$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);
            }
        });
        this.vungleApiClient$delegate = lazy;
        lazy2 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.AdInternal$special$$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.signals.SignalManager, java.lang.Object] */
            @Override // kotlin.jvm.functions.Function0
            public final SignalManager invoke() {
                return ServiceLocator.Companion.getInstance(context).getService(SignalManager.class);
            }
        });
        this.signalManager$delegate = lazy2;
    }

    public final void setAdState(AdState value) {
        AdPayload adPayload;
        String eventId;
        Lazy lazy;
        Intrinsics.checkNotNullParameter(value, "value");
        if (value.isTerminalState() && (adPayload = this.advertisement) != null && (eventId = adPayload.eventId()) != null) {
            ServiceLocator.Companion companion = ServiceLocator.Companion;
            final Context context = this.context;
            lazy = LazyKt__LazyJVMKt.lazy(LazyThreadSafetyMode.SYNCHRONIZED, new Function0() { // from class: com.vungle.ads.internal.AdInternal$_set_adState_$lambda-1$$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.task.JobRunner, java.lang.Object] */
                @Override // kotlin.jvm.functions.Function0
                public final JobRunner invoke() {
                    return ServiceLocator.Companion.getInstance(context).getService(JobRunner.class);
                }
            });
            m3835_set_adState_$lambda1$lambda0(lazy).execute(CleanupJob.Companion.makeJobInfo(eventId));
        }
        this.adState = this.adState.transitionTo(value);
    }

    /* renamed from: _set_adState_$lambda-1$lambda-0, reason: not valid java name */
    private static final JobRunner m3835_set_adState_$lambda1$lambda0(Lazy lazy) {
        return (JobRunner) lazy.getValue();
    }

    private final VungleApiClient getVungleApiClient() {
        return (VungleApiClient) this.vungleApiClient$delegate.getValue();
    }

    private final SignalManager getSignalManager() {
        return (SignalManager) this.signalManager$delegate.getValue();
    }

    public static /* synthetic */ VungleError canPlayAd$default(AdInternal adInternal, boolean z, int i, Object obj) {
        if (obj != null) {
            throw new UnsupportedOperationException("Super calls with default arguments not supported in this target, function: canPlayAd");
        }
        if ((i & 1) != 0) {
            z = false;
        }
        return adInternal.canPlayAd(z);
    }

    public final VungleError canPlayAd(boolean z) {
        VungleError invalidAdStateError;
        AdPayload adPayload = this.advertisement;
        if (adPayload == null) {
            invalidAdStateError = new AdNotLoadedCantPlay();
        } else if (adPayload == null || !adPayload.hasExpired()) {
            AdState adState = this.adState;
            if (adState == AdState.PLAYING) {
                invalidAdStateError = new ConcurrentPlaybackUnsupported();
            } else {
                if (adState == AdState.READY) {
                    return null;
                }
                invalidAdStateError = new InvalidAdStateError(0, null, null, null, null, null, 63, null);
            }
        } else if (z) {
            invalidAdStateError = new AdExpiredOnPlayError();
        } else {
            invalidAdStateError = new AdExpiredError();
        }
        if (z) {
            Placement placement = this.placement;
            VungleError placementId$vungle_ads_release = invalidAdStateError.setPlacementId$vungle_ads_release(placement != null ? placement.getReferenceId() : null);
            AdPayload adPayload2 = this.advertisement;
            VungleError creativeId$vungle_ads_release = placementId$vungle_ads_release.setCreativeId$vungle_ads_release(adPayload2 != null ? adPayload2.getCreativeId() : null);
            AdPayload adPayload3 = this.advertisement;
            creativeId$vungle_ads_release.setEventId$vungle_ads_release(adPayload3 != null ? adPayload3.eventId() : null).logErrorNoReturnValue$vungle_ads_release();
        }
        return invalidAdStateError;
    }

    /* JADX WARN: Multi-variable type inference failed */
    public final void loadAd(String placementId, String str, AdLoaderCallback adLoaderCallback) {
        Lazy lazy;
        Lazy lazy2;
        Lazy lazy3;
        Lazy lazy4;
        int i;
        Intrinsics.checkNotNullParameter(placementId, "placementId");
        Intrinsics.checkNotNullParameter(adLoaderCallback, "adLoaderCallback");
        this.adLoaderCallback = adLoaderCallback;
        if (!VungleAds.Companion.isInitialized()) {
            adLoaderCallback.onFailure(new SdkNotInitialized());
            return;
        }
        ConfigManager configManager = ConfigManager.INSTANCE;
        Placement placement = configManager.getPlacement(placementId);
        if (placement != null) {
            this.placement = placement;
            if (!isValidAdTypeForPlacement(placement)) {
                adLoaderCallback.onFailure(new PlacementAdTypeMismatchError(placement.getReferenceId()).logError$vungle_ads_release());
                return;
            }
            if ((placement.getHeaderBidding() && (str == null || str.length() == 0)) || (!placement.getHeaderBidding() && str != null && str.length() != 0)) {
                adLoaderCallback.onFailure(new InvalidWaterfallPlacementError(placementId).logError$vungle_ads_release());
                return;
            }
        } else if (configManager.configLastValidatedTimestamp() != -1) {
            adLoaderCallback.onFailure(new PlacementNotFoundError(placementId).logError$vungle_ads_release());
            return;
        } else {
            Placement placement2 = new Placement(placementId, false, (String) null, 6, (DefaultConstructorMarker) null);
            this.placement = placement2;
            placement = placement2;
        }
        VungleAdSize adSizeForAdRequest = getAdSizeForAdRequest();
        String str2 = null;
        Object[] objArr = 0;
        Object[] objArr2 = 0;
        Object[] objArr3 = 0;
        if (!isValidAdSize(adSizeForAdRequest)) {
            adLoaderCallback.onFailure(new InternalError(VungleError.INVALID_SIZE, str2, 2, objArr3 == true ? 1 : 0));
            return;
        }
        AdState adState = this.adState;
        if (adState != AdState.NEW) {
            switch (WhenMappings.$EnumSwitchMapping$0[adState.ordinal()]) {
                case 1:
                    throw new NotImplementedError(objArr2 == true ? 1 : 0, 1, objArr == true ? 1 : 0);
                case 2:
                    i = 203;
                    break;
                case 3:
                    i = 204;
                    break;
                case 4:
                    i = 205;
                    break;
                case 5:
                    i = 202;
                    break;
                case 6:
                    i = 206;
                    break;
                default:
                    throw new NoWhenBranchMatchedException();
            }
            Sdk.SDKError.Reason codeToLoggableReason = VungleError.Companion.codeToLoggableReason(i);
            String str3 = this.adState + " state is incorrect for load";
            AdPayload adPayload = this.advertisement;
            String creativeId = adPayload != null ? adPayload.getCreativeId() : null;
            AdPayload adPayload2 = this.advertisement;
            adLoaderCallback.onFailure(new InvalidAdStateError(VungleError.INVALID_AD_STATE, codeToLoggableReason, str3, placementId, creativeId, adPayload2 != null ? adPayload2.eventId() : null).logError$vungle_ads_release());
            return;
        }
        TimeIntervalMetric timeIntervalMetric = new TimeIntervalMetric(Sdk.SDKMetric.SDKMetricType.AD_REQUEST_TO_CALLBACK_ADO_DURATION_MS);
        this.requestMetric = timeIntervalMetric;
        timeIntervalMetric.markStart();
        if (str != null && str.length() != 0) {
            try {
                StringFormat stringFormat = json;
                DeserializationStrategy serializer = SerializersKt.serializer(stringFormat.getSerializersModule(), Reflection.typeOf(BidPayload.class));
                Intrinsics.checkNotNull(serializer, "null cannot be cast to non-null type kotlinx.serialization.KSerializer<T of kotlinx.serialization.internal.Platform_commonKt.cast>");
                this.bidPayload = (BidPayload) stringFormat.decodeFromString(serializer, str);
            } catch (IllegalArgumentException e) {
                AnalyticsClient analyticsClient = AnalyticsClient.INSTANCE;
                String str4 = "Unable to decode payload into BidPayload object. Error: " + e.getLocalizedMessage();
                AdPayload adPayload3 = this.advertisement;
                analyticsClient.logError$vungle_ads_release(213, str4, (r13 & 4) != 0 ? null : placementId, (r13 & 8) != 0 ? null : null, (r13 & 16) != 0 ? null : adPayload3 != null ? adPayload3.eventId() : null);
                adLoaderCallback.onFailure(new AdMarkupInvalidError());
                return;
            } catch (Throwable th) {
                AnalyticsClient analyticsClient2 = AnalyticsClient.INSTANCE;
                String str5 = "Unable to decode payload into BidPayload object. Error: " + th.getLocalizedMessage();
                AdPayload adPayload4 = this.advertisement;
                analyticsClient2.logError$vungle_ads_release(209, str5, (r13 & 4) != 0 ? null : placementId, (r13 & 8) != 0 ? null : null, (r13 & 16) != 0 ? null : adPayload4 != null ? adPayload4.eventId() : null);
                adLoaderCallback.onFailure(new AdMarkupInvalidError());
                return;
            }
        }
        setAdState(AdState.LOADING);
        ServiceLocator.Companion companion = ServiceLocator.Companion;
        final Context context = this.context;
        LazyThreadSafetyMode lazyThreadSafetyMode = LazyThreadSafetyMode.SYNCHRONIZED;
        lazy = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.AdInternal$loadAd$$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.omsdk.OMInjector, java.lang.Object] */
            @Override // kotlin.jvm.functions.Function0
            public final OMInjector invoke() {
                return ServiceLocator.Companion.getInstance(context).getService(OMInjector.class);
            }
        });
        final Context context2 = this.context;
        lazy2 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.AdInternal$loadAd$$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.SDKExecutors, java.lang.Object] */
            @Override // kotlin.jvm.functions.Function0
            public final SDKExecutors invoke() {
                return ServiceLocator.Companion.getInstance(context2).getService(SDKExecutors.class);
            }
        });
        final Context context3 = this.context;
        lazy3 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.AdInternal$loadAd$$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.util.PathProvider, java.lang.Object] */
            @Override // kotlin.jvm.functions.Function0
            public final PathProvider invoke() {
                return ServiceLocator.Companion.getInstance(context3).getService(PathProvider.class);
            }
        });
        final Context context4 = this.context;
        lazy4 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.AdInternal$loadAd$$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.downloader.Downloader, java.lang.Object] */
            @Override // kotlin.jvm.functions.Function0
            public final Downloader invoke() {
                return ServiceLocator.Companion.getInstance(context4).getService(Downloader.class);
            }
        });
        if (str == null || str.length() == 0) {
            DefaultAdLoader defaultAdLoader = new DefaultAdLoader(this.context, getVungleApiClient(), m3837loadAd$lambda3(lazy2), m3836loadAd$lambda2(lazy), m3839loadAd$lambda5(lazy4), m3838loadAd$lambda4(lazy3), new AdRequest(placement, null, adSizeForAdRequest));
            this.baseAdLoader = defaultAdLoader;
            defaultAdLoader.loadAd(this);
        } else {
            RealtimeAdLoader realtimeAdLoader = new RealtimeAdLoader(this.context, getVungleApiClient(), m3837loadAd$lambda3(lazy2), m3836loadAd$lambda2(lazy), m3839loadAd$lambda5(lazy4), m3838loadAd$lambda4(lazy3), new AdRequest(placement, this.bidPayload, adSizeForAdRequest));
            this.baseAdLoader = realtimeAdLoader;
            realtimeAdLoader.loadAd(this);
        }
    }

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

    /* renamed from: loadAd$lambda-3, reason: not valid java name */
    private static final SDKExecutors m3837loadAd$lambda3(Lazy lazy) {
        return (SDKExecutors) lazy.getValue();
    }

    /* renamed from: loadAd$lambda-4, reason: not valid java name */
    private static final PathProvider m3838loadAd$lambda4(Lazy lazy) {
        return (PathProvider) lazy.getValue();
    }

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

    public final void cancelDownload$vungle_ads_release() {
        BaseAdLoader baseAdLoader = this.baseAdLoader;
        if (baseAdLoader != null) {
            baseAdLoader.cancel();
        }
    }

    public final void play(Context context, final AdPlayCallback adPlayCallback) {
        Intrinsics.checkNotNullParameter(adPlayCallback, "adPlayCallback");
        this.playContext = context != null ? new WeakReference<>(context) : null;
        VungleError canPlayAd = canPlayAd(true);
        if (canPlayAd != null) {
            adPlayCallback.onFailure(canPlayAd);
            if (isErrorTerminal$vungle_ads_release(canPlayAd.getCode())) {
                setAdState(AdState.ERROR);
                return;
            }
            return;
        }
        AdPayload adPayload = this.advertisement;
        if (adPayload == null) {
            return;
        }
        AdPlayCallbackWrapper adPlayCallbackWrapper = new AdPlayCallbackWrapper(adPlayCallback) { // from class: com.vungle.ads.internal.AdInternal$play$callbackWrapper$1
            @Override // com.vungle.ads.internal.presenter.AdPlayCallbackWrapper, com.vungle.ads.internal.presenter.AdPlayCallback
            public void onAdStart(String str) {
                this.setAdState(AdInternal.AdState.PLAYING);
                super.onAdStart(str);
            }

            @Override // com.vungle.ads.internal.presenter.AdPlayCallbackWrapper, com.vungle.ads.internal.presenter.AdPlayCallback
            public void onAdEnd(String str) {
                this.setAdState(AdInternal.AdState.FINISHED);
                super.onAdEnd(str);
            }

            @Override // com.vungle.ads.internal.presenter.AdPlayCallbackWrapper, com.vungle.ads.internal.presenter.AdPlayCallback
            public void onFailure(VungleError error) {
                Intrinsics.checkNotNullParameter(error, "error");
                this.setAdState(AdInternal.AdState.ERROR);
                super.onFailure(error);
            }
        };
        cancelDownload$vungle_ads_release();
        renderAd$vungle_ads_release(adPlayCallbackWrapper, adPayload);
    }

    public void renderAd$vungle_ads_release(final AdPlayCallback adPlayCallback, AdPayload advertisement) {
        Context context;
        Intrinsics.checkNotNullParameter(advertisement, "advertisement");
        AdActivity.Companion companion = AdActivity.Companion;
        final Placement placement = this.placement;
        companion.setEventListener$vungle_ads_release(new AdEventListener(adPlayCallback, placement) { // from class: com.vungle.ads.internal.AdInternal$renderAd$1
        });
        companion.setAdvertisement$vungle_ads_release(advertisement);
        companion.setBidPayload$vungle_ads_release(this.bidPayload);
        WeakReference<Context> weakReference = this.playContext;
        if (weakReference == null || (context = weakReference.get()) == null) {
            context = this.context;
        }
        Intrinsics.checkNotNullExpressionValue(context, "playContext?.get() ?: context");
        Placement placement2 = this.placement;
        if (placement2 == null) {
            return;
        }
        ActivityManager.Companion.startWhenForeground(context, null, companion.createIntent(context, placement2.getReferenceId(), advertisement.eventId()), null);
    }

    @Override // com.vungle.ads.internal.load.AdLoaderCallback
    public void onSuccess(AdPayload advertisement) {
        Lazy lazy;
        Lazy lazy2;
        Intrinsics.checkNotNullParameter(advertisement, "advertisement");
        this.advertisement = advertisement;
        setAdState(AdState.READY);
        adLoadedAndUpdateConfigure$vungle_ads_release(advertisement);
        AdLoaderCallback adLoaderCallback = this.adLoaderCallback;
        if (adLoaderCallback != null) {
            adLoaderCallback.onSuccess(advertisement);
        }
        TimeIntervalMetric timeIntervalMetric = this.requestMetric;
        if (timeIntervalMetric != null) {
            if (!advertisement.adLoadOptimizationEnabled()) {
                timeIntervalMetric.setMetricType(Sdk.SDKMetric.SDKMetricType.AD_REQUEST_TO_CALLBACK_DURATION_MS);
            }
            timeIntervalMetric.markEnd();
            AnalyticsClient analyticsClient = AnalyticsClient.INSTANCE;
            Placement placement = this.placement;
            AnalyticsClient.logMetric$vungle_ads_release$default(analyticsClient, timeIntervalMetric, placement != null ? placement.getReferenceId() : null, advertisement.getCreativeId(), advertisement.eventId(), (String) null, 16, (Object) null);
            long calculateIntervalDuration = timeIntervalMetric.calculateIntervalDuration();
            ServiceLocator.Companion companion = ServiceLocator.Companion;
            final Context context = this.context;
            LazyThreadSafetyMode lazyThreadSafetyMode = LazyThreadSafetyMode.SYNCHRONIZED;
            lazy = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.AdInternal$onSuccess$lambda-9$$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.executor.SDKExecutors, java.lang.Object] */
                @Override // kotlin.jvm.functions.Function0
                public final SDKExecutors invoke() {
                    return ServiceLocator.Companion.getInstance(context).getService(SDKExecutors.class);
                }
            });
            final Context context2 = this.context;
            lazy2 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.AdInternal$onSuccess$lambda-9$$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.util.PathProvider, java.lang.Object] */
                @Override // kotlin.jvm.functions.Function0
                public final PathProvider invoke() {
                    return ServiceLocator.Companion.getInstance(context2).getService(PathProvider.class);
                }
            });
            List tpatUrls$default = AdPayload.getTpatUrls$default(advertisement, Constants.AD_LOAD_DURATION_TPAT_KEY, String.valueOf(calculateIntervalDuration), null, 4, null);
            if (tpatUrls$default != null) {
                new TpatSender(getVungleApiClient(), advertisement.placementId(), advertisement.getCreativeId(), advertisement.eventId(), m3840onSuccess$lambda9$lambda6(lazy).getIoExecutor(), m3841onSuccess$lambda9$lambda7(lazy2), getSignalManager()).sendTpats(tpatUrls$default, m3840onSuccess$lambda9$lambda6(lazy).getJobExecutor());
            }
        }
    }

    /* renamed from: onSuccess$lambda-9$lambda-6, reason: not valid java name */
    private static final SDKExecutors m3840onSuccess$lambda9$lambda6(Lazy lazy) {
        return (SDKExecutors) lazy.getValue();
    }

    /* renamed from: onSuccess$lambda-9$lambda-7, reason: not valid java name */
    private static final PathProvider m3841onSuccess$lambda9$lambda7(Lazy lazy) {
        return (PathProvider) lazy.getValue();
    }

    @Override // com.vungle.ads.internal.load.AdLoaderCallback
    public void onFailure(VungleError error) {
        Intrinsics.checkNotNullParameter(error, "error");
        setAdState(AdState.ERROR);
        AdLoaderCallback adLoaderCallback = this.adLoaderCallback;
        if (adLoaderCallback != null) {
            adLoaderCallback.onFailure(error);
        }
    }

    public final boolean isErrorTerminal$vungle_ads_release(int i) {
        return this.adState == AdState.READY && i == 304;
    }

    /* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
    /* JADX WARN: Unknown enum class pattern. Please report as an issue! */
    public static final class AdState {
        public static final AdState NEW = new NEW("NEW", 0);
        public static final AdState LOADING = new LOADING("LOADING", 1);
        public static final AdState READY = new READY("READY", 2);
        public static final AdState PLAYING = new PLAYING("PLAYING", 3);
        public static final AdState FINISHED = new FINISHED("FINISHED", 4);
        public static final AdState ERROR = new ERROR("ERROR", 5);
        private static final /* synthetic */ AdState[] $VALUES = $values();

        private static final /* synthetic */ AdState[] $values() {
            return new AdState[]{NEW, LOADING, READY, PLAYING, FINISHED, ERROR};
        }

        public /* synthetic */ AdState(String str, int i, DefaultConstructorMarker defaultConstructorMarker) {
            this(str, i);
        }

        public static AdState valueOf(String str) {
            return (AdState) Enum.valueOf(AdState.class, str);
        }

        public static AdState[] values() {
            return (AdState[]) $VALUES.clone();
        }

        public abstract boolean canTransitionTo(AdState adState);

        public static final class NEW extends AdState {
            @Override // com.vungle.ads.internal.AdInternal.AdState
            public boolean canTransitionTo(AdState adState) {
                Intrinsics.checkNotNullParameter(adState, "adState");
                return adState == AdState.LOADING || adState == AdState.READY || adState == AdState.ERROR;
            }

            public NEW(String str, int i) {
                super(str, i, null);
            }
        }

        private AdState(String str, int i) {
        }

        public static final class LOADING extends AdState {
            @Override // com.vungle.ads.internal.AdInternal.AdState
            public boolean canTransitionTo(AdState adState) {
                Intrinsics.checkNotNullParameter(adState, "adState");
                return adState == AdState.READY || adState == AdState.ERROR;
            }

            public LOADING(String str, int i) {
                super(str, i, null);
            }
        }

        public static final class READY extends AdState {
            @Override // com.vungle.ads.internal.AdInternal.AdState
            public boolean canTransitionTo(AdState adState) {
                Intrinsics.checkNotNullParameter(adState, "adState");
                return adState == AdState.PLAYING || adState == AdState.FINISHED || adState == AdState.ERROR;
            }

            public READY(String str, int i) {
                super(str, i, null);
            }
        }

        public static final class PLAYING extends AdState {
            @Override // com.vungle.ads.internal.AdInternal.AdState
            public boolean canTransitionTo(AdState adState) {
                Intrinsics.checkNotNullParameter(adState, "adState");
                return adState == AdState.FINISHED || adState == AdState.ERROR;
            }

            public PLAYING(String str, int i) {
                super(str, i, null);
            }
        }

        public static final class FINISHED extends AdState {
            @Override // com.vungle.ads.internal.AdInternal.AdState
            public boolean canTransitionTo(AdState adState) {
                Intrinsics.checkNotNullParameter(adState, "adState");
                return false;
            }

            public FINISHED(String str, int i) {
                super(str, i, null);
            }
        }

        public static final class ERROR extends AdState {
            @Override // com.vungle.ads.internal.AdInternal.AdState
            public boolean canTransitionTo(AdState adState) {
                Intrinsics.checkNotNullParameter(adState, "adState");
                return adState == AdState.FINISHED;
            }

            public ERROR(String str, int i) {
                super(str, i, null);
            }
        }

        public final AdState transitionTo(AdState adState) {
            Intrinsics.checkNotNullParameter(adState, "adState");
            if (this != adState && !canTransitionTo(adState)) {
                String str = "Cannot transition from " + name() + " to " + adState.name();
                if (AdInternal.THROW_ON_ILLEGAL_TRANSITION) {
                    throw new IllegalStateException(str);
                }
                Logger.Companion.e(AdInternal.TAG, "Illegal state transition", new IllegalStateException(str));
            }
            return adState;
        }

        public final boolean isTerminalState() {
            List listOf;
            listOf = CollectionsKt__CollectionsKt.listOf((Object[]) new AdState[]{FINISHED, ERROR});
            return listOf.contains(this);
        }
    }
}