package com.discord.stores;

import c.d.b.a.a;
import com.discord.api.user.User;
import com.discord.stores.updates.ObservationDeck;
import d0.z.d.m;
import rx.Observable;
/* compiled from: StoreMFA.kt */
public final class StoreMFA extends StoreV2 {
    private final Dispatcher dispatcher;
    private final ObservationDeck observationDeck;
    private State state = new State(MFAActivationState.NONE, false);
    private final StoreStream stream;

    /* compiled from: StoreMFA.kt */
    public enum MFAActivationState {
        PENDING_ENABLED,
        PENDING_DISABLED,
        NONE
    }

    /* compiled from: StoreMFA.kt */
    public static final class State {
        private final MFAActivationState activationState;
        private final boolean isTogglingSMSBackup;

        public State(MFAActivationState mFAActivationState, boolean z2) {
            m.checkNotNullParameter(mFAActivationState, "activationState");
            this.activationState = mFAActivationState;
            this.isTogglingSMSBackup = z2;
        }

        public static /* synthetic */ State copy$default(State state, MFAActivationState mFAActivationState, boolean z2, int i, Object obj) {
            if ((i & 1) != 0) {
                mFAActivationState = state.activationState;
            }
            if ((i & 2) != 0) {
                z2 = state.isTogglingSMSBackup;
            }
            return state.copy(mFAActivationState, z2);
        }

        public final MFAActivationState component1() {
            return this.activationState;
        }

        public final boolean component2() {
            return this.isTogglingSMSBackup;
        }

        public final State copy(MFAActivationState mFAActivationState, boolean z2) {
            m.checkNotNullParameter(mFAActivationState, "activationState");
            return new State(mFAActivationState, z2);
        }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (!(obj instanceof State)) {
                return false;
            }
            State state = (State) obj;
            return m.areEqual(this.activationState, state.activationState) && this.isTogglingSMSBackup == state.isTogglingSMSBackup;
        }

        public final MFAActivationState getActivationState() {
            return this.activationState;
        }

        public int hashCode() {
            MFAActivationState mFAActivationState = this.activationState;
            int hashCode = (mFAActivationState != null ? mFAActivationState.hashCode() : 0) * 31;
            boolean z2 = this.isTogglingSMSBackup;
            if (z2) {
                z2 = true;
            }
            int i = z2 ? 1 : 0;
            int i2 = z2 ? 1 : 0;
            int i3 = z2 ? 1 : 0;
            return hashCode + i;
        }

        public final boolean isTogglingSMSBackup() {
            return this.isTogglingSMSBackup;
        }

        public String toString() {
            StringBuilder L = a.L("State(activationState=");
            L.append(this.activationState);
            L.append(", isTogglingSMSBackup=");
            return a.G(L, this.isTogglingSMSBackup, ")");
        }
    }

    public StoreMFA(StoreStream storeStream, Dispatcher dispatcher, ObservationDeck observationDeck) {
        m.checkNotNullParameter(storeStream, "stream");
        m.checkNotNullParameter(dispatcher, "dispatcher");
        m.checkNotNullParameter(observationDeck, "observationDeck");
        this.stream = storeStream;
        this.dispatcher = dispatcher;
        this.observationDeck = observationDeck;
    }

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

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

    @StoreThread
    public final void handleUserUpdated(User user) {
        m.checkNotNullParameter(user, "user");
        if (user.i() == this.stream.getUsers$app_productionBetaRelease().getMeInternal$app_productionBetaRelease().getId()) {
            this.state = new State(MFAActivationState.NONE, false);
            markChanged();
        }
    }

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

    public final void togglingSMSBackup() {
        this.dispatcher.schedule(new StoreMFA$togglingSMSBackup$1(this));
    }

    public final void updatePendingMFAState(MFAActivationState mFAActivationState) {
        m.checkNotNullParameter(mFAActivationState, "newActivationState");
        this.dispatcher.schedule(new StoreMFA$updatePendingMFAState$1(this, mFAActivationState));
    }
}