package com.discord.stores;

import c.d.b.a.a;
import com.discord.models.domain.ModelVoiceRegion;
import com.discord.stores.updates.ObservationDeck;
import com.discord.stores.updates.ObservationDeckProvider;
import d0.t.g0;
import d0.t.h0;
import d0.t.n;
import d0.z.d.m;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import kotlin.jvm.internal.DefaultConstructorMarker;
import rx.Observable;
/* compiled from: StoreGuildVoiceRegions.kt */
public final class StoreGuildVoiceRegions extends StoreV2 {
    private final Dispatcher dispatcher;
    private Map<Long, ? extends List<? extends ModelVoiceRegion>> guildVoiceRegionsSnapshot;
    private final HashMap<Long, State> guildVoiceRegionsState;
    private final ObservationDeck observationDeck;

    /* compiled from: StoreGuildVoiceRegions.kt */
    public static abstract class State {

        /* compiled from: StoreGuildVoiceRegions.kt */
        public static final class Failure extends State {
            public static final Failure INSTANCE = new Failure();

            private Failure() {
                super(null);
            }
        }

        /* compiled from: StoreGuildVoiceRegions.kt */
        public static final class Fetching extends State {
            public static final Fetching INSTANCE = new Fetching();

            private Fetching() {
                super(null);
            }
        }

        /* compiled from: StoreGuildVoiceRegions.kt */
        public static final class Loaded extends State {
            private final List<ModelVoiceRegion> data;

            /* JADX DEBUG: Multi-variable search result rejected for r2v0, resolved type: java.util.List<? extends com.discord.models.domain.ModelVoiceRegion> */
            /* JADX WARN: Multi-variable type inference failed */
            /* JADX INFO: super call moved to the top of the method (can break code semantics) */
            public Loaded(List<? extends ModelVoiceRegion> list) {
                super(null);
                m.checkNotNullParameter(list, "data");
                this.data = list;
            }

            /* JADX DEBUG: Multi-variable search result rejected for r0v0, resolved type: com.discord.stores.StoreGuildVoiceRegions$State$Loaded */
            /* JADX WARN: Multi-variable type inference failed */
            public static /* synthetic */ Loaded copy$default(Loaded loaded, List list, int i, Object obj) {
                if ((i & 1) != 0) {
                    list = loaded.data;
                }
                return loaded.copy(list);
            }

            public final List<ModelVoiceRegion> component1() {
                return this.data;
            }

            public final Loaded copy(List<? extends ModelVoiceRegion> list) {
                m.checkNotNullParameter(list, "data");
                return new Loaded(list);
            }

            public boolean equals(Object obj) {
                if (this != obj) {
                    return (obj instanceof Loaded) && m.areEqual(this.data, ((Loaded) obj).data);
                }
                return true;
            }

            public final List<ModelVoiceRegion> getData() {
                return this.data;
            }

            public int hashCode() {
                List<ModelVoiceRegion> list = this.data;
                if (list != null) {
                    return list.hashCode();
                }
                return 0;
            }

            public String toString() {
                return a.E(a.L("Loaded(data="), this.data, ")");
            }
        }

        private State() {
        }

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

    public StoreGuildVoiceRegions(Dispatcher dispatcher, ObservationDeck observationDeck) {
        m.checkNotNullParameter(dispatcher, "dispatcher");
        m.checkNotNullParameter(observationDeck, "observationDeck");
        this.dispatcher = dispatcher;
        this.observationDeck = observationDeck;
        this.guildVoiceRegionsSnapshot = h0.emptyMap();
        this.guildVoiceRegionsState = new HashMap<>();
    }

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

    public static final /* synthetic */ Dispatcher access$getDispatcher$p(StoreGuildVoiceRegions storeGuildVoiceRegions) {
        return storeGuildVoiceRegions.dispatcher;
    }

    public static final /* synthetic */ HashMap access$getGuildVoiceRegionsState$p(StoreGuildVoiceRegions storeGuildVoiceRegions) {
        return storeGuildVoiceRegions.guildVoiceRegionsState;
    }

    public static final /* synthetic */ void access$handleGuildVoiceRegions(StoreGuildVoiceRegions storeGuildVoiceRegions, long j, List list) {
        storeGuildVoiceRegions.handleGuildVoiceRegions(j, list);
    }

    public static final /* synthetic */ void access$handleGuildVoiceRegionsFetchFailed(StoreGuildVoiceRegions storeGuildVoiceRegions, long j) {
        storeGuildVoiceRegions.handleGuildVoiceRegionsFetchFailed(j);
    }

    public static final /* synthetic */ void access$handleGuildVoiceRegionsFetchStart(StoreGuildVoiceRegions storeGuildVoiceRegions, long j) {
        storeGuildVoiceRegions.handleGuildVoiceRegionsFetchStart(j);
    }

    @StoreThread
    private final void handleGuildVoiceRegions(long j, List<? extends ModelVoiceRegion> list) {
        this.guildVoiceRegionsState.put(Long.valueOf(j), new State.Loaded(list));
        markChanged();
    }

    @StoreThread
    private final void handleGuildVoiceRegionsFetchFailed(long j) {
        this.guildVoiceRegionsState.put(Long.valueOf(j), State.Failure.INSTANCE);
        markChanged();
    }

    @StoreThread
    private final void handleGuildVoiceRegionsFetchStart(long j) {
        this.guildVoiceRegionsState.put(Long.valueOf(j), State.Fetching.INSTANCE);
        markChanged();
    }

    public final void fetchIfNonexisting(long j) {
        this.dispatcher.schedule(new StoreGuildVoiceRegions$fetchIfNonexisting$1(this, j));
    }

    public final List<ModelVoiceRegion> getGuildVoiceRegions(long j) {
        List<ModelVoiceRegion> list = (List) this.guildVoiceRegionsSnapshot.get(Long.valueOf(j));
        return list != null ? list : n.emptyList();
    }

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

    @Override // com.discord.stores.StoreV2
    public void snapshotData() {
        List<ModelVoiceRegion> list;
        super.snapshotData();
        HashMap<Long, State> hashMap = this.guildVoiceRegionsState;
        LinkedHashMap linkedHashMap = new LinkedHashMap();
        for (Map.Entry<Long, State> entry : hashMap.entrySet()) {
            if (entry.getValue() instanceof State.Loaded) {
                linkedHashMap.put(entry.getKey(), entry.getValue());
            }
        }
        LinkedHashMap linkedHashMap2 = new LinkedHashMap(g0.mapCapacity(linkedHashMap.size()));
        for (Map.Entry entry2 : linkedHashMap.entrySet()) {
            Object key = entry2.getKey();
            Object value = entry2.getValue();
            if (!(value instanceof State.Loaded)) {
                value = null;
            }
            State.Loaded loaded = (State.Loaded) value;
            if (loaded == null || (list = loaded.getData()) == null) {
                list = n.emptyList();
            }
            linkedHashMap2.put(key, list);
        }
        this.guildVoiceRegionsSnapshot = linkedHashMap2;
    }
}