package com.discord.stores;

import android.content.Context;
import c.d.b.a.a;
import com.discord.api.sticker.Sticker;
import com.discord.api.sticker.StickerType;
import com.discord.models.sticker.dto.ModelStickerPack;
import com.discord.stores.updates.ObservationDeck;
import com.discord.stores.updates.ObservationDeckProvider;
import com.discord.utilities.media.MediaFrecencyTracker;
import com.discord.utilities.persister.Persister;
import com.discord.utilities.rest.RestAPI;
import com.discord.utilities.rx.ObservableExtensionsKt;
import com.discord.utilities.time.Clock;
import com.discord.utilities.time.ClockFactory;
import com.discord.widgets.chat.input.sticker.StickerPickerFeatureFlag;
import d0.t.h0;
import d0.t.n;
import d0.t.o;
import d0.z.d.m;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.DefaultConstructorMarker;
import rx.Observable;
/* compiled from: StoreStickers.kt */
public final class StoreStickers extends StoreV2 {
    public static final Companion Companion = new Companion(null);
    private static final long FETCH_ENABLED_STICKER_PACKS_DELAY = 300000;
    private static final int MAX_FREQUENTLY_USED_STICKERS = 20;
    private final RestAPI api;
    private final Clock clock;
    private final Dispatcher dispatcher;
    private List<ModelStickerPack> enabledStickerPacks;
    private List<ModelStickerPack> enabledStickerPacksSnapshot;
    private List<Sticker> enabledStickerPacksStickersSnapshot;
    private final MediaFrecencyTracker frecency;
    private final Persister<MediaFrecencyTracker> frecencyCache;
    private long lastFetchedEnabledPacks;
    private final ObservationDeck observationDeck;
    private Map<Long, ? extends StickerPackState> stickerPacks;
    private Map<Long, ? extends StickerPackState> stickerPacksSnapshot;
    private Map<Long, Sticker> stickersSnapshot;

    /* compiled from: StoreStickers.kt */
    public static final class Companion {
        private Companion() {
        }

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

    /* compiled from: StoreStickers.kt */
    public static abstract class StickerPackState {

        /* compiled from: StoreStickers.kt */
        public static final class Loaded extends StickerPackState {
            private final ModelStickerPack stickerPack;

            /* JADX INFO: super call moved to the top of the method (can break code semantics) */
            public Loaded(ModelStickerPack modelStickerPack) {
                super(null);
                m.checkNotNullParameter(modelStickerPack, "stickerPack");
                this.stickerPack = modelStickerPack;
            }

            public static /* synthetic */ Loaded copy$default(Loaded loaded, ModelStickerPack modelStickerPack, int i, Object obj) {
                if ((i & 1) != 0) {
                    modelStickerPack = loaded.stickerPack;
                }
                return loaded.copy(modelStickerPack);
            }

            public final ModelStickerPack component1() {
                return this.stickerPack;
            }

            public final Loaded copy(ModelStickerPack modelStickerPack) {
                m.checkNotNullParameter(modelStickerPack, "stickerPack");
                return new Loaded(modelStickerPack);
            }

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

            public final ModelStickerPack getStickerPack() {
                return this.stickerPack;
            }

            public int hashCode() {
                ModelStickerPack modelStickerPack = this.stickerPack;
                if (modelStickerPack != null) {
                    return modelStickerPack.hashCode();
                }
                return 0;
            }

            public String toString() {
                StringBuilder L = a.L("Loaded(stickerPack=");
                L.append(this.stickerPack);
                L.append(")");
                return L.toString();
            }
        }

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

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

        /* compiled from: StoreStickers.kt */
        public static final class Unknown extends StickerPackState {
            public static final Unknown INSTANCE = new Unknown();

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

        private StickerPackState() {
        }

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

    public StoreStickers(Dispatcher dispatcher, RestAPI restAPI, ObservationDeck observationDeck, Clock clock) {
        m.checkNotNullParameter(dispatcher, "dispatcher");
        m.checkNotNullParameter(restAPI, "api");
        m.checkNotNullParameter(observationDeck, "observationDeck");
        m.checkNotNullParameter(clock, "clock");
        this.dispatcher = dispatcher;
        this.api = restAPI;
        this.observationDeck = observationDeck;
        this.clock = clock;
        this.stickerPacks = h0.emptyMap();
        this.stickerPacksSnapshot = h0.emptyMap();
        this.stickersSnapshot = h0.emptyMap();
        Persister<MediaFrecencyTracker> persister = new Persister<>("STICKER_HISTORY_V1", new MediaFrecencyTracker(20, 1));
        this.frecencyCache = persister;
        this.frecency = persister.get();
        this.enabledStickerPacks = n.emptyList();
        this.enabledStickerPacksSnapshot = n.emptyList();
        this.enabledStickerPacksStickersSnapshot = n.emptyList();
    }

    /* JADX INFO: this call moved to the top of the method (can break code semantics) */
    public /* synthetic */ StoreStickers(Dispatcher dispatcher, RestAPI restAPI, ObservationDeck observationDeck, Clock clock, int i, DefaultConstructorMarker defaultConstructorMarker) {
        this(dispatcher, (i & 2) != 0 ? RestAPI.Companion.getApi() : restAPI, (i & 4) != 0 ? ObservationDeckProvider.get() : observationDeck, (i & 8) != 0 ? ClockFactory.get() : clock);
    }

    public static final /* synthetic */ RestAPI access$getApi$p(StoreStickers storeStickers) {
        return storeStickers.api;
    }

    public static final /* synthetic */ Clock access$getClock$p(StoreStickers storeStickers) {
        return storeStickers.clock;
    }

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

    public static final /* synthetic */ List access$getEnabledStickerPacksSnapshot$p(StoreStickers storeStickers) {
        return storeStickers.enabledStickerPacksSnapshot;
    }

    public static final /* synthetic */ MediaFrecencyTracker access$getFrecency$p(StoreStickers storeStickers) {
        return storeStickers.frecency;
    }

    public static final /* synthetic */ Persister access$getFrecencyCache$p(StoreStickers storeStickers) {
        return storeStickers.frecencyCache;
    }

    public static final /* synthetic */ long access$getLastFetchedEnabledPacks$p(StoreStickers storeStickers) {
        return storeStickers.lastFetchedEnabledPacks;
    }

    public static final /* synthetic */ Map access$getStickerPacks$p(StoreStickers storeStickers) {
        return storeStickers.stickerPacks;
    }

    public static final /* synthetic */ void access$setEnabledStickerPacksSnapshot$p(StoreStickers storeStickers, List list) {
        storeStickers.enabledStickerPacksSnapshot = list;
    }

    public static final /* synthetic */ void access$setLastFetchedEnabledPacks$p(StoreStickers storeStickers, long j) {
        storeStickers.lastFetchedEnabledPacks = j;
    }

    public static final /* synthetic */ void access$setStickerPacks$p(StoreStickers storeStickers, Map map) {
        storeStickers.stickerPacks = map;
    }

    public final void fetchEnabledStickerDirectory() {
        if (this.lastFetchedEnabledPacks + 300000 < this.clock.currentTimeMillis()) {
            ObservableExtensionsKt.appSubscribe$default(ObservableExtensionsKt.restSubscribeOn$default(this.api.getStickerPacks(), false, 1, null), StoreStickers.class, (Context) null, (Function1) null, (Function1) null, (Function0) null, (Function0) null, new StoreStickers$fetchEnabledStickerDirectory$1(this), 62, (Object) null);
        }
    }

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

    public final List<ModelStickerPack> getEnabledStickerPacks() {
        return this.enabledStickerPacksSnapshot;
    }

    public final List<Sticker> getEnabledStickers() {
        return this.enabledStickerPacksStickersSnapshot;
    }

    public final StickerPackState getStickerPack(long j) {
        return (StickerPackState) this.stickerPacksSnapshot.get(Long.valueOf(j));
    }

    /* JADX DEBUG: Type inference failed for r0v0. Raw type applied. Possible types: java.util.Map<java.lang.Long, ? extends com.discord.stores.StoreStickers$StickerPackState>, java.util.Map<java.lang.Long, com.discord.stores.StoreStickers$StickerPackState> */
    public final Map<Long, StickerPackState> getStickerPacks() {
        return this.stickerPacksSnapshot;
    }

    public final Map<Long, Sticker> getStickers() {
        return this.stickersSnapshot;
    }

    public final void handleDeletedStickers(List<Long> list) {
        m.checkNotNullParameter(list, "stickerIds");
        this.dispatcher.schedule(new StoreStickers$handleDeletedStickers$1(this, list));
    }

    public final void handleFetchedSticker(Sticker sticker) {
        if (sticker != null && sticker.k() == StickerType.STANDARD) {
            Long i = sticker.i();
            m.checkNotNull(i);
            fetchStickerPack(i.longValue());
        }
    }

    @StoreThread
    public final void handleNewEnabledStickerDirectory(List<ModelStickerPack> list) {
        m.checkNotNullParameter(list, "enabledPacks");
        handleNewLoadedStickerPacks(list);
        this.enabledStickerPacks = list;
        markChanged();
    }

    @StoreThread
    public final void handleNewLoadedStickerPacks(List<ModelStickerPack> list) {
        m.checkNotNullParameter(list, "newStickerPacks");
        Map<Long, ? extends StickerPackState> mutableMap = h0.toMutableMap(this.stickerPacks);
        for (ModelStickerPack modelStickerPack : list) {
            StickerPackState stickerPackState = (StickerPackState) this.stickerPacks.get(Long.valueOf(modelStickerPack.getId()));
            if (stickerPackState == null || !(stickerPackState instanceof StickerPackState.Loaded) || ((StickerPackState.Loaded) stickerPackState).getStickerPack().getStoreListing() == null) {
                mutableMap.put(Long.valueOf(modelStickerPack.getId()), new StickerPackState.Loaded(modelStickerPack));
            }
        }
        this.stickerPacks = mutableMap;
        markChanged();
    }

    @StoreThread
    public final void handleNewLoadingStickerPacks(List<Long> list) {
        m.checkNotNullParameter(list, "stickerPackIds");
        Map<Long, ? extends StickerPackState> mutableMap = h0.toMutableMap(this.stickerPacks);
        for (Number number : list) {
            mutableMap.put(Long.valueOf(number.longValue()), StickerPackState.Loading.INSTANCE);
        }
        this.stickerPacks = mutableMap;
        markChanged();
    }

    @StoreThread
    public final void handlePreLogout() {
        Persister.clear$default(this.frecencyCache, false, 1, null);
    }

    public final void init() {
        if (StickerPickerFeatureFlag.Companion.getINSTANCE().isEnabled()) {
            fetchEnabledStickerDirectory();
        }
    }

    public final Observable<List<ModelStickerPack>> observeEnabledStickerPacks() {
        return ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StoreStickers$observeEnabledStickerPacks$1(this), 14, null);
    }

    public final Observable<List<Long>> observeFrequentlyUsedStickerIds() {
        Observable<R> F = this.frecencyCache.getObservable().F(StoreStickers$observeFrequentlyUsedStickerIds$1.INSTANCE);
        m.checkNotNullExpressionValue(F, "frecencyCache.getObserva…ckerId.toLong() }\n      }");
        return F;
    }

    public final Observable<StickerPackState> observeStickerPack(long j) {
        this.dispatcher.schedule(new StoreStickers$observeStickerPack$1(this, j));
        return ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StoreStickers$observeStickerPack$2(this, j), 14, null);
    }

    public final Observable<List<StickerPackState>> observeStickerPacks() {
        return ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StoreStickers$observeStickerPacks$1(this), 14, null);
    }

    public final void onStickerUsed(Sticker sticker) {
        m.checkNotNullParameter(sticker, "sticker");
        this.dispatcher.schedule(new StoreStickers$onStickerUsed$1(this, sticker));
    }

    @Override // com.discord.stores.StoreV2
    @StoreThread
    public void snapshotData() {
        HashMap hashMap = new HashMap(this.stickerPacks);
        this.stickerPacksSnapshot = hashMap;
        Collection values = hashMap.values();
        ArrayList<StickerPackState.Loaded> arrayList = new ArrayList();
        for (Object obj : values) {
            if (obj instanceof StickerPackState.Loaded) {
                arrayList.add(obj);
            }
        }
        ArrayList arrayList2 = new ArrayList(o.collectionSizeOrDefault(arrayList, 10));
        for (StickerPackState.Loaded loaded : arrayList) {
            arrayList2.add(loaded.getStickerPack().getStickers());
        }
        List flatten = o.flatten(arrayList2);
        LinkedHashMap linkedHashMap = new LinkedHashMap(a.I(flatten, 10, 16));
        for (Object obj2 : flatten) {
            linkedHashMap.put(Long.valueOf(((Sticker) obj2).getId()), obj2);
        }
        this.stickersSnapshot = linkedHashMap;
        this.enabledStickerPacksSnapshot = new ArrayList(this.enabledStickerPacks);
        List<ModelStickerPack> list = this.enabledStickerPacks;
        ArrayList arrayList3 = new ArrayList(o.collectionSizeOrDefault(list, 10));
        for (ModelStickerPack modelStickerPack : list) {
            arrayList3.add(modelStickerPack.getStickers());
        }
        this.enabledStickerPacksStickersSnapshot = new ArrayList(o.flatten(arrayList3));
    }
}