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

package io.sentry;

import io.sentry.featureflags.FeatureFlagBuffer;
import io.sentry.featureflags.IFeatureFlagBuffer;
import io.sentry.protocol.FeatureFlags;
import io.sentry.protocol.SentryId;
import org.jetbrains.annotations.ApiStatus;
import io.sentry.util.EventProcessorUtils;
import io.sentry.internal.eventprocessor.EventProcessorAndOrder;
import java.util.concurrent.CopyOnWriteArrayList;
import io.sentry.protocol.Contexts;
import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;
import java.util.Collections;
import java.util.Collection;
import java.util.ArrayList;
import java.util.Queue;
import java.util.List;
import io.sentry.protocol.Request;
import io.sentry.protocol.User;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.NotNull;

public final class CombinedScopeView implements IScope
{
    private final IScope globalScope;
    private final IScope isolationScope;
    private final IScope scope;
    
    public CombinedScopeView(@NotNull final IScope globalScope, @NotNull final IScope isolationScope, @NotNull final IScope scope) {
        this.globalScope = globalScope;
        this.isolationScope = isolationScope;
        this.scope = scope;
    }
    
    @Nullable
    @Override
    public SentryLevel getLevel() {
        final SentryLevel current = this.scope.getLevel();
        if (current != null) {
            return current;
        }
        final SentryLevel isolation = this.isolationScope.getLevel();
        if (isolation != null) {
            return isolation;
        }
        return this.globalScope.getLevel();
    }
    
    @Override
    public void setLevel(@Nullable final SentryLevel level) {
        this.getDefaultWriteScope().setLevel(level);
    }
    
    @Nullable
    @Override
    public String getTransactionName() {
        final String current = this.scope.getTransactionName();
        if (current != null) {
            return current;
        }
        final String isolation = this.isolationScope.getTransactionName();
        if (isolation != null) {
            return isolation;
        }
        return this.globalScope.getTransactionName();
    }
    
    @Override
    public void setTransaction(@NotNull final String transaction) {
        this.getDefaultWriteScope().setTransaction(transaction);
    }
    
    @Nullable
    @Override
    public ISpan getSpan() {
        final ISpan current = this.scope.getSpan();
        if (current != null) {
            return current;
        }
        final ISpan isolation = this.isolationScope.getSpan();
        if (isolation != null) {
            return isolation;
        }
        return this.globalScope.getSpan();
    }
    
    @Override
    public void setActiveSpan(@Nullable final ISpan span) {
        this.scope.setActiveSpan(span);
    }
    
    @Override
    public void setTransaction(@Nullable final ITransaction transaction) {
        this.getDefaultWriteScope().setTransaction(transaction);
    }
    
    @Nullable
    @Override
    public User getUser() {
        final User current = this.scope.getUser();
        if (current != null) {
            return current;
        }
        final User isolation = this.isolationScope.getUser();
        if (isolation != null) {
            return isolation;
        }
        return this.globalScope.getUser();
    }
    
    @Override
    public void setUser(@Nullable final User user) {
        this.getDefaultWriteScope().setUser(user);
    }
    
    @Nullable
    @Override
    public String getScreen() {
        final String current = this.scope.getScreen();
        if (current != null) {
            return current;
        }
        final String isolation = this.isolationScope.getScreen();
        if (isolation != null) {
            return isolation;
        }
        return this.globalScope.getScreen();
    }
    
    @Override
    public void setScreen(@Nullable final String screen) {
        this.getDefaultWriteScope().setScreen(screen);
    }
    
    @Nullable
    @Override
    public Request getRequest() {
        final Request current = this.scope.getRequest();
        if (current != null) {
            return current;
        }
        final Request isolation = this.isolationScope.getRequest();
        if (isolation != null) {
            return isolation;
        }
        return this.globalScope.getRequest();
    }
    
    @Override
    public void setRequest(@Nullable final Request request) {
        this.getDefaultWriteScope().setRequest(request);
    }
    
    @NotNull
    @Override
    public List<String> getFingerprint() {
        final List<String> current = this.scope.getFingerprint();
        if (!current.isEmpty()) {
            return current;
        }
        final List<String> isolation = this.isolationScope.getFingerprint();
        if (!isolation.isEmpty()) {
            return isolation;
        }
        return this.globalScope.getFingerprint();
    }
    
    @Override
    public void setFingerprint(@NotNull final List<String> fingerprint) {
        this.getDefaultWriteScope().setFingerprint(fingerprint);
    }
    
    @NotNull
    @Override
    public Queue<Breadcrumb> getBreadcrumbs() {
        final List<Breadcrumb> allBreadcrumbs = new ArrayList<Breadcrumb>();
        allBreadcrumbs.addAll(this.globalScope.getBreadcrumbs());
        allBreadcrumbs.addAll(this.isolationScope.getBreadcrumbs());
        allBreadcrumbs.addAll(this.scope.getBreadcrumbs());
        Collections.sort(allBreadcrumbs);
        final Queue<Breadcrumb> breadcrumbs = Scope.createBreadcrumbsList(this.scope.getOptions().getMaxBreadcrumbs());
        breadcrumbs.addAll((Collection<?>)allBreadcrumbs);
        return breadcrumbs;
    }
    
    @Override
    public void addBreadcrumb(@NotNull final Breadcrumb breadcrumb, @Nullable final Hint hint) {
        this.getDefaultWriteScope().addBreadcrumb(breadcrumb, hint);
    }
    
    @Override
    public void addBreadcrumb(@NotNull final Breadcrumb breadcrumb) {
        this.getDefaultWriteScope().addBreadcrumb(breadcrumb);
    }
    
    @Override
    public void clearBreadcrumbs() {
        this.getDefaultWriteScope().clearBreadcrumbs();
    }
    
    @Override
    public void clearTransaction() {
        this.getDefaultWriteScope().clearTransaction();
    }
    
    @Nullable
    @Override
    public ITransaction getTransaction() {
        final ITransaction current = this.scope.getTransaction();
        if (current != null) {
            return current;
        }
        final ITransaction isolation = this.isolationScope.getTransaction();
        if (isolation != null) {
            return isolation;
        }
        return this.globalScope.getTransaction();
    }
    
    @Override
    public void clear() {
        this.getDefaultWriteScope().clear();
    }
    
    @NotNull
    @Override
    public Map<String, String> getTags() {
        final Map<String, String> allTags = new ConcurrentHashMap<String, String>();
        allTags.putAll(this.globalScope.getTags());
        allTags.putAll(this.isolationScope.getTags());
        allTags.putAll(this.scope.getTags());
        return allTags;
    }
    
    @Override
    public void setTag(@Nullable final String key, @Nullable final String value) {
        this.getDefaultWriteScope().setTag(key, value);
    }
    
    @Override
    public void removeTag(@Nullable final String key) {
        this.getDefaultWriteScope().removeTag(key);
    }
    
    @NotNull
    @Override
    public Map<String, Object> getExtras() {
        final Map<String, Object> allTags = new ConcurrentHashMap<String, Object>();
        allTags.putAll(this.globalScope.getExtras());
        allTags.putAll(this.isolationScope.getExtras());
        allTags.putAll(this.scope.getExtras());
        return allTags;
    }
    
    @Override
    public void setExtra(@Nullable final String key, @Nullable final String value) {
        this.getDefaultWriteScope().setExtra(key, value);
    }
    
    @Override
    public void removeExtra(@Nullable final String key) {
        this.getDefaultWriteScope().removeExtra(key);
    }
    
    @NotNull
    @Override
    public Contexts getContexts() {
        return new CombinedContextsView(this.globalScope.getContexts(), this.isolationScope.getContexts(), this.scope.getContexts(), this.getOptions().getDefaultScopeType());
    }
    
    @Override
    public void setContexts(@Nullable final String key, @Nullable final Object value) {
        this.getDefaultWriteScope().setContexts(key, value);
    }
    
    @Override
    public void setContexts(@Nullable final String key, @Nullable final Boolean value) {
        this.getDefaultWriteScope().setContexts(key, value);
    }
    
    @Override
    public void setContexts(@Nullable final String key, @Nullable final String value) {
        this.getDefaultWriteScope().setContexts(key, value);
    }
    
    @Override
    public void setContexts(@Nullable final String key, @Nullable final Number value) {
        this.getDefaultWriteScope().setContexts(key, value);
    }
    
    @Override
    public void setContexts(@Nullable final String key, @Nullable final Collection<?> value) {
        this.getDefaultWriteScope().setContexts(key, value);
    }
    
    @Override
    public void setContexts(@Nullable final String key, @Nullable final Object[] value) {
        this.getDefaultWriteScope().setContexts(key, value);
    }
    
    @Override
    public void setContexts(@Nullable final String key, @Nullable final Character value) {
        this.getDefaultWriteScope().setContexts(key, value);
    }
    
    @Override
    public void removeContexts(@Nullable final String key) {
        this.getDefaultWriteScope().removeContexts(key);
    }
    
    @NotNull
    private IScope getDefaultWriteScope() {
        return this.getSpecificScope(null);
    }
    
    IScope getSpecificScope(@Nullable final ScopeType scopeType) {
        if (scopeType != null) {
            switch (scopeType) {
                case CURRENT: {
                    return this.scope;
                }
                case ISOLATION: {
                    return this.isolationScope;
                }
                case GLOBAL: {
                    return this.globalScope;
                }
                case COMBINED: {
                    return this;
                }
            }
        }
        switch (this.getOptions().getDefaultScopeType()) {
            case CURRENT: {
                return this.scope;
            }
            case ISOLATION: {
                return this.isolationScope;
            }
            case GLOBAL: {
                return this.globalScope;
            }
            default: {
                return this.scope;
            }
        }
    }
    
    @NotNull
    @Override
    public List<Attachment> getAttachments() {
        final List<Attachment> allAttachments = new CopyOnWriteArrayList<Attachment>();
        allAttachments.addAll(this.globalScope.getAttachments());
        allAttachments.addAll(this.isolationScope.getAttachments());
        allAttachments.addAll(this.scope.getAttachments());
        return allAttachments;
    }
    
    @Override
    public void addAttachment(@NotNull final Attachment attachment) {
        this.getDefaultWriteScope().addAttachment(attachment);
    }
    
    @Override
    public void clearAttachments() {
        this.getDefaultWriteScope().clearAttachments();
    }
    
    @NotNull
    @Override
    public List<EventProcessorAndOrder> getEventProcessorsWithOrder() {
        final List<EventProcessorAndOrder> allEventProcessors = new CopyOnWriteArrayList<EventProcessorAndOrder>();
        allEventProcessors.addAll(this.globalScope.getEventProcessorsWithOrder());
        allEventProcessors.addAll(this.isolationScope.getEventProcessorsWithOrder());
        allEventProcessors.addAll(this.scope.getEventProcessorsWithOrder());
        Collections.sort(allEventProcessors);
        return allEventProcessors;
    }
    
    @NotNull
    @Override
    public List<EventProcessor> getEventProcessors() {
        return EventProcessorUtils.unwrap(this.getEventProcessorsWithOrder());
    }
    
    @Override
    public void addEventProcessor(@NotNull final EventProcessor eventProcessor) {
        this.getDefaultWriteScope().addEventProcessor(eventProcessor);
    }
    
    @Nullable
    @Override
    public Session withSession(final Scope.IWithSession sessionCallback) {
        return this.getDefaultWriteScope().withSession(sessionCallback);
    }
    
    @Nullable
    @Override
    public Scope.SessionPair startSession() {
        return this.getDefaultWriteScope().startSession();
    }
    
    @Nullable
    @Override
    public Session endSession() {
        return this.getDefaultWriteScope().endSession();
    }
    
    @Override
    public void withTransaction(final Scope.IWithTransaction callback) {
        this.getDefaultWriteScope().withTransaction(callback);
    }
    
    @NotNull
    @Override
    public SentryOptions getOptions() {
        return this.globalScope.getOptions();
    }
    
    @Nullable
    @Override
    public Session getSession() {
        final Session current = this.scope.getSession();
        if (current != null) {
            return current;
        }
        final Session isolation = this.isolationScope.getSession();
        if (isolation != null) {
            return isolation;
        }
        return this.globalScope.getSession();
    }
    
    @Override
    public void clearSession() {
        this.getDefaultWriteScope().clearSession();
    }
    
    @Override
    public void setPropagationContext(@NotNull final PropagationContext propagationContext) {
        this.getDefaultWriteScope().setPropagationContext(propagationContext);
    }
    
    @ApiStatus.Internal
    @NotNull
    @Override
    public PropagationContext getPropagationContext() {
        return this.getDefaultWriteScope().getPropagationContext();
    }
    
    @NotNull
    @Override
    public PropagationContext withPropagationContext(final Scope.IWithPropagationContext callback) {
        return this.getDefaultWriteScope().withPropagationContext(callback);
    }
    
    @NotNull
    @Override
    public IScope clone() {
        return new CombinedScopeView(this.globalScope, this.isolationScope.clone(), this.scope.clone());
    }
    
    @Override
    public void setLastEventId(@NotNull final SentryId lastEventId) {
        this.globalScope.setLastEventId(lastEventId);
        this.isolationScope.setLastEventId(lastEventId);
        this.scope.setLastEventId(lastEventId);
    }
    
    @NotNull
    @Override
    public SentryId getLastEventId() {
        return this.globalScope.getLastEventId();
    }
    
    @Override
    public void bindClient(@NotNull final ISentryClient client) {
        this.getDefaultWriteScope().bindClient(client);
    }
    
    @NotNull
    @Override
    public ISentryClient getClient() {
        final ISentryClient current = this.scope.getClient();
        if (!(current instanceof NoOpSentryClient)) {
            return current;
        }
        final ISentryClient isolation = this.isolationScope.getClient();
        if (!(isolation instanceof NoOpSentryClient)) {
            return isolation;
        }
        return this.globalScope.getClient();
    }
    
    @Override
    public void assignTraceContext(@NotNull final SentryEvent event) {
        this.globalScope.assignTraceContext(event);
    }
    
    @Override
    public void setSpanContext(@NotNull final Throwable throwable, @NotNull final ISpan span, @NotNull final String transactionName) {
        this.globalScope.setSpanContext(throwable, span, transactionName);
    }
    
    @ApiStatus.Internal
    @Override
    public void replaceOptions(@NotNull final SentryOptions options) {
        this.globalScope.replaceOptions(options);
    }
    
    @NotNull
    @Override
    public SentryId getReplayId() {
        final SentryId current = this.scope.getReplayId();
        if (!SentryId.EMPTY_ID.equals(current)) {
            return current;
        }
        final SentryId isolation = this.isolationScope.getReplayId();
        if (!SentryId.EMPTY_ID.equals(isolation)) {
            return isolation;
        }
        return this.globalScope.getReplayId();
    }
    
    @Override
    public void setReplayId(@NotNull final SentryId replayId) {
        this.getDefaultWriteScope().setReplayId(replayId);
    }
    
    @Override
    public void addFeatureFlag(@Nullable final String flag, @Nullable final Boolean result) {
        this.getDefaultWriteScope().addFeatureFlag(flag, result);
        final ISpan span = this.getSpan();
        if (span != null) {
            span.addFeatureFlag(flag, result);
        }
    }
    
    @Nullable
    @Override
    public FeatureFlags getFeatureFlags() {
        return this.getFeatureFlagBuffer().getFeatureFlags();
    }
    
    @NotNull
    @Override
    public IFeatureFlagBuffer getFeatureFlagBuffer() {
        return FeatureFlagBuffer.merged(this.getOptions(), this.globalScope.getFeatureFlagBuffer(), this.isolationScope.getFeatureFlagBuffer(), this.scope.getFeatureFlagBuffer());
    }
}