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

package io.sentry.protocol;

import java.util.concurrent.ConcurrentHashMap;
import io.sentry.vendor.gson.stream.JsonToken;
import io.sentry.ObjectReader;
import io.sentry.JsonDeserializer;
import java.io.IOException;
import java.util.Iterator;
import io.sentry.ILogger;
import io.sentry.ObjectWriter;
import io.sentry.util.Objects;
import io.sentry.util.CollectionUtils;
import org.jetbrains.annotations.NotNull;
import java.util.List;
import java.util.Map;
import java.util.Date;
import org.jetbrains.annotations.Nullable;
import io.sentry.JsonSerializable;
import io.sentry.JsonUnknown;

public final class App implements JsonUnknown, JsonSerializable
{
    public static final String TYPE = "app";
    @Nullable
    private String appIdentifier;
    @Nullable
    private Date appStartTime;
    @Nullable
    private String deviceAppHash;
    @Nullable
    private String buildType;
    @Nullable
    private String appName;
    @Nullable
    private String appVersion;
    @Nullable
    private String appBuild;
    @Nullable
    private Map<String, String> permissions;
    @Nullable
    private List<String> viewNames;
    @Nullable
    private String startType;
    @Nullable
    private Boolean inForeground;
    @Nullable
    private Boolean isSplitApks;
    @Nullable
    private List<String> splitNames;
    @Nullable
    private Map<String, Object> unknown;
    
    public App() {
    }
    
    App(@NotNull final App app) {
        this.appBuild = app.appBuild;
        this.appIdentifier = app.appIdentifier;
        this.appName = app.appName;
        this.appStartTime = app.appStartTime;
        this.appVersion = app.appVersion;
        this.buildType = app.buildType;
        this.deviceAppHash = app.deviceAppHash;
        this.permissions = CollectionUtils.newConcurrentHashMap(app.permissions);
        this.inForeground = app.inForeground;
        this.viewNames = CollectionUtils.newArrayList(app.viewNames);
        this.startType = app.startType;
        this.isSplitApks = app.isSplitApks;
        this.splitNames = app.splitNames;
        this.unknown = CollectionUtils.newConcurrentHashMap(app.unknown);
    }
    
    @Nullable
    public String getAppIdentifier() {
        return this.appIdentifier;
    }
    
    public void setAppIdentifier(@Nullable final String appIdentifier) {
        this.appIdentifier = appIdentifier;
    }
    
    @Nullable
    public Date getAppStartTime() {
        final Date appStartTimeRef = this.appStartTime;
        return (appStartTimeRef != null) ? ((Date)appStartTimeRef.clone()) : null;
    }
    
    public void setAppStartTime(@Nullable final Date appStartTime) {
        this.appStartTime = appStartTime;
    }
    
    @Nullable
    public String getDeviceAppHash() {
        return this.deviceAppHash;
    }
    
    public void setDeviceAppHash(@Nullable final String deviceAppHash) {
        this.deviceAppHash = deviceAppHash;
    }
    
    @Nullable
    public String getBuildType() {
        return this.buildType;
    }
    
    public void setBuildType(@Nullable final String buildType) {
        this.buildType = buildType;
    }
    
    @Nullable
    public String getAppName() {
        return this.appName;
    }
    
    public void setAppName(@Nullable final String appName) {
        this.appName = appName;
    }
    
    @Nullable
    public String getAppVersion() {
        return this.appVersion;
    }
    
    public void setAppVersion(@Nullable final String appVersion) {
        this.appVersion = appVersion;
    }
    
    @Nullable
    public String getAppBuild() {
        return this.appBuild;
    }
    
    public void setAppBuild(@Nullable final String appBuild) {
        this.appBuild = appBuild;
    }
    
    @Nullable
    public Map<String, String> getPermissions() {
        return this.permissions;
    }
    
    public void setPermissions(@Nullable final Map<String, String> permissions) {
        this.permissions = permissions;
    }
    
    @Nullable
    public Boolean getInForeground() {
        return this.inForeground;
    }
    
    public void setInForeground(@Nullable final Boolean inForeground) {
        this.inForeground = inForeground;
    }
    
    @Nullable
    public List<String> getViewNames() {
        return this.viewNames;
    }
    
    public void setViewNames(@Nullable final List<String> viewNames) {
        this.viewNames = viewNames;
    }
    
    @Nullable
    public String getStartType() {
        return this.startType;
    }
    
    public void setStartType(@Nullable final String startType) {
        this.startType = startType;
    }
    
    @Nullable
    public Boolean getSplitApks() {
        return this.isSplitApks;
    }
    
    public void setSplitApks(@Nullable final Boolean splitApks) {
        this.isSplitApks = splitApks;
    }
    
    @Nullable
    public List<String> getSplitNames() {
        return this.splitNames;
    }
    
    public void setSplitNames(@Nullable final List<String> splitNames) {
        this.splitNames = splitNames;
    }
    
    @Override
    public boolean equals(final Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || this.getClass() != o.getClass()) {
            return false;
        }
        final App app = (App)o;
        return Objects.equals(this.appIdentifier, app.appIdentifier) && Objects.equals(this.appStartTime, app.appStartTime) && Objects.equals(this.deviceAppHash, app.deviceAppHash) && Objects.equals(this.buildType, app.buildType) && Objects.equals(this.appName, app.appName) && Objects.equals(this.appVersion, app.appVersion) && Objects.equals(this.appBuild, app.appBuild) && Objects.equals(this.permissions, app.permissions) && Objects.equals(this.inForeground, app.inForeground) && Objects.equals(this.viewNames, app.viewNames) && Objects.equals(this.startType, app.startType) && Objects.equals(this.isSplitApks, app.isSplitApks) && Objects.equals(this.splitNames, app.splitNames);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(this.appIdentifier, this.appStartTime, this.deviceAppHash, this.buildType, this.appName, this.appVersion, this.appBuild, this.permissions, this.inForeground, this.viewNames, this.startType, this.isSplitApks, this.splitNames);
    }
    
    @Nullable
    @Override
    public Map<String, Object> getUnknown() {
        return this.unknown;
    }
    
    @Override
    public void setUnknown(@Nullable final Map<String, Object> unknown) {
        this.unknown = unknown;
    }
    
    @Override
    public void serialize(@NotNull final ObjectWriter writer, @NotNull final ILogger logger) throws IOException {
        writer.beginObject();
        if (this.appIdentifier != null) {
            writer.name("app_identifier").value(this.appIdentifier);
        }
        if (this.appStartTime != null) {
            writer.name("app_start_time").value(logger, this.appStartTime);
        }
        if (this.deviceAppHash != null) {
            writer.name("device_app_hash").value(this.deviceAppHash);
        }
        if (this.buildType != null) {
            writer.name("build_type").value(this.buildType);
        }
        if (this.appName != null) {
            writer.name("app_name").value(this.appName);
        }
        if (this.appVersion != null) {
            writer.name("app_version").value(this.appVersion);
        }
        if (this.appBuild != null) {
            writer.name("app_build").value(this.appBuild);
        }
        if (this.permissions != null && !this.permissions.isEmpty()) {
            writer.name("permissions").value(logger, this.permissions);
        }
        if (this.inForeground != null) {
            writer.name("in_foreground").value(this.inForeground);
        }
        if (this.viewNames != null) {
            writer.name("view_names").value(logger, this.viewNames);
        }
        if (this.startType != null) {
            writer.name("start_type").value(this.startType);
        }
        if (this.isSplitApks != null) {
            writer.name("is_split_apks").value(this.isSplitApks);
        }
        if (this.splitNames != null && !this.splitNames.isEmpty()) {
            writer.name("split_names").value(logger, this.splitNames);
        }
        if (this.unknown != null) {
            for (final String key : this.unknown.keySet()) {
                final Object value = this.unknown.get(key);
                writer.name(key).value(logger, value);
            }
        }
        writer.endObject();
    }
    
    public static final class JsonKeys
    {
        public static final String APP_IDENTIFIER = "app_identifier";
        public static final String APP_START_TIME = "app_start_time";
        public static final String DEVICE_APP_HASH = "device_app_hash";
        public static final String BUILD_TYPE = "build_type";
        public static final String APP_NAME = "app_name";
        public static final String APP_VERSION = "app_version";
        public static final String APP_BUILD = "app_build";
        public static final String APP_PERMISSIONS = "permissions";
        public static final String IN_FOREGROUND = "in_foreground";
        public static final String VIEW_NAMES = "view_names";
        public static final String START_TYPE = "start_type";
        public static final String IS_SPLIT_APKS = "is_split_apks";
        public static final String SPLIT_NAMES = "split_names";
    }
    
    public static final class Deserializer implements JsonDeserializer<App>
    {
        @NotNull
        @Override
        public App deserialize(@NotNull final ObjectReader reader, @NotNull final ILogger logger) throws Exception {
            reader.beginObject();
            final App app = new App();
            Map<String, Object> unknown = null;
            while (reader.peek() == JsonToken.NAME) {
                final String nextName2;
                final String nextName = nextName2 = reader.nextName();
                switch (nextName2) {
                    case "app_identifier": {
                        app.appIdentifier = reader.nextStringOrNull();
                        continue;
                    }
                    case "app_start_time": {
                        app.appStartTime = reader.nextDateOrNull(logger);
                        continue;
                    }
                    case "device_app_hash": {
                        app.deviceAppHash = reader.nextStringOrNull();
                        continue;
                    }
                    case "build_type": {
                        app.buildType = reader.nextStringOrNull();
                        continue;
                    }
                    case "app_name": {
                        app.appName = reader.nextStringOrNull();
                        continue;
                    }
                    case "app_version": {
                        app.appVersion = reader.nextStringOrNull();
                        continue;
                    }
                    case "app_build": {
                        app.appBuild = reader.nextStringOrNull();
                        continue;
                    }
                    case "permissions": {
                        app.permissions = (Map<String, String>)CollectionUtils.newConcurrentHashMap((Map<Object, Object>)reader.nextObjectOrNull());
                        continue;
                    }
                    case "in_foreground": {
                        app.inForeground = reader.nextBooleanOrNull();
                        continue;
                    }
                    case "view_names": {
                        final List<String> viewNames = (List<String>)reader.nextObjectOrNull();
                        if (viewNames != null) {
                            app.setViewNames(viewNames);
                            continue;
                        }
                        continue;
                    }
                    case "start_type": {
                        app.startType = reader.nextStringOrNull();
                        continue;
                    }
                    case "is_split_apks": {
                        app.isSplitApks = reader.nextBooleanOrNull();
                        continue;
                    }
                    case "split_names": {
                        final List<String> splitNames = (List<String>)reader.nextObjectOrNull();
                        if (splitNames != null) {
                            app.setSplitNames(splitNames);
                            continue;
                        }
                        continue;
                    }
                    default: {
                        if (unknown == null) {
                            unknown = new ConcurrentHashMap<String, Object>();
                        }
                        reader.nextUnknown(logger, unknown, nextName);
                        continue;
                    }
                }
            }
            app.setUnknown(unknown);
            reader.endObject();
            return app;
        }
    }
}