package com.parse;

import android.os.Bundle;
import android.os.Parcel;
import com.parse.ParseObject;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.json.JSONObject;
import p137.C2742;
import p137.InterfaceC2741;
import p138.p176.p177.p242.p246.p251.C4303;

/* JADX INFO: loaded from: classes.dex */
@ParseClassName("_User")
public class ParseUser extends ParseObject {
    public static final List<String> READ_ONLY_KEYS = Collections.unmodifiableList(Arrays.asList("sessionToken", "authData"));
    public static final Object isAutoUserEnabledMutex = new Object();
    public boolean isCurrentUser;

    /* JADX INFO: renamed from: com.parse.ParseUser$13, reason: invalid class name */
    public class AnonymousClass13 implements InterfaceC2741<Void, C2742<Void>> {
        public final /* synthetic */ ParseOperationSet val$operations;
        public final /* synthetic */ String val$sessionToken;

        public AnonymousClass13(ParseOperationSet parseOperationSet, String str) {
            this.val$operations = parseOperationSet;
            this.val$sessionToken = str;
        }

        @Override // p137.InterfaceC2741
        public C2742<Void> then(C2742<Void> c2742) {
            return ParseUser.getUserController().signUpAsync(ParseUser.this.getState(), this.val$operations, this.val$sessionToken).m4815(new InterfaceC2741<State, C2742<Void>>() { // from class: com.parse.ParseUser.13.1
                @Override // p137.InterfaceC2741
                public C2742<Void> then(final C2742<State> c27422) {
                    State stateM4812 = c27422.m4812();
                    AnonymousClass13 anonymousClass13 = AnonymousClass13.this;
                    return ParseUser.this.handleSaveResultAsync(stateM4812, anonymousClass13.val$operations).m4815(new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.ParseUser.13.1.1
                        @Override // p137.InterfaceC2741
                        public C2742<Void> then(C2742<Void> c27423) {
                            return (c27422.m4818() || c27422.m4820()) ? c27422.m4821() : ParseUser.access$000(ParseUser.this);
                        }
                    }, C2742.f8455, null);
                }
            }, C2742.f8455, null);
        }
    }

    public static class State extends ParseObject.State {
        public final boolean isNew;

        public static class Builder extends ParseObject.State.Init<Builder> {
            public boolean isNew;

            public Builder() {
                super("_User");
            }

            public Builder(State state) {
                super(state);
                this.isNew = state.isNew;
            }

            @Override // com.parse.ParseObject.State.Init
            public ParseObject.State.Init apply(ParseObject.State state) {
                this.isNew = ((State) state).isNew;
                return (Builder) super.apply(state);
            }

            @Override // com.parse.ParseObject.State.Init
            public State build() {
                return new State(this, null);
            }

            @Override // com.parse.ParseObject.State.Init
            public ParseObject.State.Init self() {
                return this;
            }
        }

        public State(Parcel parcel, String str, ParseParcelDecoder parseParcelDecoder) {
            super(parcel, str, parseParcelDecoder);
            this.isNew = parcel.readByte() == 1;
        }

        public /* synthetic */ State(Builder builder, AnonymousClass1 anonymousClass1) {
            super(builder);
            this.isNew = builder.isNew;
        }

        @Override // com.parse.ParseObject.State
        public ParseObject.State.Init newBuilder() {
            return new Builder(this);
        }

        public String sessionToken() {
            return (String) this.serverData.get("sessionToken");
        }

        @Override // com.parse.ParseObject.State
        public void writeToParcel(Parcel parcel, ParseParcelEncoder parseParcelEncoder) {
            super.writeToParcel(parcel, parseParcelEncoder);
            parcel.writeByte(this.isNew ? (byte) 1 : (byte) 0);
        }
    }

    public ParseUser() {
        super("_Automatic");
        this.isCurrentUser = false;
    }

    public static /* synthetic */ C2742 access$000(ParseUser parseUser) {
        return getCurrentUserController().setAsync(parseUser);
    }

    public static ParseAuthenticationManager getAuthenticationManager() {
        ParseCorePlugins parseCorePlugins = ParseCorePlugins.INSTANCE;
        if (parseCorePlugins.authenticationController.get() == null) {
            parseCorePlugins.authenticationController.compareAndSet(null, new ParseAuthenticationManager(parseCorePlugins.getCurrentUserController()));
        }
        return parseCorePlugins.authenticationController.get();
    }

    public static ParseUser getCurrentUser() {
        isAutomaticUserEnabled();
        try {
            return (ParseUser) C4303.wait(getCurrentUserController().getAsync(false));
        } catch (ParseException unused) {
            return null;
        }
    }

    public static C2742<ParseUser> getCurrentUserAsync() {
        return getCurrentUserController().getAsync();
    }

    public static ParseCurrentUserController getCurrentUserController() {
        return ParseCorePlugins.INSTANCE.getCurrentUserController();
    }

    public static ParseUserController getUserController() {
        ParseCorePlugins parseCorePlugins = ParseCorePlugins.INSTANCE;
        if (parseCorePlugins.userController.get() == null) {
            parseCorePlugins.userController.compareAndSet(null, new NetworkUserController(ParsePlugins.get().restClient()));
        }
        return parseCorePlugins.userController.get();
    }

    public static boolean isAutomaticUserEnabled() {
        synchronized (isAutoUserEnabledMutex) {
        }
        return false;
    }

    public static void logInInBackground(String str, String str2, LogInCallback logInCallback) {
        if (str == null) {
            throw new IllegalArgumentException("Must specify a username for the user to log in with");
        }
        if (str2 == null) {
            throw new IllegalArgumentException("Must specify a password for the user to log in with");
        }
        C4303.callbackOnMainThreadAsync(getUserController().logInAsync(str, str2).m4817(new InterfaceC2741<State, C2742<ParseUser>>() { // from class: com.parse.ParseUser.1
            @Override // p137.InterfaceC2741
            public C2742<ParseUser> then(C2742<State> c2742) {
                final ParseUser parseUser = (ParseUser) ParseObject.from(c2742.m4812());
                return ParseUser.access$000(parseUser).m4816(new InterfaceC2741<Void, ParseUser>(this) { // from class: com.parse.ParseUser.1.1
                    @Override // p137.InterfaceC2741
                    public ParseUser then(C2742<Void> c27422) {
                        return parseUser;
                    }
                });
            }
        }, C2742.f8455), logInCallback, false);
    }

    public static void logOut() {
        try {
            C4303.wait(getCurrentUserController().logOutAsync());
        } catch (ParseException unused) {
        }
    }

    public static C2742<Void> pinCurrentUserIfNeededAsync(ParseUser parseUser) {
        if (Parse.isLocalDatastoreEnabled) {
            return getCurrentUserController().setIfNeededAsync(parseUser);
        }
        throw new IllegalStateException("Method requires Local Datastore. Please refer to `Parse#enableLocalDatastore(Context)`.");
    }

    public C2742<Void> cleanUpAuthDataAsync() {
        ParseAuthenticationManager authenticationManager = getAuthenticationManager();
        synchronized (this.mutex) {
            Map map = (Map) getState().serverData.get("authData");
            if (map == null) {
                map = new HashMap();
            }
            if (map.size() == 0) {
                return C2742.m4805((Object) null);
            }
            ArrayList arrayList = new ArrayList();
            Iterator it = map.entrySet().iterator();
            while (it.hasNext()) {
                Map.Entry entry = (Map.Entry) it.next();
                if (entry.getValue() == null) {
                    it.remove();
                    arrayList.add(authenticationManager.restoreAuthenticationAsync((String) entry.getKey(), null).m4821());
                }
            }
            State state = getState();
            if (state == null) {
                throw null;
            }
            State.Builder builder = new State.Builder(state);
            builder.serverData.put("authData", map);
            builder.availableKeys.add("authData");
            setState(builder.build());
            return C2742.m4801((Collection<? extends C2742<?>>) arrayList);
        }
    }

    @Override // com.parse.ParseObject
    public <T extends ParseObject> C2742<T> fetchFromLocalDatastoreAsync() {
        if (isLazy()) {
            return C2742.m4805(this);
        }
        if (Parse.isLocalDatastoreEnabled) {
            return Parse.offlineStore.fetchLocallyAsync(this);
        }
        throw new IllegalStateException("Method requires Local Datastore. Please refer to `Parse#enableLocalDatastore(Context)`.");
    }

    public Map<String, Map<String, String>> getAuthData() {
        Map<String, Map<String, String>> map;
        synchronized (this.mutex) {
            map = getMap("authData");
            if (map == null) {
                map = new HashMap<>();
            }
        }
        return map;
    }

    public String getPassword() {
        return getString("password");
    }

    public String getSessionToken() {
        return getState().sessionToken();
    }

    @Override // com.parse.ParseObject
    public State getState() {
        return (State) super.getState();
    }

    public String getUsername() {
        return getString("username");
    }

    @Override // com.parse.ParseObject
    public C2742<Void> handleSaveResultAsync(ParseObject.State state, ParseOperationSet parseOperationSet) {
        if (state != null) {
            parseOperationSet.remove("password");
        }
        return super.handleSaveResultAsync(state, parseOperationSet);
    }

    public boolean isAuthenticated() {
        boolean z;
        synchronized (this.mutex) {
            ParseUser currentUser = getCurrentUser();
            z = isLazy() || !(getState().sessionToken() == null || currentUser == null || !getObjectId().equals(currentUser.getObjectId()));
        }
        return z;
    }

    public boolean isCurrentUser() {
        boolean z;
        synchronized (this.mutex) {
            z = this.isCurrentUser;
        }
        return z;
    }

    @Override // com.parse.ParseObject
    public boolean isKeyMutable(String str) {
        return !READ_ONLY_KEYS.contains(str);
    }

    public boolean isLazy() {
        boolean z;
        synchronized (this.mutex) {
            z = getObjectId() == null && C4303.isLinked(this);
        }
        return z;
    }

    public C2742<Void> logOutAsync(boolean z) {
        String strSessionToken;
        ParseAuthenticationManager authenticationManager = getAuthenticationManager();
        ArrayList arrayList = new ArrayList();
        synchronized (this.mutex) {
            strSessionToken = getState().sessionToken();
            Iterator<Map.Entry<String, Map<String, String>>> it = getAuthData().entrySet().iterator();
            while (it.hasNext()) {
                arrayList.add(authenticationManager.deauthenticateAsync(it.next().getKey()));
            }
            State state = getState();
            if (state == null) {
                throw null;
            }
            State.Builder builder = new State.Builder(state);
            builder.serverData.put("sessionToken", null);
            builder.availableKeys.add("sessionToken");
            builder.isNew = false;
            State stateBuild = builder.build();
            this.isCurrentUser = false;
            setState(stateBuild);
        }
        if (z) {
            arrayList.add(ParseSession.revokeAsync(strSessionToken));
        }
        return C2742.m4801((Collection<? extends C2742<?>>) arrayList);
    }

    @Override // com.parse.ParseObject
    public boolean needsDefaultACL() {
        return false;
    }

    @Override // com.parse.ParseObject
    public ParseObject.State.Init newStateBuilder(String str) {
        return new State.Builder();
    }

    @Override // com.parse.ParseObject
    public void onRestoreInstanceState(Bundle bundle) {
        setIsCurrentUser(bundle.getBoolean("_isCurrentUser", false));
    }

    @Override // com.parse.ParseObject
    public void onSaveInstanceState(Bundle bundle) {
        synchronized (this.mutex) {
            bundle.putBoolean("_isCurrentUser", this.isCurrentUser);
        }
    }

    @Override // com.parse.ParseObject
    public void put(String str, Object obj) {
        synchronized (this.mutex) {
            if ("username".equals(str)) {
                stripAnonymity();
            }
            super.put(str, obj);
        }
    }

    public void putAuthData(String str, Map<String, String> map) {
        synchronized (this.mutex) {
            Map<String, Map<String, String>> authData = getAuthData();
            authData.put(str, map);
            performPut("authData", authData);
        }
    }

    public final void removeAuthData(String str) {
        synchronized (this.mutex) {
            Map<String, Map<String, String>> authData = getAuthData();
            authData.remove(str);
            performPut("authData", authData);
        }
    }

    public C2742<Void> resolveLazinessAsync(C2742<Void> c2742) {
        synchronized (this.mutex) {
            if (getAuthData().size() == 0) {
                return signUpAsync(c2742);
            }
            final ParseOperationSet parseOperationSetStartSave = startSave();
            return c2742.m4817(new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.ParseUser.17
                @Override // p137.InterfaceC2741
                public C2742<Void> then(C2742<Void> c27422) {
                    return ParseUser.getUserController().logInAsync(ParseUser.this.getState(), parseOperationSetStartSave).m4817(new InterfaceC2741<State, C2742<Void>>() { // from class: com.parse.ParseUser.17.1
                        @Override // p137.InterfaceC2741
                        public C2742<Void> then(C2742<State> c27423) {
                            C2742 c2742M4816;
                            final State stateM4812 = c27423.m4812();
                            if (!Parse.isLocalDatastoreEnabled || stateM4812.isNew) {
                                AnonymousClass17 anonymousClass17 = AnonymousClass17.this;
                                c2742M4816 = ParseUser.this.handleSaveResultAsync(stateM4812, parseOperationSetStartSave).m4816(new InterfaceC2741<Void, State>(this) { // from class: com.parse.ParseUser.17.1.1
                                    @Override // p137.InterfaceC2741
                                    public State then(C2742<Void> c27424) {
                                        return stateM4812;
                                    }
                                });
                            } else {
                                c2742M4816 = C2742.m4805(stateM4812);
                            }
                            return c2742M4816.m4817(new InterfaceC2741<State, C2742<Void>>(this) { // from class: com.parse.ParseUser.17.1.2
                                @Override // p137.InterfaceC2741
                                public C2742<Void> then(C2742<State> c27424) {
                                    State stateM48122 = c27424.m4812();
                                    return !stateM48122.isNew ? ParseUser.access$000((ParseUser) ParseObject.from(stateM48122)) : c27424.m4821();
                                }
                            }, C2742.f8455);
                        }
                    }, C2742.f8455);
                }
            }, C2742.f8455);
        }
    }

    public final void restoreAnonymity(Map<String, String> map) {
        synchronized (this.mutex) {
            if (map != null) {
                putAuthData("anonymous", map);
            }
        }
    }

    @Override // com.parse.ParseObject
    public C2742<Void> saveAsync(String str, C2742<Void> c2742) {
        return saveAsync(str, isLazy(), c2742);
    }

    public C2742<Void> saveAsync(String str, boolean z, C2742<Void> c2742) {
        C2742<Void> c2742ResolveLazinessAsync = z ? resolveLazinessAsync(c2742) : super.saveAsync(str, c2742);
        return isCurrentUser() ? c2742ResolveLazinessAsync.m4817(new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.ParseUser.7
            @Override // p137.InterfaceC2741
            public C2742<Void> then(C2742<Void> c27422) {
                return ParseUser.this.cleanUpAuthDataAsync();
            }
        }, C2742.f8455).m4817(new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.ParseUser.6
            @Override // p137.InterfaceC2741
            public C2742<Void> then(C2742<Void> c27422) {
                return ParseUser.access$000(ParseUser.this);
            }
        }, C2742.f8455) : c2742ResolveLazinessAsync;
    }

    public void setIsCurrentUser(boolean z) {
        synchronized (this.mutex) {
            this.isCurrentUser = z;
        }
    }

    @Override // com.parse.ParseObject
    public void setState(ParseObject.State state) {
        if (isCurrentUser()) {
            State.Builder builder = (State.Builder) state.newBuilder();
            if (getSessionToken() != null && state.serverData.get("sessionToken") == null) {
                builder.serverData.put("sessionToken", getSessionToken());
                builder.availableKeys.add("sessionToken");
            }
            if (getAuthData().size() > 0 && state.serverData.get("authData") == null) {
                builder.serverData.put("authData", getAuthData());
                builder.availableKeys.add("authData");
            }
            state = builder.build();
        }
        super.setState(state);
    }

    public C2742<Void> signUpAsync(C2742<Void> c2742) {
        String sessionToken;
        final ParseUser currentUser = getCurrentUser();
        synchronized (this.mutex) {
            if (currentUser != null) {
                try {
                    sessionToken = currentUser.getSessionToken();
                } catch (Throwable th) {
                    throw th;
                }
            } else {
                sessionToken = null;
            }
            if (C4303.isEmpty(getUsername())) {
                return C2742.m4804((Exception) new IllegalArgumentException("Username cannot be missing or blank"));
            }
            if (C4303.isEmpty(getPassword())) {
                return C2742.m4804((Exception) new IllegalArgumentException("Password cannot be missing or blank"));
            }
            if (getObjectId() != null) {
                Map<String, Map<String, String>> authData = getAuthData();
                if (authData.containsKey("anonymous") && authData.get("anonymous") == null) {
                    return saveAsync(sessionToken, c2742);
                }
                return C2742.m4804((Exception) new IllegalArgumentException("Cannot sign up a user that has already signed up."));
            }
            if (this.operationSetQueue.size() > 1) {
                return C2742.m4804((Exception) new IllegalArgumentException("Cannot sign up a user that is already signing up."));
            }
            if (currentUser == null || !C4303.isLinked(currentUser)) {
                return c2742.m4817(new AnonymousClass13(startSave(), sessionToken), C2742.f8455);
            }
            if (this == currentUser) {
                return C2742.m4804((Exception) new IllegalArgumentException("Attempt to merge currentUser with itself."));
            }
            boolean zIsLazy = currentUser.isLazy();
            final String username = currentUser.getUsername();
            final String password = currentUser.getPassword();
            final Map<String, String> map = currentUser.getAuthData().get("anonymous");
            currentUser.copyChangesFrom(this);
            currentUser.put("username", getUsername());
            currentUser.put("password", getPassword());
            revert();
            return currentUser.saveAsync(sessionToken, zIsLazy, c2742).m4815(new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.ParseUser.12
                @Override // p137.InterfaceC2741
                public C2742<Void> then(C2742<Void> c27422) {
                    if (!c27422.m4818() && !c27422.m4820()) {
                        currentUser.revert("password");
                        ParseUser.this.revert("password");
                        ParseUser.this.mergeFromObject(currentUser);
                        return ParseUser.access$000(ParseUser.this);
                    }
                    synchronized (currentUser.mutex) {
                        if (username != null) {
                            currentUser.put("username", username);
                        } else {
                            currentUser.revert("username");
                        }
                        if (password != null) {
                            currentUser.put("password", password);
                        } else {
                            currentUser.revert("password");
                        }
                        currentUser.restoreAnonymity(map);
                    }
                    return c27422;
                }
            }, C2742.f8455, null);
        }
    }

    public final void stripAnonymity() {
        synchronized (this.mutex) {
            if (C4303.isLinked(this)) {
                if (getObjectId() != null) {
                    putAuthData("anonymous", null);
                } else {
                    removeAuthData("anonymous");
                }
            }
        }
    }

    public C2742<Void> synchronizeAllAuthDataAsync() {
        synchronized (this.mutex) {
            if (!isCurrentUser()) {
                return C2742.m4805((Object) null);
            }
            Map<String, Map<String, String>> authData = getAuthData();
            ArrayList arrayList = new ArrayList(authData.size());
            Iterator<String> it = authData.keySet().iterator();
            while (it.hasNext()) {
                arrayList.add(synchronizeAuthDataAsync(it.next()));
            }
            return C2742.m4801((Collection<? extends C2742<?>>) arrayList);
        }
    }

    public C2742<Void> synchronizeAuthDataAsync(final String str) {
        synchronized (this.mutex) {
            if (isCurrentUser()) {
                return getAuthenticationManager().restoreAuthenticationAsync(str, getAuthData().get(str)).m4815(new InterfaceC2741<Boolean, C2742<Void>>() { // from class: com.parse.ParseUser.14
                    @Override // p137.InterfaceC2741
                    public C2742<Void> then(C2742<Boolean> c2742) {
                        return !(!c2742.m4820() && c2742.m4812().booleanValue()) ? ParseUser.this.unlinkFromInBackground(str) : c2742.m4821();
                    }
                }, C2742.f8455, null);
            }
            return C2742.m4805((Object) null);
        }
    }

    @Override // com.parse.ParseObject
    public JSONObject toRest(ParseObject.State state, List<ParseOperationSet> list, ParseEncoder parseEncoder) {
        List<ParseOperationSet> linkedList = list;
        for (int i = 0; i < list.size(); i++) {
            ParseOperationSet parseOperationSet = list.get(i);
            if (parseOperationSet.containsKey("password")) {
                if (linkedList == list) {
                    linkedList = new LinkedList<>(list);
                }
                ParseOperationSet parseOperationSet2 = new ParseOperationSet(parseOperationSet);
                parseOperationSet2.remove("password");
                linkedList.set(i, parseOperationSet2);
            }
        }
        return super.toRest(state, linkedList, parseEncoder);
    }

    public C2742<Void> unlinkFromInBackground(String str) {
        if (str == null) {
            return C2742.m4805((Object) null);
        }
        synchronized (this.mutex) {
            if (getAuthData().containsKey(str)) {
                putAuthData(str, null);
                return saveInBackground();
            }
            return C2742.m4805((Object) null);
        }
    }

    @Override // com.parse.ParseObject
    public void validateSave() {
        ParseUser currentUser;
        synchronized (this.mutex) {
            if (getObjectId() == null) {
                throw new IllegalArgumentException("Cannot save a ParseUser until it has been signed up. Call signUp first.");
            }
            if (!isAuthenticated() && isDirty() && !isCurrentUser()) {
                if (Parse.isLocalDatastoreEnabled || (currentUser = getCurrentUser()) == null || !getObjectId().equals(currentUser.getObjectId())) {
                    throw new IllegalArgumentException("Cannot save a ParseUser that is not authenticated.");
                }
            }
        }
    }
}