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

package io.sentry;

import java.util.concurrent.ConcurrentHashMap;
import io.sentry.vendor.gson.stream.JsonToken;
import java.io.IOException;
import java.util.Iterator;
import io.sentry.util.SentryRandom;
import org.jetbrains.annotations.VisibleForTesting;
import java.util.Map;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.ApiStatus;

@ApiStatus.Internal
public final class SentryAppStartProfilingOptions implements JsonUnknown, JsonSerializable
{
    boolean profileSampled;
    @Nullable
    Double profileSampleRate;
    boolean traceSampled;
    @Nullable
    Double traceSampleRate;
    @Nullable
    String profilingTracesDirPath;
    boolean isProfilingEnabled;
    boolean isContinuousProfilingEnabled;
    int profilingTracesHz;
    boolean continuousProfileSampled;
    boolean isEnableAppStartProfiling;
    boolean isStartProfilerOnAppStart;
    @NotNull
    ProfileLifecycle profileLifecycle;
    @Nullable
    private Map<String, Object> unknown;
    
    @VisibleForTesting
    public SentryAppStartProfilingOptions() {
        this.traceSampled = false;
        this.traceSampleRate = null;
        this.profileSampled = false;
        this.profileSampleRate = null;
        this.continuousProfileSampled = false;
        this.profilingTracesDirPath = null;
        this.isProfilingEnabled = false;
        this.isContinuousProfilingEnabled = false;
        this.profileLifecycle = ProfileLifecycle.MANUAL;
        this.profilingTracesHz = 0;
        this.isEnableAppStartProfiling = true;
        this.isStartProfilerOnAppStart = false;
    }
    
    SentryAppStartProfilingOptions(@NotNull final SentryOptions options, @NotNull final TracesSamplingDecision samplingDecision) {
        this.traceSampled = samplingDecision.getSampled();
        this.traceSampleRate = samplingDecision.getSampleRate();
        this.profileSampled = samplingDecision.getProfileSampled();
        this.profileSampleRate = samplingDecision.getProfileSampleRate();
        this.continuousProfileSampled = options.getInternalTracesSampler().sampleSessionProfile(SentryRandom.current().nextDouble());
        this.profilingTracesDirPath = options.getProfilingTracesDirPath();
        this.isProfilingEnabled = options.isProfilingEnabled();
        this.isContinuousProfilingEnabled = options.isContinuousProfilingEnabled();
        this.profileLifecycle = options.getProfileLifecycle();
        this.profilingTracesHz = options.getProfilingTracesHz();
        this.isEnableAppStartProfiling = options.isEnableAppStartProfiling();
        this.isStartProfilerOnAppStart = options.isStartProfilerOnAppStart();
    }
    
    public void setProfileSampled(final boolean profileSampled) {
        this.profileSampled = profileSampled;
    }
    
    public boolean isProfileSampled() {
        return this.profileSampled;
    }
    
    public void setContinuousProfileSampled(final boolean continuousProfileSampled) {
        this.continuousProfileSampled = continuousProfileSampled;
    }
    
    public boolean isContinuousProfileSampled() {
        return this.continuousProfileSampled;
    }
    
    public void setProfileLifecycle(@NotNull final ProfileLifecycle profileLifecycle) {
        this.profileLifecycle = profileLifecycle;
    }
    
    @NotNull
    public ProfileLifecycle getProfileLifecycle() {
        return this.profileLifecycle;
    }
    
    public void setProfileSampleRate(@Nullable final Double profileSampleRate) {
        this.profileSampleRate = profileSampleRate;
    }
    
    @Nullable
    public Double getProfileSampleRate() {
        return this.profileSampleRate;
    }
    
    public void setTraceSampled(final boolean traceSampled) {
        this.traceSampled = traceSampled;
    }
    
    public boolean isTraceSampled() {
        return this.traceSampled;
    }
    
    public void setTraceSampleRate(@Nullable final Double traceSampleRate) {
        this.traceSampleRate = traceSampleRate;
    }
    
    @Nullable
    public Double getTraceSampleRate() {
        return this.traceSampleRate;
    }
    
    public void setProfilingTracesDirPath(@Nullable final String profilingTracesDirPath) {
        this.profilingTracesDirPath = profilingTracesDirPath;
    }
    
    @Nullable
    public String getProfilingTracesDirPath() {
        return this.profilingTracesDirPath;
    }
    
    public void setProfilingEnabled(final boolean profilingEnabled) {
        this.isProfilingEnabled = profilingEnabled;
    }
    
    public boolean isProfilingEnabled() {
        return this.isProfilingEnabled;
    }
    
    public void setContinuousProfilingEnabled(final boolean continuousProfilingEnabled) {
        this.isContinuousProfilingEnabled = continuousProfilingEnabled;
    }
    
    public boolean isContinuousProfilingEnabled() {
        return this.isContinuousProfilingEnabled;
    }
    
    public void setProfilingTracesHz(final int profilingTracesHz) {
        this.profilingTracesHz = profilingTracesHz;
    }
    
    public int getProfilingTracesHz() {
        return this.profilingTracesHz;
    }
    
    public void setEnableAppStartProfiling(final boolean enableAppStartProfiling) {
        this.isEnableAppStartProfiling = enableAppStartProfiling;
    }
    
    public boolean isEnableAppStartProfiling() {
        return this.isEnableAppStartProfiling;
    }
    
    public void setStartProfilerOnAppStart(final boolean startProfilerOnAppStart) {
        this.isStartProfilerOnAppStart = startProfilerOnAppStart;
    }
    
    public boolean isStartProfilerOnAppStart() {
        return this.isStartProfilerOnAppStart;
    }
    
    @Override
    public void serialize(@NotNull final ObjectWriter writer, @NotNull final ILogger logger) throws IOException {
        writer.beginObject();
        writer.name("profile_sampled").value(logger, this.profileSampled);
        writer.name("profile_sample_rate").value(logger, this.profileSampleRate);
        writer.name("continuous_profile_sampled").value(logger, this.continuousProfileSampled);
        writer.name("trace_sampled").value(logger, this.traceSampled);
        writer.name("trace_sample_rate").value(logger, this.traceSampleRate);
        writer.name("profiling_traces_dir_path").value(logger, this.profilingTracesDirPath);
        writer.name("is_profiling_enabled").value(logger, this.isProfilingEnabled);
        writer.name("is_continuous_profiling_enabled").value(logger, this.isContinuousProfilingEnabled);
        writer.name("profile_lifecycle").value(logger, this.profileLifecycle.name());
        writer.name("profiling_traces_hz").value(logger, this.profilingTracesHz);
        writer.name("is_enable_app_start_profiling").value(logger, this.isEnableAppStartProfiling);
        writer.name("is_start_profiler_on_app_start").value(logger, this.isStartProfilerOnAppStart);
        if (this.unknown != null) {
            for (final String key : this.unknown.keySet()) {
                final Object value = this.unknown.get(key);
                writer.name(key);
                writer.value(logger, value);
            }
        }
        writer.endObject();
    }
    
    @Nullable
    @Override
    public Map<String, Object> getUnknown() {
        return this.unknown;
    }
    
    @Override
    public void setUnknown(@Nullable final Map<String, Object> unknown) {
        this.unknown = unknown;
    }
    
    public static final class JsonKeys
    {
        public static final String PROFILE_SAMPLED = "profile_sampled";
        public static final String PROFILE_SAMPLE_RATE = "profile_sample_rate";
        public static final String CONTINUOUS_PROFILE_SAMPLED = "continuous_profile_sampled";
        public static final String TRACE_SAMPLED = "trace_sampled";
        public static final String TRACE_SAMPLE_RATE = "trace_sample_rate";
        public static final String PROFILING_TRACES_DIR_PATH = "profiling_traces_dir_path";
        public static final String IS_PROFILING_ENABLED = "is_profiling_enabled";
        public static final String IS_CONTINUOUS_PROFILING_ENABLED = "is_continuous_profiling_enabled";
        public static final String PROFILE_LIFECYCLE = "profile_lifecycle";
        public static final String PROFILING_TRACES_HZ = "profiling_traces_hz";
        public static final String IS_ENABLE_APP_START_PROFILING = "is_enable_app_start_profiling";
        public static final String IS_START_PROFILER_ON_APP_START = "is_start_profiler_on_app_start";
    }
    
    public static final class Deserializer implements JsonDeserializer<SentryAppStartProfilingOptions>
    {
        @NotNull
        @Override
        public SentryAppStartProfilingOptions deserialize(@NotNull final ObjectReader reader, @NotNull final ILogger logger) throws Exception {
            reader.beginObject();
            final SentryAppStartProfilingOptions options = new SentryAppStartProfilingOptions();
            Map<String, Object> unknown = null;
            while (reader.peek() == JsonToken.NAME) {
                final String nextName2;
                final String nextName = nextName2 = reader.nextName();
                switch (nextName2) {
                    case "profile_sampled": {
                        final Boolean profileSampled = reader.nextBooleanOrNull();
                        if (profileSampled != null) {
                            options.profileSampled = profileSampled;
                            continue;
                        }
                        continue;
                    }
                    case "profile_sample_rate": {
                        final Double profileSampleRate = reader.nextDoubleOrNull();
                        if (profileSampleRate != null) {
                            options.profileSampleRate = profileSampleRate;
                            continue;
                        }
                        continue;
                    }
                    case "continuous_profile_sampled": {
                        final Boolean continuousProfileSampled = reader.nextBooleanOrNull();
                        if (continuousProfileSampled != null) {
                            options.continuousProfileSampled = continuousProfileSampled;
                            continue;
                        }
                        continue;
                    }
                    case "trace_sampled": {
                        final Boolean traceSampled = reader.nextBooleanOrNull();
                        if (traceSampled != null) {
                            options.traceSampled = traceSampled;
                            continue;
                        }
                        continue;
                    }
                    case "trace_sample_rate": {
                        final Double traceSampleRate = reader.nextDoubleOrNull();
                        if (traceSampleRate != null) {
                            options.traceSampleRate = traceSampleRate;
                            continue;
                        }
                        continue;
                    }
                    case "profiling_traces_dir_path": {
                        final String profilingTracesDirPath = reader.nextStringOrNull();
                        if (profilingTracesDirPath != null) {
                            options.profilingTracesDirPath = profilingTracesDirPath;
                            continue;
                        }
                        continue;
                    }
                    case "is_profiling_enabled": {
                        final Boolean isProfilingEnabled = reader.nextBooleanOrNull();
                        if (isProfilingEnabled != null) {
                            options.isProfilingEnabled = isProfilingEnabled;
                            continue;
                        }
                        continue;
                    }
                    case "is_continuous_profiling_enabled": {
                        final Boolean isContinuousProfilingEnabled = reader.nextBooleanOrNull();
                        if (isContinuousProfilingEnabled != null) {
                            options.isContinuousProfilingEnabled = isContinuousProfilingEnabled;
                            continue;
                        }
                        continue;
                    }
                    case "profile_lifecycle": {
                        final String profileLifecycle = reader.nextStringOrNull();
                        if (profileLifecycle != null) {
                            try {
                                options.profileLifecycle = ProfileLifecycle.valueOf(profileLifecycle);
                            }
                            catch (final IllegalArgumentException e) {
                                logger.log(SentryLevel.ERROR, "Error when deserializing ProfileLifecycle: " + profileLifecycle, new Object[0]);
                            }
                            continue;
                        }
                        continue;
                    }
                    case "profiling_traces_hz": {
                        final Integer profilingTracesHz = reader.nextIntegerOrNull();
                        if (profilingTracesHz != null) {
                            options.profilingTracesHz = profilingTracesHz;
                            continue;
                        }
                        continue;
                    }
                    case "is_enable_app_start_profiling": {
                        final Boolean isEnableAppStartProfiling = reader.nextBooleanOrNull();
                        if (isEnableAppStartProfiling != null) {
                            options.isEnableAppStartProfiling = isEnableAppStartProfiling;
                            continue;
                        }
                        continue;
                    }
                    case "is_start_profiler_on_app_start": {
                        final Boolean isStartProfilerOnAppStart = reader.nextBooleanOrNull();
                        if (isStartProfilerOnAppStart != null) {
                            options.isStartProfilerOnAppStart = isStartProfilerOnAppStart;
                            continue;
                        }
                        continue;
                    }
                    default: {
                        if (unknown == null) {
                            unknown = new ConcurrentHashMap<String, Object>();
                        }
                        reader.nextUnknown(logger, unknown, nextName);
                        continue;
                    }
                }
            }
            options.setUnknown(unknown);
            reader.endObject();
            return options;
        }
    }
}