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

package io.sentry;

import org.jetbrains.annotations.Nullable;
import io.sentry.protocol.SentryException;
import io.sentry.hints.EventDropReason;
import io.sentry.util.HintUtils;
import java.util.Collections;
import java.util.HashMap;
import org.jetbrains.annotations.NotNull;
import java.util.Map;

public final class DeduplicateMultithreadedEventProcessor implements EventProcessor
{
    @NotNull
    private final Map<String, Long> processedEvents;
    @NotNull
    private final SentryOptions options;
    
    public DeduplicateMultithreadedEventProcessor(@NotNull final SentryOptions options) {
        this.processedEvents = Collections.synchronizedMap(new HashMap<String, Long>());
        this.options = options;
    }
    
    @Nullable
    @Override
    public SentryEvent process(@NotNull final SentryEvent event, @NotNull final Hint hint) {
        if (!HintUtils.hasType(hint, UncaughtExceptionHandlerIntegration.UncaughtExceptionHint.class)) {
            return event;
        }
        final SentryException exception = event.getUnhandledException();
        if (exception == null) {
            return event;
        }
        final String type = exception.getType();
        if (type == null) {
            return event;
        }
        final Long currentEventTid = exception.getThreadId();
        if (currentEventTid == null) {
            return event;
        }
        final Long tid = this.processedEvents.get(type);
        if (tid != null && !tid.equals(currentEventTid)) {
            this.options.getLogger().log(SentryLevel.INFO, "Event %s has been dropped due to multi-threaded deduplication", event.getEventId());
            HintUtils.setEventDropReason(hint, EventDropReason.MULTITHREADED_DEDUPLICATION);
            return null;
        }
        this.processedEvents.put(type, currentEventTid);
        return event;
    }
    
    @Nullable
    @Override
    public Long getOrder() {
        return 7000L;
    }
}