package com.discord.stores;

import com.airbnb.lottie.parser.AnimatableValueParser;
import com.discord.api.guild.Guild;
import com.discord.api.voice.state.VoiceState;
import com.discord.models.domain.ModelPayload;
import com.discord.stores.updates.ObservationDeck;
import d0.t.h0;
import d0.z.d.m;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import kotlin.Unit;
import kotlin.jvm.functions.Function3;
import rx.Observable;
/* compiled from: StoreVoiceStates.kt */
public final class StoreVoiceStates extends StoreV2 {
    private final HashSet<Long> dirtyGuildIds = new HashSet<>();
    private Long myUserId;
    private final Function3<Long, Long, Long, Unit> notifyVoiceStatesUpdated;
    private final ObservationDeck observationDeck;
    private String sessionId;
    private final HashMap<Long, HashMap<Long, VoiceState>> voiceStates;
    private Map<Long, ? extends Map<Long, VoiceState>> voiceStatesSnapshot;

    /* JADX DEBUG: Multi-variable search result rejected for r2v0, resolved type: kotlin.jvm.functions.Function3<? super java.lang.Long, ? super java.lang.Long, ? super java.lang.Long, kotlin.Unit> */
    /* JADX WARN: Multi-variable type inference failed */
    public StoreVoiceStates(Function3<? super Long, ? super Long, ? super Long, Unit> function3, ObservationDeck observationDeck) {
        m.checkNotNullParameter(function3, "notifyVoiceStatesUpdated");
        m.checkNotNullParameter(observationDeck, "observationDeck");
        this.notifyVoiceStatesUpdated = function3;
        this.observationDeck = observationDeck;
        HashMap<Long, HashMap<Long, VoiceState>> hashMap = new HashMap<>();
        this.voiceStates = hashMap;
        this.voiceStatesSnapshot = new HashMap(hashMap);
    }

    public static final /* synthetic */ Map access$getVoiceStatesSnapshot$p(StoreVoiceStates storeVoiceStates) {
        return storeVoiceStates.voiceStatesSnapshot;
    }

    public static final /* synthetic */ void access$setVoiceStatesSnapshot$p(StoreVoiceStates storeVoiceStates, Map map) {
        storeVoiceStates.voiceStatesSnapshot = map;
    }

    @StoreThread
    private final void clear() {
        this.dirtyGuildIds.addAll(this.voiceStates.keySet());
        this.voiceStates.clear();
        markChanged();
    }

    /* JADX WARNING: Removed duplicated region for block: B:35:0x00bf  */
    @StoreThread
    private final void updateVoiceState(VoiceState voiceState, Long l) {
        Long a;
        Long l2;
        long longValue = l != null ? l.longValue() : voiceState.c();
        long m = voiceState.m();
        if (!(!m.areEqual(voiceState.k(), this.sessionId)) || (l2 = this.myUserId) == null || m != l2.longValue()) {
            boolean z2 = false;
            HashMap<Long, HashMap<Long, VoiceState>> hashMap = this.voiceStates;
            Long valueOf = Long.valueOf(longValue);
            HashMap<Long, VoiceState> hashMap2 = this.voiceStates.get(Long.valueOf(longValue));
            if (hashMap2 == null) {
                hashMap2 = new HashMap<>();
            }
            long j = 0;
            if (AnimatableValueParser.v1(voiceState)) {
                VoiceState remove = hashMap2.remove(Long.valueOf(m));
                if (remove != null) {
                    Long a2 = remove.a();
                    if (a2 != null) {
                        j = a2.longValue();
                    }
                }
                hashMap.put(valueOf, hashMap2);
                if (z2) {
                    this.dirtyGuildIds.add(Long.valueOf(longValue));
                    this.notifyVoiceStatesUpdated.invoke(Long.valueOf(longValue), Long.valueOf(j), Long.valueOf(m));
                }
            } else {
                if (!m.areEqual(voiceState, hashMap2.get(Long.valueOf(m)))) {
                    VoiceState voiceState2 = hashMap2.get(Long.valueOf(m));
                    if (!(voiceState2 == null || (a = voiceState2.a()) == null)) {
                        j = a.longValue();
                    }
                    hashMap2.put(Long.valueOf(m), voiceState);
                }
                hashMap.put(valueOf, hashMap2);
                if (z2) {
                }
            }
            z2 = true;
            hashMap.put(valueOf, hashMap2);
            if (z2) {
            }
        } else {
            HashMap<Long, VoiceState> hashMap3 = this.voiceStates.get(Long.valueOf(longValue));
            if (!(hashMap3 == null || hashMap3.remove(Long.valueOf(m)) == null)) {
                this.dirtyGuildIds.add(Long.valueOf(longValue));
            }
        }
        if (!this.dirtyGuildIds.isEmpty()) {
            markChanged();
        }
    }

    public static /* synthetic */ void updateVoiceState$default(StoreVoiceStates storeVoiceStates, VoiceState voiceState, Long l, int i, Object obj) {
        if ((i & 2) != 0) {
            l = null;
        }
        storeVoiceStates.updateVoiceState(voiceState, l);
    }

    /* JADX DEBUG: Type inference failed for r0v0. Raw type applied. Possible types: java.util.Map<java.lang.Long, ? extends java.util.Map<java.lang.Long, com.discord.api.voice.state.VoiceState>>, java.util.Map<java.lang.Long, java.util.Map<java.lang.Long, com.discord.api.voice.state.VoiceState>> */
    public final Map<Long, Map<Long, VoiceState>> get() {
        return this.voiceStatesSnapshot;
    }

    public final Map<Long, VoiceState> getForChannel(long j, long j2) {
        Map map = (Map) this.voiceStatesSnapshot.get(Long.valueOf(j));
        if (map == null) {
            map = h0.emptyMap();
        }
        LinkedHashMap linkedHashMap = new LinkedHashMap();
        for (Map.Entry entry : map.entrySet()) {
            Long a = ((VoiceState) entry.getValue()).a();
            if (a != null && a.longValue() == j2) {
                linkedHashMap.put(entry.getKey(), entry.getValue());
            }
        }
        return linkedHashMap;
    }

    @StoreThread
    public final Map<Long, Map<Long, VoiceState>> getInternal$app_productionBetaRelease() {
        return this.voiceStates;
    }

    @StoreThread
    public final void handleAuthToken(String str) {
        if (str == null) {
            clear();
        }
    }

    @StoreThread
    public final void handleConnectionOpen(ModelPayload modelPayload) {
        m.checkNotNullParameter(modelPayload, "payload");
        this.sessionId = modelPayload.getSessionId();
        this.myUserId = Long.valueOf(modelPayload.getMe().i());
        clear();
        List<Guild> guilds = modelPayload.getGuilds();
        m.checkNotNullExpressionValue(guilds, "payload.guilds");
        for (Guild guild : guilds) {
            List<VoiceState> O = guild.O();
            if (O != null) {
                for (VoiceState voiceState : O) {
                    updateVoiceState(voiceState, Long.valueOf(guild.o()));
                }
            }
        }
    }

    @StoreThread
    public final void handleGuildAdd(Guild guild) {
        m.checkNotNullParameter(guild, "guild");
        List<VoiceState> O = guild.O();
        if (O != null) {
            for (VoiceState voiceState : O) {
                updateVoiceState(voiceState, Long.valueOf(guild.o()));
            }
        }
    }

    @StoreThread
    public final void handleGuildRemove(Guild guild) {
        m.checkNotNullParameter(guild, "guild");
        this.voiceStates.remove(Long.valueOf(guild.o()));
        this.dirtyGuildIds.add(Long.valueOf(guild.o()));
        markChanged();
    }

    @StoreThread
    public final void handleVoiceStateUpdate(VoiceState voiceState) {
        m.checkNotNullParameter(voiceState, "voiceState");
        updateVoiceState$default(this, voiceState, null, 2, null);
    }

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

    public final Observable<Map<Long, VoiceState>> observe(long j, long j2) {
        Observable<Map<Long, VoiceState>> r = observe(j).Y(new StoreVoiceStates$observe$2(j2)).r();
        m.checkNotNullExpressionValue(r, "observe(guildId)\n       …  .distinctUntilChanged()");
        return r;
    }

    public final Observable<Map<Long, VoiceState>> observeForPrivateChannels(long j) {
        return observe(0, j);
    }

    @Override // com.discord.stores.StoreV2
    @StoreThread
    public void snapshotData() {
        HashMap hashMap = new HashMap(this.voiceStates.size());
        for (Map.Entry<Long, HashMap<Long, VoiceState>> entry : this.voiceStates.entrySet()) {
            long longValue = entry.getKey().longValue();
            HashMap<Long, VoiceState> value = entry.getValue();
            if (this.dirtyGuildIds.contains(Long.valueOf(longValue))) {
                hashMap.put(Long.valueOf(longValue), new HashMap(value));
            } else {
                Map map = (Map) this.voiceStatesSnapshot.get(Long.valueOf(longValue));
                if (map != null) {
                    hashMap.put(Long.valueOf(longValue), map);
                }
            }
        }
        this.voiceStatesSnapshot = hashMap;
        this.dirtyGuildIds.clear();
    }
}