discord-jadx/app/src/main/java/com/discord/stores/StorePinnedMessages.java

package com.discord.stores;

import android.content.Context;
import com.discord.api.utcdatetime.UtcDateTime;
import com.discord.models.message.Message;
import com.discord.stores.updates.ObservationDeck;
import com.discord.utilities.rest.RestAPI;
import com.discord.utilities.rx.ObservableExtensionsKt;
import d0.t.n;
import d0.t.u;
import d0.z.d.m;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.DefaultConstructorMarker;
import rx.Observable;
/* compiled from: StorePinnedMessages.kt */
public final class StorePinnedMessages extends StoreV2 {
    public static final Companion Companion = new Companion(null);
    private final Dispatcher dispatcher;
    private final ObservationDeck observationDeck;
    private final Map<Long, List<Message>> pinnedMessages = new HashMap();
    private Map<Long, ? extends List<Message>> pinnedMessagesSnapshot = new HashMap();
    private final Set<Long> updatedChannelIds = new HashSet();

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

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

        public static final /* synthetic */ Message access$getMessage(Companion companion, List list, long j) {
            return companion.getMessage(list, j);
        }

        public static final /* synthetic */ int access$getMessageIndex(Companion companion, List list, long j) {
            return companion.getMessageIndex(list, j);
        }

        private final Message getMessage(List<Message> list, long j) {
            boolean z2;
            Object obj = null;
            if (list == null) {
                return null;
            }
            Iterator<T> it = list.iterator();
            while (true) {
                if (!it.hasNext()) {
                    break;
                }
                Object next = it.next();
                if (((Message) next).getId() == j) {
                    z2 = true;
                    continue;
                } else {
                    z2 = false;
                    continue;
                }
                if (z2) {
                    obj = next;
                    break;
                }
            }
            return (Message) obj;
        }

        private final int getMessageIndex(List<Message> list, long j) {
            int i = 0;
            for (Message message : list) {
                if (message.getId() == j) {
                    return i;
                }
                i++;
            }
            return -1;
        }
    }

    public StorePinnedMessages(Dispatcher dispatcher, ObservationDeck observationDeck) {
        m.checkNotNullParameter(dispatcher, "dispatcher");
        m.checkNotNullParameter(observationDeck, "observationDeck");
        this.dispatcher = dispatcher;
        this.observationDeck = observationDeck;
    }

    public static final /* synthetic */ Map access$getPinnedMessages$p(StorePinnedMessages storePinnedMessages) {
        return storePinnedMessages.pinnedMessages;
    }

    public static final /* synthetic */ void access$handlePinnedMessagesLoaded(StorePinnedMessages storePinnedMessages, long j, List list) {
        storePinnedMessages.handlePinnedMessagesLoaded(j, list);
    }

    @StoreThread
    private final void handlePinnedMessagesLoaded(long j, List<Message> list) {
        this.pinnedMessages.put(Long.valueOf(j), u.toMutableList((Collection) list));
        this.updatedChannelIds.add(Long.valueOf(j));
        markChanged();
    }

    private final void loadPinnedMessages(long j) {
        if (!this.pinnedMessagesSnapshot.containsKey(Long.valueOf(j))) {
            Observable F = ObservableExtensionsKt.restSubscribeOn$default(RestAPI.Companion.getApi().getChannelPins(j), false, 1, null).F(StorePinnedMessages$loadPinnedMessages$1.INSTANCE);
            m.checkNotNullExpressionValue(F, "api\n        .getChannelP…messages.map(::Message) }");
            ObservableExtensionsKt.appSubscribe$default(F, StorePinnedMessages.class, (Context) null, (Function1) null, (Function1) null, (Function0) null, (Function0) null, new StorePinnedMessages$loadPinnedMessages$2(this, j), 62, (Object) null);
        }
    }

    public final Dispatcher getDispatcher() {
        return this.dispatcher;
    }

    public final ObservationDeck getObservationDeck() {
        return this.observationDeck;
    }

    @StoreThread
    public final void handleMessageDeleteBulk(long j, Collection<Long> collection) {
        m.checkNotNullParameter(collection, "messageIds");
        List<Message> list = this.pinnedMessages.get(Long.valueOf(j));
        if (list != null) {
            Iterator<Message> it = list.iterator();
            while (it.hasNext()) {
                if (collection.contains(Long.valueOf(it.next().getId()))) {
                    it.remove();
                    this.updatedChannelIds.add(Long.valueOf(j));
                }
            }
            if (!this.updatedChannelIds.isEmpty()) {
                markChanged();
            }
        }
    }

    @StoreThread
    public final void handleMessageUpdate(com.discord.api.message.Message message) {
        UtcDateTime timestamp;
        m.checkNotNullParameter(message, "updatedMessage");
        long g = message.g();
        long o = message.o();
        boolean areEqual = m.areEqual(message.w(), Boolean.TRUE);
        List<Message> list = this.pinnedMessages.get(Long.valueOf(g));
        if (list != null) {
            int access$getMessageIndex = Companion.access$getMessageIndex(Companion, list, o);
            if (access$getMessageIndex != -1) {
                if (!areEqual) {
                    list.remove(access$getMessageIndex);
                } else {
                    list.set(access$getMessageIndex, list.get(access$getMessageIndex).merge(message));
                }
                this.updatedChannelIds.add(Long.valueOf(g));
                markChanged();
            } else if (areEqual) {
                UtcDateTime C = message.C();
                long j = 0;
                long f = C != null ? C.f() : 0;
                int i = 0;
                if (list.size() > 0 && (timestamp = list.get(0).getTimestamp()) != null) {
                    j = timestamp.f();
                }
                while (i < list.size() && f < j) {
                    i++;
                }
                list.add(i, new Message(message));
                this.updatedChannelIds.add(Long.valueOf(g));
                markChanged();
            }
        }
    }

    public final Observable<List<Message>> observeForChannel(long j) {
        loadPinnedMessages(j);
        return ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StorePinnedMessages$observeForChannel$1(this, j), 14, null);
    }

    public final Observable<Message> observePinnedMessage(long j, long j2) {
        Observable<Message> r = ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StorePinnedMessages$observePinnedMessage$1(this, j, j2), 14, null).r();
        m.checkNotNullExpressionValue(r, "observationDeck.connectR… }.distinctUntilChanged()");
        return r;
    }

    @Override // com.discord.stores.StoreV2
    @StoreThread
    public void snapshotData() {
        HashMap hashMap = new HashMap(this.pinnedMessages);
        for (Long l : this.updatedChannelIds) {
            long longValue = l.longValue();
            Long valueOf = Long.valueOf(longValue);
            List list = (List) hashMap.get(Long.valueOf(longValue));
            if (list == null) {
                list = n.emptyList();
            }
            hashMap.put(valueOf, new ArrayList(list));
        }
        this.pinnedMessagesSnapshot = hashMap;
        this.updatedChannelIds.clear();
    }
}