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

package io.sentry;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import io.sentry.util.CollectionUtils;
import org.jetbrains.annotations.ApiStatus;
import io.sentry.exception.ExceptionMechanismException;
import io.sentry.protocol.DebugMeta;
import java.util.List;
import io.sentry.protocol.User;
import java.util.Map;
import io.sentry.protocol.Request;
import io.sentry.protocol.SdkVersion;
import org.jetbrains.annotations.NotNull;
import io.sentry.protocol.Contexts;
import org.jetbrains.annotations.Nullable;
import io.sentry.protocol.SentryId;

public abstract class SentryBaseEvent
{
    public static final String DEFAULT_PLATFORM = "java";
    @Nullable
    private SentryId eventId;
    @NotNull
    private final Contexts contexts;
    @Nullable
    private SdkVersion sdk;
    @Nullable
    private Request request;
    @Nullable
    private Map<String, String> tags;
    @Nullable
    private String release;
    @Nullable
    private String environment;
    @Nullable
    private String platform;
    @Nullable
    private User user;
    @Nullable
    protected transient Throwable throwable;
    @Nullable
    private String serverName;
    @Nullable
    private String dist;
    @Nullable
    private List<Breadcrumb> breadcrumbs;
    @Nullable
    private DebugMeta debugMeta;
    @Nullable
    private Map<String, Object> extra;
    
    protected SentryBaseEvent(@NotNull final SentryId eventId) {
        this.contexts = new Contexts();
        this.eventId = eventId;
    }
    
    protected SentryBaseEvent() {
        this(new SentryId());
    }
    
    @Nullable
    public SentryId getEventId() {
        return this.eventId;
    }
    
    public void setEventId(@Nullable final SentryId eventId) {
        this.eventId = eventId;
    }
    
    @NotNull
    public Contexts getContexts() {
        return this.contexts;
    }
    
    @Nullable
    public SdkVersion getSdk() {
        return this.sdk;
    }
    
    public void setSdk(@Nullable final SdkVersion sdk) {
        this.sdk = sdk;
    }
    
    @Nullable
    public Request getRequest() {
        return this.request;
    }
    
    public void setRequest(@Nullable final Request request) {
        this.request = request;
    }
    
    @Nullable
    public Throwable getThrowable() {
        final Throwable ex = this.throwable;
        if (ex instanceof ExceptionMechanismException) {
            return ((ExceptionMechanismException)ex).getThrowable();
        }
        return ex;
    }
    
    @ApiStatus.Internal
    @Nullable
    public Throwable getThrowableMechanism() {
        return this.throwable;
    }
    
    public void setThrowable(@Nullable final Throwable throwable) {
        this.throwable = throwable;
    }
    
    @ApiStatus.Internal
    @Nullable
    public Map<String, String> getTags() {
        return this.tags;
    }
    
    public void setTags(@Nullable final Map<String, String> tags) {
        this.tags = CollectionUtils.newHashMap(tags);
    }
    
    public void removeTag(@Nullable final String key) {
        if (this.tags != null && key != null) {
            this.tags.remove(key);
        }
    }
    
    @Nullable
    public String getTag(@Nullable final String key) {
        if (this.tags != null && key != null) {
            return this.tags.get(key);
        }
        return null;
    }
    
    public void setTag(@Nullable final String key, @Nullable final String value) {
        if (this.tags == null) {
            this.tags = new HashMap<String, String>();
        }
        if (key == null) {
            return;
        }
        if (value == null) {
            this.removeTag(key);
        }
        else {
            this.tags.put(key, value);
        }
    }
    
    @Nullable
    public String getRelease() {
        return this.release;
    }
    
    public void setRelease(@Nullable final String release) {
        this.release = release;
    }
    
    @Nullable
    public String getEnvironment() {
        return this.environment;
    }
    
    public void setEnvironment(@Nullable final String environment) {
        this.environment = environment;
    }
    
    @Nullable
    public String getPlatform() {
        return this.platform;
    }
    
    public void setPlatform(@Nullable final String platform) {
        this.platform = platform;
    }
    
    @Nullable
    public String getServerName() {
        return this.serverName;
    }
    
    public void setServerName(@Nullable final String serverName) {
        this.serverName = serverName;
    }
    
    @Nullable
    public String getDist() {
        return this.dist;
    }
    
    public void setDist(@Nullable final String dist) {
        this.dist = dist;
    }
    
    @Nullable
    public User getUser() {
        return this.user;
    }
    
    public void setUser(@Nullable final User user) {
        this.user = user;
    }
    
    @Nullable
    public List<Breadcrumb> getBreadcrumbs() {
        return this.breadcrumbs;
    }
    
    public void setBreadcrumbs(@Nullable final List<Breadcrumb> breadcrumbs) {
        this.breadcrumbs = CollectionUtils.newArrayList(breadcrumbs);
    }
    
    public void addBreadcrumb(@NotNull final Breadcrumb breadcrumb) {
        if (this.breadcrumbs == null) {
            this.breadcrumbs = new ArrayList<Breadcrumb>();
        }
        this.breadcrumbs.add(breadcrumb);
    }
    
    @Nullable
    public DebugMeta getDebugMeta() {
        return this.debugMeta;
    }
    
    public void setDebugMeta(@Nullable final DebugMeta debugMeta) {
        this.debugMeta = debugMeta;
    }
    
    @Nullable
    public Map<String, Object> getExtras() {
        return this.extra;
    }
    
    public void setExtras(@Nullable final Map<String, Object> extra) {
        this.extra = CollectionUtils.newHashMap(extra);
    }
    
    public void setExtra(@Nullable final String key, @Nullable final Object value) {
        if (this.extra == null) {
            this.extra = new HashMap<String, Object>();
        }
        if (key == null) {
            return;
        }
        if (value == null) {
            this.removeExtra(key);
        }
        else {
            this.extra.put(key, value);
        }
    }
    
    public void removeExtra(@Nullable final String key) {
        if (this.extra != null && key != null) {
            this.extra.remove(key);
        }
    }
    
    @Nullable
    public Object getExtra(@Nullable final String key) {
        if (this.extra != null && key != null) {
            return this.extra.get(key);
        }
        return null;
    }
    
    public void addBreadcrumb(@Nullable final String message) {
        this.addBreadcrumb(new Breadcrumb(message));
    }
    
    public static final class JsonKeys
    {
        public static final String EVENT_ID = "event_id";
        public static final String CONTEXTS = "contexts";
        public static final String SDK = "sdk";
        public static final String REQUEST = "request";
        public static final String TAGS = "tags";
        public static final String RELEASE = "release";
        public static final String ENVIRONMENT = "environment";
        public static final String PLATFORM = "platform";
        public static final String USER = "user";
        public static final String SERVER_NAME = "server_name";
        public static final String DIST = "dist";
        public static final String BREADCRUMBS = "breadcrumbs";
        public static final String DEBUG_META = "debug_meta";
        public static final String EXTRA = "extra";
    }
    
    public static final class Serializer
    {
        public void serialize(@NotNull final SentryBaseEvent baseEvent, @NotNull final ObjectWriter writer, @NotNull final ILogger logger) throws IOException {
            if (baseEvent.eventId != null) {
                writer.name("event_id").value(logger, baseEvent.eventId);
            }
            writer.name("contexts").value(logger, baseEvent.contexts);
            if (baseEvent.sdk != null) {
                writer.name("sdk").value(logger, baseEvent.sdk);
            }
            if (baseEvent.request != null) {
                writer.name("request").value(logger, baseEvent.request);
            }
            if (baseEvent.tags != null && !baseEvent.tags.isEmpty()) {
                writer.name("tags").value(logger, baseEvent.tags);
            }
            if (baseEvent.release != null) {
                writer.name("release").value(baseEvent.release);
            }
            if (baseEvent.environment != null) {
                writer.name("environment").value(baseEvent.environment);
            }
            if (baseEvent.platform != null) {
                writer.name("platform").value(baseEvent.platform);
            }
            if (baseEvent.user != null) {
                writer.name("user").value(logger, baseEvent.user);
            }
            if (baseEvent.serverName != null) {
                writer.name("server_name").value(baseEvent.serverName);
            }
            if (baseEvent.dist != null) {
                writer.name("dist").value(baseEvent.dist);
            }
            if (baseEvent.breadcrumbs != null && !baseEvent.breadcrumbs.isEmpty()) {
                writer.name("breadcrumbs").value(logger, baseEvent.breadcrumbs);
            }
            if (baseEvent.debugMeta != null) {
                writer.name("debug_meta").value(logger, baseEvent.debugMeta);
            }
            if (baseEvent.extra != null && !baseEvent.extra.isEmpty()) {
                writer.name("extra").value(logger, baseEvent.extra);
            }
        }
    }
    
    public static final class Deserializer
    {
        public boolean deserializeValue(@NotNull final SentryBaseEvent baseEvent, @NotNull final String nextName, @NotNull final ObjectReader reader, @NotNull final ILogger logger) throws Exception {
            switch (nextName) {
                case "event_id": {
                    baseEvent.eventId = reader.nextOrNull(logger, (JsonDeserializer<SentryId>)new SentryId.Deserializer());
                    return true;
                }
                case "contexts": {
                    final Contexts deserializedContexts = new Contexts.Deserializer().deserialize(reader, logger);
                    baseEvent.contexts.putAll(deserializedContexts);
                    return true;
                }
                case "sdk": {
                    baseEvent.sdk = reader.nextOrNull(logger, (JsonDeserializer<SdkVersion>)new SdkVersion.Deserializer());
                    return true;
                }
                case "request": {
                    baseEvent.request = reader.nextOrNull(logger, (JsonDeserializer<Request>)new Request.Deserializer());
                    return true;
                }
                case "tags": {
                    final Map<String, String> deserializedTags = (Map<String, String>)reader.nextObjectOrNull();
                    baseEvent.tags = CollectionUtils.newConcurrentHashMap(deserializedTags);
                    return true;
                }
                case "release": {
                    baseEvent.release = reader.nextStringOrNull();
                    return true;
                }
                case "environment": {
                    baseEvent.environment = reader.nextStringOrNull();
                    return true;
                }
                case "platform": {
                    baseEvent.platform = reader.nextStringOrNull();
                    return true;
                }
                case "user": {
                    baseEvent.user = reader.nextOrNull(logger, (JsonDeserializer<User>)new User.Deserializer());
                    return true;
                }
                case "server_name": {
                    baseEvent.serverName = reader.nextStringOrNull();
                    return true;
                }
                case "dist": {
                    baseEvent.dist = reader.nextStringOrNull();
                    return true;
                }
                case "breadcrumbs": {
                    baseEvent.breadcrumbs = (List<Breadcrumb>)reader.nextListOrNull(logger, (JsonDeserializer<Object>)new Breadcrumb.Deserializer());
                    return true;
                }
                case "debug_meta": {
                    baseEvent.debugMeta = reader.nextOrNull(logger, (JsonDeserializer<DebugMeta>)new DebugMeta.Deserializer());
                    return true;
                }
                case "extra": {
                    final Map<String, Object> deserializedExtra = (Map<String, Object>)reader.nextObjectOrNull();
                    baseEvent.extra = CollectionUtils.newConcurrentHashMap(deserializedExtra);
                    return true;
                }
                default: {
                    return false;
                }
            }
        }
    }
}