package com.discord.stores;

import c.d.b.a.a;
import com.android.billingclient.api.SkuDetails;
import com.discord.stores.updates.ObservationDeck;
import com.discord.utilities.billing.GooglePlayInAppSkus;
import d0.t.h0;
import d0.z.d.m;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import kotlin.NoWhenBranchMatchedException;
import kotlin.jvm.internal.DefaultConstructorMarker;
import rx.Observable;
/* compiled from: StoreGooglePlaySkuDetails.kt */
public final class StoreGooglePlaySkuDetails extends StoreV2 {
    private final Dispatcher dispatcher;
    private final ObservationDeck observationDeck;
    private State skuState;
    private State skuStateSnapshot;

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

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

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

        /* compiled from: StoreGooglePlaySkuDetails.kt */
        public static final class Loaded extends State {
            private final Map<String, SkuDetails> skuDetails;

            /* JADX DEBUG: Multi-variable search result rejected for r2v0, resolved type: java.util.Map<java.lang.String, ? extends com.android.billingclient.api.SkuDetails> */
            /* JADX WARN: Multi-variable type inference failed */
            /* JADX INFO: super call moved to the top of the method (can break code semantics) */
            public Loaded(Map<String, ? extends SkuDetails> map) {
                super(null);
                m.checkNotNullParameter(map, "skuDetails");
                this.skuDetails = map;
            }

            /* JADX DEBUG: Multi-variable search result rejected for r0v0, resolved type: com.discord.stores.StoreGooglePlaySkuDetails$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.skuDetails;
                }
                return loaded.copy(map);
            }

            public final Map<String, SkuDetails> component1() {
                return this.skuDetails;
            }

            public final Loaded copy(Map<String, ? extends SkuDetails> map) {
                m.checkNotNullParameter(map, "skuDetails");
                return new Loaded(map);
            }

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

            public final Map<String, SkuDetails> getSkuDetails() {
                return this.skuDetails;
            }

            public int hashCode() {
                Map<String, SkuDetails> map = this.skuDetails;
                if (map != null) {
                    return map.hashCode();
                }
                return 0;
            }

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

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

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

        private State() {
        }

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

    public StoreGooglePlaySkuDetails(ObservationDeck observationDeck, Dispatcher dispatcher) {
        m.checkNotNullParameter(observationDeck, "observationDeck");
        m.checkNotNullParameter(dispatcher, "dispatcher");
        this.observationDeck = observationDeck;
        this.dispatcher = dispatcher;
        State.Uninitialized uninitialized = State.Uninitialized.INSTANCE;
        this.skuState = uninitialized;
        this.skuStateSnapshot = uninitialized;
    }

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

    public final void handleError() {
        this.dispatcher.schedule(new StoreGooglePlaySkuDetails$handleError$1(this));
    }

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

    @StoreThread
    public final void handleFetchSuccess(List<? extends SkuDetails> list) {
        m.checkNotNullParameter(list, "newSkuDetails");
        State state = this.skuState;
        Map<String, SkuDetails> map = null;
        if (!(state instanceof State.Loaded)) {
            state = null;
        }
        State.Loaded loaded = (State.Loaded) state;
        if (loaded != null) {
            map = loaded.getSkuDetails();
        }
        if (map == null) {
            map = h0.emptyMap();
        }
        Map<String, ? extends SkuDetails> mutableMap = h0.toMutableMap(map);
        LinkedHashMap linkedHashMap = new LinkedHashMap(a.x(list, 10, 16));
        for (Object obj : list) {
            linkedHashMap.put(((SkuDetails) obj).d(), obj);
        }
        mutableMap.putAll(linkedHashMap);
        GooglePlayInAppSkus.INSTANCE.populateSkuDetails(mutableMap);
        this.skuState = new State.Loaded(mutableMap);
        markChanged();
    }

    public final Observable<State> observeState() {
        Observable<State> r = ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StoreGooglePlaySkuDetails$observeState$1(this), 14, null).r();
        m.checkNotNullExpressionValue(r, "observationDeck.connectR…  .distinctUntilChanged()");
        return r;
    }

    @Override // com.discord.stores.StoreV2
    public void snapshotData() {
        super.snapshotData();
        State state = this.skuState;
        if (state instanceof State.Loaded) {
            State.Loaded loaded = (State.Loaded) state;
            state = loaded.copy(new HashMap(loaded.getSkuDetails()));
        } else if (!m.areEqual(state, State.Uninitialized.INSTANCE) && !m.areEqual(state, State.Failure.INSTANCE)) {
            throw new NoWhenBranchMatchedException();
        }
        this.skuStateSnapshot = state;
    }

    public final void updateSkuDetails(List<? extends SkuDetails> list) {
        m.checkNotNullParameter(list, "skuDetails");
        this.dispatcher.schedule(new StoreGooglePlaySkuDetails$updateSkuDetails$1(this, list));
    }
}