package com.discord.stores;

import com.airbnb.lottie.parser.AnimatableValueParser;
import com.discord.api.channel.Channel;
import com.discord.api.guild.Guild;
import com.discord.api.message.Message;
import com.discord.models.domain.ModelChannelUnreadUpdate;
import com.discord.models.domain.ModelPayload;
import com.discord.models.domain.ModelReadState;
import com.discord.models.thread.dto.ModelThreadListSync;
import com.discord.stores.updates.ObservationDeck;
import com.discord.stores.updates.ObservationDeckProvider;
import com.discord.utilities.message.MessageUtils;
import com.discord.utilities.persister.Persister;
import d0.t.h0;
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 kotlin.jvm.internal.DefaultConstructorMarker;
import rx.Observable;
/* compiled from: StoreMessagesMostRecent.kt */
public final class StoreMessagesMostRecent extends StoreV2 {
    private final HashMap<Long, Long> mostRecentIds;
    private final Persister<Map<Long, Long>> mostRecentIdsCache;
    private Map<Long, Long> mostRecentIdsSnapshot;
    private final ObservationDeck observationDeck;

    public StoreMessagesMostRecent() {
        this(null, 1, null);
    }

    public StoreMessagesMostRecent(ObservationDeck observationDeck) {
        m.checkNotNullParameter(observationDeck, "observationDeck");
        this.observationDeck = observationDeck;
        HashMap<Long, Long> hashMap = new HashMap<>();
        this.mostRecentIds = hashMap;
        this.mostRecentIdsSnapshot = h0.emptyMap();
        this.mostRecentIdsCache = new Persister<>("MOST_RECENT_MESSAGE_IDS", new HashMap(hashMap));
    }

    /* JADX INFO: this call moved to the top of the method (can break code semantics) */
    public /* synthetic */ StoreMessagesMostRecent(ObservationDeck observationDeck, int i, DefaultConstructorMarker defaultConstructorMarker) {
        this((i & 1) != 0 ? ObservationDeckProvider.get() : observationDeck);
    }

    @StoreThread
    private final void mostRecentIdsUpdateFromChannels(ModelChannelUnreadUpdate modelChannelUnreadUpdate) {
        for (ModelReadState modelReadState : modelChannelUnreadUpdate.getChannelReadStates()) {
            if (updateMostRecentIds(modelReadState.getChannelId(), modelReadState.getLastMessageId())) {
                markChanged();
            }
        }
    }

    @StoreThread
    private final void mostRecentIdsUpdateFromChannels(Collection<Channel> collection) {
        for (Channel channel : collection) {
            if (AnimatableValueParser.y1(channel) && updateMostRecentIds(channel.h(), channel.i())) {
                markChanged();
            }
        }
    }

    @StoreThread
    private final void mostRecentIdsUpdateFromMessage(Message message) {
        if (updateMostRecentIds(message.g(), message.o())) {
            markChanged();
        }
    }

    @StoreThread
    private final boolean updateMostRecentIds(long j, long j2) {
        boolean z2 = MessageUtils.compareMessages(this.mostRecentIds.get(Long.valueOf(j)), Long.valueOf(j2)) < 0;
        if (z2) {
            this.mostRecentIds.put(Long.valueOf(j), Long.valueOf(j2));
        }
        return z2;
    }

    public final Map<Long, Long> getMostRecentIds() {
        return this.mostRecentIdsSnapshot;
    }

    @StoreThread
    public final void handleChannelCreateOrUpdate(Channel channel) {
        m.checkNotNullParameter(channel, "channel");
        mostRecentIdsUpdateFromChannels(d0.t.m.listOf(channel));
    }

    @StoreThread
    public final void handleChannelUnreadUpdate(ModelChannelUnreadUpdate modelChannelUnreadUpdate) {
        m.checkNotNullParameter(modelChannelUnreadUpdate, "channelReadStateUpdate");
        mostRecentIdsUpdateFromChannels(modelChannelUnreadUpdate);
    }

    @StoreThread
    public final void handleConnectionOpen(ModelPayload modelPayload) {
        m.checkNotNullParameter(modelPayload, "payload");
        Collection<Channel> privateChannels = modelPayload.getPrivateChannels();
        m.checkNotNullExpressionValue(privateChannels, "payload.privateChannels");
        mostRecentIdsUpdateFromChannels(privateChannels);
        List<Guild> guilds = modelPayload.getGuilds();
        m.checkNotNullExpressionValue(guilds, "payload.guilds");
        for (Guild guild : guilds) {
            Collection<Channel> g = guild.g();
            if (g != null) {
                mostRecentIdsUpdateFromChannels(g);
            }
            List<Channel> K = guild.K();
            if (K != null) {
                Collection<Channel> arrayList = new ArrayList<>();
                for (Channel channel : K) {
                    if (AnimatableValueParser.z1(channel)) {
                        arrayList.add(channel);
                    }
                }
                mostRecentIdsUpdateFromChannels(arrayList);
            }
        }
        markChanged();
    }

    @StoreThread
    public final void handleGuildAdd(Guild guild) {
        m.checkNotNullParameter(guild, "guild");
        Collection<Channel> g = guild.g();
        if (g != null) {
            mostRecentIdsUpdateFromChannels(g);
        }
        List<Channel> K = guild.K();
        if (K != null) {
            Collection<Channel> arrayList = new ArrayList<>();
            for (Channel channel : K) {
                if (AnimatableValueParser.z1(channel)) {
                    arrayList.add(channel);
                }
            }
            mostRecentIdsUpdateFromChannels(arrayList);
        }
    }

    @StoreThread
    public final void handleMessageCreate(Message message) {
        m.checkNotNullParameter(message, "message");
        mostRecentIdsUpdateFromMessage(message);
    }

    @StoreThread
    public final void handleThreadCreateOrUpdate(Channel channel) {
        m.checkNotNullParameter(channel, "channel");
        if (AnimatableValueParser.z1(channel)) {
            mostRecentIdsUpdateFromChannels(d0.t.m.listOf(channel));
        }
    }

    @StoreThread
    public final void handleThreadListSync(ModelThreadListSync modelThreadListSync) {
        m.checkNotNullParameter(modelThreadListSync, "payload");
        List<Channel> threads = modelThreadListSync.getThreads();
        Collection<Channel> arrayList = new ArrayList<>();
        for (Channel channel : threads) {
            if (AnimatableValueParser.z1(channel)) {
                arrayList.add(channel);
            }
        }
        mostRecentIdsUpdateFromChannels(arrayList);
    }

    public final Observable<Map<Long, Long>> observeRecentMessageIds() {
        return ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StoreMessagesMostRecent$observeRecentMessageIds$1(this), 14, null);
    }

    public final Observable<Long> observeRecentMessageIds(long j) {
        Observable<Long> r = observeRecentMessageIds().F(new StoreMessagesMostRecent$observeRecentMessageIds$2(j)).r();
        m.checkNotNullExpressionValue(r, "observeRecentMessageIds(…  .distinctUntilChanged()");
        return r;
    }

    @Override // com.discord.stores.StoreV2
    @StoreThread
    public void snapshotData() {
        super.snapshotData();
        HashMap hashMap = new HashMap(this.mostRecentIds);
        this.mostRecentIdsSnapshot = hashMap;
        Persister.set$default(this.mostRecentIdsCache, hashMap, false, 2, null);
    }
}