package com.discord.stores;

import com.discord.api.channel.Channel;
import com.discord.api.guildmember.GuildMember;
import com.discord.api.thread.AugmentedThreadMember;
import com.discord.api.thread.ThreadListMember;
import com.discord.api.thread.ThreadMemberListUpdate;
import com.discord.api.thread.ThreadMembersUpdate;
import com.discord.api.thread.ThreadMetadata;
import com.discord.api.user.User;
import com.discord.stores.updates.ObservationDeck;
import d0.t.g0;
import d0.t.o;
import d0.t.u;
import d0.z.d.m;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import rx.Observable;
/* compiled from: StoreThreadMembers.kt */
public final class StoreThreadMembers extends StoreV2 {
    private final Map<Long, Set<Long>> memberLists = new LinkedHashMap();
    private HashMap<Long, Set<Long>> memberListsSnapshot = new HashMap<>();
    private final ObservationDeck observationDeck;
    private final StoreChannels storeChannels;

    public StoreThreadMembers(ObservationDeck observationDeck, StoreChannels storeChannels) {
        m.checkNotNullParameter(observationDeck, "observationDeck");
        m.checkNotNullParameter(storeChannels, "storeChannels");
        this.observationDeck = observationDeck;
        this.storeChannels = storeChannels;
    }

    public static final /* synthetic */ HashMap access$getMemberListsSnapshot$p(StoreThreadMembers storeThreadMembers) {
        return storeThreadMembers.memberListsSnapshot;
    }

    public static final /* synthetic */ void access$setMemberListsSnapshot$p(StoreThreadMembers storeThreadMembers, HashMap hashMap) {
        storeThreadMembers.memberListsSnapshot = hashMap;
    }

    @StoreThread
    public final void handleConnectionOpen() {
        this.memberLists.clear();
        markChanged();
    }

    @StoreThread
    public final void handleThreadCreateOrUpdate(Channel channel) {
        ThreadMetadata y2;
        m.checkNotNullParameter(channel, "channel");
        if (this.memberLists.containsKey(Long.valueOf(channel.h())) && (y2 = channel.y()) != null && y2.b()) {
            this.memberLists.remove(Long.valueOf(channel.h()));
            markChanged();
        }
    }

    @StoreThread
    public final void handleThreadDelete(Channel channel) {
        m.checkNotNullParameter(channel, "channel");
        if (this.memberLists.containsKey(Long.valueOf(channel.h()))) {
            this.memberLists.remove(Long.valueOf(channel.h()));
            markChanged();
        }
    }

    /* JADX WARNING: Code restructure failed: missing block: B:12:0x005d, code lost:
        if (r6 != null) goto L_0x0065;
     */
    @StoreThread
    public final void handleThreadMemberListUpdate(ThreadMemberListUpdate threadMemberListUpdate) {
        Set<Long> set;
        m.checkNotNullParameter(threadMemberListUpdate, "threadMemberListUpdate");
        Channel channelInternal$app_productionBetaRelease = this.storeChannels.getChannelInternal$app_productionBetaRelease(threadMemberListUpdate.a(), threadMemberListUpdate.c());
        if ((channelInternal$app_productionBetaRelease != null ? Long.valueOf(channelInternal$app_productionBetaRelease.r()) : null) != null) {
            Map<Long, Set<Long>> map = this.memberLists;
            Long valueOf = Long.valueOf(channelInternal$app_productionBetaRelease.h());
            List<ThreadListMember> b = threadMemberListUpdate.b();
            if (b != null) {
                ArrayList arrayList = new ArrayList(o.collectionSizeOrDefault(b, 10));
                for (ThreadListMember threadListMember : b) {
                    arrayList.add(Long.valueOf(threadListMember.c()));
                }
                set = u.toMutableSet(arrayList);
            }
            set = new LinkedHashSet<>();
            map.put(valueOf, set);
            markChanged();
        }
    }

    @StoreThread
    public final void handleThreadMembersUpdate(ThreadMembersUpdate threadMembersUpdate) {
        User j;
        m.checkNotNullParameter(threadMembersUpdate, "threadMembersUpdate");
        if (this.memberLists.containsKey(Long.valueOf(threadMembersUpdate.c()))) {
            List<AugmentedThreadMember> a = threadMembersUpdate.a();
            if (a != null) {
                for (AugmentedThreadMember augmentedThreadMember : a) {
                    GuildMember e = augmentedThreadMember.e();
                    Long valueOf = (e == null || (j = e.j()) == null) ? null : Long.valueOf(j.i());
                    if (valueOf != null) {
                        Set<Long> set = this.memberLists.get(Long.valueOf(threadMembersUpdate.c()));
                        if (set != null) {
                            set.add(valueOf);
                        }
                        markChanged();
                    }
                }
            }
            List<Long> d = threadMembersUpdate.d();
            if (d != null) {
                for (Number number : d) {
                    long longValue = number.longValue();
                    Set<Long> set2 = this.memberLists.get(Long.valueOf(threadMembersUpdate.c()));
                    if (set2 != null) {
                        set2.remove(Long.valueOf(longValue));
                    }
                    markChanged();
                }
            }
        }
    }

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

    @Override // com.discord.stores.StoreV2
    @StoreThread
    public void snapshotData() {
        super.snapshotData();
        Map<Long, Set<Long>> map = this.memberLists;
        LinkedHashMap linkedHashMap = new LinkedHashMap(g0.mapCapacity(map.size()));
        Iterator<T> it = map.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            linkedHashMap.put(entry.getKey(), u.toSet((Iterable) entry.getValue()));
        }
        this.memberListsSnapshot = new HashMap<>(linkedHashMap);
    }
}