package com.discord.gateway;

import android.content.Context;
import c.d.b.a.a;
import c.i.d.c;
import c.i.d.e;
import com.discord.api.activity.Activity;
import com.discord.api.activity.ActivityType;
import com.discord.api.activity.ActivityTypeTypeAdapter;
import com.discord.api.channel.Channel;
import com.discord.api.guild.Guild;
import com.discord.api.presence.ClientStatus;
import com.discord.gateway.GatewaySocketLogger;
import com.discord.gateway.io.Incoming;
import com.discord.gateway.io.IncomingParser;
import com.discord.gateway.io.Outgoing;
import com.discord.gateway.io.OutgoingPayload;
import com.discord.gateway.opcodes.Opcode;
import com.discord.gateway.rest.RestClient;
import com.discord.gateway.rest.RestConfig;
import com.discord.models.domain.Model;
import com.discord.models.domain.ModelPayload;
import com.discord.utilities.logging.Logger;
import com.discord.utilities.networking.Backoff;
import com.discord.utilities.networking.NetworkMonitor;
import com.discord.utilities.time.Clock;
import com.discord.utilities.time.ClockFactory;
import com.discord.utilities.websocket.WebSocket;
import com.google.gson.Gson;
import com.google.gson.stream.JsonReader;
import d0.t.h0;
import d0.t.n0;
import d0.t.u;
import d0.z.d.e0;
import d0.z.d.m;
import d0.z.d.o;
import j0.k.b;
import j0.l.a.r;
import j0.l.a.v1;
import j0.l.a.w1;
import j0.l.e.j;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import javax.net.ssl.SSLSocketFactory;
import kotlin.NoWhenBranchMatchedException;
import kotlin.Pair;
import kotlin.Unit;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.DefaultConstructorMarker;
import rx.Observable;
import rx.Scheduler;
import rx.Subscription;
import rx.functions.Action1;
/* compiled from: GatewaySocket.kt */
public final class GatewaySocket {
    private static final long CLIENT_CAPABILITIES = 95;
    private static final int CLOSE_CODE_CLEAN = 1000;
    private static final int CLOSE_CODE_DIRTY = 4000;
    private static final int CLOSE_CODE_UNAUTHORIZED = 4004;
    private static final boolean COMPRESS_DATA = true;
    private static final int CONNECTED = 5;
    private static final int CONNECTING = 2;
    public static final Companion Companion = new Companion(null);
    private static final long DEDUPE_USER_OBJECTS = 16;
    private static final int DISCONNECTED = 0;
    private static final int DISCOVERING = 1;
    private static final Set<String> EXPECTED_NULL_DATA_EVENTS = n0.setOf((Object[]) new String[]{"USER_SUBSCRIPTIONS_UPDATE", "USER_PAYMENT_SOURCES_UPDATE"});
    private static final String GATEWAY_COMPRESSION = "zlib-stream";
    private static final String GATEWAY_ENCODING = "json";
    private static final int GATEWAY_URL_RESET_THRESHOLD = 4;
    private static final int GATEWAY_VERSION = 9;
    private static final int HEARTBEAT_MAX_RESUME_THRESHOLD = 180000;
    private static final long HELLO_TIMEOUT = 20000;
    private static final int IDENTIFYING = 3;
    private static final int LARGE_GUILD_THRESHOLD = 100;
    private static final long LAZY_USER_NOTES = 1;
    private static final long MULTIPLE_GUILD_EXPERIMENT_POPULATIONS = 64;
    private static final long NO_AFFINE_USER_IDS = 2;
    private static final int RESUMING = 4;
    private static final long VERSIONED_READ_STATES = 4;
    private static final long VERSIONED_USER_GUILD_SETTINGS = 8;
    private static final Clock clock = ClockFactory.get();
    private static final Gson gsonIncludeNulls;
    private static final Gson gsonOmitNulls;
    private boolean connected;
    private boolean connectionReady;
    private long connectionStartTime;
    private int connectionState;
    private final GatewayEventHandler eventHandler;
    private final Backoff gatewayBackoff;
    private final GatewayDiscovery gatewayDiscovery;
    private final GatewaySocketLogger gatewaySocketLogger;
    private final Function1<String, String> gatewayUrlTransform;
    private boolean hasConnectedOnce;
    private boolean heartbeatAck;
    private long heartbeatAckTimeMostRecent;
    private Timer heartbeatExpeditedTimeout;
    private long heartbeatInterval;
    private Timer heartbeater;
    private Timer helloTimeout;
    private final Function0<IdentifyData> identifyDataProvider;
    private final Map<String, Object> identifyProperties;
    private long identifyStartTime;
    private final Logger logger;
    private boolean nextReconnectIsImmediate;
    private int replayedEvents;
    private final Scheduler scheduler;
    private int seq;
    private String sessionId;
    private final SSLSocketFactory sslSocketFactory;
    private String token;
    private final Function1<Map<String, ? extends Object>, Unit> trackReadyPayload;
    private WebSocket webSocket;

    /* compiled from: GatewaySocket.kt */
    /* renamed from: com.discord.gateway.GatewaySocket$1  reason: invalid class name */
    public static final class AnonymousClass1 extends o implements Function1<String, Unit> {
        public final /* synthetic */ GatewaySocket this$0;

        /* JADX INFO: super call moved to the top of the method (can break code semantics) */
        public AnonymousClass1(GatewaySocket gatewaySocket) {
            super(1);
            this.this$0 = gatewaySocket;
        }

        /* Return type fixed from 'java.lang.Object' to match base method */
        /* JADX DEBUG: Method arguments types fixed to match base method, original types: [java.lang.Object] */
        @Override // kotlin.jvm.functions.Function1
        public /* bridge */ /* synthetic */ Unit invoke(String str) {
            invoke(str);
            return Unit.a;
        }

        public final void invoke(String str) {
            m.checkNotNullParameter(str, "message");
            Companion.log$default(GatewaySocket.Companion, GatewaySocket.access$getLogger$p(this.this$0), str, false, 2, null);
        }
    }

    /* compiled from: GatewaySocket.kt */
    /* renamed from: com.discord.gateway.GatewaySocket$2  reason: invalid class name */
    public static final class AnonymousClass2<T, R> implements b<Boolean, Boolean> {
        public static final AnonymousClass2 INSTANCE = new AnonymousClass2();

        public final Boolean call(Boolean bool) {
            return bool;
        }
    }

    /* compiled from: GatewaySocket.kt */
    /* renamed from: com.discord.gateway.GatewaySocket$3  reason: invalid class name */
    public static final class AnonymousClass3<T> implements Action1<Boolean> {
        public final /* synthetic */ GatewaySocket this$0;

        public AnonymousClass3(GatewaySocket gatewaySocket) {
            this.this$0 = gatewaySocket;
        }

        public final void call(Boolean bool) {
            GatewaySocket gatewaySocket = this.this$0;
            m.checkNotNullExpressionValue(bool, "isConnected");
            GatewaySocket.access$handleDeviceConnectivityChange(gatewaySocket, bool.booleanValue());
        }
    }

    /* compiled from: GatewaySocket.kt */
    /* renamed from: com.discord.gateway.GatewaySocket$4  reason: invalid class name */
    public static final class AnonymousClass4<T> implements Action1<Throwable> {
        public final /* synthetic */ GatewaySocket this$0;

        public AnonymousClass4(GatewaySocket gatewaySocket) {
            this.this$0 = gatewaySocket;
        }

        public final void call(Throwable th) {
            Logger access$getLogger$p = GatewaySocket.access$getLogger$p(this.this$0);
            StringBuilder L = a.L("failed to handle connectivity change in ");
            L.append(this.this$0.getClass().getSimpleName());
            Logger.e$default(access$getLogger$p, L.toString(), th, null, 4, null);
        }
    }

    /* compiled from: GatewaySocket.kt */
    public static final class Companion {
        private Companion() {
        }

        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
            this();
        }

        public static final /* synthetic */ void access$log(Companion companion, Logger logger, String str, boolean z2) {
            companion.log(logger, str, z2);
        }

        private final long getDelay(long j, Long l) {
            return (l != null ? l.longValue() : ClockFactory.get().currentTimeMillis()) - j;
        }

        public static /* synthetic */ long getDelay$default(Companion companion, long j, Long l, int i, Object obj) {
            if ((i & 2) != 0) {
                l = null;
            }
            return companion.getDelay(j, l);
        }

        private final void log(Logger logger, String str, boolean z2) {
            Logger.v$default(logger, a.u("[GatewaySocket] ", str), null, 2, null);
            if (z2) {
                logger.recordBreadcrumb("Gateway [" + str + ']', "log");
            }
        }

        public static /* synthetic */ void log$default(Companion companion, Logger logger, String str, boolean z2, int i, Object obj) {
            if ((i & 2) != 0) {
                z2 = true;
            }
            companion.log(logger, str, z2);
        }
    }

    /* compiled from: GatewaySocket.kt */
    public static final class IdentifyData {
        private final OutgoingPayload.IdentifyClientState clientState;
        private final String token;

        public IdentifyData(String str, OutgoingPayload.IdentifyClientState identifyClientState) {
            m.checkNotNullParameter(str, "token");
            this.token = str;
            this.clientState = identifyClientState;
        }

        public final OutgoingPayload.IdentifyClientState getClientState() {
            return this.clientState;
        }

        public final String getToken() {
            return this.token;
        }
    }

    /* compiled from: GatewaySocket.kt */
    public static final class SizeRecordingInputStreamReader extends Reader {
        private int size;
        private final InputStreamReader source;

        public SizeRecordingInputStreamReader(InputStreamReader inputStreamReader, int i) {
            m.checkNotNullParameter(inputStreamReader, "source");
            this.source = inputStreamReader;
            this.size = i;
        }

        /* JADX INFO: this call moved to the top of the method (can break code semantics) */
        public /* synthetic */ SizeRecordingInputStreamReader(InputStreamReader inputStreamReader, int i, int i2, DefaultConstructorMarker defaultConstructorMarker) {
            this(inputStreamReader, (i2 & 2) != 0 ? 0 : i);
        }

        @Override // java.io.Reader, java.io.Closeable, java.lang.AutoCloseable
        public void close() {
            this.source.close();
        }

        public final int getSize() {
            return this.size;
        }

        public final InputStreamReader getSource() {
            return this.source;
        }

        @Override // java.io.Reader
        public int read(char[] cArr, int i, int i2) {
            m.checkNotNullParameter(cArr, "buffer");
            int read = this.source.read(cArr, i, i2);
            if (read != -1) {
                this.size += read;
            }
            return read;
        }

        public final void setSize(int i) {
            this.size = i;
        }
    }

    /* compiled from: GatewaySocket.kt */
    public static final class Timer implements Backoff.Scheduler {
        private final Scheduler scheduler;
        private Subscription subscription;

        public Timer(Scheduler scheduler) {
            m.checkNotNullParameter(scheduler, "scheduler");
            this.scheduler = scheduler;
        }

        public static final /* synthetic */ Subscription access$getSubscription$p(Timer timer) {
            return timer.subscription;
        }

        public static final /* synthetic */ void access$setSubscription$p(Timer timer, Subscription subscription) {
            timer.subscription = subscription;
        }

        /* JADX DEBUG: Multi-variable search result rejected for r0v0, resolved type: com.discord.gateway.GatewaySocket$Timer */
        /* JADX WARN: Multi-variable type inference failed */
        public static /* synthetic */ void cancel$default(Timer timer, Function0 function0, int i, Object obj) {
            if ((i & 1) != 0) {
                function0 = null;
            }
            timer.cancel(function0);
        }

        @Override // com.discord.utilities.networking.Backoff.Scheduler
        public void cancel() {
            cancel(null);
        }

        public final void cancel(Function0<Unit> function0) {
            Subscription subscription = this.subscription;
            if (subscription != null) {
                if (subscription != null) {
                    subscription.unsubscribe();
                }
                this.subscription = null;
                if (function0 != null) {
                    function0.mo1invoke();
                }
            }
        }

        public final boolean getPending() {
            return this.subscription != null;
        }

        public final void postInterval(Function0<Unit> function0, long j) {
            m.checkNotNullParameter(function0, "callback");
            cancel();
            this.subscription = Observable.E(j, j, TimeUnit.MILLISECONDS, j0.p.a.a()).I(this.scheduler).W(new GatewaySocket$Timer$postInterval$1(function0), GatewaySocket$Timer$postInterval$2.INSTANCE);
        }

        @Override // com.discord.utilities.networking.Backoff.Scheduler
        public void schedule(Function0<Unit> function0, long j) {
            m.checkNotNullParameter(function0, "action");
            cancel();
            this.subscription = Observable.d0(j, TimeUnit.MILLISECONDS).I(this.scheduler).W(new GatewaySocket$Timer$schedule$1(this, function0), GatewaySocket$Timer$schedule$2.INSTANCE);
        }
    }

    public final /* synthetic */ class WhenMappings {
        public static final /* synthetic */ int[] $EnumSwitchMapping$0;
        public static final /* synthetic */ int[] $EnumSwitchMapping$1;

        static {
            GatewaySocketLogger.LogLevel.values();
            int[] iArr = new int[2];
            $EnumSwitchMapping$0 = iArr;
            iArr[GatewaySocketLogger.LogLevel.NONE.ordinal()] = 1;
            iArr[GatewaySocketLogger.LogLevel.VERBOSE.ordinal()] = 2;
            Opcode.values();
            int[] iArr2 = new int[20];
            $EnumSwitchMapping$1 = iArr2;
            iArr2[Opcode.HELLO.ordinal()] = 1;
            iArr2[Opcode.RECONNECT.ordinal()] = 2;
            iArr2[Opcode.INVALID_SESSION.ordinal()] = 3;
            iArr2[Opcode.HEARTBEAT.ordinal()] = 4;
            iArr2[Opcode.HEARTBEAT_ACK.ordinal()] = 5;
            iArr2[Opcode.DISPATCH.ordinal()] = 6;
        }
    }

    static {
        e eVar = new e();
        eVar.g = true;
        c cVar = c.LOWER_CASE_WITH_UNDERSCORES;
        eVar.f1382c = cVar;
        eVar.b(ActivityType.class, new ActivityTypeTypeAdapter());
        gsonIncludeNulls = eVar.a();
        e eVar2 = new e();
        eVar2.f1382c = cVar;
        gsonOmitNulls = eVar2.a();
    }

    /* JADX DEBUG: Multi-variable search result rejected for r22v0, resolved type: kotlin.jvm.functions.Function1<? super java.util.Map<java.lang.String, ? extends java.lang.Object>, kotlin.Unit> */
    /* JADX DEBUG: Multi-variable search result rejected for r29v0, resolved type: kotlin.jvm.functions.Function1<? super java.lang.String, java.lang.String> */
    /* JADX WARN: Multi-variable type inference failed */
    public GatewaySocket(Function0<IdentifyData> function0, Function1<? super Map<String, ? extends Object>, Unit> function1, GatewayEventHandler gatewayEventHandler, Scheduler scheduler, Logger logger, NetworkMonitor networkMonitor, RestConfig restConfig, Context context, Function1<? super String, String> function12, SSLSocketFactory sSLSocketFactory, Map<String, ? extends Object> map, GatewaySocketLogger gatewaySocketLogger) {
        m.checkNotNullParameter(function0, "identifyDataProvider");
        m.checkNotNullParameter(function1, "trackReadyPayload");
        m.checkNotNullParameter(gatewayEventHandler, "eventHandler");
        m.checkNotNullParameter(scheduler, "scheduler");
        m.checkNotNullParameter(logger, "logger");
        m.checkNotNullParameter(networkMonitor, "networkMonitor");
        m.checkNotNullParameter(restConfig, "restConfig");
        m.checkNotNullParameter(context, "context");
        m.checkNotNullParameter(map, "identifyProperties");
        m.checkNotNullParameter(gatewaySocketLogger, "gatewaySocketLogger");
        this.identifyDataProvider = function0;
        this.trackReadyPayload = function1;
        this.eventHandler = gatewayEventHandler;
        this.scheduler = scheduler;
        this.logger = logger;
        this.gatewayUrlTransform = function12;
        this.sslSocketFactory = sSLSocketFactory;
        this.identifyProperties = map;
        this.gatewaySocketLogger = gatewaySocketLogger;
        Backoff backoff = new Backoff(1000, 10000, 4, true, new Timer(scheduler));
        this.gatewayBackoff = backoff;
        this.heartbeatExpeditedTimeout = new Timer(scheduler);
        this.heartbeatInterval = Long.MAX_VALUE;
        this.heartbeater = new Timer(scheduler);
        this.heartbeatAck = true;
        this.helloTimeout = new Timer(scheduler);
        RestClient restClient = RestClient.INSTANCE;
        restClient.init(restConfig, context);
        this.gatewayDiscovery = new GatewayDiscovery(context, scheduler, backoff, new AnonymousClass1(this), restClient.getGateway());
        Observable<Boolean> I = networkMonitor.observeIsConnected().I(scheduler);
        Observable.h0(new r(I.i, new w1(new v1(AnonymousClass2.INSTANCE)))).W(new AnonymousClass3(this), new AnonymousClass4(this));
    }

    /* JADX INFO: this call moved to the top of the method (can break code semantics) */
    public /* synthetic */ GatewaySocket(Function0 function0, Function1 function1, GatewayEventHandler gatewayEventHandler, Scheduler scheduler, Logger logger, NetworkMonitor networkMonitor, RestConfig restConfig, Context context, Function1 function12, SSLSocketFactory sSLSocketFactory, Map map, GatewaySocketLogger gatewaySocketLogger, int i, DefaultConstructorMarker defaultConstructorMarker) {
        this(function0, function1, gatewayEventHandler, scheduler, logger, networkMonitor, restConfig, context, (i & 256) != 0 ? null : function12, (i & 512) != 0 ? null : sSLSocketFactory, (i & 1024) != 0 ? h0.emptyMap() : map, gatewaySocketLogger);
    }

    public static final /* synthetic */ void access$cleanup(GatewaySocket gatewaySocket, Function1 function1) {
        gatewaySocket.cleanup(function1);
    }

    public static final /* synthetic */ void access$connect(GatewaySocket gatewaySocket, String str) {
        gatewaySocket.connect(str);
    }

    public static final /* synthetic */ void access$discover(GatewaySocket gatewaySocket) {
        gatewaySocket.discover();
    }

    public static final /* synthetic */ void access$discoveryFailed(GatewaySocket gatewaySocket) {
        gatewaySocket.discoveryFailed();
    }

    public static final /* synthetic */ long access$getConnectionStartTime$p(GatewaySocket gatewaySocket) {
        return gatewaySocket.connectionStartTime;
    }

    public static final /* synthetic */ int access$getConnectionState$p(GatewaySocket gatewaySocket) {
        return gatewaySocket.connectionState;
    }

    public static final /* synthetic */ Backoff access$getGatewayBackoff$p(GatewaySocket gatewaySocket) {
        return gatewaySocket.gatewayBackoff;
    }

    public static final /* synthetic */ GatewaySocketLogger access$getGatewaySocketLogger$p(GatewaySocket gatewaySocket) {
        return gatewaySocket.gatewaySocketLogger;
    }

    public static final /* synthetic */ Function1 access$getGatewayUrlTransform$p(GatewaySocket gatewaySocket) {
        return gatewaySocket.gatewayUrlTransform;
    }

    public static final /* synthetic */ Gson access$getGsonOmitNulls$cp() {
        return gsonOmitNulls;
    }

    public static final /* synthetic */ boolean access$getHeartbeatAck$p(GatewaySocket gatewaySocket) {
        return gatewaySocket.heartbeatAck;
    }

    public static final /* synthetic */ Timer access$getHeartbeatExpeditedTimeout$p(GatewaySocket gatewaySocket) {
        return gatewaySocket.heartbeatExpeditedTimeout;
    }

    public static final /* synthetic */ Logger access$getLogger$p(GatewaySocket gatewaySocket) {
        return gatewaySocket.logger;
    }

    public static final /* synthetic */ boolean access$getNextReconnectIsImmediate$p(GatewaySocket gatewaySocket) {
        return gatewaySocket.nextReconnectIsImmediate;
    }

    public static final /* synthetic */ int access$getSeq$p(GatewaySocket gatewaySocket) {
        return gatewaySocket.seq;
    }

    public static final /* synthetic */ WebSocket access$getWebSocket$p(GatewaySocket gatewaySocket) {
        return gatewaySocket.webSocket;
    }

    public static final /* synthetic */ void access$handleClose(GatewaySocket gatewaySocket, boolean z2, int i, String str) {
        gatewaySocket.handleClose(z2, i, str);
    }

    public static final /* synthetic */ void access$handleDeviceConnectivityChange(GatewaySocket gatewaySocket, boolean z2) {
        gatewaySocket.handleDeviceConnectivityChange(z2);
    }

    public static final /* synthetic */ void access$handleHeartbeatTimeout(GatewaySocket gatewaySocket) {
        gatewaySocket.handleHeartbeatTimeout();
    }

    public static final /* synthetic */ void access$handleWebSocketClose(GatewaySocket gatewaySocket, WebSocket.Closed closed) {
        gatewaySocket.handleWebSocketClose(closed);
    }

    public static final /* synthetic */ void access$handleWebSocketError(GatewaySocket gatewaySocket) {
        gatewaySocket.handleWebSocketError();
    }

    public static final /* synthetic */ void access$handleWebSocketMessage(GatewaySocket gatewaySocket, InputStreamReader inputStreamReader, int i) {
        gatewaySocket.handleWebSocketMessage(inputStreamReader, i);
    }

    public static final /* synthetic */ void access$handleWebSocketOpened(GatewaySocket gatewaySocket, String str) {
        gatewaySocket.handleWebSocketOpened(str);
    }

    public static final /* synthetic */ void access$heartbeat(GatewaySocket gatewaySocket, int i) {
        gatewaySocket.heartbeat(i);
    }

    public static final /* synthetic */ void access$logError(GatewaySocket gatewaySocket, String str, Exception exc, Map map) {
        gatewaySocket.logError(str, exc, map);
    }

    public static final /* synthetic */ void access$reset(GatewaySocket gatewaySocket, boolean z2, int i, String str) {
        gatewaySocket.reset(z2, i, str);
    }

    public static final /* synthetic */ void access$setConnectionStartTime$p(GatewaySocket gatewaySocket, long j) {
        gatewaySocket.connectionStartTime = j;
    }

    public static final /* synthetic */ void access$setConnectionState$p(GatewaySocket gatewaySocket, int i) {
        gatewaySocket.connectionState = i;
    }

    public static final /* synthetic */ void access$setHeartbeatAck$p(GatewaySocket gatewaySocket, boolean z2) {
        gatewaySocket.heartbeatAck = z2;
    }

    public static final /* synthetic */ void access$setHeartbeatExpeditedTimeout$p(GatewaySocket gatewaySocket, Timer timer) {
        gatewaySocket.heartbeatExpeditedTimeout = timer;
    }

    public static final /* synthetic */ void access$setNextReconnectIsImmediate$p(GatewaySocket gatewaySocket, boolean z2) {
        gatewaySocket.nextReconnectIsImmediate = z2;
    }

    public static final /* synthetic */ void access$setSeq$p(GatewaySocket gatewaySocket, int i) {
        gatewaySocket.seq = i;
    }

    public static final /* synthetic */ void access$setWebSocket$p(GatewaySocket gatewaySocket, WebSocket webSocket) {
        gatewaySocket.webSocket = webSocket;
    }

    private final void cleanup(Function1<? super WebSocket, Unit> function1) {
        stopHeartbeater();
        clearHelloTimeout();
        if (function1 != null) {
            function1.invoke(this.webSocket);
        }
        WebSocket webSocket = this.webSocket;
        if (webSocket != null) {
            webSocket.resetListeners();
        }
        this.webSocket = null;
        this.gatewayBackoff.cancel();
    }

    private final void clearHelloTimeout() {
        this.helloTimeout.cancel();
    }

    public static /* synthetic */ void close$default(GatewaySocket gatewaySocket, boolean z2, int i, Object obj) {
        if ((i & 1) != 0) {
            z2 = true;
        }
        gatewaySocket.close(z2);
    }

    private final void connect(String str) {
        GatewaySocket$connect$$inlined$apply$lambda$4 gatewaySocket$connect$$inlined$apply$lambda$4;
        if (this.connectionState == 1) {
            this.connectionState = 2;
            Companion.log$default(Companion, this.logger, a.v("Connect to: ", str, ", encoding: json, version 9."), false, 2, null);
            cleanup(GatewaySocket$connect$2.INSTANCE);
            this.connectionStartTime = clock.currentTimeMillis();
            this.helloTimeout.schedule(new GatewaySocket$connect$3(this), 20000);
            WebSocket webSocket = new WebSocket(this.scheduler, new GatewaySocket$connect$4(this), this.sslSocketFactory);
            webSocket.setOnOpened(new GatewaySocket$connect$$inlined$apply$lambda$1(this, str));
            webSocket.setOnClosed(new GatewaySocket$connect$$inlined$apply$lambda$2(this, str));
            webSocket.setOnMessage(new GatewaySocket$connect$$inlined$apply$lambda$3(this, str));
            int ordinal = this.gatewaySocketLogger.getLogLevel().ordinal();
            if (ordinal == 0) {
                gatewaySocket$connect$$inlined$apply$lambda$4 = null;
            } else if (ordinal == 1) {
                gatewaySocket$connect$$inlined$apply$lambda$4 = new GatewaySocket$connect$$inlined$apply$lambda$4(this, str);
            } else {
                throw new NoWhenBranchMatchedException();
            }
            webSocket.setRawMessageHandler(gatewaySocket$connect$$inlined$apply$lambda$4);
            webSocket.setOnError(new GatewaySocket$connect$$inlined$apply$lambda$5(this, str));
            webSocket.connect(str + "/?encoding=json&v=9&compress=zlib-stream");
            this.webSocket = webSocket;
        }
    }

    private final void discover() {
        this.nextReconnectIsImmediate = false;
        if (this.connectionState == 1) {
            this.gatewayDiscovery.discoverGatewayUrl(new GatewaySocket$discover$1(this), new GatewaySocket$discover$2(this));
        }
    }

    private final void discoveryFailed() {
        Companion.log$default(Companion, this.logger, a.r("Discovery failed, retrying in ", this.gatewayBackoff.fail(new GatewaySocket$discoveryFailed$delay$1(this)), "ms."), false, 2, null);
        if (this.gatewayBackoff.hasReachedFailureThreshold()) {
            reset(false, 0, "Gateway discovery failed.");
        }
    }

    private final void doIdentify() {
        this.seq = 0;
        this.sessionId = null;
        IdentifyData invoke = this.identifyDataProvider.mo1invoke();
        if (invoke == null) {
            handleClose(true, 4004, "No connection info provided.");
            return;
        }
        this.connectionState = 3;
        this.identifyStartTime = clock.currentTimeMillis();
        this.token = invoke.getToken();
        Companion.log$default(Companion, this.logger, "Sending identify.", false, 2, null);
        send$default(this, new Outgoing(Opcode.IDENTIFY, new OutgoingPayload.Identify(invoke.getToken(), 100, true, 95, this.identifyProperties, invoke.getClientState())), false, null, 4, null);
    }

    private final void doResume() {
        this.connectionState = 4;
        this.replayedEvents = 0;
        Companion companion = Companion;
        Logger logger = this.logger;
        StringBuilder L = a.L("Resuming session ");
        String str = this.sessionId;
        if (str == null) {
            str = "";
        }
        L.append(str);
        L.append(" at sequence: ");
        Companion.log$default(companion, logger, a.y(L, this.seq, '.'), false, 2, null);
        send$default(this, new Outgoing(Opcode.RESUME, new OutgoingPayload.Resume(this.token, this.sessionId, this.seq)), false, null, 4, null);
    }

    private final void doResumeOrIdentify() {
        Companion companion = Companion;
        long delay$default = Companion.getDelay$default(companion, this.heartbeatAckTimeMostRecent, null, 2, null);
        float f = this.heartbeatAckTimeMostRecent == 0 ? 0.0f : (((float) delay$default) / 1000.0f) / 60.0f;
        if (this.sessionId != null && delay$default <= ((long) 180000)) {
            Logger logger = this.logger;
            StringBuilder L = a.L("Attempting to resume after elapsed duration of ");
            String format = String.format("%.2f", Arrays.copyOf(new Object[]{Float.valueOf(f)}, 1));
            m.checkNotNullExpressionValue(format, "java.lang.String.format(this, *args)");
            L.append(format);
            L.append(" minutes.");
            Companion.log$default(companion, logger, L.toString(), false, 2, null);
            doResume();
        } else {
            handleInvalidSession(false);
        }
        this.heartbeatAckTimeMostRecent = clock.currentTimeMillis();
    }

    public static /* synthetic */ void expeditedHeartbeat$default(GatewaySocket gatewaySocket, long j, String str, boolean z2, int i, Object obj) {
        if ((i & 2) != 0) {
            str = null;
        }
        if ((i & 4) != 0) {
            z2 = true;
        }
        gatewaySocket.expeditedHeartbeat(j, str, z2);
    }

    /* JADX DEBUG: Multi-variable search result rejected for r4v7, resolved type: java.lang.Object */
    /* JADX WARN: Multi-variable type inference failed */
    private final void flattenTraces(Object obj, ArrayList<Pair<String, Integer>> arrayList) {
        if (obj != null) {
            try {
                if (e0.isMutableList(obj)) {
                    int i = 0;
                    while (true) {
                        int i2 = i + 1;
                        if (i2 < ((List) obj).size()) {
                            Object obj2 = ((List) obj).get(i);
                            Number number = null;
                            if (!(obj2 instanceof String)) {
                                obj2 = null;
                            }
                            String str = (String) obj2;
                            Object obj3 = ((List) obj).get(i2);
                            if (!e0.isMutableMap(obj3)) {
                                obj3 = null;
                            }
                            Map map = (Map) obj3;
                            i += 2;
                            if (!(str == null || map == null)) {
                                if (map.containsKey("micros")) {
                                    Object obj4 = map.get("micros");
                                    if (obj4 instanceof Number) {
                                        number = obj4;
                                    }
                                    number = number;
                                }
                                if (number != null) {
                                    arrayList.add(new Pair<>(str, Integer.valueOf(number.intValue() / 1000)));
                                }
                                flattenTraces(map.get("calls"), arrayList);
                            }
                        } else {
                            return;
                        }
                    }
                }
            } catch (Exception e) {
                Logger.e$default(this.logger, "Unable to parse ready payload traces", e, null, 4, null);
            }
        }
    }

    private final String getConnectionPath(ModelPayload.Hello hello) {
        String joinToString$default;
        List<String> trace = hello.getTrace();
        return (trace == null || (joinToString$default = u.joinToString$default(trace, " -> ", null, null, 0, null, null, 62, null)) == null) ? "???" : joinToString$default;
    }

    private final void handleClose(boolean z2, int i, String str) {
        cleanup(GatewaySocket$handleClose$1.INSTANCE);
        handleConnected$default(this, null, Boolean.FALSE, 1, null);
        if (i == 4004) {
            this.connectionState = 0;
            reset(z2, i, str);
            return;
        }
        this.connectionState = 1;
        StringBuilder sb = new StringBuilder();
        sb.append("Closed cleanly: ");
        sb.append(z2);
        sb.append(", with code: ");
        sb.append(i);
        sb.append(", for reason: '");
        String D = a.D(sb, str, "'.");
        if (this.nextReconnectIsImmediate) {
            Companion.log$default(Companion, this.logger, a.u(D, " Retrying immediately."), false, 2, null);
            discover();
            return;
        }
        long fail = this.gatewayBackoff.fail(new GatewaySocket$handleClose$delay$1(this));
        Companion companion = Companion;
        Logger logger = this.logger;
        Companion.log$default(companion, logger, D + " Retrying in: " + fail + "ms.", false, 2, null);
        if (this.gatewayBackoff.hasReachedFailureThreshold()) {
            reset(z2, i, str);
        }
    }

    private final void handleConnected(Boolean bool, Boolean bool2) {
        if (bool != null) {
            boolean booleanValue = bool.booleanValue();
            this.connected = booleanValue;
            this.hasConnectedOnce = this.hasConnectedOnce || booleanValue;
            this.eventHandler.handleConnected(booleanValue);
        }
        if (bool2 != null) {
            boolean booleanValue2 = bool2.booleanValue();
            this.connectionReady = booleanValue2;
            this.eventHandler.handleConnectionReady(booleanValue2);
        }
    }

    public static /* synthetic */ void handleConnected$default(GatewaySocket gatewaySocket, Boolean bool, Boolean bool2, int i, Object obj) {
        if ((i & 1) != 0) {
            bool = null;
        }
        if ((i & 2) != 0) {
            bool2 = null;
        }
        gatewaySocket.handleConnected(bool, bool2);
    }

    private final void handleDeviceConnectivityChange(boolean z2) {
        if (z2) {
            expeditedHeartbeat$default(this, 4500, "network detected online", false, 4, null);
        } else {
            expeditedHeartbeat$default(this, 9000, "network detected offline", false, 4, null);
        }
    }

    private final void handleDispatch(Object obj, String str, int i, int i2, long j) {
        if (this.connectionState == 4) {
            this.replayedEvents++;
        }
        if (m.areEqual(str, "READY") || m.areEqual(str, "RESUMED")) {
            if (str != null) {
                int hashCode = str.hashCode();
                if (hashCode != 77848963) {
                    if (hashCode == 1815529911 && str.equals("RESUMED")) {
                        StringBuilder sb = new StringBuilder();
                        StringBuilder L = a.L("Resumed session, took ");
                        Companion companion = Companion;
                        L.append(Companion.getDelay$default(companion, this.connectionStartTime, null, 2, null));
                        L.append("ms, ");
                        sb.append(L.toString());
                        sb.append("replayed " + this.replayedEvents + " events, new seq: " + this.seq + '.');
                        String sb2 = sb.toString();
                        m.checkNotNullExpressionValue(sb2, "StringBuilder()\n        …              .toString()");
                        Companion.log$default(companion, this.logger, sb2, false, 2, null);
                        this.replayedEvents = 0;
                    }
                } else if (str.equals("READY")) {
                    ModelPayload modelPayload = (ModelPayload) obj;
                    if (modelPayload == null) {
                        handleReconnect$default(this, "Reconnect due to invalid ready payload received.", false, 2, null);
                        return;
                    }
                    this.sessionId = modelPayload.getSessionId();
                    trackReadyPayload(modelPayload, i, i2, j);
                    Companion companion2 = Companion;
                    Logger logger = this.logger;
                    StringBuilder L2 = a.L("Ready with session id: ");
                    L2.append(this.sessionId);
                    L2.append(", took ");
                    Companion.log$default(companion2, logger, a.A(L2, Companion.getDelay$default(companion2, this.connectionStartTime, null, 2, null), "ms"), false, 2, null);
                }
            }
            this.gatewayBackoff.succeed();
            this.connectionState = 5;
            Boolean bool = Boolean.TRUE;
            handleConnected(bool, bool);
        }
        if (obj != null) {
            this.eventHandler.handleDispatch(str, obj);
        } else if (u.contains(EXPECTED_NULL_DATA_EVENTS, str)) {
            this.eventHandler.handleDispatch(str, Unit.a);
        } else if ((!m.areEqual(str, "READY")) && (!m.areEqual(str, "RESUMED"))) {
            Logger.w$default(this.logger, a.v("handleDispatch() ", str, " is unhandled!"), null, 2, null);
        }
    }

    private final void handleHeartbeat() {
        heartbeat(this.seq);
    }

    private final void handleHeartbeatAck() {
        Companion.access$log(Companion, this.logger, "Received heartbeat ACK.", false);
        this.heartbeatAckTimeMostRecent = clock.currentTimeMillis();
        this.heartbeatAck = true;
        this.heartbeatExpeditedTimeout.cancel(new GatewaySocket$handleHeartbeatAck$1(this));
    }

    private final void handleHeartbeatTimeout() {
        cleanup(GatewaySocket$handleHeartbeatTimeout$1.INSTANCE);
        this.connectionState = 1;
        Companion.log$default(Companion, this.logger, a.r("Ack timeout, reconnecting om ", this.gatewayBackoff.fail(new GatewaySocket$handleHeartbeatTimeout$delay$1(this)), "ms."), false, 2, null);
    }

    private final void handleHello(ModelPayload.Hello hello) {
        clearHelloTimeout();
        this.heartbeatInterval = (long) hello.getHeartbeatInterval();
        Companion companion = Companion;
        Logger logger = this.logger;
        StringBuilder L = a.L("Hello via ");
        L.append(getConnectionPath(hello));
        L.append(", at interval ");
        L.append(this.heartbeatInterval);
        L.append(" took ");
        Companion.log$default(companion, logger, a.A(L, Companion.getDelay$default(companion, this.connectionStartTime, null, 2, null), "ms."), false, 2, null);
        startHeartbeater();
    }

    private final void handleInvalidSession(boolean z2) {
        Companion.log$default(Companion, this.logger, a.D(a.L("Invalid session, is "), z2 ? "" : "not", " resumable."), false, 2, null);
        if (z2) {
            doResumeOrIdentify();
            return;
        }
        Boolean bool = Boolean.FALSE;
        handleConnected(bool, bool);
        doIdentify();
    }

    private final void handleReconnect(String str, boolean z2) {
        cleanup(new GatewaySocket$handleReconnect$1(str));
        reset(!z2, z2 ? 1000 : 4000, str);
        handleClose(!z2, 0, str);
    }

    public static /* synthetic */ void handleReconnect$default(GatewaySocket gatewaySocket, String str, boolean z2, int i, Object obj) {
        if ((i & 1) != 0) {
            str = "Reconnect to gateway requested.";
        }
        if ((i & 2) != 0) {
            z2 = true;
        }
        gatewaySocket.handleReconnect(str, z2);
    }

    /* JADX WARNING: Code restructure failed: missing block: B:6:0x0010, code lost:
        if ((r0.length() > 0) != false) goto L_0x0016;
     */
    private final void handleWebSocketClose(WebSocket.Closed closed) {
        String reason = closed.getReason();
        if (reason != null) {
        }
        reason = "unspecified reason";
        handleClose(true, closed.getCode(), reason);
    }

    private final void handleWebSocketError() {
        handleClose(false, 0, "An error with the web socket occurred.");
    }

    private final void handleWebSocketMessage(InputStreamReader inputStreamReader, int i) {
        long currentTimeMillis = clock.currentTimeMillis();
        SizeRecordingInputStreamReader sizeRecordingInputStreamReader = new SizeRecordingInputStreamReader(inputStreamReader, 0, 2, null);
        Incoming build = ((IncomingParser) new Model.JsonReader(new JsonReader(sizeRecordingInputStreamReader)).parse(new IncomingParser(new GatewaySocket$handleWebSocketMessage$incomingParser$1(this)))).build();
        Integer seq = build.getSeq();
        Companion companion = Companion;
        long delay$default = Companion.getDelay$default(companion, currentTimeMillis, null, 2, null);
        if (seq != null) {
            this.seq = seq.intValue();
        }
        int ordinal = build.getOpcode().ordinal();
        if (ordinal == 1) {
            handleDispatch(build.getData(), build.getType(), i, sizeRecordingInputStreamReader.getSize(), delay$default);
        } else if (ordinal == 2) {
            handleHeartbeat();
        } else if (ordinal != 8) {
            switch (ordinal) {
                case 10:
                    Object data = build.getData();
                    Objects.requireNonNull(data, "null cannot be cast to non-null type kotlin.Boolean");
                    handleInvalidSession(((Boolean) data).booleanValue());
                    return;
                case 11:
                    Object data2 = build.getData();
                    Objects.requireNonNull(data2, "null cannot be cast to non-null type com.discord.models.domain.ModelPayload.Hello");
                    handleHello((ModelPayload.Hello) data2);
                    return;
                case 12:
                    handleHeartbeatAck();
                    return;
                default:
                    Logger logger = this.logger;
                    StringBuilder L = a.L("Unhandled op code ");
                    L.append(build.getOpcode());
                    L.append('.');
                    Companion.log$default(companion, logger, L.toString(), false, 2, null);
                    return;
            }
        } else {
            handleReconnect$default(this, null, false, 1, null);
        }
    }

    private final void handleWebSocketOpened(String str) {
        Companion companion = Companion;
        Companion.log$default(companion, this.logger, a.A(a.Q("Connected to ", str, " in "), Companion.getDelay$default(companion, this.connectionStartTime, null, 2, null), "ms."), false, 2, null);
        doResumeOrIdentify();
    }

    private final void heartbeat(int i) {
        Companion companion = Companion;
        Logger logger = this.logger;
        Companion.access$log(companion, logger, "Sending heartbeat at sequence: " + i + '.', false);
        send$default(this, new Outgoing(Opcode.HEARTBEAT, Integer.valueOf(i)), false, null, 4, null);
    }

    private final void logError(String str, Exception exc, Map<String, String> map) {
        Logger logger = this.logger;
        if (map == null) {
            map = h0.emptyMap();
        }
        logger.e(str, exc, map);
    }

    /* JADX DEBUG: Multi-variable search result rejected for r2v0, resolved type: com.discord.gateway.GatewaySocket */
    /* JADX WARN: Multi-variable type inference failed */
    public static /* synthetic */ void presenceUpdate$default(GatewaySocket gatewaySocket, ClientStatus clientStatus, Long l, List list, Boolean bool, int i, Object obj) {
        if ((i & 2) != 0) {
            l = Long.valueOf(clock.currentTimeMillis());
        }
        if ((i & 4) != 0) {
            list = null;
        }
        if ((i & 8) != 0) {
            bool = Boolean.FALSE;
        }
        gatewaySocket.presenceUpdate(clientStatus, l, list, bool);
    }

    /* JADX DEBUG: Multi-variable search result rejected for r1v0, resolved type: com.discord.gateway.GatewaySocket */
    /* JADX WARN: Multi-variable type inference failed */
    public static /* synthetic */ void requestGuildMembers$default(GatewaySocket gatewaySocket, List list, String str, List list2, Integer num, int i, Object obj) {
        if ((i & 2) != 0) {
            str = null;
        }
        if ((i & 4) != 0) {
            list2 = null;
        }
        if ((i & 8) != 0) {
            num = null;
        }
        gatewaySocket.requestGuildMembers(list, str, list2, num);
    }

    private final void reset(boolean z2, int i, String str) {
        boolean z3 = false;
        if (i != 4000) {
            this.sessionId = null;
            this.seq = 0;
        }
        String str2 = z2 ? "cleanly" : "dirty";
        Companion companion = Companion;
        Logger logger = this.logger;
        Companion.log$default(companion, logger, "Reset " + str2 + ", with code " + i + ", at sequence " + this.seq + ". Reason: '" + str + "'.", false, 2, null);
        handleConnected(Boolean.valueOf(i == 4000 && this.connected), Boolean.FALSE);
        GatewayEventHandler gatewayEventHandler = this.eventHandler;
        if (i == 4004) {
            z3 = true;
        }
        gatewayEventHandler.handleDisconnect(z3);
    }

    private final void schedule(Function0<Unit> function0) {
        new j(function0).X(this.scheduler).W(GatewaySocket$schedule$1.INSTANCE, GatewaySocket$schedule$2.INSTANCE);
    }

    private final void send(Outgoing outgoing, boolean z2, Gson gson) {
        if (!z2 || isSessionEstablished()) {
            WebSocket webSocket = this.webSocket;
            if (webSocket == null) {
                Companion companion = Companion;
                Logger logger = this.logger;
                StringBuilder L = a.L("Attempted to send without a web socket that exists, opcode: ");
                L.append(outgoing.getOp());
                L.append('.');
                Companion.log$default(companion, logger, L.toString(), false, 2, null);
                return;
            }
            String m = gson.m(outgoing);
            GatewaySocketLogger gatewaySocketLogger = this.gatewaySocketLogger;
            m.checkNotNullExpressionValue(m, "json");
            gatewaySocketLogger.logOutboundMessage(m);
            webSocket.message(m);
            return;
        }
        Companion companion2 = Companion;
        Logger logger2 = this.logger;
        StringBuilder L2 = a.L("Attempted to send while not being in a connected state, opcode: ");
        L2.append(outgoing.getOp());
        L2.append('.');
        Companion.log$default(companion2, logger2, L2.toString(), false, 2, null);
    }

    public static /* synthetic */ void send$default(GatewaySocket gatewaySocket, Outgoing outgoing, boolean z2, Gson gson, int i, Object obj) {
        if ((i & 2) != 0) {
            z2 = true;
        }
        if ((i & 4) != 0) {
            gson = gsonIncludeNulls;
            m.checkNotNullExpressionValue(gson, "gsonIncludeNulls");
        }
        gatewaySocket.send(outgoing, z2, gson);
    }

    private final void startHeartbeater() {
        this.heartbeater.cancel();
        this.heartbeatAck = true;
        this.heartbeater.postInterval(new GatewaySocket$startHeartbeater$1(this), this.heartbeatInterval);
    }

    private final void stopHeartbeater() {
        this.heartbeater.cancel();
        this.heartbeatExpeditedTimeout.cancel();
    }

    /* JADX WARNING: Code restructure failed: missing block: B:14:0x0073, code lost:
        if (d0.g0.t.startsWith$default(r6.component1(), "gateway-", false, 2, null) != false) goto L_0x0077;
     */
    private final void trackReadyPayload(ModelPayload modelPayload, int i, int i2, long j) {
        int i3;
        int size = modelPayload.getGuilds().size();
        int i4 = 0;
        int i5 = 0;
        for (Guild guild : modelPayload.getGuilds()) {
            List<Channel> g = guild.g();
            if (g != null) {
                for (Channel channel : g) {
                    i4++;
                    if (channel.A() == 4) {
                        i5++;
                    }
                }
            }
        }
        ArrayList<Pair<String, Integer>> arrayList = new ArrayList<>();
        flattenTraces(modelPayload.getTrace(), arrayList);
        if (arrayList.size() > 0) {
            Pair<String, Integer> pair = arrayList.get(0);
            i3 = pair.component2().intValue();
        }
        i3 = 0;
        Iterator<Pair<String, Integer>> it = arrayList.iterator();
        int i6 = 0;
        int i7 = 0;
        while (it.hasNext()) {
            Pair<String, Integer> next = it.next();
            String component1 = next.component1();
            int intValue = next.component2().intValue();
            if (m.areEqual(component1, "start_session")) {
                i6 = intValue;
            } else if (m.areEqual(component1, "guilds_connect")) {
                i7 = intValue;
            }
        }
        Function1<Map<String, ? extends Object>, Unit> function1 = this.trackReadyPayload;
        Companion companion = Companion;
        function1.invoke(h0.mapOf(d0.o.to("duration_ms_since_connection_start", Long.valueOf(Companion.getDelay$default(companion, this.connectionStartTime, null, 2, null))), d0.o.to("duration_ms_since_identify_start", Long.valueOf(Companion.getDelay$default(companion, this.identifyStartTime, null, 2, null))), d0.o.to("identify_total_server_duration_ms", Integer.valueOf(i3)), d0.o.to("identify_api_duration_ms", Integer.valueOf(i6)), d0.o.to("identify_guilds_duration_ms", Integer.valueOf(i7)), d0.o.to("compressed_byte_size", Integer.valueOf(i)), d0.o.to("uncompressed_byte_size", Integer.valueOf(i2)), d0.o.to("compression_algorithm", "zlib"), d0.o.to("packing_algorithm", "json"), d0.o.to("unpack_duration_ms", Long.valueOf(j)), d0.o.to("is_reconnect", Boolean.valueOf(this.hasConnectedOnce)), d0.o.to("is_fast_connect", Boolean.FALSE), d0.o.to("num_guilds", Integer.valueOf(size)), d0.o.to("num_guild_channels", Integer.valueOf(i4)), d0.o.to("num_guild_category_channels", Integer.valueOf(i5))));
    }

    public final void callConnect(long j) {
        schedule(new GatewaySocket$callConnect$1(this, j));
    }

    public final void close(boolean z2) {
        schedule(new GatewaySocket$close$1(this, z2));
    }

    public final void connect() {
        schedule(new GatewaySocket$connect$1(this));
    }

    public final void expeditedHeartbeat(long j, String str, boolean z2) {
        schedule(new GatewaySocket$expeditedHeartbeat$1(this, str, j, z2));
    }

    public final boolean isSessionEstablished() {
        return this.connectionState == 5;
    }

    public final void presenceUpdate(ClientStatus clientStatus, Long l, List<Activity> list, Boolean bool) {
        schedule(new GatewaySocket$presenceUpdate$1(this, clientStatus, list, l, bool));
    }

    public final void requestApplicationCommands(OutgoingPayload.ApplicationCommandRequest applicationCommandRequest) {
        m.checkNotNullParameter(applicationCommandRequest, "request");
        Outgoing outgoing = new Outgoing(Opcode.REQUEST_GUILD_APPLICATION_COMMANDS, applicationCommandRequest);
        Gson gson = gsonOmitNulls;
        m.checkNotNullExpressionValue(gson, "gsonOmitNulls");
        send$default(this, outgoing, false, gson, 2, null);
    }

    public final void requestGuildMembers(List<Long> list) {
        requestGuildMembers$default(this, list, null, null, null, 14, null);
    }

    public final void requestGuildMembers(List<Long> list, String str) {
        requestGuildMembers$default(this, list, str, null, null, 12, null);
    }

    public final void requestGuildMembers(List<Long> list, String str, List<Long> list2) {
        requestGuildMembers$default(this, list, str, list2, null, 8, null);
    }

    public final void requestGuildMembers(List<Long> list, String str, List<Long> list2, Integer num) {
        m.checkNotNullParameter(list, "guildIds");
        schedule(new GatewaySocket$requestGuildMembers$1(this, list, str, list2, num));
    }

    public final void resetOnError() {
        schedule(new GatewaySocket$resetOnError$1(this));
    }

    public final void simulateReconnectForTesting() {
        schedule(new GatewaySocket$simulateReconnectForTesting$1(this));
    }

    public final void streamCreate(String str, long j, Long l, String str2) {
        m.checkNotNullParameter(str, "streamType");
        Companion companion = Companion;
        Logger logger = this.logger;
        Companion.log$default(companion, logger, "Sending STREAM_CREATE: " + j + ' ' + l, false, 2, null);
        send$default(this, new Outgoing(Opcode.STREAM_CREATE, new OutgoingPayload.CreateStream(str, j, l, str2)), false, null, 6, null);
    }

    public final void streamDelete(String str) {
        m.checkNotNullParameter(str, "streamKey");
        schedule(new GatewaySocket$streamDelete$1(this, str));
    }

    public final void streamPing(String str) {
        m.checkNotNullParameter(str, "streamKey");
        schedule(new GatewaySocket$streamPing$1(this, str));
    }

    public final void streamWatch(String str) {
        m.checkNotNullParameter(str, "streamKey");
        schedule(new GatewaySocket$streamWatch$1(this, str));
    }

    public final void updateGuildSubscriptions(long j, OutgoingPayload.GuildSubscriptions guildSubscriptions) {
        m.checkNotNullParameter(guildSubscriptions, "guildSubscriptions");
        Companion companion = Companion;
        Logger logger = this.logger;
        Companion.log$default(companion, logger, "sending guild subscriptions: " + j + " -- " + guildSubscriptions, false, 2, null);
        Opcode opcode = Opcode.GUILD_SUBSCRIPTIONS;
        Boolean typing = guildSubscriptions.getTyping();
        Boolean activities = guildSubscriptions.getActivities();
        List<Long> members = guildSubscriptions.getMembers();
        Outgoing outgoing = new Outgoing(opcode, new OutgoingPayload.GuildSubscriptionsUpdate(j, typing, activities, members != null ? u.toList(members) : null, guildSubscriptions.getChannels(), guildSubscriptions.getThreads(), guildSubscriptions.getThreadMemberLists()));
        Gson gson = gsonOmitNulls;
        m.checkNotNullExpressionValue(gson, "gsonOmitNulls");
        send$default(this, outgoing, false, gson, 2, null);
    }

    public final void voiceServerPing() {
        schedule(new GatewaySocket$voiceServerPing$1(this));
    }

    public final void voiceStateUpdate(Long l, Long l2, boolean z2, boolean z3, boolean z4, String str, boolean z5) {
        schedule(new GatewaySocket$voiceStateUpdate$1(this, l, l2, z2, z3, str, z5, z4));
    }
}