package com.discord.utilities.messagesend;

import android.content.ContentResolver;
import android.content.Context;
import com.discord.api.activity.Activity;
import com.discord.api.application.Application;
import com.discord.api.message.MessageReference;
import com.discord.api.message.activity.MessageActivity;
import com.discord.api.message.allowedmentions.MessageAllowedMentions;
import com.discord.api.sticker.Sticker;
import com.discord.api.sticker.StickerPartial;
import com.discord.models.message.Message;
import com.discord.restapi.RestAPIParams;
import com.discord.utilities.captcha.CaptchaHelper;
import com.discord.utilities.error.Error;
import com.discord.utilities.messagesend.MessageRequest;
import com.discord.utilities.messagesend.MessageResult;
import com.discord.utilities.networking.Backoff;
import com.discord.utilities.rest.RestAPI;
import com.discord.utilities.rest.SendUtils;
import com.discord.utilities.rx.ObservableExtensionsKt;
import com.discord.utilities.time.Clock;
import d0.t.o;
import d0.z.d.m;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.atomic.AtomicBoolean;
import kotlin.Unit;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.DefaultConstructorMarker;
import rx.Observable;
import rx.Subscription;
/* compiled from: MessageQueue.kt */
public final class MessageQueue {
    private static final Companion Companion = new Companion(null);
    @Deprecated
    private static final long DEFAULT_MESSAGE_TIMEOUT_MS = 3600000;
    @Deprecated
    private static final long DEFAULT_NETWORK_INITIAL_FAILURE_RETRY_MS = 5000;
    @Deprecated
    private static final long DEFAULT_RETRY_MS = 100;
    private final Clock clock;
    private final ContentResolver contentResolver;
    private final ExecutorService executorService;
    private InflightRequest inFlightRequest;
    private boolean isDraining;
    private final Backoff networkBackoff = new Backoff(5000, DEFAULT_MESSAGE_TIMEOUT_MS, 0, false, null, 28, null);
    private final ArrayDeque<MessageRequest> queue = new ArrayDeque<>();
    private Subscription retrySubscription;

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

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

    /* compiled from: MessageQueue.kt */
    public static final class DrainListener {
        private AtomicBoolean isCompleted = new AtomicBoolean(false);
        private final Function1<MessageResult, Unit> onCompleted;

        /* JADX DEBUG: Multi-variable search result rejected for r2v0, resolved type: kotlin.jvm.functions.Function1<? super com.discord.utilities.messagesend.MessageResult, kotlin.Unit> */
        /* JADX WARN: Multi-variable type inference failed */
        public DrainListener(Function1<? super MessageResult, Unit> function1) {
            m.checkNotNullParameter(function1, "onCompleted");
            this.onCompleted = function1;
        }

        public final synchronized void complete(MessageResult messageResult) {
            m.checkNotNullParameter(messageResult, "result");
            if (!this.isCompleted.getAndSet(true)) {
                this.onCompleted.invoke(messageResult);
            }
        }
    }

    /* compiled from: MessageQueue.kt */
    public static final class InflightRequest {
        private final MessageRequest baseRequest;
        private final DrainListener drainListener;
        private final Subscription networkSubscription;

        public InflightRequest(MessageRequest messageRequest, Subscription subscription, DrainListener drainListener) {
            m.checkNotNullParameter(messageRequest, "baseRequest");
            m.checkNotNullParameter(subscription, "networkSubscription");
            m.checkNotNullParameter(drainListener, "drainListener");
            this.baseRequest = messageRequest;
            this.networkSubscription = subscription;
            this.drainListener = drainListener;
        }

        public final MessageRequest getBaseRequest() {
            return this.baseRequest;
        }

        public final DrainListener getDrainListener() {
            return this.drainListener;
        }

        public final Subscription getNetworkSubscription() {
            return this.networkSubscription;
        }
    }

    public MessageQueue(ContentResolver contentResolver, ExecutorService executorService, Clock clock) {
        m.checkNotNullParameter(contentResolver, "contentResolver");
        m.checkNotNullParameter(executorService, "executorService");
        m.checkNotNullParameter(clock, "clock");
        this.contentResolver = contentResolver;
        this.executorService = executorService;
        this.clock = clock;
    }

    public static final /* synthetic */ ExecutorService access$getExecutorService$p(MessageQueue messageQueue) {
        return messageQueue.executorService;
    }

    public static final /* synthetic */ InflightRequest access$getInFlightRequest$p(MessageQueue messageQueue) {
        return messageQueue.inFlightRequest;
    }

    public static final /* synthetic */ Backoff access$getNetworkBackoff$p(MessageQueue messageQueue) {
        return messageQueue.networkBackoff;
    }

    public static final /* synthetic */ ArrayDeque access$getQueue$p(MessageQueue messageQueue) {
        return messageQueue.queue;
    }

    public static final /* synthetic */ Subscription access$getRetrySubscription$p(MessageQueue messageQueue) {
        return messageQueue.retrySubscription;
    }

    public static final /* synthetic */ void access$handleError(MessageQueue messageQueue, Error error, DrainListener drainListener, Message message) {
        messageQueue.handleError(error, drainListener, message);
    }

    public static final /* synthetic */ void access$handleSuccess(MessageQueue messageQueue, com.discord.api.message.Message message, DrainListener drainListener) {
        messageQueue.handleSuccess(message, drainListener);
    }

    public static final /* synthetic */ void access$onDrainingCompleted(MessageQueue messageQueue) {
        messageQueue.onDrainingCompleted();
    }

    public static final /* synthetic */ void access$processNextRequest(MessageQueue messageQueue) {
        messageQueue.processNextRequest();
    }

    public static final /* synthetic */ void access$setInFlightRequest$p(MessageQueue messageQueue, InflightRequest inflightRequest) {
        messageQueue.inFlightRequest = inflightRequest;
    }

    public static final /* synthetic */ void access$setRetrySubscription$p(MessageQueue messageQueue, Subscription subscription) {
        messageQueue.retrySubscription = subscription;
    }

    private final void doEdit(MessageRequest.Edit edit, DrainListener drainListener) {
        RestAPI api = RestAPI.Companion.getApi();
        long channelId = edit.getChannelId();
        long messageId = edit.getMessageId();
        String content = edit.getContent();
        MessageAllowedMentions allowedMentions = edit.getAllowedMentions();
        ObservableExtensionsKt.appSubscribe$default(ObservableExtensionsKt.restSubscribeOn(api.editMessage(channelId, messageId, new RestAPIParams.Message(content, null, null, null, null, null, allowedMentions != null ? RestAPIParams.Message.AllowedMentions.Companion.create(allowedMentions) : null, null, null, 444, null)), false), MessageQueue.class, (Context) null, new MessageQueue$doEdit$4(this, edit, drainListener), new MessageQueue$doEdit$3(this, drainListener), (Function0) null, (Function0) null, new MessageQueue$doEdit$2(this, drainListener), 50, (Object) null);
    }

    /* JADX WARNING: Removed duplicated region for block: B:46:0x00f1  */
    /* JADX WARNING: Removed duplicated region for block: B:47:0x00f8  */
    /* JADX WARNING: Removed duplicated region for block: B:50:0x0100  */
    private final void doSend(MessageRequest.Send send, DrainListener drainListener) {
        RestAPIParams.Message.Activity activity;
        RestAPIParams.Message.MessageReference messageReference;
        ArrayList arrayList;
        CaptchaHelper.CaptchaPayload captchaPayload;
        ArrayList arrayList2;
        String k;
        MessageResult.ValidationError validateMessage = send.validateMessage();
        if (validateMessage != null) {
            drainListener.complete(validateMessage);
            return;
        }
        Message message = send.getMessage();
        boolean z2 = message.getNonce() != null;
        MessageActivity activity2 = message.getActivity();
        String str = null;
        if (activity2 != null) {
            Activity activity3 = send.getActivity();
            activity = (activity3 == null || (k = activity3.k()) == null) ? null : new RestAPIParams.Message.Activity(activity2.b(), activity2.a(), k);
        } else {
            activity = null;
        }
        MessageReference messageReference2 = message.getMessageReference();
        if (messageReference2 != null) {
            Long b2 = messageReference2.b();
            Long a = messageReference2.a();
            m.checkNotNull(a);
            messageReference = new RestAPIParams.Message.MessageReference(b2, a.longValue(), messageReference2.c());
        } else {
            messageReference = null;
        }
        MessageAllowedMentions allowedMentions = message.getAllowedMentions();
        RestAPIParams.Message.AllowedMentions create = allowedMentions != null ? RestAPIParams.Message.AllowedMentions.Companion.create(allowedMentions) : null;
        String content = message.getContent();
        String nonce = message.getNonce();
        Application application = message.getApplication();
        Long valueOf = application != null ? Long.valueOf(application.g()) : null;
        List<StickerPartial> stickerItems = message.getStickerItems();
        if (stickerItems != null) {
            arrayList2 = new ArrayList(o.collectionSizeOrDefault(stickerItems, 10));
            for (StickerPartial stickerPartial : stickerItems) {
                arrayList2.add(Long.valueOf(stickerPartial.getId()));
            }
        } else {
            List<Sticker> stickers = message.getStickers();
            if (stickers != null) {
                arrayList2 = new ArrayList(o.collectionSizeOrDefault(stickers, 10));
                for (Sticker sticker : stickers) {
                    arrayList2.add(Long.valueOf(sticker.getId()));
                }
            } else {
                arrayList = null;
                CaptchaHelper.CaptchaPayload captchaPayload2 = message.getCaptchaPayload();
                String captchaKey = captchaPayload2 == null ? captchaPayload2.getCaptchaKey() : null;
                captchaPayload = message.getCaptchaPayload();
                if (captchaPayload != null) {
                    str = captchaPayload.getCaptchaRqtoken();
                }
                Observable<SendUtils.SendPayload> t = SendUtils.INSTANCE.getSendPayload(this.contentResolver, new RestAPIParams.Message(content, nonce, valueOf, activity, arrayList, messageReference, create, captchaKey, str), send.getAttachments()).t(new MessageQueue$doSend$1(send));
                m.checkNotNullExpressionValue(t, "SendUtils\n        .getSe…  }\n          }\n        }");
                Observable<R> F = t.x(MessageQueue$doSend$$inlined$filterIs$1.INSTANCE).F(MessageQueue$doSend$$inlined$filterIs$2.INSTANCE);
                m.checkNotNullExpressionValue(F, "filter { it is T }.map { it as T }");
                Observable z3 = F.Z(1).z(new MessageQueue$doSend$2(message));
                m.checkNotNullExpressionValue(z3, "SendUtils\n        .getSe…ge)\n          }\n        }");
                ObservableExtensionsKt.appSubscribe$default(ObservableExtensionsKt.restSubscribeOn(z3, z2), MessageQueue.class, (Context) null, new MessageQueue$doSend$5(this, send, drainListener), new MessageQueue$doSend$4(this, drainListener, message), (Function0) null, (Function0) null, new MessageQueue$doSend$3(this, drainListener), 50, (Object) null);
            }
        }
        arrayList = arrayList2;
        CaptchaHelper.CaptchaPayload captchaPayload2 = message.getCaptchaPayload();
        if (captchaPayload2 == null) {
        }
        captchaPayload = message.getCaptchaPayload();
        if (captchaPayload != null) {
        }
        Observable<SendUtils.SendPayload> t = SendUtils.INSTANCE.getSendPayload(this.contentResolver, new RestAPIParams.Message(content, nonce, valueOf, activity, arrayList, messageReference, create, captchaKey, str), send.getAttachments()).t(new MessageQueue$doSend$1(send));
        m.checkNotNullExpressionValue(t, "SendUtils\n        .getSe…  }\n          }\n        }");
        Observable<R> F = t.x(MessageQueue$doSend$$inlined$filterIs$1.INSTANCE).F(MessageQueue$doSend$$inlined$filterIs$2.INSTANCE);
        m.checkNotNullExpressionValue(F, "filter { it is T }.map { it as T }");
        Observable z3 = F.Z(1).z(new MessageQueue$doSend$2(message));
        m.checkNotNullExpressionValue(z3, "SendUtils\n        .getSe…ge)\n          }\n        }");
        ObservableExtensionsKt.appSubscribe$default(ObservableExtensionsKt.restSubscribeOn(z3, z2), MessageQueue.class, (Context) null, new MessageQueue$doSend$5(this, send, drainListener), new MessageQueue$doSend$4(this, drainListener, message), (Function0) null, (Function0) null, new MessageQueue$doSend$3(this, drainListener), 50, (Object) null);
    }

    private final void doSendApplicationCommand(MessageRequest.SendApplicationCommand sendApplicationCommand, DrainListener drainListener) {
        Observable<SendUtils.SendPayload> t = SendUtils.INSTANCE.getSendCommandPayload(this.contentResolver, sendApplicationCommand.getApplicationCommandSendData(), sendApplicationCommand.getAttachments()).t(new MessageQueue$doSendApplicationCommand$1(sendApplicationCommand));
        m.checkNotNullExpressionValue(t, "SendUtils\n        .getSe…  }\n          }\n        }");
        Observable<R> F = t.x(MessageQueue$doSendApplicationCommand$$inlined$filterIs$1.INSTANCE).F(MessageQueue$doSendApplicationCommand$$inlined$filterIs$2.INSTANCE);
        m.checkNotNullExpressionValue(F, "filter { it is T }.map { it as T }");
        Observable z2 = F.y().z(MessageQueue$doSendApplicationCommand$2.INSTANCE);
        m.checkNotNullExpressionValue(z2, "SendUtils\n        .getSe…())\n          }\n        }");
        Observable restSubscribeOn = ObservableExtensionsKt.restSubscribeOn(z2, false);
        MessageQueue$doSendApplicationCommand$3 messageQueue$doSendApplicationCommand$3 = new MessageQueue$doSendApplicationCommand$3(this, sendApplicationCommand, drainListener);
        ObservableExtensionsKt.appSubscribe$default(restSubscribeOn, MessageQueue.class, (Context) null, new MessageQueue$doSendApplicationCommand$5(this, sendApplicationCommand, drainListener), new MessageQueue$doSendApplicationCommand$4(this, drainListener), (Function0) null, (Function0) null, messageQueue$doSendApplicationCommand$3, 50, (Object) null);
    }

    private final void handleError(Error error, DrainListener drainListener, Message message) {
        MessageResult messageResult;
        Error.Response response = error.getResponse();
        m.checkNotNullExpressionValue(response, "error.response");
        Long l = 100L;
        if (response.getCode() == 20016) {
            Error.Response response2 = error.getResponse();
            m.checkNotNullExpressionValue(response2, "error.response");
            Long retryAfterMs = response2.getRetryAfterMs();
            if (retryAfterMs != null) {
                l = retryAfterMs;
            }
            m.checkNotNullExpressionValue(l, "error.response.retryAfterMs ?: DEFAULT_RETRY_MS");
            messageResult = new MessageResult.Slowmode(l.longValue());
        } else if (error.getType() == Error.Type.RATE_LIMITED) {
            Error.Response response3 = error.getResponse();
            m.checkNotNullExpressionValue(response3, "error.response");
            Long retryAfterMs2 = response3.getRetryAfterMs();
            if (retryAfterMs2 != null) {
                l = retryAfterMs2;
            }
            m.checkNotNullExpressionValue(l, "error.response.retryAfterMs ?: DEFAULT_RETRY_MS");
            messageResult = new MessageResult.RateLimited(l.longValue());
        } else if (error.getType() == Error.Type.NETWORK) {
            messageResult = MessageResult.NetworkFailure.INSTANCE;
        } else {
            if (error.getType() == Error.Type.DISCORD_BAD_REQUEST) {
                Error.Response response4 = error.getResponse();
                m.checkNotNullExpressionValue(response4, "error.response");
                if (response4.getMessages().containsKey(CaptchaHelper.CAPTCHA_KEY) && message != null) {
                    messageResult = new MessageResult.CaptchaRequired(error, message.getChannelId(), message.getNonce());
                }
            }
            messageResult = new MessageResult.UnknownFailure(error);
        }
        drainListener.complete(messageResult);
    }

    public static /* synthetic */ void handleError$default(MessageQueue messageQueue, Error error, DrainListener drainListener, Message message, int i, Object obj) {
        if ((i & 4) != 0) {
            message = null;
        }
        messageQueue.handleError(error, drainListener, message);
    }

    private final void handleSuccess(com.discord.api.message.Message message, DrainListener drainListener) {
        drainListener.complete(new MessageResult.Success(message));
    }

    private final void onDrainingCompleted() {
        this.isDraining = false;
        this.inFlightRequest = null;
    }

    private final void processNextRequest() {
        MessageRequest remove;
        if (this.queue.isEmpty() || this.retrySubscription != null || this.networkBackoff.isPending() || this.isDraining || (remove = this.queue.remove()) == null) {
            return;
        }
        if (this.clock.currentTimeMillis() - remove.getAttemptTimestamp() > DEFAULT_MESSAGE_TIMEOUT_MS) {
            remove.getOnCompleted().invoke(MessageResult.Timeout.INSTANCE, Boolean.valueOf(this.queue.isEmpty()));
            this.networkBackoff.succeed();
            processNextRequest();
            return;
        }
        this.isDraining = true;
        DrainListener drainListener = new DrainListener(new MessageQueue$processNextRequest$listener$1(this, remove));
        if (remove instanceof MessageRequest.Send) {
            doSend((MessageRequest.Send) remove, drainListener);
        } else if (remove instanceof MessageRequest.Edit) {
            doEdit((MessageRequest.Edit) remove, drainListener);
        } else if (remove instanceof MessageRequest.SendApplicationCommand) {
            doSendApplicationCommand((MessageRequest.SendApplicationCommand) remove, drainListener);
        }
    }

    public final void cancel(String str) {
        m.checkNotNullParameter(str, "requestId");
        this.executorService.submit(new MessageQueue$cancel$1(this, str));
    }

    public final void enqueue(MessageRequest messageRequest) {
        m.checkNotNullParameter(messageRequest, "request");
        this.executorService.submit(new MessageQueue$enqueue$1(this, messageRequest));
    }

    public final void handleConnected() {
        this.executorService.submit(new MessageQueue$handleConnected$1(this));
    }
}