package com.discord.stores;

import com.discord.api.channel.Channel;
import com.discord.api.guildmember.GuildMembersChunk;
import com.discord.api.user.User;
import com.discord.models.member.GuildMember;
import com.discord.models.message.Message;
import com.discord.utilities.lazy.requester.GuildMemberRequestManager;
import d0.t.o;
import d0.z.d.m;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
/* compiled from: StoreGuildMemberRequester.kt */
public final class StoreGuildMemberRequester extends Store {
    private final TreeMap<Long, Map<Long, Message>> channelPendingMessages = new TreeMap<>();
    private final StoreStream collector;
    private final Dispatcher dispatcher;
    private boolean isConnected;
    private final GuildMemberRequestManager requestManager = new GuildMemberRequestManager(new StoreGuildMemberRequester$requestManager$1(this), new StoreGuildMemberRequester$requestManager$2(this));

    public StoreGuildMemberRequester(StoreStream storeStream, Dispatcher dispatcher) {
        m.checkNotNullParameter(storeStream, "collector");
        m.checkNotNullParameter(dispatcher, "dispatcher");
        this.collector = storeStream;
        this.dispatcher = dispatcher;
    }

    public static final /* synthetic */ GuildMemberRequestManager access$getRequestManager$p(StoreGuildMemberRequester storeGuildMemberRequester) {
        return storeGuildMemberRequester.requestManager;
    }

    public static final /* synthetic */ boolean access$guildMemberExists(StoreGuildMemberRequester storeGuildMemberRequester, long j, long j2) {
        return storeGuildMemberRequester.guildMemberExists(j, j2);
    }

    public static final /* synthetic */ void access$sendRequests(StoreGuildMemberRequester storeGuildMemberRequester, long j, List list) {
        storeGuildMemberRequester.sendRequests(j, list);
    }

    @StoreThread
    private final boolean guildMemberExists(long j, long j2) {
        Map<Long, GuildMember> map = this.collector.getGuilds$app_productionBetaRelease().getGuildMembersComputedInternal$app_productionBetaRelease().get(Long.valueOf(j));
        return (map != null ? map.get(Long.valueOf(j2)) : null) != null;
    }

    @StoreThread
    private final void requestForMessages(long j, Iterable<Message> iterable) {
        for (Message message : iterable) {
            User author = message.getAuthor();
            if (author != null) {
                this.requestManager.queueRequest(j, author.i());
            }
            List<User> mentions = message.getMentions();
            if (mentions != null) {
                for (User user : mentions) {
                    this.requestManager.queueRequest(j, user.i());
                }
            }
        }
    }

    @StoreThread
    private final void sendRequests(long j, List<Long> list) {
        StoreGatewayConnection.requestGuildMembers$default(this.collector.getGatewaySocket$app_productionBetaRelease(), j, null, list, null, 2, null);
    }

    @StoreThread
    public final void handleConnectionOpen() {
        this.isConnected = true;
        this.requestManager.reset();
        for (Map.Entry<Long, Map<Long, Message>> entry : this.channelPendingMessages.entrySet()) {
            handleLoadMessages(entry.getKey().longValue(), entry.getValue().values());
        }
        this.channelPendingMessages.clear();
    }

    @StoreThread
    public final void handleConnectionReady(boolean z2) {
        this.isConnected = z2;
        if (z2) {
            this.requestManager.requestUnacknowledged();
        }
    }

    @StoreThread
    public final void handleGuildMembersChunk(GuildMembersChunk guildMembersChunk) {
        m.checkNotNullParameter(guildMembersChunk, "chunk");
        long a = guildMembersChunk.a();
        List<com.discord.api.guildmember.GuildMember> b = guildMembersChunk.b();
        ArrayList<User> arrayList = new ArrayList(o.collectionSizeOrDefault(b, 10));
        for (com.discord.api.guildmember.GuildMember guildMember : b) {
            arrayList.add(guildMember.j());
        }
        for (User user : arrayList) {
            this.requestManager.acknowledge(a, user.i());
        }
        List<Long> c2 = guildMembersChunk.c();
        if (c2 != null) {
            for (Number number : c2) {
                this.requestManager.acknowledge(a, number.longValue());
            }
        }
    }

    /* JADX WARNING: Unknown variable types count: 1 */
    @StoreThread
    public final void handleLoadMessages(long j, Collection<Message> collection) {
        m.checkNotNullParameter(collection, "messages");
        if (this.isConnected) {
            Channel findChannelByIdInternal$app_productionBetaRelease = this.collector.getChannels$app_productionBetaRelease().findChannelByIdInternal$app_productionBetaRelease(j);
            if (findChannelByIdInternal$app_productionBetaRelease != null) {
                Long valueOf = Long.valueOf(findChannelByIdInternal$app_productionBetaRelease.f());
                if (!(valueOf.longValue() > 0)) {
                    valueOf = null;
                }
                if (valueOf != null) {
                    requestForMessages(valueOf.longValue(), collection);
                    this.requestManager.flush();
                    return;
                }
                return;
            }
            return;
        }
        Map<Long, Message> map = this.channelPendingMessages.get(Long.valueOf(j));
        if (map == null) {
            map = new HashMap<>(collection.size());
        }
        for (?? r1 : collection) {
            map.put(Long.valueOf(((Message) r1).getId()), r1);
        }
        this.channelPendingMessages.put(Long.valueOf(j), map);
    }

    public final void performQueuedRequests() {
        this.dispatcher.schedule(new StoreGuildMemberRequester$performQueuedRequests$1(this));
    }

    public final void queueRequest(long j, long j2) {
        this.dispatcher.schedule(new StoreGuildMemberRequester$queueRequest$1(this, j, j2));
    }
}