package com.unity3d.services;

import android.app.Activity;
import android.app.Application;
import android.content.Context;
import com.unity3d.ads.IUnityAdsInitializationListener;
import com.unity3d.ads.UnityAds;
import com.unity3d.services.core.configuration.EnvironmentCheck;
import com.unity3d.services.core.configuration.InitializeEventsMetricSender;
import com.unity3d.services.core.device.Device;
import com.unity3d.services.core.lifecycle.CachedLifecycle;
import com.unity3d.services.core.log.DeviceLog;
import com.unity3d.services.core.properties.ClientProperties;
import com.unity3d.services.core.properties.SdkProperties;
import com.unity3d.services.core.properties.Session;
import com.unity3d.services.core.request.metrics.InitMetric;
import kotlin.jvm.internal.Intrinsics;
import kotlin.text.StringsKt__StringNumberConversionsKt;

/* loaded from: classes4.dex */
public final class UnityServices {
    public static final UnityServices INSTANCE = new UnityServices();
    private static final boolean isSupported = true;

    public enum UnityServicesError {
        INVALID_ARGUMENT,
        INIT_SANITY_CHECK_FAIL
    }

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

        static {
            int[] iArr = new int[SdkProperties.InitializationState.values().length];
            try {
                iArr[SdkProperties.InitializationState.INITIALIZED_SUCCESSFULLY.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                iArr[SdkProperties.InitializationState.INITIALIZED_FAILED.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                iArr[SdkProperties.InitializationState.INITIALIZING.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            $EnumSwitchMapping$0 = iArr;
        }
    }

    public static /* synthetic */ void getDebugMode$annotations() {
    }

    public static /* synthetic */ void getVersion$annotations() {
    }

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

    public static final boolean isSupported() {
        return isSupported;
    }

    public static /* synthetic */ void isSupported$annotations() {
    }

    private UnityServices() {
    }

    public static final void initialize(Context context, String str, boolean z, IUnityAdsInitializationListener iUnityAdsInitializationListener) {
        Integer intOrNull;
        String str2;
        DeviceLog.entered();
        if (str != null) {
            intOrNull = StringsKt__StringNumberConversionsKt.toIntOrNull(str);
            if (intOrNull != null) {
                if (SdkProperties.getCurrentInitializationState() != SdkProperties.InitializationState.NOT_INITIALIZED) {
                    String gameId = ClientProperties.getGameId();
                    boolean isTestMode = SdkProperties.isTestMode();
                    StringBuilder sb = new StringBuilder();
                    if (gameId != null && !Intrinsics.areEqual(gameId, str)) {
                        InitializeEventsMetricSender.getInstance().sendMetric(InitMetric.newInitGameIdChanged(gameId, str));
                        sb.append(INSTANCE.createExpectedParametersString("Game ID", gameId, str));
                        Intrinsics.checkNotNullExpressionValue(sb, "append(value)");
                        sb.append('\n');
                        Intrinsics.checkNotNullExpressionValue(sb, "append('\\n')");
                    } else {
                        InitializeEventsMetricSender.getInstance().sendMetric(InitMetric.newInitGameIdSame(gameId, str));
                    }
                    if (isTestMode != z) {
                        InitializeEventsMetricSender.getInstance().sendMetric(InitMetric.newInitTestModeChanged(Boolean.valueOf(isTestMode), Boolean.valueOf(z)));
                        sb.append(INSTANCE.createExpectedParametersString("Test Mode", Boolean.valueOf(isTestMode), Boolean.valueOf(z)));
                        Intrinsics.checkNotNullExpressionValue(sb, "append(value)");
                        sb.append('\n');
                        Intrinsics.checkNotNullExpressionValue(sb, "append('\\n')");
                    } else {
                        InitializeEventsMetricSender.getInstance().sendMetric(InitMetric.newInitTestModeSame(Boolean.valueOf(isTestMode), Boolean.valueOf(z)));
                    }
                    String sb2 = sb.toString();
                    Intrinsics.checkNotNullExpressionValue(sb2, "StringBuilder().apply(builderAction).toString()");
                    if (sb2.length() > 0) {
                        str2 = "different parameters: \n" + sb2;
                    } else {
                        str2 = "the same Game ID: " + str + " and Test Mode: " + z + " values.";
                    }
                    DeviceLog.warning("Unity Ads SDK initialize has already been called with " + str2 + " Responding with first initialization result.");
                }
                SdkProperties.addInitializationListener(iUnityAdsInitializationListener);
                SdkProperties.InitializationState currentInitializationState = SdkProperties.getCurrentInitializationState();
                int i = currentInitializationState == null ? -1 : WhenMappings.$EnumSwitchMapping$0[currentInitializationState.ordinal()];
                if (i == 1) {
                    SdkProperties.notifyInitializationComplete();
                    return;
                }
                if (i != 2) {
                    if (i == 3) {
                        return;
                    } else {
                        SdkProperties.setInitializeState(SdkProperties.InitializationState.INITIALIZING);
                    }
                } else {
                    if (!UnityAdsSDK.INSTANCE.isAlternativeFlowEnabled()) {
                        SdkProperties.notifyInitializationFailed(UnityAds.UnityAdsInitializationError.INTERNAL_ERROR, "Unity Ads SDK failed to initialize due to previous failed reason");
                        return;
                    }
                    SdkProperties.setInitializeState(SdkProperties.InitializationState.INITIALIZING);
                }
                ClientProperties.setGameId(str);
                SdkProperties.setTestMode(z);
                if (!isSupported) {
                    DeviceLog.error("Error while initializing Unity Services: device is not supported");
                    SdkProperties.notifyInitializationFailed(UnityAds.UnityAdsInitializationError.INTERNAL_ERROR, "Unity Ads SDK failed to initialize due to device is not supported");
                    return;
                }
                SdkProperties.setInitializationTime(Device.getElapsedRealtime());
                SdkProperties.setInitializationTimeSinceEpoch(System.currentTimeMillis());
                if (str.length() == 0) {
                    DeviceLog.error("Error while initializing Unity Services: empty game ID, halting Unity Ads init");
                    SdkProperties.notifyInitializationFailed(UnityAds.UnityAdsInitializationError.INVALID_ARGUMENT, "Unity Ads SDK failed to initialize due to empty game ID");
                    return;
                }
                if (context == null) {
                    DeviceLog.error("Error while initializing Unity Services: null context, halting Unity Ads init");
                    SdkProperties.notifyInitializationFailed(UnityAds.UnityAdsInitializationError.INVALID_ARGUMENT, "Unity Ads SDK failed to initialize due to null context");
                    return;
                }
                if (context instanceof Application) {
                    ClientProperties.setApplication((Application) context);
                } else if (context instanceof Activity) {
                    Activity activity = (Activity) context;
                    if (activity.getApplication() != null) {
                        ClientProperties.setApplication(activity.getApplication());
                    } else {
                        DeviceLog.error("Error while initializing Unity Services: cannot retrieve application from context, halting Unity Ads init");
                        SdkProperties.notifyInitializationFailed(UnityAds.UnityAdsInitializationError.INVALID_ARGUMENT, "Unity Ads SDK failed to initialize due to inability to retrieve application from context");
                        return;
                    }
                } else {
                    DeviceLog.error("Error while initializing Unity Services: invalid context, halting Unity Ads init");
                    SdkProperties.notifyInitializationFailed(UnityAds.UnityAdsInitializationError.INVALID_ARGUMENT, "Unity Ads SDK failed to initialize due to invalid context");
                    return;
                }
                DeviceLog.info("Initializing Unity Services " + SdkProperties.getVersionName() + " (" + SdkProperties.getVersionCode() + ") with game id " + str + " in " + (z ? "test mode" : "production mode") + ", session " + Session.Default.getId());
                SdkProperties.setDebugMode(SdkProperties.getDebugMode());
                if (context.getApplicationContext() != null) {
                    ClientProperties.setApplicationContext(context.getApplicationContext());
                    if (!EnvironmentCheck.isEnvironmentOk()) {
                        DeviceLog.error("Error during Unity Services environment check, halting Unity Services init");
                        SdkProperties.notifyInitializationFailed(UnityAds.UnityAdsInitializationError.INTERNAL_ERROR, "Unity Ads SDK failed to initialize due to environment check failed");
                        return;
                    } else {
                        DeviceLog.info("Unity Services environment check OK");
                        CachedLifecycle.register();
                        UnityAdsSDK.INSTANCE.initialize();
                        return;
                    }
                }
                DeviceLog.error("Error while initializing Unity Services: cannot retrieve application context, halting Unity Ads init");
                SdkProperties.notifyInitializationFailed(UnityAds.UnityAdsInitializationError.INVALID_ARGUMENT, "Unity Ads SDK failed to initialize due to inability to retrieve application context");
                return;
            }
        }
        if (iUnityAdsInitializationListener != null) {
            iUnityAdsInitializationListener.onInitializationFailed(UnityAds.UnityAdsInitializationError.INVALID_ARGUMENT, "gameId \"" + str + "\" should be a number.");
        }
    }

    public static final boolean isInitialized() {
        return SdkProperties.isInitialized();
    }

    public static final String getVersion() {
        String versionName = SdkProperties.getVersionName();
        Intrinsics.checkNotNullExpressionValue(versionName, "getVersionName()");
        return versionName;
    }

    public static final boolean getDebugMode() {
        return SdkProperties.getDebugMode();
    }

    public static final void setDebugMode(boolean z) {
        SdkProperties.setDebugMode(z);
    }

    private final String createExpectedParametersString(String str, Object obj, Object obj2) {
        return "- " + str + " Current: " + obj + " | Received: " + obj2;
    }
}