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

package io.sentry;

import io.sentry.vendor.gson.stream.JsonToken;
import java.io.IOException;
import java.util.List;
import java.util.Collections;
import io.sentry.util.Objects;
import org.jetbrains.annotations.Nullable;
import java.util.Iterator;
import java.util.Map;
import org.jetbrains.annotations.NotNull;
import java.util.concurrent.ConcurrentHashMap;

public final class MonitorContexts extends ConcurrentHashMap<String, Object> implements JsonSerializable
{
    private static final long serialVersionUID = 3987329379811822556L;
    
    public MonitorContexts() {
    }
    
    public MonitorContexts(@NotNull final MonitorContexts contexts) {
        for (final Map.Entry<String, Object> entry : contexts.entrySet()) {
            if (entry != null) {
                final Object value = entry.getValue();
                if ("trace".equals(entry.getKey()) && value instanceof SpanContext) {
                    this.setTrace(new SpanContext((SpanContext)value));
                }
                else {
                    this.put(entry.getKey(), value);
                }
            }
        }
    }
    
    @Nullable
    private <T> T toContextType(@NotNull final String key, @NotNull final Class<T> clazz) {
        final Object item = ((ConcurrentHashMap<K, Object>)this).get(key);
        return clazz.isInstance(item) ? clazz.cast(item) : null;
    }
    
    @Nullable
    public SpanContext getTrace() {
        return this.toContextType("trace", SpanContext.class);
    }
    
    public void setTrace(@NotNull final SpanContext traceContext) {
        Objects.requireNonNull(traceContext, "traceContext is required");
        ((ConcurrentHashMap<String, SpanContext>)this).put("trace", traceContext);
    }
    
    @Override
    public void serialize(@NotNull final ObjectWriter writer, @NotNull final ILogger logger) throws IOException {
        writer.beginObject();
        final List<String> sortedKeys = Collections.list(((ConcurrentHashMap<String, V>)this).keys());
        Collections.sort(sortedKeys);
        for (final String key : sortedKeys) {
            final Object value = ((ConcurrentHashMap<K, Object>)this).get(key);
            if (value != null) {
                writer.name(key).value(logger, value);
            }
        }
        writer.endObject();
    }
    
    public static final class Deserializer implements JsonDeserializer<MonitorContexts>
    {
        @NotNull
        @Override
        public MonitorContexts deserialize(@NotNull final ObjectReader reader, @NotNull final ILogger logger) throws Exception {
            final MonitorContexts contexts = new MonitorContexts();
            reader.beginObject();
            while (reader.peek() == JsonToken.NAME) {
                final String nextName2;
                final String nextName = nextName2 = reader.nextName();
                switch (nextName2) {
                    case "trace": {
                        contexts.setTrace(new SpanContext.Deserializer().deserialize(reader, logger));
                        continue;
                    }
                    default: {
                        final Object object = reader.nextObjectOrNull();
                        if (object != null) {
                            contexts.put(nextName, object);
                            continue;
                        }
                        continue;
                    }
                }
            }
            reader.endObject();
            return contexts;
        }
    }
}