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

package io.sentry;

import java.io.StringWriter;
import java.util.Iterator;
import java.io.BufferedWriter;
import java.io.OutputStreamWriter;
import java.io.BufferedOutputStream;
import java.io.OutputStream;
import java.io.Writer;
import java.io.IOException;
import io.sentry.util.Objects;
import java.io.InputStream;
import java.util.List;
import java.util.Collection;
import org.jetbrains.annotations.Nullable;
import java.io.Reader;
import io.sentry.protocol.ViewHierarchy;
import io.sentry.protocol.ViewHierarchyNode;
import io.sentry.clientreport.ClientReport;
import io.sentry.protocol.Geo;
import io.sentry.protocol.User;
import io.sentry.protocol.SentryTransaction;
import io.sentry.protocol.SentryThread;
import io.sentry.protocol.SentryStackTrace;
import io.sentry.protocol.SentryStackFrame;
import io.sentry.protocol.SentrySpan;
import io.sentry.protocol.SentryRuntime;
import io.sentry.protocol.SentryPackage;
import io.sentry.protocol.SentryException;
import io.sentry.protocol.SdkVersion;
import io.sentry.protocol.SdkInfo;
import io.sentry.rrweb.RRWebVideoEvent;
import io.sentry.rrweb.RRWebSpanEvent;
import io.sentry.rrweb.RRWebMetaEvent;
import io.sentry.rrweb.RRWebInteractionMoveEvent;
import io.sentry.rrweb.RRWebInteractionEvent;
import io.sentry.rrweb.RRWebEventType;
import io.sentry.rrweb.RRWebBreadcrumbEvent;
import io.sentry.protocol.Request;
import io.sentry.profilemeasurements.ProfileMeasurementValue;
import io.sentry.profilemeasurements.ProfileMeasurement;
import io.sentry.protocol.OperatingSystem;
import io.sentry.protocol.Message;
import io.sentry.protocol.Mechanism;
import io.sentry.protocol.MeasurementValue;
import io.sentry.protocol.Gpu;
import io.sentry.protocol.Feedback;
import io.sentry.protocol.Device;
import io.sentry.protocol.DebugMeta;
import io.sentry.protocol.DebugImage;
import io.sentry.protocol.Contexts;
import io.sentry.protocol.Browser;
import io.sentry.protocol.App;
import java.util.HashMap;
import java.util.Map;
import org.jetbrains.annotations.NotNull;
import java.nio.charset.Charset;

public final class JsonSerializer implements ISerializer
{
    private static final Charset UTF_8;
    @NotNull
    private final SentryOptions options;
    @NotNull
    private final Map<Class<?>, JsonDeserializer<?>> deserializersByClass;
    
    public JsonSerializer(@NotNull final SentryOptions options) {
        this.options = options;
        (this.deserializersByClass = new HashMap<Class<?>, JsonDeserializer<?>>()).put(App.class, new App.Deserializer());
        this.deserializersByClass.put(Breadcrumb.class, new Breadcrumb.Deserializer());
        this.deserializersByClass.put(Browser.class, new Browser.Deserializer());
        this.deserializersByClass.put(Contexts.class, new Contexts.Deserializer());
        this.deserializersByClass.put(DebugImage.class, new DebugImage.Deserializer());
        this.deserializersByClass.put(DebugMeta.class, new DebugMeta.Deserializer());
        this.deserializersByClass.put(Device.class, new Device.Deserializer());
        this.deserializersByClass.put(Device.DeviceOrientation.class, new Device.DeviceOrientation.Deserializer());
        this.deserializersByClass.put(Feedback.class, new Feedback.Deserializer());
        this.deserializersByClass.put(Gpu.class, new Gpu.Deserializer());
        this.deserializersByClass.put(MeasurementValue.class, new MeasurementValue.Deserializer());
        this.deserializersByClass.put(Mechanism.class, new Mechanism.Deserializer());
        this.deserializersByClass.put(Message.class, new Message.Deserializer());
        this.deserializersByClass.put(OperatingSystem.class, new OperatingSystem.Deserializer());
        this.deserializersByClass.put(ProfileChunk.class, new ProfileChunk.Deserializer());
        this.deserializersByClass.put(ProfileContext.class, new ProfileContext.Deserializer());
        this.deserializersByClass.put(ProfilingTraceData.class, new ProfilingTraceData.Deserializer());
        this.deserializersByClass.put(ProfilingTransactionData.class, new ProfilingTransactionData.Deserializer());
        this.deserializersByClass.put(ProfileMeasurement.class, new ProfileMeasurement.Deserializer());
        this.deserializersByClass.put(ProfileMeasurementValue.class, new ProfileMeasurementValue.Deserializer());
        this.deserializersByClass.put(Request.class, new Request.Deserializer());
        this.deserializersByClass.put(ReplayRecording.class, new ReplayRecording.Deserializer());
        this.deserializersByClass.put(RRWebBreadcrumbEvent.class, new RRWebBreadcrumbEvent.Deserializer());
        this.deserializersByClass.put(RRWebEventType.class, new RRWebEventType.Deserializer());
        this.deserializersByClass.put(RRWebInteractionEvent.class, new RRWebInteractionEvent.Deserializer());
        this.deserializersByClass.put(RRWebInteractionMoveEvent.class, new RRWebInteractionMoveEvent.Deserializer());
        this.deserializersByClass.put(RRWebMetaEvent.class, new RRWebMetaEvent.Deserializer());
        this.deserializersByClass.put(RRWebSpanEvent.class, new RRWebSpanEvent.Deserializer());
        this.deserializersByClass.put(RRWebVideoEvent.class, new RRWebVideoEvent.Deserializer());
        this.deserializersByClass.put(SdkInfo.class, new SdkInfo.Deserializer());
        this.deserializersByClass.put(SdkVersion.class, new SdkVersion.Deserializer());
        this.deserializersByClass.put(SentryEnvelopeHeader.class, new SentryEnvelopeHeader.Deserializer());
        this.deserializersByClass.put(SentryEnvelopeItemHeader.class, new SentryEnvelopeItemHeader.Deserializer());
        this.deserializersByClass.put(SentryEvent.class, new SentryEvent.Deserializer());
        this.deserializersByClass.put(SentryException.class, new SentryException.Deserializer());
        this.deserializersByClass.put(SentryItemType.class, new SentryItemType.Deserializer());
        this.deserializersByClass.put(SentryLevel.class, new SentryLevel.Deserializer());
        this.deserializersByClass.put(SentryLockReason.class, new SentryLockReason.Deserializer());
        this.deserializersByClass.put(SentryLogEvents.class, new SentryLogEvents.Deserializer());
        this.deserializersByClass.put(SentryPackage.class, new SentryPackage.Deserializer());
        this.deserializersByClass.put(SentryRuntime.class, new SentryRuntime.Deserializer());
        this.deserializersByClass.put(SentryReplayEvent.class, new SentryReplayEvent.Deserializer());
        this.deserializersByClass.put(SentrySpan.class, new SentrySpan.Deserializer());
        this.deserializersByClass.put(SentryStackFrame.class, new SentryStackFrame.Deserializer());
        this.deserializersByClass.put(SentryStackTrace.class, new SentryStackTrace.Deserializer());
        this.deserializersByClass.put(SentryAppStartProfilingOptions.class, new SentryAppStartProfilingOptions.Deserializer());
        this.deserializersByClass.put(SentryThread.class, new SentryThread.Deserializer());
        this.deserializersByClass.put(SentryTransaction.class, new SentryTransaction.Deserializer());
        this.deserializersByClass.put(Session.class, new Session.Deserializer());
        this.deserializersByClass.put(SpanContext.class, new SpanContext.Deserializer());
        this.deserializersByClass.put(SpanId.class, new SpanId.Deserializer());
        this.deserializersByClass.put(SpanStatus.class, new SpanStatus.Deserializer());
        this.deserializersByClass.put(User.class, new User.Deserializer());
        this.deserializersByClass.put(Geo.class, new Geo.Deserializer());
        this.deserializersByClass.put(UserFeedback.class, new UserFeedback.Deserializer());
        this.deserializersByClass.put(ClientReport.class, new ClientReport.Deserializer());
        this.deserializersByClass.put(ViewHierarchyNode.class, new ViewHierarchyNode.Deserializer());
        this.deserializersByClass.put(ViewHierarchy.class, new ViewHierarchy.Deserializer());
    }
    
    @Nullable
    @Override
    public <T, R> T deserializeCollection(@NotNull final Reader reader, @NotNull final Class<T> clazz, @Nullable final JsonDeserializer<R> elementDeserializer) {
        try (final JsonObjectReader jsonObjectReader = new JsonObjectReader(reader)) {
            if (!Collection.class.isAssignableFrom(clazz)) {
                final Object nextObjectOrNull = jsonObjectReader.nextObjectOrNull();
                jsonObjectReader.close();
                return (T)nextObjectOrNull;
            }
            if (elementDeserializer == null) {
                final Object nextObjectOrNull2 = jsonObjectReader.nextObjectOrNull();
                jsonObjectReader.close();
                return (T)nextObjectOrNull2;
            }
            final List<R> nextListOrNull = jsonObjectReader.nextListOrNull(this.options.getLogger(), elementDeserializer);
            return (T)nextListOrNull;
        }
        catch (final Throwable e) {
            this.options.getLogger().log(SentryLevel.ERROR, "Error when deserializing", e);
            return null;
        }
    }
    
    @Nullable
    @Override
    public <T> T deserialize(@NotNull final Reader reader, @NotNull final Class<T> clazz) {
        try (final JsonObjectReader jsonObjectReader = new JsonObjectReader(reader)) {
            final JsonDeserializer<?> deserializer = this.deserializersByClass.get(clazz);
            if (deserializer != null) {
                final Object object = deserializer.deserialize(jsonObjectReader, this.options.getLogger());
                final T cast = clazz.cast(object);
                jsonObjectReader.close();
                return cast;
            }
            if (this.isKnownPrimitive(clazz)) {
                final Object nextObjectOrNull = jsonObjectReader.nextObjectOrNull();
                jsonObjectReader.close();
                return (T)nextObjectOrNull;
            }
            return null;
        }
        catch (final Exception e) {
            this.options.getLogger().log(SentryLevel.ERROR, "Error when deserializing", e);
            return null;
        }
    }
    
    @Nullable
    @Override
    public SentryEnvelope deserializeEnvelope(@NotNull final InputStream inputStream) {
        Objects.requireNonNull(inputStream, "The InputStream object is required.");
        try {
            return this.options.getEnvelopeReader().read(inputStream);
        }
        catch (final IOException e) {
            this.options.getLogger().log(SentryLevel.ERROR, "Error deserializing envelope.", e);
            return null;
        }
    }
    
    @Override
    public <T> void serialize(@NotNull final T entity, @NotNull final Writer writer) throws IOException {
        Objects.requireNonNull(entity, "The entity is required.");
        Objects.requireNonNull(writer, "The Writer object is required.");
        if (this.options.getLogger().isEnabled(SentryLevel.DEBUG)) {
            final String serialized = this.serializeToString(entity, this.options.isEnablePrettySerializationOutput());
            this.options.getLogger().log(SentryLevel.DEBUG, "Serializing object: %s", serialized);
        }
        final JsonObjectWriter jsonObjectWriter = new JsonObjectWriter(writer, this.options.getMaxDepth());
        jsonObjectWriter.value(this.options.getLogger(), (Object)entity);
        writer.flush();
    }
    
    @Override
    public void serialize(@NotNull final SentryEnvelope envelope, @NotNull final OutputStream outputStream) throws Exception {
        Objects.requireNonNull(envelope, "The SentryEnvelope object is required.");
        Objects.requireNonNull(outputStream, "The Stream object is required.");
        final BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
        final Writer writer = new BufferedWriter(new OutputStreamWriter(bufferedOutputStream, JsonSerializer.UTF_8));
        try {
            envelope.getHeader().serialize(new JsonObjectWriter(writer, this.options.getMaxDepth()), this.options.getLogger());
            writer.write("\n");
            for (final SentryEnvelopeItem item : envelope.getItems()) {
                try {
                    final byte[] data = item.getData();
                    item.getHeader().serialize(new JsonObjectWriter(writer, this.options.getMaxDepth()), this.options.getLogger());
                    writer.write("\n");
                    writer.flush();
                    outputStream.write(data);
                    writer.write("\n");
                }
                catch (final Exception exception) {
                    this.options.getLogger().log(SentryLevel.ERROR, "Failed to create envelope item. Dropping it.", exception);
                }
            }
        }
        finally {
            writer.flush();
        }
    }
    
    @NotNull
    @Override
    public String serialize(@NotNull final Map<String, Object> data) throws Exception {
        return this.serializeToString(data, false);
    }
    
    @NotNull
    private String serializeToString(final Object object, final boolean pretty) throws IOException {
        final StringWriter stringWriter = new StringWriter();
        final JsonObjectWriter jsonObjectWriter = new JsonObjectWriter(stringWriter, this.options.getMaxDepth());
        if (pretty) {
            jsonObjectWriter.setIndent("\t");
        }
        jsonObjectWriter.value(this.options.getLogger(), object);
        return stringWriter.toString();
    }
    
    private <T> boolean isKnownPrimitive(@NotNull final Class<T> clazz) {
        return clazz.isArray() || Collection.class.isAssignableFrom(clazz) || String.class.isAssignableFrom(clazz) || Map.class.isAssignableFrom(clazz);
    }
    
    static {
        UTF_8 = Charset.forName("UTF-8");
    }
}