discord-jadx/app/src/main/java/com/discord/stores/StoreUserSurvey.java

package com.discord.stores;

import android.content.Context;
import android.content.SharedPreferences;
import com.discord.api.guild.GuildFeature;
import com.discord.api.user.SurveyGuildRequirements;
import com.discord.api.user.UserSurvey;
import com.discord.api.user.UserSurveyFetchResponse;
import com.discord.models.guild.Guild;
import com.discord.models.user.MeUser;
import com.discord.stores.updates.ObservationDeck;
import com.discord.utilities.permissions.PermissionUtils;
import com.discord.utilities.rest.RestAPI;
import com.discord.utilities.rx.ObservableExtensionsKt;
import com.discord.utilities.time.Clock;
import d0.z.d.m;
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: StoreUserSurvey.kt */
public final class StoreUserSurvey extends StoreV2 {
    private final Clock clock;
    private final Dispatcher dispatcher;
    private final ObservationDeck observationDeck;
    private int refetchIntervalMs;
    private final RestAPI restApi;
    private final SharedPreferences sharedPreferences;
    private final StoreGuilds storeGuilds;
    private final StorePermissions storePermissions;
    private final StoreUser storeUser;
    private UserSurvey userSurvey;

    public StoreUserSurvey(Dispatcher dispatcher, StoreUser storeUser, StoreGuilds storeGuilds, StorePermissions storePermissions, ObservationDeck observationDeck, RestAPI restAPI, Clock clock, SharedPreferences sharedPreferences) {
        m.checkNotNullParameter(dispatcher, "dispatcher");
        m.checkNotNullParameter(storeUser, "storeUser");
        m.checkNotNullParameter(storeGuilds, "storeGuilds");
        m.checkNotNullParameter(storePermissions, "storePermissions");
        m.checkNotNullParameter(observationDeck, "observationDeck");
        m.checkNotNullParameter(restAPI, "restApi");
        m.checkNotNullParameter(clock, "clock");
        m.checkNotNullParameter(sharedPreferences, "sharedPreferences");
        this.dispatcher = dispatcher;
        this.storeUser = storeUser;
        this.storeGuilds = storeGuilds;
        this.storePermissions = storePermissions;
        this.observationDeck = observationDeck;
        this.restApi = restAPI;
        this.clock = clock;
        this.sharedPreferences = sharedPreferences;
        this.refetchIntervalMs = 86400000;
    }

    /* JADX INFO: this call moved to the top of the method (can break code semantics) */
    public /* synthetic */ StoreUserSurvey(Dispatcher dispatcher, StoreUser storeUser, StoreGuilds storeGuilds, StorePermissions storePermissions, ObservationDeck observationDeck, RestAPI restAPI, Clock clock, SharedPreferences sharedPreferences, int i, DefaultConstructorMarker defaultConstructorMarker) {
        this(dispatcher, storeUser, storeGuilds, storePermissions, observationDeck, (i & 32) != 0 ? RestAPI.Companion.getApi() : restAPI, clock, sharedPreferences);
    }

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

    public static final /* synthetic */ UserSurvey access$getUserSurvey(StoreUserSurvey storeUserSurvey) {
        return storeUserSurvey.getUserSurvey();
    }

    public static final /* synthetic */ void access$handleUserSurveyFetchSuccess(StoreUserSurvey storeUserSurvey, UserSurveyFetchResponse userSurveyFetchResponse) {
        storeUserSurvey.handleUserSurveyFetchSuccess(userSurveyFetchResponse);
    }

    @StoreThread
    private final void fetchUserSurvey() {
        setLastFetched();
        ObservableExtensionsKt.appSubscribe$default(ObservableExtensionsKt.restSubscribeOn$default(this.restApi.getUserSurvey(), false, 1, null), StoreUserSurvey.class, (Context) null, (Function1) null, (Function1) null, (Function0) null, (Function0) null, new StoreUserSurvey$fetchUserSurvey$1(this), 62, (Object) null);
    }

    private final UserSurvey getUserSurvey() {
        return this.userSurvey;
    }

    @StoreThread
    private final void handleUserSurveyFetchSuccess(UserSurveyFetchResponse userSurveyFetchResponse) {
        UserSurvey a;
        if (userSurveyFetchResponse != null && (a = userSurveyFetchResponse.a()) != null && meetsGuildRequirements(a)) {
            this.userSurvey = a;
            markChanged();
        }
    }

    private final boolean meetsGuildRequirements(UserSurvey userSurvey) {
        List<String> b = userSurvey.b();
        if (b.isEmpty()) {
            return true;
        }
        MeUser me2 = this.storeUser.getMe();
        for (Map.Entry<Long, Guild> entry : this.storeGuilds.getGuilds().entrySet()) {
            long longValue = entry.getKey().longValue();
            Guild value = entry.getValue();
            if (!b.contains(SurveyGuildRequirements.IS_COMMUNITY.getValue()) || value.getFeatures().contains(GuildFeature.COMMUNITY)) {
                if (b.contains(SurveyGuildRequirements.GUILD_SIZE.getValue())) {
                    Integer num = userSurvey.c().get(0);
                    Integer num2 = userSurvey.c().get(1);
                    int memberCount = value.getMemberCount();
                    if (num == null || memberCount >= num.intValue()) {
                        if (num2 != null && memberCount > num2.intValue()) {
                        }
                    }
                }
                boolean isOwner = value.isOwner(me2.getId());
                boolean can = PermissionUtils.can(8, this.storePermissions.getGuildPermissions().get(Long.valueOf(longValue)));
                if (!b.contains(SurveyGuildRequirements.IS_OWNER.getValue()) || isOwner) {
                    if (!b.contains(SurveyGuildRequirements.IS_ADMIN.getValue()) || can) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    private final void setLastFetched() {
        this.sharedPreferences.edit().putLong("CACHE_KEY_USER_SURVEY_LAST_FETCHED", this.clock.currentTimeMillis()).apply();
    }

    @StoreThread
    public final void handleConnectionOpen() {
        if (this.clock.currentTimeMillis() - this.sharedPreferences.getLong("CACHE_KEY_USER_SURVEY_LAST_FETCHED", 0) > ((long) this.refetchIntervalMs)) {
            fetchUserSurvey();
        }
    }

    public final Observable<UserSurvey> observeUserSurvey() {
        return ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StoreUserSurvey$observeUserSurvey$1(this), 14, null);
    }
}