package com.discord.stores;

import android.content.Context;
import com.discord.models.domain.ModelPayload;
import com.discord.models.experiments.domain.Experiment;
import com.discord.models.experiments.domain.ExperimentHash;
import com.discord.models.experiments.dto.GuildExperimentDto;
import com.discord.models.experiments.dto.UserExperimentDto;
import com.discord.stores.updates.ObservationDeck;
import com.discord.stores.updates.ObservationDeckProvider;
import com.discord.utilities.analytics.AnalyticsTracker;
import com.discord.utilities.experiments.ExperimentRegistry;
import com.discord.utilities.experiments.ExperimentUtils;
import com.discord.utilities.experiments.RegisteredExperiment;
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.widgets.chat.input.sticker.StickerPickerFeatureFlag;
import com.google.gson.Gson;
import d0.t.h0;
import d0.z.d.m;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.DefaultConstructorMarker;
import rx.Observable;
/* compiled from: StoreExperiments.kt */
public final class StoreExperiments extends StoreV2 {
    public static final Companion Companion = new Companion(null);
    private static final long DISCORD_TESTERS_GUILD_ID = 197038439483310086L;
    private static final String EXPERIMENT_OVERRIDES_CACHE_KEY = "EXPERIMENT_OVERRIDES_CACHE_KEY";
    private static final String EXPERIMENT_TRACKED_EXPOSURE_TIMESTAMPS_CACHE_KEY = "EXPERIMENT_TRIGGER_TIMESTAMPS_CACHE_KEY";
    private static final StoreExperiments$Companion$ExperimentOverridesUpdateSource$1 ExperimentOverridesUpdateSource = new StoreExperiments$Companion$ExperimentOverridesUpdateSource$1();
    private static final String GUILD_EXPERIMENTS_CACHE_KEY = "GUILD_EXPERIMENTS_CACHE_KEY";
    private static final StoreExperiments$Companion$InitializedUpdateSource$1 InitializedUpdateSource = new StoreExperiments$Companion$InitializedUpdateSource$1();
    private static final String UNINITIALIZED = "UNINITIALIZED";
    private static final String USER_EXPERIMENTS_CACHE_KEY = "USER_EXPERIMENTS_CACHE_KEY";
    private String authToken;
    private final Clock clock;
    private final Dispatcher dispatcher;
    private final HashMap<String, Integer> experimentOverrides;
    private final Persister<Map<String, Integer>> experimentOverridesCache;
    private Map<String, Integer> experimentOverridesSnapshot;
    private final HashMap<String, Long> experimentTrackedExposureTimestamps;
    private String fingerprint;
    private final HashMap<Long, GuildExperimentDto> guildExperiments;
    private final Persister<List<GuildExperimentDto>> guildExperimentsCache;
    private Map<Long, GuildExperimentDto> guildExperimentsSnapshot;
    private boolean initialized;
    private final HashMap<String, Experiment> memoizedGuildExperiments;
    private final ObservationDeck observationDeck;
    private final StoreAuthentication storeAuthentication;
    private final StoreGuildMemberCounts storeGuildMemberCounts;
    private final StoreGuilds storeGuilds;
    private final StoreUser storeUser;
    private final HashMap<Long, UserExperimentDto> userExperiments;
    private final Persister<Map<Long, UserExperimentDto>> userExperimentsCache;
    private Map<Long, UserExperimentDto> userExperimentsSnapshot;

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

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

    public StoreExperiments(Clock clock, Dispatcher dispatcher, StoreUser storeUser, StoreGuilds storeGuilds, StoreAuthentication storeAuthentication, StoreGuildMemberCounts storeGuildMemberCounts, ObservationDeck observationDeck) {
        m.checkNotNullParameter(clock, "clock");
        m.checkNotNullParameter(dispatcher, "dispatcher");
        m.checkNotNullParameter(storeUser, "storeUser");
        m.checkNotNullParameter(storeGuilds, "storeGuilds");
        m.checkNotNullParameter(storeAuthentication, "storeAuthentication");
        m.checkNotNullParameter(storeGuildMemberCounts, "storeGuildMemberCounts");
        m.checkNotNullParameter(observationDeck, "observationDeck");
        this.clock = clock;
        this.dispatcher = dispatcher;
        this.storeUser = storeUser;
        this.storeGuilds = storeGuilds;
        this.storeAuthentication = storeAuthentication;
        this.storeGuildMemberCounts = storeGuildMemberCounts;
        this.observationDeck = observationDeck;
        this.authToken = "UNINITIALIZED";
        this.fingerprint = "UNINITIALIZED";
        this.userExperimentsSnapshot = h0.emptyMap();
        this.guildExperimentsSnapshot = h0.emptyMap();
        this.experimentOverridesSnapshot = h0.emptyMap();
        this.userExperiments = new HashMap<>();
        this.guildExperiments = new HashMap<>();
        this.experimentOverrides = new HashMap<>();
        this.memoizedGuildExperiments = new HashMap<>();
        this.experimentTrackedExposureTimestamps = new HashMap<>();
        this.userExperimentsCache = new Persister<>("USER_EXPERIMENTS_CACHE_KEY", new HashMap());
        this.guildExperimentsCache = new Persister<>("GUILD_EXPERIMENTS_CACHE_KEY", new ArrayList());
        this.experimentOverridesCache = new Persister<>("EXPERIMENT_OVERRIDES_CACHE_KEY", new HashMap());
    }

    /* JADX INFO: this call moved to the top of the method (can break code semantics) */
    public /* synthetic */ StoreExperiments(Clock clock, Dispatcher dispatcher, StoreUser storeUser, StoreGuilds storeGuilds, StoreAuthentication storeAuthentication, StoreGuildMemberCounts storeGuildMemberCounts, ObservationDeck observationDeck, int i, DefaultConstructorMarker defaultConstructorMarker) {
        this(clock, dispatcher, storeUser, storeGuilds, storeAuthentication, storeGuildMemberCounts, (i & 64) != 0 ? ObservationDeckProvider.get() : observationDeck);
    }

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

    public static final /* synthetic */ HashMap access$getExperimentOverrides$p(StoreExperiments storeExperiments) {
        return storeExperiments.experimentOverrides;
    }

    public static final /* synthetic */ boolean access$getInitialized$p(StoreExperiments storeExperiments) {
        return storeExperiments.initialized;
    }

    public static final /* synthetic */ StoreAuthentication access$getStoreAuthentication$p(StoreExperiments storeExperiments) {
        return storeExperiments.storeAuthentication;
    }

    public static final /* synthetic */ StoreGuilds access$getStoreGuilds$p(StoreExperiments storeExperiments) {
        return storeExperiments.storeGuilds;
    }

    public static final /* synthetic */ StoreUser access$getStoreUser$p(StoreExperiments storeExperiments) {
        return storeExperiments.storeUser;
    }

    public static final /* synthetic */ void access$handleClearOverride(StoreExperiments storeExperiments, String str) {
        storeExperiments.handleClearOverride(str);
    }

    public static final /* synthetic */ void access$handleLoadedUserExperiments(StoreExperiments storeExperiments, Map map, boolean z2) {
        storeExperiments.handleLoadedUserExperiments(map, z2);
    }

    public static final /* synthetic */ void access$handleSetOverride(StoreExperiments storeExperiments, String str, int i) {
        storeExperiments.handleSetOverride(str, i);
    }

    public static final /* synthetic */ void access$setInitialized(StoreExperiments storeExperiments) {
        storeExperiments.setInitialized();
    }

    public static final /* synthetic */ void access$setInitialized$p(StoreExperiments storeExperiments, boolean z2) {
        storeExperiments.initialized = z2;
    }

    public static final /* synthetic */ void access$trackExposureToGuildExperiment(StoreExperiments storeExperiments, String str, long j, int i, int i2) {
        storeExperiments.trackExposureToGuildExperiment(str, j, i, i2);
    }

    public static final /* synthetic */ void access$trackExposureToUserExperiment(StoreExperiments storeExperiments, String str, int i, int i2, int i3) {
        storeExperiments.trackExposureToUserExperiment(str, i, i2, i3);
    }

    private final void cacheExperimentTrackedExposureTimestamps() {
        getPrefs().edit().putString("EXPERIMENT_TRIGGER_TIMESTAMPS_CACHE_KEY", new Gson().m(this.experimentTrackedExposureTimestamps)).apply();
    }

    private final void cacheGuildExperiments() {
        boolean z2;
        Collection<GuildExperimentDto> values = this.guildExperiments.values();
        m.checkNotNullExpressionValue(values, "guildExperiments.values");
        ArrayList arrayList = new ArrayList();
        Iterator<T> it = values.iterator();
        while (true) {
            boolean z3 = true;
            if (it.hasNext()) {
                Object next = it.next();
                GuildExperimentDto guildExperimentDto = (GuildExperimentDto) next;
                Collection<RegisteredExperiment> values2 = ExperimentRegistry.INSTANCE.getRegisteredExperiments().values();
                m.checkNotNullExpressionValue(values2, "ExperimentRegistry.registeredExperiments.values");
                if (!(values2 instanceof Collection) || !values2.isEmpty()) {
                    Iterator<T> it2 = values2.iterator();
                    while (true) {
                        if (!it2.hasNext()) {
                            break;
                        }
                        if (ExperimentHash.INSTANCE.from(((RegisteredExperiment) it2.next()).getName()) == guildExperimentDto.getExperimentIdHash()) {
                            z2 = true;
                            continue;
                        } else {
                            z2 = false;
                            continue;
                        }
                        if (z2) {
                            break;
                        }
                    }
                }
                z3 = false;
                if (z3) {
                    arrayList.add(next);
                }
            } else {
                this.guildExperimentsCache.set(arrayList, true);
                return;
            }
        }
    }

    /* JADX WARNING: Removed duplicated region for block: B:20:0x0067 A[SYNTHETIC] */
    /* JADX WARNING: Removed duplicated region for block: B:23:0x000f A[SYNTHETIC] */
    private final void cacheUserExperiments() {
        boolean z2;
        HashMap<Long, UserExperimentDto> hashMap = this.userExperiments;
        LinkedHashMap linkedHashMap = new LinkedHashMap();
        Iterator<Map.Entry<Long, UserExperimentDto>> it = hashMap.entrySet().iterator();
        while (true) {
            boolean z3 = true;
            if (it.hasNext()) {
                Map.Entry<Long, UserExperimentDto> next = it.next();
                Collection<RegisteredExperiment> values = ExperimentRegistry.INSTANCE.getRegisteredExperiments().values();
                m.checkNotNullExpressionValue(values, "ExperimentRegistry.registeredExperiments.values");
                if (!(values instanceof Collection) || !values.isEmpty()) {
                    Iterator<T> it2 = values.iterator();
                    while (true) {
                        if (!it2.hasNext()) {
                            break;
                        }
                        if (ExperimentHash.INSTANCE.from(((RegisteredExperiment) it2.next()).getName()) == next.getValue().getNameHash()) {
                            z2 = true;
                            continue;
                        } else {
                            z2 = false;
                            continue;
                        }
                        if (z2) {
                            break;
                        }
                    }
                    if (!z3) {
                        linkedHashMap.put(next.getKey(), next.getValue());
                    }
                }
                z3 = false;
                if (!z3) {
                }
            } else {
                this.userExperimentsCache.set(linkedHashMap, true);
                return;
            }
        }
    }

    private final void didTrackExposureToExperiment(String str) {
        this.experimentTrackedExposureTimestamps.put(str, Long.valueOf(this.clock.currentTimeMillis()));
        cacheExperimentTrackedExposureTimestamps();
    }

    @StoreThread
    private final void handleClearOverride(String str) {
        this.experimentOverrides.remove(str);
        markChanged(ExperimentOverridesUpdateSource);
    }

    @StoreThread
    private final void handleLoadedGuildExperiments(Collection<GuildExperimentDto> collection, boolean z2) {
        this.guildExperiments.clear();
        this.memoizedGuildExperiments.clear();
        AbstractMap abstractMap = this.guildExperiments;
        for (Object obj : collection) {
            abstractMap.put(Long.valueOf(((GuildExperimentDto) obj).getExperimentIdHash()), obj);
        }
        if (z2) {
            cacheGuildExperiments();
        }
        markChanged();
    }

    @StoreThread
    private final void handleLoadedUserExperiments(Map<Long, UserExperimentDto> map, boolean z2) {
        this.userExperiments.clear();
        this.userExperiments.putAll(map);
        if (z2) {
            cacheUserExperiments();
        }
        markChanged();
    }

    @StoreThread
    private final void handleSetOverride(String str, int i) {
        this.experimentOverrides.put(str, Integer.valueOf(i));
        markChanged(ExperimentOverridesUpdateSource);
    }

    private final Map<String, Long> loadCachedExperimentTrackedExposureTimestamps() {
        String string = getPrefs().getString("EXPERIMENT_TRIGGER_TIMESTAMPS_CACHE_KEY", null);
        if (string == null) {
            return h0.emptyMap();
        }
        Object g = new Gson().g(string, new StoreExperiments$loadCachedExperimentTrackedExposureTimestamps$typeToken$1().getType());
        m.checkNotNullExpressionValue(g, "Gson().fromJson(json, typeToken)");
        return (Map) g;
    }

    private final synchronized void memoizeGuildExperiment(String str, long j, Experiment experiment) {
        this.memoizedGuildExperiments.put(str + ':' + j, experiment);
    }

    @StoreThread
    private final void reset() {
        if (this.authToken == null) {
            this.userExperiments.clear();
            this.guildExperiments.clear();
            this.userExperimentsCache.set(new HashMap(), true);
            this.guildExperimentsCache.set(new ArrayList(), true);
            this.initialized = false;
            markChanged();
        }
    }

    @StoreThread
    private final void setInitialized() {
        this.initialized = true;
        markChanged(InitializedUpdateSource);
    }

    private final synchronized void trackExposureToGuildExperiment(String str, long j, int i, int i2) {
        String str2 = str + ':' + j;
        if (!wasExperimentExposureTrackedRecently(str2, this.clock.currentTimeMillis())) {
            AnalyticsTracker.guildExperimentTriggered(str, i2, i, j);
            didTrackExposureToExperiment(str2);
        }
    }

    private final synchronized void trackExposureToUserExperiment(String str, int i, int i2, int i3) {
        if (!wasExperimentExposureTrackedRecently(str, this.clock.currentTimeMillis())) {
            AnalyticsTracker.userExperimentTriggered(str, i3, i2, i);
            didTrackExposureToExperiment(str);
        }
    }

    @StoreThread
    private final void tryInitializeExperiments() {
        if (!this.initialized && !m.areEqual(this.authToken, "UNINITIALIZED") && !m.areEqual(this.fingerprint, "UNINITIALIZED")) {
            this.initialized = true;
            if (this.authToken != null) {
                setInitialized();
                return;
            }
            Observable c02 = ObservableExtensionsKt.restSubscribeOn$default(RestAPI.Companion.getApi().getExperiments(), false, 1, null).c0(2000, TimeUnit.MILLISECONDS);
            m.checkNotNullExpressionValue(c02, "RestAPI\n          .api\n …0, TimeUnit.MILLISECONDS)");
            ObservableExtensionsKt.appSubscribe$default(c02, StoreExperiments.class, (Context) null, (Function1) null, new StoreExperiments$tryInitializeExperiments$2(this), (Function0) null, (Function0) null, new StoreExperiments$tryInitializeExperiments$1(this), 54, (Object) null);
        }
    }

    private final boolean wasExperimentExposureTrackedRecently(String str, long j) {
        Long l = this.experimentTrackedExposureTimestamps.get(str);
        if (l == null) {
            l = Long.MIN_VALUE;
        }
        m.checkNotNullExpressionValue(l, "experimentTrackedExposur…y] ?: Timestamp.MIN_VALUE");
        return j - 604800000 < l.longValue();
    }

    public final void clearOverride(String str) {
        m.checkNotNullParameter(str, "experimentName");
        this.dispatcher.schedule(new StoreExperiments$clearOverride$1(this, str));
    }

    public final Observable<Boolean> getExperimentalAlpha() {
        return ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this.storeUser, this.storeGuilds}, false, null, null, new StoreExperiments$getExperimentalAlpha$1(this), 14, null);
    }

    public final Experiment getGuildExperiment(String str, long j, boolean z2) {
        m.checkNotNullParameter(str, "experimentName");
        long from = ExperimentHash.INSTANCE.from(str);
        Integer num = this.experimentOverridesSnapshot.get(str);
        GuildExperimentDto guildExperimentDto = this.guildExperimentsSnapshot.get(Long.valueOf(from));
        if (num != null) {
            return new Experiment(guildExperimentDto != null ? guildExperimentDto.getRevision() : 0, num.intValue(), 0, true, StoreExperiments$getGuildExperiment$1.INSTANCE);
        }
        Experiment memoizedGuildExperiment$app_productionBetaRelease = getMemoizedGuildExperiment$app_productionBetaRelease(j + ':' + str, j);
        if (memoizedGuildExperiment$app_productionBetaRelease != null) {
            return memoizedGuildExperiment$app_productionBetaRelease;
        }
        if (guildExperimentDto == null) {
            return null;
        }
        int computeGuildExperimentBucket = ExperimentUtils.INSTANCE.computeGuildExperimentBucket(str, j, this.storeGuildMemberCounts.getApproximateMemberCount(j), this.storeGuilds.getGuild(j), guildExperimentDto);
        int revision = guildExperimentDto.getRevision();
        Experiment experiment = new Experiment(revision, computeGuildExperimentBucket, 0, false, new StoreExperiments$getGuildExperiment$experiment$1(this, str, j, computeGuildExperimentBucket, revision));
        if (z2) {
            experiment.getTrackExposure().mo1invoke();
        }
        memoizeGuildExperiment(str, j, experiment);
        return experiment;
    }

    public final synchronized Experiment getMemoizedGuildExperiment$app_productionBetaRelease(String str, long j) {
        m.checkNotNullParameter(str, "experimentName");
        return this.memoizedGuildExperiments.get(str + ':' + j);
    }

    public final Experiment getUserExperiment(String str, boolean z2) {
        m.checkNotNullParameter(str, "name");
        long from = ExperimentHash.INSTANCE.from(str);
        Integer num = this.experimentOverridesSnapshot.get(str);
        UserExperimentDto userExperimentDto = this.userExperimentsSnapshot.get(Long.valueOf(from));
        if (num != null) {
            return new Experiment(userExperimentDto != null ? userExperimentDto.getRevision() : 0, num.intValue(), userExperimentDto != null ? userExperimentDto.getPopulation() : 0, true, StoreExperiments$getUserExperiment$1.INSTANCE);
        } else if (userExperimentDto == null) {
            return null;
        } else {
            int bucket = userExperimentDto.getBucket();
            int population = userExperimentDto.getPopulation();
            int revision = userExperimentDto.getRevision();
            Experiment experiment = new Experiment(revision, bucket, population, false, new StoreExperiments$getUserExperiment$experiment$1(this, str, bucket, population, revision));
            if (z2) {
                experiment.getTrackExposure().mo1invoke();
            }
            return experiment;
        }
    }

    @StoreThread
    public final void handleAuthToken(String str) {
        this.authToken = str;
        reset();
        tryInitializeExperiments();
    }

    @StoreThread
    public final void handleConnectionOpen(ModelPayload modelPayload) {
        m.checkNotNullParameter(modelPayload, "payload");
        Map<Long, UserExperimentDto> experiments = modelPayload.getExperiments();
        m.checkNotNullExpressionValue(experiments, "payload.experiments");
        handleLoadedUserExperiments(experiments, true);
        List<GuildExperimentDto> guildExperiments = modelPayload.getGuildExperiments();
        if (guildExperiments != null) {
            m.checkNotNullExpressionValue(guildExperiments, "it");
            handleLoadedGuildExperiments(guildExperiments, true);
        }
    }

    @StoreThread
    public final void handleFingerprint(String str) {
        this.fingerprint = str;
        tryInitializeExperiments();
    }

    @StoreThread
    public final void handlePreLogout() {
        StickerPickerFeatureFlag.Companion.getINSTANCE().clearCachedExperiment();
    }

    @Override // com.discord.stores.Store
    @StoreThread
    public void init(Context context) {
        m.checkNotNullParameter(context, "context");
        super.init(context);
        this.experimentTrackedExposureTimestamps.putAll(loadCachedExperimentTrackedExposureTimestamps());
        this.experimentOverrides.putAll(this.experimentOverridesCache.get());
        handleLoadedUserExperiments(this.userExperimentsCache.get(), false);
        handleLoadedGuildExperiments(this.guildExperimentsCache.get(), false);
        markChanged(this, ExperimentOverridesUpdateSource);
    }

    public final Observable<Boolean> isInitialized() {
        return ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{InitializedUpdateSource}, false, null, null, new StoreExperiments$isInitialized$1(this), 14, null);
    }

    public final Observable<Experiment> observeGuildExperiment(String str, long j, boolean z2) {
        m.checkNotNullParameter(str, "experimentName");
        return ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StoreExperiments$observeGuildExperiment$1(this, str, j, z2), 14, null);
    }

    public final Observable<Map<String, Integer>> observeOverrides() {
        return ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{ExperimentOverridesUpdateSource}, false, null, null, new StoreExperiments$observeOverrides$1(this), 14, null);
    }

    public final Observable<Experiment> observeUserExperiment(String str, boolean z2) {
        m.checkNotNullParameter(str, "name");
        Observable<Experiment> r = ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StoreExperiments$observeUserExperiment$1(this, str, z2), 14, null).r();
        m.checkNotNullExpressionValue(r, "observationDeck.connectR…  .distinctUntilChanged()");
        return r;
    }

    public final void setOverride(String str, int i) {
        m.checkNotNullParameter(str, "experimentName");
        this.dispatcher.schedule(new StoreExperiments$setOverride$1(this, i, str));
    }

    @Override // com.discord.stores.StoreV2
    @StoreThread
    public void snapshotData() {
        super.snapshotData();
        this.userExperimentsSnapshot = new HashMap(this.userExperiments);
        this.guildExperimentsSnapshot = new HashMap(this.guildExperiments);
        if (getUpdateSources().contains(ExperimentOverridesUpdateSource)) {
            this.experimentOverridesSnapshot = new HashMap(this.experimentOverrides);
            this.experimentOverridesCache.set(this.experimentOverrides, true);
        }
    }
}