package com.parse;

import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import com.parse.OfflineStore;
import com.parse.ParseFile.AnonymousClass6;
import com.parse.ParseUser;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.Lock;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import p137.C2739;
import p137.C2740;
import p137.C2742;
import p137.C2753;
import p137.C2754;
import p137.InterfaceC2741;
import p138.p139.p143.p144.C2803;
import p138.p176.p177.p242.p246.p251.C4303;

/* JADX INFO: loaded from: classes.dex */
public class ParseObject implements Parcelable {
    public final Map<String, Object> estimatedData;
    public boolean isDeleted;
    public int isDeletingEventually;
    public boolean ldsEnabledWhenParceling;
    public String localId;
    public final Object mutex;
    public final LinkedList<ParseOperationSet> operationSetQueue;
    public final ParseMulticastDelegate<ParseObject> saveEvent;
    public State state;
    public final TaskQueue taskQueue;
    public static final ThreadLocal<String> isCreatingPointerForObjectId = new ThreadLocal<String>() { // from class: com.parse.ParseObject.1
        @Override // java.lang.ThreadLocal
        public String initialValue() {
            return null;
        }
    };
    public static final Parcelable.Creator<ParseObject> CREATOR = new Parcelable.Creator<ParseObject>() { // from class: com.parse.ParseObject.2
        @Override // android.os.Parcelable.Creator
        public ParseObject createFromParcel(Parcel parcel) {
            return ParseObject.createFromParcel(parcel, new ParseObjectParcelDecoder());
        }

        @Override // android.os.Parcelable.Creator
        public ParseObject[] newArray(int i) {
            return new ParseObject[i];
        }
    };

    /* JADX INFO: renamed from: com.parse.ParseObject$22, reason: invalid class name */
    public class AnonymousClass22 extends ParseTraverser {
        public final /* synthetic */ Map val$fetchedObjects;

        public AnonymousClass22(ParseObject parseObject, Map map) {
            this.val$fetchedObjects = map;
        }

        @Override // com.parse.ParseTraverser
        public boolean visit(Object obj) {
            ParseObject parseObject;
            State state;
            String str;
            if (!(obj instanceof ParseObject) || (str = (state = (parseObject = (ParseObject) obj).getState()).objectId) == null || !state.isComplete) {
                return true;
            }
            this.val$fetchedObjects.put(str, parseObject);
            return true;
        }
    }

    /* JADX INFO: renamed from: com.parse.ParseObject$30, reason: invalid class name */
    public class AnonymousClass30 implements InterfaceC2741<Void, C2742<Void>> {
        public final /* synthetic */ String val$sessionToken;

        public AnonymousClass30(String str) {
            this.val$sessionToken = str;
        }

        @Override // p137.InterfaceC2741
        public C2742<Void> then(C2742<Void> c2742) {
            return ParseObject.this.saveAsync(this.val$sessionToken, c2742);
        }
    }

    /* JADX INFO: renamed from: com.parse.ParseObject$8, reason: invalid class name */
    public final class AnonymousClass8 extends ParseTraverser {
        public final /* synthetic */ Set val$alreadySeen;
        public final /* synthetic */ Set val$alreadySeenNew;
        public final /* synthetic */ Collection val$dirtyChildren;
        public final /* synthetic */ Collection val$dirtyFiles;

        public AnonymousClass8(Collection collection, Collection collection2, Set set, Set set2) {
            this.val$dirtyFiles = collection;
            this.val$dirtyChildren = collection2;
            this.val$alreadySeen = set;
            this.val$alreadySeenNew = set2;
        }

        @Override // com.parse.ParseTraverser
        public boolean visit(Object obj) {
            HashSet hashSet;
            if (obj instanceof ParseFile) {
                Collection collection = this.val$dirtyFiles;
                if (collection == null) {
                    return true;
                }
                ParseFile parseFile = (ParseFile) obj;
                if (parseFile.state.url == null) {
                    collection.add(parseFile);
                }
                return true;
            }
            if (!(obj instanceof ParseObject) || this.val$dirtyChildren == null) {
                return true;
            }
            ParseObject parseObject = (ParseObject) obj;
            Set set = this.val$alreadySeen;
            Set set2 = this.val$alreadySeenNew;
            if (parseObject.getObjectId() != null) {
                hashSet = new HashSet();
            } else {
                if (set2.contains(parseObject)) {
                    throw new RuntimeException("Found a circular dependency while saving.");
                }
                HashSet hashSet2 = new HashSet(set2);
                hashSet2.add(parseObject);
                hashSet = hashSet2;
            }
            if (set.contains(parseObject)) {
                return true;
            }
            HashSet hashSet3 = new HashSet(set);
            hashSet3.add(parseObject);
            Map<String, Object> map = parseObject.estimatedData;
            AnonymousClass8 anonymousClass8 = new AnonymousClass8(this.val$dirtyFiles, this.val$dirtyChildren, hashSet3, hashSet);
            anonymousClass8.yieldRoot = true;
            anonymousClass8.traverse(map);
            if (parseObject.isDirty(false)) {
                this.val$dirtyChildren.add(parseObject);
            }
            return true;
        }
    }

    public static class State {
        public final Set<String> availableKeys;
        public final String className;
        public final long createdAt;
        public final boolean isComplete;
        public final String objectId;
        public final Map<String, Object> serverData;
        public final long updatedAt;

        public static class Builder extends Init<Builder> {
            public Builder(State state) {
                super(state);
            }

            public Builder(String str) {
                super(str);
            }

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

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

        public static abstract class Init<T extends Init> {
            public Set<String> availableKeys;
            public final String className;
            public long createdAt;
            public boolean isComplete;
            public String objectId;
            public Map<String, Object> serverData;
            public long updatedAt;

            public Init(State state) {
                this.serverData = new HashMap();
                this.createdAt = -1L;
                this.updatedAt = -1L;
                this.availableKeys = new HashSet();
                this.className = state.className;
                this.objectId = state.objectId;
                this.createdAt = state.createdAt;
                this.updatedAt = state.updatedAt;
                this.availableKeys = Collections.synchronizedSet(new HashSet(state.availableKeys));
                for (String str : state.keySet()) {
                    this.serverData.put(str, state.get(str));
                    this.availableKeys.add(str);
                }
                this.isComplete = state.isComplete;
            }

            public Init(String str) {
                this.serverData = new HashMap();
                this.createdAt = -1L;
                this.updatedAt = -1L;
                this.availableKeys = new HashSet();
                this.className = str;
            }

            public T apply(State state) {
                String str = state.objectId;
                if (str != null) {
                    this.objectId = str;
                    self();
                }
                long j = state.createdAt;
                if (j > 0) {
                    this.createdAt = j;
                    self();
                }
                long j2 = state.updatedAt;
                if (j2 > 0) {
                    this.updatedAt = j2;
                    self();
                }
                isComplete(this.isComplete || state.isComplete);
                for (String str2 : state.keySet()) {
                    put(str2, state.get(str2));
                }
                this.availableKeys.addAll(state.availableKeys);
                self();
                return (T) self();
            }

            public T apply(ParseOperationSet parseOperationSet) {
                for (String str : parseOperationSet.keySet()) {
                    Object objApply = ((ParseFieldOperation) parseOperationSet.get(str)).apply(this.serverData.get(str), str);
                    if (objApply != null) {
                        put(str, objApply);
                    } else {
                        this.serverData.remove(str);
                        self();
                    }
                }
                return (T) self();
            }

            public abstract <S extends State> S build();

            public T clear() {
                this.objectId = null;
                this.createdAt = -1L;
                this.updatedAt = -1L;
                this.isComplete = false;
                this.serverData.clear();
                this.availableKeys.clear();
                return (T) self();
            }

            public T createdAt(Date date) {
                this.createdAt = date.getTime();
                return (T) self();
            }

            public T isComplete(boolean z) {
                this.isComplete = z;
                return (T) self();
            }

            public T objectId(String str) {
                this.objectId = str;
                return (T) self();
            }

            public T put(String str, Object obj) {
                this.serverData.put(str, obj);
                this.availableKeys.add(str);
                return (T) self();
            }

            public abstract T self();

            public T updatedAt(Date date) {
                this.updatedAt = date.getTime();
                return (T) self();
            }
        }

        public State(Parcel parcel, String str, ParseParcelDecoder parseParcelDecoder) {
            this.className = str;
            this.objectId = parcel.readByte() == 1 ? parcel.readString() : null;
            this.createdAt = parcel.readLong();
            long j = parcel.readLong();
            this.updatedAt = j <= 0 ? this.createdAt : j;
            int i = parcel.readInt();
            HashMap map = new HashMap();
            for (int i2 = 0; i2 < i; i2++) {
                map.put(parcel.readString(), parseParcelDecoder.decode(parcel));
            }
            this.serverData = Collections.unmodifiableMap(map);
            this.isComplete = parcel.readByte() == 1;
            ArrayList arrayList = new ArrayList();
            parcel.readStringList(arrayList);
            this.availableKeys = new HashSet(arrayList);
        }

        public State(Init<?> init) {
            this.className = init.className;
            this.objectId = init.objectId;
            long j = init.createdAt;
            this.createdAt = j;
            long j2 = init.updatedAt;
            this.updatedAt = j2 > 0 ? j2 : j;
            this.serverData = Collections.unmodifiableMap(new HashMap(init.serverData));
            this.isComplete = init.isComplete;
            this.availableKeys = Collections.synchronizedSet(init.availableKeys);
        }

        public Object get(String str) {
            return this.serverData.get(str);
        }

        public Set<String> keySet() {
            return this.serverData.keySet();
        }

        public <T extends Init<?>> T newBuilder() {
            return new Builder(this);
        }

        public String toString() {
            return String.format(Locale.US, "%s@%s[className=%s, objectId=%s, createdAt=%d, updatedAt=%d, isComplete=%s, serverData=%s, availableKeys=%s]", getClass().getName(), Integer.toHexString(hashCode()), this.className, this.objectId, Long.valueOf(this.createdAt), Long.valueOf(this.updatedAt), Boolean.valueOf(this.isComplete), this.serverData, this.availableKeys);
        }

        public void writeToParcel(Parcel parcel, ParseParcelEncoder parseParcelEncoder) {
            parcel.writeString(this.className);
            parcel.writeByte(this.objectId != null ? (byte) 1 : (byte) 0);
            String str = this.objectId;
            if (str != null) {
                parcel.writeString(str);
            }
            parcel.writeLong(this.createdAt);
            parcel.writeLong(this.updatedAt);
            parcel.writeInt(this.serverData.size());
            for (String str2 : this.serverData.keySet()) {
                parcel.writeString(str2);
                parseParcelEncoder.encode(this.serverData.get(str2), parcel);
            }
            parcel.writeByte(this.isComplete ? (byte) 1 : (byte) 0);
            parcel.writeStringList(new ArrayList(this.availableKeys));
        }
    }

    public ParseObject() {
        this("_Automatic");
    }

    /* JADX WARN: Multi-variable type inference failed */
    public ParseObject(String str) {
        this.mutex = new Object();
        this.taskQueue = new TaskQueue();
        this.saveEvent = new ParseMulticastDelegate<>();
        String str2 = isCreatingPointerForObjectId.get();
        if (str == null) {
            throw new IllegalArgumentException("You must specify a Parse class name when creating a new ParseObject.");
        }
        str = "_Automatic".equals(str) ? getSubclassingController().getClassName(getClass()) : str;
        if (!getSubclassingController().isSubclassValid(str, getClass())) {
            throw new IllegalArgumentException("You must create this type of ParseObject using ParseObject.create() or the proper subclass.");
        }
        LinkedList<ParseOperationSet> linkedList = new LinkedList<>();
        this.operationSetQueue = linkedList;
        linkedList.add(new ParseOperationSet());
        this.estimatedData = new HashMap();
        State.Init<?> initNewStateBuilder = newStateBuilder(str);
        if (str2 == null) {
            if (needsDefaultACL()) {
                ParseACL.getDefaultACL();
            }
            initNewStateBuilder.isComplete(true);
        } else {
            if (!str2.equals("*** Offline Object ***")) {
                initNewStateBuilder.objectId = str2;
                initNewStateBuilder.self();
            }
            initNewStateBuilder.isComplete(false);
        }
        this.state = initNewStateBuilder.build();
        OfflineStore offlineStore = Parse.offlineStore;
        if (offlineStore != null) {
            offlineStore.registerNewObject(this);
        }
    }

    public static /* synthetic */ C2742 access$600(final List list, final String str, C2742 c2742) {
        return c2742.m4815(new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.ParseObject.13
            @Override // p137.InterfaceC2741
            public C2742<Void> then(C2742<Void> c27422) {
                int size = list.size();
                ArrayList arrayList = new ArrayList(size);
                ArrayList arrayList2 = new ArrayList(size);
                ArrayList arrayList3 = new ArrayList(size);
                for (int i = 0; i < size; i++) {
                    ParseObject parseObject = (ParseObject) list.get(i);
                    parseObject.updateBeforeSave();
                    parseObject.validateSave();
                    arrayList.add(parseObject.getState());
                    arrayList2.add(parseObject.startSave());
                    HashMap map = new HashMap();
                    new AnonymousClass22(parseObject, map).traverse(parseObject.estimatedData);
                    arrayList3.add(new KnownParseObjectDecoder(map));
                }
                List<C2742<State>> listSaveAllAsync = ParseObject.getObjectController().saveAllAsync(arrayList, arrayList2, str, arrayList3);
                ArrayList arrayList4 = new ArrayList(size);
                for (int i2 = 0; i2 < size; i2++) {
                    C2742<State> c27423 = listSaveAllAsync.get(i2);
                    final ParseObject parseObject2 = (ParseObject) list.get(i2);
                    final ParseOperationSet parseOperationSet = (ParseOperationSet) arrayList2.get(i2);
                    arrayList4.add(c27423.m4815(new InterfaceC2741<State, C2742<Void>>(this) { // from class: com.parse.ParseObject.13.1
                        @Override // p137.InterfaceC2741
                        public C2742<Void> then(final C2742<State> c27424) {
                            return parseObject2.handleSaveResultAsync(c27424.m4812(), parseOperationSet).m4815(new InterfaceC2741<Void, C2742<Void>>(this) { // from class: com.parse.ParseObject.13.1.1
                                @Override // p137.InterfaceC2741
                                public C2742<Void> then(C2742<Void> c27425) {
                                    return (c27425.m4820() || c27425.m4818()) ? c27425 : c27424.m4821();
                                }
                            }, C2742.f8455, null);
                        }
                    }, C2742.f8455, null));
                }
                return C2742.m4801((Collection<? extends C2742<?>>) arrayList4);
            }
        }, C2742.f8455, null);
    }

    public static <T extends ParseObject> T create(Class<T> cls) {
        return (T) getSubclassingController().newInstance(getSubclassingController().getClassName(cls));
    }

    public static ParseObject createFromParcel(Parcel parcel, ParseParcelDecoder parseParcelDecoder) {
        ParseObject parseObjectCreateWithoutData = createWithoutData(parcel.readString(), parcel.readByte() == 1 ? parcel.readString() : null);
        if (parseParcelDecoder instanceof ParseObjectParcelDecoder) {
            ((ParseObjectParcelDecoder) parseParcelDecoder).objects.put(parseObjectCreateWithoutData.getObjectId() != null ? parseObjectCreateWithoutData.getObjectId() : parseObjectCreateWithoutData.getOrCreateLocalId(), parseObjectCreateWithoutData);
        }
        String string = parcel.readString();
        parseObjectCreateWithoutData.setState("_User".equals(string) ? new ParseUser.State(parcel, string, parseParcelDecoder) : new State(parcel, string, parseParcelDecoder));
        if (parcel.readByte() == 1) {
            parseObjectCreateWithoutData.localId = parcel.readString();
        }
        if (parcel.readByte() == 1) {
            parseObjectCreateWithoutData.isDeleted = true;
        }
        boolean z = !parseObjectCreateWithoutData.ldsEnabledWhenParceling;
        ParseOperationSet parseOperationSet = new ParseOperationSet(parcel.readString());
        parseOperationSet.isSaveEventually = parcel.readByte() == 1;
        int i = parcel.readInt();
        for (int i2 = 0; i2 < i; i2++) {
            parseOperationSet.put(parcel.readString(), (ParseFieldOperation) parseParcelDecoder.decode(parcel));
        }
        if (z) {
            for (String str : parseOperationSet.keySet()) {
                parseObjectCreateWithoutData.performOperation(str, parseOperationSet.get(str));
            }
        }
        parseObjectCreateWithoutData.onRestoreInstanceState(parcel.readBundle(ParseObject.class.getClassLoader()));
        return parseObjectCreateWithoutData;
    }

    public static ParseObject createWithoutData(String str, String str2) {
        OfflineStore offlineStore = Parse.offlineStore;
        try {
            try {
                if (str2 == null) {
                    isCreatingPointerForObjectId.set("*** Offline Object ***");
                } else {
                    isCreatingPointerForObjectId.set(str2);
                }
                ParseObject object = (offlineStore == null || str2 == null) ? null : offlineStore.getObject(str, str2);
                if (object == null) {
                    object = getSubclassingController().newInstance(str);
                    if (object.hasChanges()) {
                        throw new IllegalStateException("A ParseObject subclass default constructor must not make changes to the object that cause it to be dirty.");
                    }
                }
                return object;
            } catch (RuntimeException e) {
                throw e;
            } catch (Exception e2) {
                throw new RuntimeException("Failed to create instance of subclass.", e2);
            }
        } finally {
            isCreatingPointerForObjectId.set(null);
        }
    }

    /* JADX WARN: Type inference failed for: r5v3, types: [T, ފ.ވ] */
    public static C2742<Void> deepSaveAsync(Object obj, final String str) {
        HashSet<ParseObject> hashSet = new HashSet();
        HashSet<ParseFile> hashSet2 = new HashSet();
        AnonymousClass8 anonymousClass8 = new AnonymousClass8(hashSet2, hashSet, new HashSet(), new HashSet());
        anonymousClass8.yieldRoot = true;
        anonymousClass8.traverse(obj);
        HashSet<ParseUser> hashSet3 = new HashSet();
        for (ParseObject parseObject : hashSet) {
            if (parseObject instanceof ParseUser) {
                ParseUser parseUser = (ParseUser) parseObject;
                if (parseUser.isLazy()) {
                    hashSet3.add(parseUser);
                }
            }
        }
        hashSet.removeAll(hashSet3);
        final AtomicBoolean atomicBoolean = new AtomicBoolean(false);
        ArrayList arrayList = new ArrayList();
        for (ParseFile parseFile : hashSet2) {
            arrayList.add(parseFile.taskQueue.enqueue(parseFile.new AnonymousClass6(str, null, null)));
        }
        C2742 c2742M4809 = C2742.m4801((Collection<? extends C2742<?>>) arrayList).m4809((InterfaceC2741<Void, TContinuationResult>) new InterfaceC2741<Void, Void>() { // from class: com.parse.ParseObject.9
            @Override // p137.InterfaceC2741
            public Void then(C2742<Void> c2742) {
                atomicBoolean.set(true);
                return null;
            }
        }, C2742.f8455, (C2739) null);
        final AtomicBoolean atomicBoolean2 = new AtomicBoolean(false);
        ArrayList arrayList2 = new ArrayList();
        for (ParseUser parseUser2 : hashSet3) {
            arrayList2.add(parseUser2.taskQueue.enqueue(new AnonymousClass30(str)));
        }
        C2742 c2742M48092 = C2742.m4801((Collection<? extends C2742<?>>) arrayList2).m4809((InterfaceC2741<Void, TContinuationResult>) new InterfaceC2741<Void, Void>() { // from class: com.parse.ParseObject.10
            @Override // p137.InterfaceC2741
            public Void then(C2742<Void> c2742) {
                atomicBoolean2.set(true);
                return null;
            }
        }, C2742.f8455, (C2739) null);
        final C2740 c2740 = new C2740(hashSet);
        C2742 c2742M4805 = C2742.m4805((Object) null);
        Callable<Boolean> callable = new Callable<Boolean>() { // from class: com.parse.ParseObject.11
            @Override // java.util.concurrent.Callable
            public Boolean call() {
                return Boolean.valueOf(((Set) c2740.f8453).size() > 0);
            }
        };
        InterfaceC2741<Void, C2742<Void>> interfaceC2741 = new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.ParseObject.12
            /* JADX WARN: Type inference failed for: r0v0, types: [T, java.util.HashSet] */
            @Override // p137.InterfaceC2741
            public C2742<Void> then(C2742<Void> c2742) {
                ArrayList arrayList3 = new ArrayList();
                ?? hashSet4 = new HashSet();
                for (ParseObject parseObject2 : (Set) c2740.f8453) {
                    if (parseObject2.canBeSerialized()) {
                        arrayList3.add(parseObject2);
                    } else {
                        hashSet4.add(parseObject2);
                    }
                }
                c2740.f8453 = hashSet4;
                if (arrayList3.size() == 0 && atomicBoolean.get() && atomicBoolean2.get()) {
                    throw new RuntimeException("Unable to save a ParseObject with a relation to a cycle.");
                }
                if (arrayList3.size() == 0) {
                    return C2742.m4805((Object) null);
                }
                final C2754 c2754 = new C2754();
                ArrayList arrayList4 = new ArrayList(arrayList3.size());
                Iterator it = arrayList3.iterator();
                while (it.hasNext()) {
                    arrayList4.add(((ParseObject) it.next()).taskQueue.lock);
                }
                LockSet lockSet = new LockSet(arrayList4);
                Iterator<Lock> it2 = lockSet.locks.iterator();
                while (it2.hasNext()) {
                    try {
                        it2.next().lock();
                    } finally {
                        lockSet.unlock();
                    }
                }
                try {
                    final C2742<Void> c2742Access$600 = ParseObject.access$600(arrayList3, str, c2754.f8503);
                    final ArrayList arrayList5 = new ArrayList();
                    Iterator it3 = arrayList3.iterator();
                    while (it3.hasNext()) {
                        ((ParseObject) it3.next()).taskQueue.enqueue(new InterfaceC2741<Void, C2742<T>>() { // from class: com.parse.ParseObject.3
                            @Override // p137.InterfaceC2741
                            public Object then(C2742<Void> c27422) {
                                arrayList5.add(c27422);
                                return c2742Access$600;
                            }
                        });
                    }
                    C2742.m4801((Collection<? extends C2742<?>>) arrayList5).m4809((InterfaceC2741<Void, TContinuationResult>) new InterfaceC2741<Void, Void>() { // from class: com.parse.ParseObject.4
                        @Override // p137.InterfaceC2741
                        public Void then(C2742<Void> c27422) {
                            c2754.m4827((Object) null);
                            return null;
                        }
                    }, C2742.f8455, (C2739) null);
                    return c2742Access$600;
                } catch (RuntimeException e) {
                    throw e;
                } catch (Exception e2) {
                    throw new RuntimeException(e2);
                }
            }
        };
        if (c2742M4805 == null) {
            throw null;
        }
        Executor executor = C2742.f8455;
        C2740 c27402 = new C2740();
        c27402.f8453 = new C2753(c2742M4805, callable, interfaceC2741, executor, c27402);
        return C2742.m4801((Collection<? extends C2742<?>>) Arrays.asList(c2742M4809, c2742M48092, c2742M4805.m4821().m4808((InterfaceC2741<Void, C2742<TContinuationResult>>) c27402.f8453, executor)));
    }

    public static <T extends ParseObject> T from(State state) {
        T t = (T) createWithoutData(state.className, state.objectId);
        synchronized (t.mutex) {
            if (!state.isComplete) {
                state = t.getState().newBuilder().apply(state).build();
            }
            t.setState(state);
        }
        return t;
    }

    public static <T extends ParseObject> T fromJSON(JSONObject jSONObject, String str, ParseDecoder parseDecoder) {
        String strOptString = jSONObject.optString("className", str);
        if (strOptString == null) {
            return null;
        }
        String strOptString2 = jSONObject.optString("objectId", null);
        boolean z = !jSONObject.has("__selectedKeys");
        T t = (T) createWithoutData(strOptString, strOptString2);
        t.setState(t.mergeFromServer(t.getState(), jSONObject, parseDecoder, z));
        return t;
    }

    public static <T extends ParseObject> T fromJSON(JSONObject jSONObject, String str, ParseDecoder parseDecoder, Set<String> set) {
        if (set != null && !set.isEmpty()) {
            try {
                jSONObject.put("__selectedKeys", new JSONArray((Collection) set));
            } catch (JSONException e) {
                throw new RuntimeException(e);
            }
        }
        return (T) fromJSON(jSONObject, str, parseDecoder);
    }

    public static ParseObjectController getObjectController() {
        ParseCorePlugins parseCorePlugins = ParseCorePlugins.INSTANCE;
        if (parseCorePlugins.objectController.get() == null) {
            parseCorePlugins.objectController.compareAndSet(null, new NetworkObjectController(ParsePlugins.get().restClient()));
        }
        return parseCorePlugins.objectController.get();
    }

    public static ParseObjectSubclassingController getSubclassingController() {
        return ParseCorePlugins.INSTANCE.getSubclassingController();
    }

    public static void registerParseSubclasses() {
        registerSubclass(ParseUser.class);
        registerSubclass(ParseRole.class);
        registerSubclass(ParseInstallation.class);
        registerSubclass(ParseSession.class);
        registerSubclass(ParsePin.class);
        registerSubclass(EventuallyPin.class);
    }

    public static void registerSubclass(Class<? extends ParseObject> cls) {
        getSubclassingController().registerSubclass(cls);
    }

    public static C2742<Void> unpinAllInBackground(final String str) {
        if (!Parse.isLocalDatastoreEnabled) {
            throw new IllegalStateException("Method requires Local Datastore. Please refer to `Parse#enableLocalDatastore(Context)`.");
        }
        if (str == null) {
            str = "_default";
        }
        final OfflineStore offlineStore = Parse.offlineStore;
        if (offlineStore != null) {
            return offlineStore.runWithManagedTransaction(new OfflineStore.SQLiteDatabaseCallable<C2742<Void>>() { // from class: com.parse.OfflineStore.41
                @Override // com.parse.OfflineStore.SQLiteDatabaseCallable
                public C2742<Void> call(final ParseSQLiteDatabase parseSQLiteDatabase) {
                    final OfflineStore offlineStore2 = OfflineStore.this;
                    return offlineStore2.getParsePin(str, parseSQLiteDatabase).m4815(new InterfaceC2741<ParsePin, C2742<Void>>() { // from class: com.parse.OfflineStore.42
                        @Override // p137.InterfaceC2741
                        public C2742<Void> then(C2742<ParsePin> c2742) {
                            if (c2742.m4820()) {
                                return c2742.m4821();
                            }
                            return OfflineStore.access$1800(OfflineStore.this, c2742.m4812(), parseSQLiteDatabase);
                        }
                    }, C2742.f8455, null);
                }
            });
        }
        throw null;
    }

    /* JADX WARN: Multi-variable type inference failed */
    public final boolean canBeSerialized() {
        boolean zBooleanValue;
        synchronized (this.mutex) {
            final C2740 c2740 = new C2740(true);
            ParseTraverser parseTraverser = new ParseTraverser(this) { // from class: com.parse.ParseObject.53
                /* JADX WARN: Multi-variable type inference failed */
                /* JADX WARN: Type inference failed for: r1v1, types: [T, java.lang.Boolean] */
                @Override // com.parse.ParseTraverser
                public boolean visit(Object obj) {
                    if ((obj instanceof ParseFile) && ((ParseFile) obj).isDirty()) {
                        c2740.f8453 = false;
                    }
                    if ((obj instanceof ParseObject) && ((ParseObject) obj).getObjectId() == null) {
                        c2740.f8453 = false;
                    }
                    return ((Boolean) c2740.f8453).booleanValue();
                }
            };
            parseTraverser.yieldRoot = false;
            parseTraverser.traverseParseObjects = true;
            parseTraverser.traverse(this);
            zBooleanValue = ((Boolean) c2740.f8453).booleanValue();
        }
        return zBooleanValue;
    }

    public final void checkGetAccess(String str) {
        if (!isDataAvailable(str)) {
            throw new IllegalStateException(C2803.m4880("ParseObject has no data for '", str, "'. Call fetchIfNeeded() to get the data."));
        }
    }

    public boolean containsKey(String str) {
        boolean zContainsKey;
        synchronized (this.mutex) {
            zContainsKey = this.estimatedData.containsKey(str);
        }
        return zContainsKey;
    }

    public void copyChangesFrom(ParseObject parseObject) {
        synchronized (this.mutex) {
            ParseOperationSet first = parseObject.operationSetQueue.getFirst();
            for (String str : first.keySet()) {
                performOperation(str, first.get(str));
            }
        }
    }

    public final ParseOperationSet currentOperations() {
        ParseOperationSet last;
        synchronized (this.mutex) {
            last = this.operationSetQueue.getLast();
        }
        return last;
    }

    @Override // android.os.Parcelable
    public int describeContents() {
        return 0;
    }

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

    public Object get(String str) {
        synchronized (this.mutex) {
            if (str.equals("ACL")) {
                return getACL(true);
            }
            checkGetAccess(str);
            Object obj = this.estimatedData.get(str);
            if (obj instanceof ParseRelation) {
                ((ParseRelation) obj).ensureParentAndKey(this, str);
            }
            return obj;
        }
    }

    public final ParseACL getACL(boolean z) {
        synchronized (this.mutex) {
            checkGetAccess("ACL");
            Object obj = this.estimatedData.get("ACL");
            if (obj == null) {
                return null;
            }
            if (!(obj instanceof ParseACL)) {
                throw new RuntimeException("only ACLs can be stored in the ACL key");
            }
            if (!z || !((ParseACL) obj).shared) {
                return (ParseACL) obj;
            }
            ParseACL parseACL = new ParseACL((ParseACL) obj);
            this.estimatedData.put("ACL", parseACL);
            return parseACL;
        }
    }

    public String getClassName() {
        String str;
        synchronized (this.mutex) {
            str = this.state.className;
        }
        return str;
    }

    public JSONObject getJSONObject(String str) {
        synchronized (this.mutex) {
            checkGetAccess(str);
            Object objEncode = this.estimatedData.get(str);
            if (objEncode instanceof Map) {
                objEncode = PointerOrLocalIdEncoder.INSTANCE.encode(objEncode);
            }
            if (!(objEncode instanceof JSONObject)) {
                return null;
            }
            return (JSONObject) objEncode;
        }
    }

    public <T> List<T> getList(String str) {
        synchronized (this.mutex) {
            Object obj = this.estimatedData.get(str);
            if (!(obj instanceof List)) {
                return null;
            }
            return (List) obj;
        }
    }

    public <V> Map<String, V> getMap(String str) {
        synchronized (this.mutex) {
            Object obj = this.estimatedData.get(str);
            if (!(obj instanceof Map)) {
                return null;
            }
            return (Map) obj;
        }
    }

    public Number getNumber(String str) {
        synchronized (this.mutex) {
            checkGetAccess(str);
            Object obj = this.estimatedData.get(str);
            if (!(obj instanceof Number)) {
                return null;
            }
            return (Number) obj;
        }
    }

    public String getObjectId() {
        String str;
        synchronized (this.mutex) {
            str = this.state.objectId;
        }
        return str;
    }

    public String getOrCreateLocalId() {
        String str;
        synchronized (this.mutex) {
            if (this.localId == null) {
                if (this.state.objectId != null) {
                    throw new IllegalStateException("Attempted to get a localId for an object with an objectId.");
                }
                this.localId = ParseCorePlugins.INSTANCE.getLocalIdManager().createLocalId();
            }
            str = this.localId;
        }
        return str;
    }

    public State getState() {
        State state;
        synchronized (this.mutex) {
            state = this.state;
        }
        return state;
    }

    public String getString(String str) {
        synchronized (this.mutex) {
            checkGetAccess(str);
            Object obj = this.estimatedData.get(str);
            if (!(obj instanceof String)) {
                return null;
            }
            return (String) obj;
        }
    }

    public C2742<Void> handleDeleteEventuallyResultAsync() {
        synchronized (this.mutex) {
            this.isDeletingEventually--;
        }
        return handleDeleteResultAsync().m4817(new InterfaceC2741<Void, C2742<Void>>(this) { // from class: com.parse.ParseObject.37
            @Override // p137.InterfaceC2741
            public C2742<Void> then(C2742<Void> c2742) {
                if (Parse.getEventuallyQueue() != null) {
                    return c2742;
                }
                throw null;
            }
        }, C2742.f8455);
    }

    public C2742<Void> handleDeleteResultAsync() {
        C2742<Void> c2742M4805 = C2742.m4805((Object) null);
        synchronized (this.mutex) {
            this.isDeleted = true;
        }
        final OfflineStore offlineStore = Parse.offlineStore;
        return offlineStore != null ? c2742M4805.m4815(new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.ParseObject.51
            @Override // p137.InterfaceC2741
            public /* bridge */ /* synthetic */ C2742<Void> then(C2742<Void> c2742) {
                return then();
            }

            public C2742 then() {
                synchronized (ParseObject.this.mutex) {
                    if (!ParseObject.this.isDeleted) {
                        return offlineStore.updateDataForObjectAsync(ParseObject.this);
                    }
                    offlineStore.unregisterObject(ParseObject.this);
                    final OfflineStore offlineStore2 = offlineStore;
                    final ParseObject parseObject = ParseObject.this;
                    return offlineStore2.helper.getWritableDatabaseAsync().m4815(new InterfaceC2741<ParseSQLiteDatabase, C2742<Void>>() { // from class: com.parse.OfflineStore.29
                        @Override // p137.InterfaceC2741
                        public C2742<Void> then(C2742<ParseSQLiteDatabase> c2742) {
                            final ParseSQLiteDatabase parseSQLiteDatabaseM4812 = c2742.m4812();
                            return parseSQLiteDatabaseM4812.beginTransactionAsync().m4817(new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.OfflineStore.29.1
                                @Override // p137.InterfaceC2741
                                public C2742<Void> then(C2742<Void> c27422) {
                                    AnonymousClass29 anonymousClass29 = AnonymousClass29.this;
                                    return OfflineStore.this.deleteDataForObjectAsync(parseObject, parseSQLiteDatabaseM4812).m4817(new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.OfflineStore.29.1.2
                                        @Override // p137.InterfaceC2741
                                        public C2742<Void> then(C2742<Void> c27423) {
                                            return parseSQLiteDatabaseM4812.setTransactionSuccessfulAsync();
                                        }
                                    }, C2742.f8455).m4815(new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.OfflineStore.29.1.1
                                        @Override // p137.InterfaceC2741
                                        public C2742<Void> then(C2742<Void> c27423) {
                                            parseSQLiteDatabaseM4812.endTransactionAsync();
                                            parseSQLiteDatabaseM4812.closeAsync();
                                            return c27423;
                                        }
                                    }, C2742.f8455, null);
                                }
                            }, C2742.f8455);
                        }
                    }, C2742.f8455, null);
                }
            }
        }, C2742.f8455, null) : c2742M4805;
    }

    public C2742<Void> handleSaveResultAsync(final State state, final ParseOperationSet parseOperationSet) {
        C2742<Void> c2742M4805 = C2742.m4805((Object) null);
        final OfflineStore offlineStore = Parse.offlineStore;
        if (offlineStore != null) {
            c2742M4805 = c2742M4805.m4817(new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.ParseObject.23
                @Override // p137.InterfaceC2741
                public C2742<Void> then(C2742<Void> c2742) {
                    return offlineStore.fetchLocallyAsync(ParseObject.this).m4821();
                }
            }, C2742.f8455);
        }
        boolean z = state != null;
        synchronized (this.mutex) {
            ListIterator<ParseOperationSet> listIterator = this.operationSetQueue.listIterator(this.operationSetQueue.indexOf(parseOperationSet));
            listIterator.next();
            listIterator.remove();
            if (z) {
                C2742 c2742M4809 = c2742M4805.m4809((InterfaceC2741<Void, TContinuationResult>) new InterfaceC2741<Void, Void>() { // from class: com.parse.ParseObject.25
                    @Override // p137.InterfaceC2741
                    public /* bridge */ /* synthetic */ Void then(C2742<Void> c2742) {
                        then();
                        return null;
                    }

                    public Void then() {
                        synchronized (ParseObject.this.mutex) {
                            ParseObject.this.setState(state.isComplete ? state : ParseObject.this.getState().newBuilder().apply(parseOperationSet).apply(state).build());
                        }
                        return null;
                    }
                }, C2742.f8455, (C2739) null);
                if (offlineStore != null) {
                    c2742M4809 = c2742M4809.m4817(new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.ParseObject.26
                        @Override // p137.InterfaceC2741
                        public C2742<Void> then(C2742<Void> c2742) {
                            return offlineStore.updateDataForObjectAsync(ParseObject.this);
                        }
                    }, C2742.f8455);
                }
                return c2742M4809.m4816(new InterfaceC2741<Void, Void>() { // from class: com.parse.ParseObject.27
                    @Override // p137.InterfaceC2741
                    public Void then(C2742<Void> c2742) {
                        ParseObject parseObject = ParseObject.this;
                        ParseMulticastDelegate<ParseObject> parseMulticastDelegate = parseObject.saveEvent;
                        if (parseMulticastDelegate == null) {
                            throw null;
                        }
                        Iterator it = new ArrayList(parseMulticastDelegate.callbacks).iterator();
                        while (it.hasNext()) {
                            ((ParseCallback2) it.next()).done(parseObject, null);
                        }
                        return null;
                    }
                });
            }
            listIterator.next().mergeFrom(parseOperationSet);
            if (offlineStore != null) {
                c2742M4805 = c2742M4805.m4815(new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.ParseObject.24
                    @Override // p137.InterfaceC2741
                    public C2742<Void> then(C2742<Void> c2742) {
                        return c2742.m4820() ? C2742.m4805((Object) null) : offlineStore.updateDataForObjectAsync(ParseObject.this);
                    }
                }, C2742.f8455, null);
            }
            return c2742M4805;
        }
    }

    public C2742<Void> handleSaveResultAsync(JSONObject jSONObject, ParseOperationSet parseOperationSet) {
        State stateBuild;
        if (jSONObject != null) {
            synchronized (this.mutex) {
                HashMap map = new HashMap();
                new AnonymousClass22(this, map).traverse(this.estimatedData);
                stateBuild = ParseObjectCoder.INSTANCE.decode(getState().newBuilder().clear(), jSONObject, new KnownParseObjectDecoder(map)).isComplete(false).build();
            }
        } else {
            stateBuild = null;
        }
        return handleSaveResultAsync(stateBuild, parseOperationSet);
    }

    public boolean hasChanges() {
        boolean z;
        synchronized (this.mutex) {
            z = currentOperations().size() > 0;
        }
        return z;
    }

    public final boolean hasDirtyChildren() {
        boolean z;
        synchronized (this.mutex) {
            ArrayList arrayList = new ArrayList();
            Map<String, Object> map = this.estimatedData;
            AnonymousClass8 anonymousClass8 = new AnonymousClass8(null, arrayList, new HashSet(), new HashSet());
            z = true;
            anonymousClass8.yieldRoot = true;
            anonymousClass8.traverse(map);
            if (arrayList.size() <= 0) {
                z = false;
            }
        }
        return z;
    }

    public boolean hasOutstandingOperations() {
        boolean z;
        synchronized (this.mutex) {
            z = true;
            if (this.operationSetQueue.size() <= 1) {
                z = false;
            }
        }
        return z;
    }

    public boolean isDataAvailable() {
        boolean z;
        synchronized (this.mutex) {
            z = this.state.isComplete;
        }
        return z;
    }

    public boolean isDataAvailable(String str) {
        boolean z;
        synchronized (this.mutex) {
            z = isDataAvailable() || this.state.availableKeys.contains(str) || this.estimatedData.containsKey(str);
        }
        return z;
    }

    public boolean isDirty() {
        return isDirty(true);
    }

    public boolean isDirty(String str) {
        boolean zContainsKey;
        synchronized (this.mutex) {
            zContainsKey = currentOperations().containsKey(str);
        }
        return zContainsKey;
    }

    public boolean isDirty(boolean z) {
        boolean z2;
        synchronized (this.mutex) {
            z2 = this.isDeleted || getObjectId() == null || hasChanges() || (z && hasDirtyChildren());
        }
        return z2;
    }

    public boolean isKeyMutable(String str) {
        return true;
    }

    public Set<String> keySet() {
        Set<String> setUnmodifiableSet;
        synchronized (this.mutex) {
            setUnmodifiableSet = Collections.unmodifiableSet(this.estimatedData.keySet());
        }
        return setUnmodifiableSet;
    }

    public void markAllFieldsDirty() {
        synchronized (this.mutex) {
            for (String str : this.state.keySet()) {
                performPut(str, this.state.get(str));
            }
        }
    }

    public void mergeFromObject(ParseObject parseObject) {
        synchronized (this.mutex) {
            if (this == parseObject) {
                return;
            }
            setState(parseObject.getState().newBuilder().build(), false);
        }
    }

    public State mergeFromServer(State state, JSONObject jSONObject, ParseDecoder parseDecoder, boolean z) {
        try {
            State.Init initNewBuilder = state.newBuilder();
            if (z) {
                initNewBuilder.clear();
            }
            initNewBuilder.isComplete(state.isComplete || z);
            Iterator<String> itKeys = jSONObject.keys();
            while (itKeys.hasNext()) {
                String next = itKeys.next();
                if (!next.equals("__type") && !next.equals("className")) {
                    if (next.equals("objectId")) {
                        initNewBuilder.objectId(jSONObject.getString(next));
                    } else if (next.equals("createdAt")) {
                        initNewBuilder.createdAt(ParseDateFormat.INSTANCE.parse(jSONObject.getString(next)));
                    } else if (next.equals("updatedAt")) {
                        initNewBuilder.updatedAt(ParseDateFormat.INSTANCE.parse(jSONObject.getString(next)));
                    } else if (next.equals("ACL")) {
                        initNewBuilder.serverData.put("ACL", ParseACL.createACLFromJSONObject(jSONObject.getJSONObject(next), parseDecoder));
                        initNewBuilder.availableKeys.add("ACL");
                        initNewBuilder.self();
                    } else if (next.equals("__selectedKeys")) {
                        JSONArray jSONArray = jSONObject.getJSONArray(next);
                        if (jSONArray.length() > 0) {
                            HashSet hashSet = new HashSet();
                            for (int i = 0; i < jSONArray.length(); i++) {
                                String string = jSONArray.getString(i);
                                if (string.contains(".")) {
                                    string = string.split("\\.")[0];
                                }
                                hashSet.add(string);
                            }
                            initNewBuilder.availableKeys.addAll(hashSet);
                            initNewBuilder.self();
                        }
                    } else {
                        Object obj = jSONObject.get(next);
                        if ((obj instanceof JSONObject) && jSONObject.has("__selectedKeys")) {
                            JSONArray jSONArray2 = jSONObject.getJSONArray("__selectedKeys");
                            JSONArray jSONArray3 = new JSONArray();
                            for (int i2 = 0; i2 < jSONArray2.length(); i2++) {
                                String string2 = jSONArray2.getString(i2);
                                if (string2.startsWith(next + ".")) {
                                    jSONArray3.put(string2.substring(next.length() + 1));
                                }
                            }
                            if (jSONArray3.length() > 0) {
                                ((JSONObject) obj).put("__selectedKeys", jSONArray3);
                            }
                        }
                        initNewBuilder.serverData.put(next, parseDecoder.decode(obj));
                        initNewBuilder.availableKeys.add(next);
                        initNewBuilder.self();
                    }
                }
            }
            return initNewBuilder.build();
        } catch (JSONException e) {
            throw new RuntimeException(e);
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:27:0x009a A[Catch: all -> 0x00de, JSONException -> 0x00e0, TRY_LEAVE, TryCatch #1 {JSONException -> 0x00e0, blocks: (B:4:0x0008, B:5:0x0033, B:7:0x0039, B:10:0x0047, B:11:0x004d, B:15:0x005c, B:13:0x0058, B:17:0x0061, B:18:0x0066, B:27:0x009a, B:21:0x0076, B:23:0x007e), top: B:45:0x0008, outer: #0 }] */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public void mergeREST(State state, JSONObject jSONObject, ParseDecoder parseDecoder) {
        ArrayList<ParseOperationSet> arrayList = new ArrayList();
        synchronized (this.mutex) {
            try {
                boolean z = jSONObject.getBoolean("__complete");
                this.isDeletingEventually = C4303.getInt(jSONObject, Arrays.asList("__isDeletingEventually", "isDeletingEventually"));
                JSONArray jSONArray = jSONObject.getJSONArray("__operations");
                ParseOperationSet parseOperationSetCurrentOperations = currentOperations();
                this.operationSetQueue.clear();
                boolean z2 = false;
                ParseOperationSet parseOperationSet = null;
                for (int i = 0; i < jSONArray.length(); i++) {
                    ParseOperationSet parseOperationSetFromRest = ParseOperationSet.fromRest(jSONArray.getJSONObject(i), parseDecoder);
                    if (parseOperationSetFromRest.isSaveEventually) {
                        if (parseOperationSet != null) {
                            this.operationSetQueue.add(parseOperationSet);
                            parseOperationSet = null;
                        }
                        arrayList.add(parseOperationSetFromRest);
                        this.operationSetQueue.add(parseOperationSetFromRest);
                    } else {
                        if (parseOperationSet != null) {
                            parseOperationSetFromRest.mergeFrom(parseOperationSet);
                        }
                        parseOperationSet = parseOperationSetFromRest;
                    }
                }
                if (parseOperationSet != null) {
                    this.operationSetQueue.add(parseOperationSet);
                }
                currentOperations().mergeFrom(parseOperationSetCurrentOperations);
                if (state.updatedAt >= 0) {
                    if (jSONObject.has("updatedAt")) {
                        if (new Date(state.updatedAt).compareTo(ParseDateFormat.INSTANCE.parse(jSONObject.getString("updatedAt"))) < 0) {
                        }
                    }
                    if (z2) {
                        setState(mergeFromServer(state, C4303.create(jSONObject, Arrays.asList("__complete", "__isDeletingEventually", "isDeletingEventually", "__operations")), parseDecoder, z));
                    }
                }
                z2 = true;
                if (z2) {
                }
            } catch (JSONException e) {
                throw new RuntimeException(e);
            }
        }
        for (final ParseOperationSet parseOperationSet2 : arrayList) {
            if (!parseOperationSet2.isSaveEventually) {
                throw new IllegalStateException("This should only be used to enqueue saveEventually operation sets");
            }
            this.taskQueue.enqueue(new InterfaceC2741<Void, C2742<Void>>(this) { // from class: com.parse.ParseObject.34
                @Override // p137.InterfaceC2741
                public C2742<Void> then(C2742<Void> c2742) {
                    return c2742.m4815(new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.ParseObject.34.1
                        @Override // p137.InterfaceC2741
                        public C2742<Void> then(C2742<Void> c27422) {
                            return Parse.getEventuallyQueue().waitForOperationSetAndEventuallyPin(parseOperationSet2, null).m4821();
                        }
                    }, C2742.f8455, null);
                }
            });
        }
    }

    public boolean needsDefaultACL() {
        return true;
    }

    public State.Init<?> newStateBuilder(String str) {
        return new State.Builder(str);
    }

    public final void notifyObjectIdChanged(String str, String str2) {
        synchronized (this.mutex) {
            OfflineStore offlineStore = Parse.offlineStore;
            if (offlineStore != null) {
                offlineStore.updateObjectId(this, str, str2);
            }
            if (this.localId != null) {
                ParseCorePlugins.INSTANCE.getLocalIdManager().setObjectId(this.localId, str2);
                this.localId = null;
            }
        }
    }

    public void onRestoreInstanceState(Bundle bundle) {
    }

    public void onSaveInstanceState(Bundle bundle) {
    }

    public void performOperation(String str, ParseFieldOperation parseFieldOperation) {
        synchronized (this.mutex) {
            Object objApply = parseFieldOperation.apply(this.estimatedData.get(str), str);
            if (objApply != null) {
                this.estimatedData.put(str, objApply);
            } else {
                this.estimatedData.remove(str);
            }
            currentOperations().put(str, parseFieldOperation.mergeWithPrevious(currentOperations().get(str)));
        }
    }

    public void performPut(String str, Object obj) {
        if (str == null) {
            throw new IllegalArgumentException("key may not be null.");
        }
        if (obj == null) {
            throw new IllegalArgumentException("value may not be null.");
        }
        if (obj instanceof JSONObject) {
            obj = ParseDecoder.INSTANCE.convertJSONObjectToMap((JSONObject) obj);
        } else if (obj instanceof JSONArray) {
            obj = ParseDecoder.INSTANCE.convertJSONArrayToList((JSONArray) obj);
        }
        if (ParseEncoder.isValidType(obj)) {
            performOperation(str, new ParseSetOperation(obj));
        } else {
            StringBuilder sbM4889 = C2803.m4889("invalid type for value: ");
            sbM4889.append(obj.getClass().toString());
            throw new IllegalArgumentException(sbM4889.toString());
        }
    }

    public void put(String str, Object obj) {
        if (isKeyMutable(str)) {
            performPut(str, obj);
            return;
        }
        StringBuilder sbM4898 = C2803.m4898("Cannot modify `", str, "` property of an ");
        sbM4898.append(getClassName());
        sbM4898.append(" object.");
        throw new IllegalArgumentException(sbM4898.toString());
    }

    public final void rebuildEstimatedData() {
        synchronized (this.mutex) {
            this.estimatedData.clear();
            for (String str : this.state.keySet()) {
                this.estimatedData.put(str, this.state.get(str));
            }
            for (ParseOperationSet parseOperationSet : this.operationSetQueue) {
                Map<String, Object> map = this.estimatedData;
                for (String str2 : parseOperationSet.keySet()) {
                    Object objApply = ((ParseFieldOperation) parseOperationSet.get(str2)).apply(map.get(str2), str2);
                    if (objApply != null) {
                        map.put(str2, objApply);
                    } else {
                        map.remove(str2);
                    }
                }
            }
        }
    }

    public void registerSaveListener(GetCallback<ParseObject> getCallback) {
        synchronized (this.mutex) {
            this.saveEvent.callbacks.add(getCallback);
        }
    }

    public void revert() {
        synchronized (this.mutex) {
            if (isDirty()) {
                currentOperations().clear();
                rebuildEstimatedData();
            }
        }
    }

    public void revert(String str) {
        synchronized (this.mutex) {
            if (isDirty(str)) {
                currentOperations().remove(str);
                rebuildEstimatedData();
            }
        }
    }

    public C2742<Void> saveAsync(String str) {
        return this.taskQueue.enqueue(new AnonymousClass30(str));
    }

    public C2742<Void> saveAsync(final String str, final C2742<Void> c2742) {
        final ParseOperationSet parseOperationSetStartSave;
        C2742<Void> c2742DeepSaveAsync;
        if (!isDirty()) {
            return C2742.m4805((Object) null);
        }
        synchronized (this.mutex) {
            updateBeforeSave();
            validateSave();
            parseOperationSetStartSave = startSave();
        }
        synchronized (this.mutex) {
            c2742DeepSaveAsync = deepSaveAsync(this.estimatedData, str);
        }
        return c2742DeepSaveAsync.m4817(new InterfaceC2741<T, C2742<T>>() { // from class: com.parse.TaskQueue.1

            /* JADX INFO: renamed from: com.parse.TaskQueue$1$1 */
            public class C03681 implements InterfaceC2741<Void, C2742<T>> {
                public final /* synthetic */ C2742 val$task;

                public C03681(AnonymousClass1 anonymousClass1, C2742 c2742) {
                    c2742 = c2742;
                }

                @Override // p137.InterfaceC2741
                public Object then(C2742<Void> c2742) {
                    return c2742;
                }
            }

            public AnonymousClass1() {
            }

            @Override // p137.InterfaceC2741
            public Object then(C2742 c27422) {
                return c2742.m4815(new InterfaceC2741<Void, C2742<T>>(this) { // from class: com.parse.TaskQueue.1.1
                    public final /* synthetic */ C2742 val$task;

                    public C03681(AnonymousClass1 this, C2742 c274222) {
                        c2742 = c274222;
                    }

                    @Override // p137.InterfaceC2741
                    public Object then(C2742<Void> c27423) {
                        return c2742;
                    }
                }, C2742.f8455, null);
            }
        }, C2742.f8455).m4817(new InterfaceC2741<Void, C2742<State>>() { // from class: com.parse.ParseObject.32
            @Override // p137.InterfaceC2741
            public C2742<State> then(C2742<Void> c27422) {
                ParseObject parseObject = ParseObject.this;
                if (parseObject == null) {
                    throw null;
                }
                HashMap map = new HashMap();
                new AnonymousClass22(parseObject, map).traverse(parseObject.estimatedData);
                return ParseObject.getObjectController().saveAsync(ParseObject.this.getState(), parseOperationSetStartSave, str, new KnownParseObjectDecoder(map));
            }
        }, C2742.f8455).m4815(new InterfaceC2741<State, C2742<Void>>() { // from class: com.parse.ParseObject.31
            @Override // p137.InterfaceC2741
            public C2742<Void> then(final C2742<State> c27422) {
                return ParseObject.this.handleSaveResultAsync(c27422.m4812(), parseOperationSetStartSave).m4815(new InterfaceC2741<Void, C2742<Void>>(this) { // from class: com.parse.ParseObject.31.1
                    @Override // p137.InterfaceC2741
                    public C2742<Void> then(C2742<Void> c27423) {
                        return (c27423.m4820() || c27423.m4818()) ? c27423 : c27422.m4821();
                    }
                }, C2742.f8455, null);
            }
        }, C2742.f8455, null);
    }

    public final C2742<Void> saveInBackground() {
        return ParseUser.getCurrentUserAsync().m4817(new InterfaceC2741<ParseUser, C2742<String>>() { // from class: com.parse.ParseObject.29
            @Override // p137.InterfaceC2741
            public C2742<String> then(C2742<ParseUser> c2742) {
                final ParseACL acl;
                ParseUser parseUserM4812 = c2742.m4812();
                if (parseUserM4812 == null) {
                    return C2742.m4805((Object) null);
                }
                if (!parseUserM4812.isLazy()) {
                    return C2742.m4805(parseUserM4812.getSessionToken());
                }
                if (ParseObject.this.isDataAvailable("ACL") && (acl = ParseObject.this.getACL(false)) != null) {
                    final ParseUser parseUser = acl.unresolvedUser;
                    return (parseUser == null || !parseUser.isCurrentUser()) ? C2742.m4805((Object) null) : parseUser.saveAsync(null).m4816(new InterfaceC2741<Void, String>(this) { // from class: com.parse.ParseObject.29.1
                        @Override // p137.InterfaceC2741
                        public String then(C2742<Void> c27422) {
                            if (acl.unresolvedUser != null) {
                                throw new IllegalStateException("ACL has an unresolved ParseUser. Save or sign up before attempting to serialize the ACL.");
                            }
                            return parseUser.getSessionToken();
                        }
                    });
                }
                return C2742.m4805((Object) null);
            }
        }, C2742.f8455).m4817(new InterfaceC2741<String, C2742<Void>>() { // from class: com.parse.ParseObject.28
            @Override // p137.InterfaceC2741
            public C2742<Void> then(C2742<String> c2742) {
                return ParseObject.this.saveAsync(c2742.m4812());
            }
        }, C2742.f8455);
    }

    public void setState(State state) {
        synchronized (this.mutex) {
            setState(state, true);
        }
    }

    public final void setState(State state, boolean z) {
        synchronized (this.mutex) {
            String str = this.state.objectId;
            String str2 = state.objectId;
            this.state = state;
            if (z) {
                if (!(str == str2 || (str != null && str.equals(str2)))) {
                    notifyObjectIdChanged(str, str2);
                }
            }
            rebuildEstimatedData();
        }
    }

    public ParseOperationSet startSave() {
        ParseOperationSet parseOperationSetCurrentOperations;
        synchronized (this.mutex) {
            parseOperationSetCurrentOperations = currentOperations();
            this.operationSetQueue.addLast(new ParseOperationSet());
        }
        return parseOperationSetCurrentOperations;
    }

    public JSONObject toRest(ParseEncoder parseEncoder) {
        State state;
        ArrayList arrayList;
        synchronized (this.mutex) {
            state = getState();
            int size = this.operationSetQueue.size();
            arrayList = new ArrayList(size);
            for (int i = 0; i < size; i++) {
                arrayList.add(new ParseOperationSet(this.operationSetQueue.get(i)));
            }
        }
        return toRest(state, arrayList, parseEncoder);
    }

    public JSONObject toRest(State state, List<ParseOperationSet> list, ParseEncoder parseEncoder) {
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject.put("className", state.className);
            if (state.objectId != null) {
                jSONObject.put("objectId", state.objectId);
            }
            if (state.createdAt > 0) {
                jSONObject.put("createdAt", ParseDateFormat.INSTANCE.format(new Date(state.createdAt)));
            }
            if (state.updatedAt > 0) {
                jSONObject.put("updatedAt", ParseDateFormat.INSTANCE.format(new Date(state.updatedAt)));
            }
            for (String str : state.keySet()) {
                jSONObject.put(str, parseEncoder.encode(state.get(str)));
            }
            jSONObject.put("__complete", state.isComplete);
            jSONObject.put("__isDeletingEventually", this.isDeletingEventually);
            jSONObject.put("__selectedKeys", new JSONArray((Collection) state.availableKeys));
            JSONArray jSONArray = new JSONArray();
            Iterator<ParseOperationSet> it = list.iterator();
            while (it.hasNext()) {
                jSONArray.put(it.next().toRest(parseEncoder));
            }
            jSONObject.put("__operations", jSONArray);
            return jSONObject;
        } catch (JSONException unused) {
            throw new RuntimeException("could not serialize object to JSON");
        }
    }

    public void unregisterSaveListener(GetCallback<ParseObject> getCallback) {
        synchronized (this.mutex) {
            this.saveEvent.callbacks.remove(getCallback);
        }
    }

    public void updateBeforeSave() {
    }

    public void validateSave() {
    }

    @Override // android.os.Parcelable
    public void writeToParcel(Parcel parcel, int i) {
        writeToParcel(parcel, new ParseObjectParcelEncoder(this));
    }

    public void writeToParcel(Parcel parcel, ParseParcelEncoder parseParcelEncoder) {
        ParseOperationSet last;
        synchronized (this.mutex) {
            this.ldsEnabledWhenParceling = Parse.isLocalDatastoreEnabled;
            boolean zHasOutstandingOperations = hasOutstandingOperations();
            byte b = 1;
            boolean z = this.isDeletingEventually > 0;
            if (zHasOutstandingOperations) {
                PLog.w("ParseObject", "About to parcel a ParseObject while a save / saveEventually operation is going on. If recovered from LDS, the unparceled object will be internally updated when these tasks end. If not, it will act as if these tasks have failed. This means that the subsequent call to save() will update again the same keys, and this is dangerous for certain operations, like increment(). To avoid inconsistencies, wait for operations to end before parceling.");
            }
            if (z) {
                PLog.w("ParseObject", "About to parcel a ParseObject while a delete / deleteEventually operation is going on. If recovered from LDS, the unparceled object will be internally updated when these tasks end. If not, it will assume it's not deleted, and might incorrectly return false for isDirty(). To avoid inconsistencies, wait for operations to end before parceling.");
            }
            parcel.writeString(getClassName());
            String objectId = getObjectId();
            parcel.writeByte(objectId != null ? (byte) 1 : (byte) 0);
            if (objectId != null) {
                parcel.writeString(objectId);
            }
            this.state.writeToParcel(parcel, parseParcelEncoder);
            parcel.writeByte(this.localId != null ? (byte) 1 : (byte) 0);
            if (this.localId != null) {
                parcel.writeString(this.localId);
            }
            if (!this.isDeleted) {
                b = 0;
            }
            parcel.writeByte(b);
            if (hasOutstandingOperations()) {
                last = new ParseOperationSet();
                Iterator<ParseOperationSet> it = this.operationSetQueue.iterator();
                while (it.hasNext()) {
                    ParseOperationSet parseOperationSet = new ParseOperationSet(it.next());
                    parseOperationSet.mergeFrom(last);
                    last = parseOperationSet;
                }
            } else {
                last = this.operationSetQueue.getLast();
            }
            last.isSaveEventually = false;
            parcel.writeString(last.uuid);
            parcel.writeByte(last.isSaveEventually ? (byte) 1 : (byte) 0);
            parcel.writeInt(last.size());
            for (String str : last.keySet()) {
                parcel.writeString(str);
                parseParcelEncoder.encode(last.get(str), parcel);
            }
            Bundle bundle = new Bundle();
            onSaveInstanceState(bundle);
            parcel.writeBundle(bundle);
        }
    }
}