package com.discord.stores;

import android.content.Context;
import c.d.b.a.a;
import com.discord.models.domain.ModelPremiumGuildSubscription;
import com.discord.models.domain.ModelPremiumGuildSubscriptionSlot;
import com.discord.stores.updates.ObservationDeck;
import com.discord.utilities.rest.RestAPI;
import com.discord.utilities.rx.ObservableExtensionsKt;
import d0.d0.f;
import d0.t.g0;
import d0.t.h0;
import d0.t.o;
import d0.z.d.m;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import kotlin.NoWhenBranchMatchedException;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.DefaultConstructorMarker;
import rx.Observable;
/* compiled from: StorePremiumGuildSubscription.kt */
public final class StorePremiumGuildSubscription extends StoreV2 {
    private final Dispatcher dispatcher;
    private final ObservationDeck observationDeck;
    private State state;
    private State stateSnapshot;

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

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

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

        /* compiled from: StorePremiumGuildSubscription.kt */
        public static final class Loaded extends State {
            private final Map<Long, ModelPremiumGuildSubscriptionSlot> premiumGuildSubscriptionSlotMap;

            /* JADX INFO: super call moved to the top of the method (can break code semantics) */
            public Loaded(Map<Long, ModelPremiumGuildSubscriptionSlot> map) {
                super(null);
                m.checkNotNullParameter(map, "premiumGuildSubscriptionSlotMap");
                this.premiumGuildSubscriptionSlotMap = map;
            }

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

            public final Map<Long, ModelPremiumGuildSubscriptionSlot> component1() {
                return this.premiumGuildSubscriptionSlotMap;
            }

            public final Loaded copy(Map<Long, ModelPremiumGuildSubscriptionSlot> map) {
                m.checkNotNullParameter(map, "premiumGuildSubscriptionSlotMap");
                return new Loaded(map);
            }

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

            public final Loaded filterByGuildId(Long l) {
                Map<Long, ModelPremiumGuildSubscriptionSlot> map;
                if (l == null) {
                    map = this.premiumGuildSubscriptionSlotMap;
                } else {
                    Map<Long, ModelPremiumGuildSubscriptionSlot> map2 = this.premiumGuildSubscriptionSlotMap;
                    LinkedHashMap linkedHashMap = new LinkedHashMap();
                    for (Map.Entry<Long, ModelPremiumGuildSubscriptionSlot> entry : map2.entrySet()) {
                        ModelPremiumGuildSubscription premiumGuildSubscription = entry.getValue().getPremiumGuildSubscription();
                        if (m.areEqual(premiumGuildSubscription != null ? Long.valueOf(premiumGuildSubscription.getGuildId()) : null, l)) {
                            linkedHashMap.put(entry.getKey(), entry.getValue());
                        }
                    }
                    map = linkedHashMap;
                }
                return new Loaded(map);
            }

            public final Map<Long, ModelPremiumGuildSubscriptionSlot> getPremiumGuildSubscriptionSlotMap() {
                return this.premiumGuildSubscriptionSlotMap;
            }

            public int hashCode() {
                Map<Long, ModelPremiumGuildSubscriptionSlot> map = this.premiumGuildSubscriptionSlotMap;
                if (map != null) {
                    return map.hashCode();
                }
                return 0;
            }

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

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

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

        private State() {
        }

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

    public StorePremiumGuildSubscription(Dispatcher dispatcher, ObservationDeck observationDeck) {
        m.checkNotNullParameter(dispatcher, "dispatcher");
        m.checkNotNullParameter(observationDeck, "observationDeck");
        this.dispatcher = dispatcher;
        this.observationDeck = observationDeck;
        State.Loading loading = State.Loading.INSTANCE;
        this.state = loading;
        this.stateSnapshot = loading;
    }

    public static final /* synthetic */ State access$getState$p(StorePremiumGuildSubscription storePremiumGuildSubscription) {
        return storePremiumGuildSubscription.state;
    }

    public static final /* synthetic */ void access$setState$p(StorePremiumGuildSubscription storePremiumGuildSubscription, State state) {
        storePremiumGuildSubscription.state = state;
    }

    public static /* synthetic */ State getPremiumGuildSubscriptionsState$default(StorePremiumGuildSubscription storePremiumGuildSubscription, Long l, int i, Object obj) {
        if ((i & 1) != 0) {
            l = null;
        }
        return storePremiumGuildSubscription.getPremiumGuildSubscriptionsState(l);
    }

    public static /* synthetic */ Observable observePremiumGuildSubscriptionsState$default(StorePremiumGuildSubscription storePremiumGuildSubscription, Long l, int i, Object obj) {
        if ((i & 1) != 0) {
            l = null;
        }
        return storePremiumGuildSubscription.observePremiumGuildSubscriptionsState(l);
    }

    public final void fetchUserGuildPremiumState() {
        this.dispatcher.schedule(new StorePremiumGuildSubscription$fetchUserGuildPremiumState$1(this));
        ObservableExtensionsKt.appSubscribe$default(ObservableExtensionsKt.restSubscribeOn$default(RestAPI.Companion.getApi().getSubscriptionSlots(), false, 1, null), StorePremiumGuildSubscription.class, (Context) null, (Function1) null, new StorePremiumGuildSubscription$fetchUserGuildPremiumState$2(this), (Function0) null, (Function0) null, new StorePremiumGuildSubscription$fetchUserGuildPremiumState$3(this), 54, (Object) null);
    }

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

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

    public final State getPremiumGuildSubscriptionsState(Long l) {
        State state = getState();
        return state instanceof State.Loaded ? ((State.Loaded) state).filterByGuildId(l) : state;
    }

    public final State getState() {
        return this.stateSnapshot;
    }

    @StoreThread
    public final void handleFetchError() {
        this.state = State.Failure.INSTANCE;
        markChanged();
    }

    @StoreThread
    public final void handleFetchStateSuccess(List<ModelPremiumGuildSubscriptionSlot> list) {
        m.checkNotNullParameter(list, "premiumGuildSubscriptionSlots");
        LinkedHashMap linkedHashMap = new LinkedHashMap(f.coerceAtLeast(g0.mapCapacity(o.collectionSizeOrDefault(list, 10)), 16));
        for (Object obj : list) {
            linkedHashMap.put(Long.valueOf(((ModelPremiumGuildSubscriptionSlot) obj).getId()), obj);
        }
        this.state = new State.Loaded(linkedHashMap);
        markChanged();
    }

    @StoreThread
    public final void handleFetchingState() {
        this.state = State.Loading.INSTANCE;
        markChanged();
    }

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

    @Override // com.discord.stores.StoreV2
    @StoreThread
    public void snapshotData() {
        State state = this.state;
        if (!(state instanceof State.Loading) && !(state instanceof State.Failure)) {
            if (state instanceof State.Loaded) {
                state = new State.Loaded(h0.toMap(((State.Loaded) state).getPremiumGuildSubscriptionSlotMap()));
            } else {
                throw new NoWhenBranchMatchedException();
            }
        }
        this.stateSnapshot = state;
    }

    public final void updateUserPremiumGuildSubscriptionSlot(ModelPremiumGuildSubscriptionSlot modelPremiumGuildSubscriptionSlot) {
        m.checkNotNullParameter(modelPremiumGuildSubscriptionSlot, "newSlot");
        this.dispatcher.schedule(new StorePremiumGuildSubscription$updateUserPremiumGuildSubscriptionSlot$1(this, modelPremiumGuildSubscriptionSlot));
    }
}