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

package io.sentry.util;

import io.sentry.ILogger;
import io.sentry.NoOpLogger;
import io.sentry.TracesSamplingDecision;
import org.jetbrains.annotations.ApiStatus;
import java.util.Iterator;
import io.sentry.FilterString;
import io.sentry.IScope;
import io.sentry.Baggage;
import io.sentry.SpanContext;
import io.sentry.SentryTraceHeader;
import io.sentry.BaggageHeader;
import io.sentry.W3CTraceparentHeader;
import io.sentry.SentryOptions;
import io.sentry.ISpan;
import org.jetbrains.annotations.Nullable;
import java.util.List;
import io.sentry.PropagationContext;
import org.jetbrains.annotations.NotNull;
import io.sentry.IScopes;

public final class TracingUtils
{
    public static void startNewTrace(@NotNull final IScopes scopes) {
        scopes.configureScope(scope -> scope.withPropagationContext(propagationContext -> scope.setPropagationContext(new PropagationContext())));
    }
    
    public static void setTrace(@NotNull final IScopes scopes, @NotNull final PropagationContext propagationContext) {
        scopes.configureScope(scope -> scope.withPropagationContext(oldPropagationContext -> scope.setPropagationContext(propagationContext)));
    }
    
    @Nullable
    public static TracingHeaders traceIfAllowed(@NotNull final IScopes scopes, @NotNull final String requestUrl, @Nullable final List<String> thirdPartyBaggageHeaders, @Nullable final ISpan span) {
        final SentryOptions sentryOptions = scopes.getOptions();
        if (sentryOptions.isTraceSampling() && shouldAttachTracingHeaders(requestUrl, sentryOptions)) {
            return trace(scopes, thirdPartyBaggageHeaders, span);
        }
        return null;
    }
    
    @Nullable
    public static TracingHeaders trace(@NotNull final IScopes scopes, @Nullable final List<String> thirdPartyBaggageHeaders, @Nullable final ISpan span) {
        final SentryOptions sentryOptions = scopes.getOptions();
        if (span != null && !span.isNoOp()) {
            final SentryTraceHeader sentryTraceHeader = span.toSentryTrace();
            final BaggageHeader baggageHeader = span.toBaggageHeader(thirdPartyBaggageHeaders);
            W3CTraceparentHeader w3cTraceparentHeader = null;
            if (sentryOptions.isPropagateTraceparent()) {
                final SpanContext spanContext = span.getSpanContext();
                w3cTraceparentHeader = new W3CTraceparentHeader(spanContext.getTraceId(), spanContext.getSpanId(), sentryTraceHeader.isSampled());
            }
            return new TracingHeaders(sentryTraceHeader, baggageHeader, w3cTraceparentHeader);
        }
        final PropagationContextHolder returnValue = new PropagationContextHolder();
        scopes.configureScope(scope -> returnValue.propagationContext = maybeUpdateBaggage(scope, sentryOptions));
        if (returnValue.propagationContext != null) {
            final PropagationContext propagationContext = returnValue.propagationContext;
            final Baggage baggage = propagationContext.getBaggage();
            final BaggageHeader baggageHeader2 = BaggageHeader.fromBaggageAndOutgoingHeader(baggage, thirdPartyBaggageHeaders);
            final SentryTraceHeader sentryTraceHeader2 = new SentryTraceHeader(propagationContext.getTraceId(), propagationContext.getSpanId(), propagationContext.isSampled());
            W3CTraceparentHeader w3cTraceparentHeader2 = null;
            if (sentryOptions.isPropagateTraceparent()) {
                w3cTraceparentHeader2 = new W3CTraceparentHeader(propagationContext.getTraceId(), propagationContext.getSpanId(), propagationContext.isSampled());
            }
            return new TracingHeaders(sentryTraceHeader2, baggageHeader2, w3cTraceparentHeader2);
        }
        return null;
    }
    
    @NotNull
    public static PropagationContext maybeUpdateBaggage(@NotNull final IScope scope, @NotNull final SentryOptions sentryOptions) {
        return scope.withPropagationContext(propagationContext -> {
            final Baggage baggage = propagationContext.getBaggage();
            if (baggage.isMutable()) {
                baggage.setValuesFromScope(scope, sentryOptions);
                baggage.freeze();
            }
        });
    }
    
    private static boolean shouldAttachTracingHeaders(@NotNull final String requestUrl, @NotNull final SentryOptions sentryOptions) {
        return PropagationTargetsUtils.contain(sentryOptions.getTracePropagationTargets(), requestUrl);
    }
    
    @ApiStatus.Internal
    public static boolean isIgnored(@Nullable final List<FilterString> ignoredTransactions, @Nullable final String transactionName) {
        if (transactionName == null) {
            return false;
        }
        if (ignoredTransactions == null || ignoredTransactions.isEmpty()) {
            return false;
        }
        for (final FilterString ignoredTransaction : ignoredTransactions) {
            if (ignoredTransaction.getFilterString().equalsIgnoreCase(transactionName)) {
                return true;
            }
        }
        for (final FilterString ignoredTransaction : ignoredTransactions) {
            try {
                if (ignoredTransaction.matches(transactionName)) {
                    return true;
                }
                continue;
            }
            catch (final Throwable t) {}
        }
        return false;
    }
    
    @ApiStatus.Internal
    @NotNull
    public static Baggage ensureBaggage(@Nullable final Baggage incomingBaggage, @Nullable final TracesSamplingDecision decision) {
        final Boolean decisionSampled = (decision == null) ? null : decision.getSampled();
        final Double decisionSampleRate = (decision == null) ? null : decision.getSampleRate();
        final Double decisionSampleRand = (decision == null) ? null : decision.getSampleRand();
        return ensureBaggage(incomingBaggage, decisionSampled, decisionSampleRate, decisionSampleRand);
    }
    
    @ApiStatus.Internal
    @NotNull
    public static Baggage ensureBaggage(@Nullable final Baggage incomingBaggage, @Nullable final Boolean decisionSampled, @Nullable final Double decisionSampleRate, @Nullable final Double decisionSampleRand) {
        final Baggage baggage = (incomingBaggage == null) ? new Baggage(NoOpLogger.getInstance()) : incomingBaggage;
        if (baggage.getSampleRand() == null) {
            final Double baggageSampleRate = baggage.getSampleRate();
            final Double sampleRateMaybe = (baggageSampleRate == null) ? decisionSampleRate : baggageSampleRate;
            final Double sampleRand = SampleRateUtils.backfilledSampleRand(decisionSampleRand, sampleRateMaybe, decisionSampled);
            baggage.setSampleRand(sampleRand);
        }
        if (baggage.isMutable() && baggage.isShouldFreeze()) {
            baggage.freeze();
        }
        return baggage;
    }
    
    private static final class PropagationContextHolder
    {
        @Nullable
        private PropagationContext propagationContext;
        
        private PropagationContextHolder() {
            this.propagationContext = null;
        }
    }
    
    public static final class TracingHeaders
    {
        @NotNull
        private final SentryTraceHeader sentryTraceHeader;
        @Nullable
        private final BaggageHeader baggageHeader;
        @Nullable
        private final W3CTraceparentHeader w3cTraceparentHeader;
        
        public TracingHeaders(@NotNull final SentryTraceHeader sentryTraceHeader, @Nullable final BaggageHeader baggageHeader) {
            this.sentryTraceHeader = sentryTraceHeader;
            this.baggageHeader = baggageHeader;
            this.w3cTraceparentHeader = null;
        }
        
        public TracingHeaders(@NotNull final SentryTraceHeader sentryTraceHeader, @Nullable final BaggageHeader baggageHeader, @Nullable final W3CTraceparentHeader w3cTraceparentHeader) {
            this.sentryTraceHeader = sentryTraceHeader;
            this.baggageHeader = baggageHeader;
            this.w3cTraceparentHeader = w3cTraceparentHeader;
        }
        
        @NotNull
        public SentryTraceHeader getSentryTraceHeader() {
            return this.sentryTraceHeader;
        }
        
        @Nullable
        public BaggageHeader getBaggageHeader() {
            return this.baggageHeader;
        }
        
        @Nullable
        public W3CTraceparentHeader getW3cTraceparentHeader() {
            return this.w3cTraceparentHeader;
        }
    }
}