// 
// Decompiled by Procyon v0.6.0
// 

package io.sentry.util;

import io.sentry.hints.ApplyScopeData;
import io.sentry.hints.Backfillable;
import io.sentry.hints.Cached;
import io.sentry.ILogger;
import org.jetbrains.annotations.Nullable;
import io.sentry.hints.EventDropReason;
import org.jetbrains.annotations.NotNull;
import io.sentry.Hint;
import org.jetbrains.annotations.ApiStatus;

@ApiStatus.Internal
public final class HintUtils
{
    private HintUtils() {
    }
    
    public static void setIsFromHybridSdk(@NotNull final Hint hint, @NotNull final String sdkName) {
        if (sdkName.startsWith("sentry.javascript") || sdkName.startsWith("sentry.dart") || sdkName.startsWith("sentry.dotnet")) {
            hint.set("sentry:isFromHybridSdk", true);
        }
    }
    
    public static boolean isFromHybridSdk(@NotNull final Hint hint) {
        return Boolean.TRUE.equals(hint.getAs("sentry:isFromHybridSdk", Boolean.class));
    }
    
    public static void setEventDropReason(@NotNull final Hint hint, @NotNull final EventDropReason eventDropReason) {
        hint.set("sentry:eventDropReason", eventDropReason);
    }
    
    @Nullable
    public static EventDropReason getEventDropReason(@NotNull final Hint hint) {
        return hint.getAs("sentry:eventDropReason", EventDropReason.class);
    }
    
    public static Hint createWithTypeCheckHint(final Object typeCheckHint) {
        final Hint hint = new Hint();
        setTypeCheckHint(hint, typeCheckHint);
        return hint;
    }
    
    public static void setTypeCheckHint(@NotNull final Hint hint, final Object typeCheckHint) {
        hint.set("sentry:typeCheckHint", typeCheckHint);
    }
    
    @Nullable
    public static Object getSentrySdkHint(@NotNull final Hint hint) {
        return hint.get("sentry:typeCheckHint");
    }
    
    public static boolean hasType(@NotNull final Hint hint, @NotNull final Class<?> clazz) {
        final Object sentrySdkHint = getSentrySdkHint(hint);
        return clazz.isInstance(sentrySdkHint);
    }
    
    public static <T> void runIfDoesNotHaveType(@NotNull final Hint hint, @NotNull final Class<T> clazz, final SentryNullableConsumer<Object> lambda) {
        runIfHasType(hint, clazz, ignored -> {}, (value, clazz2) -> lambda.accept(value));
    }
    
    public static <T> void runIfHasType(@NotNull final Hint hint, @NotNull final Class<T> clazz, final SentryConsumer<T> lambda) {
        runIfHasType(hint, clazz, lambda, (value, clazz2) -> {});
    }
    
    public static <T> void runIfHasTypeLogIfNot(@NotNull final Hint hint, @NotNull final Class<T> clazz, final ILogger logger, final SentryConsumer<T> lambda) {
        runIfHasType(hint, clazz, lambda, (sentrySdkHint, expectedClass) -> LogUtils.logNotInstanceOf(expectedClass, sentrySdkHint, logger));
    }
    
    public static <T> void runIfHasType(@NotNull final Hint hint, @NotNull final Class<T> clazz, final SentryConsumer<T> lambda, final SentryHintFallback fallbackLambda) {
        final Object sentrySdkHint = getSentrySdkHint(hint);
        if (hasType(hint, clazz) && sentrySdkHint != null) {
            lambda.accept((T)sentrySdkHint);
        }
        else {
            fallbackLambda.accept(sentrySdkHint, clazz);
        }
    }
    
    public static boolean shouldApplyScopeData(@NotNull final Hint hint) {
        return (!hasType(hint, Cached.class) && !hasType(hint, Backfillable.class)) || hasType(hint, ApplyScopeData.class);
    }
    
    @FunctionalInterface
    public interface SentryConsumer<T>
    {
        void accept(@NotNull final T p0);
    }
    
    @FunctionalInterface
    public interface SentryNullableConsumer<T>
    {
        void accept(@Nullable final T p0);
    }
    
    @FunctionalInterface
    public interface SentryHintFallback
    {
        void accept(@Nullable final Object p0, @NotNull final Class<?> p1);
    }
}