package com.parse;

import android.content.Context;
import android.content.pm.ResolveInfo;
import android.os.Parcel;
import com.parse.ParseFieldOperations;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Callable;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import p137.C2739;
import p137.C2742;
import p137.InterfaceC2741;
import p138.p139.p143.p144.C2803;
import p138.p176.p177.p242.p246.p251.C4303;
import p447.C6921;

/* JADX INFO: loaded from: classes.dex */
public class Parse {
    public static final Object MUTEX = new Object();
    public static final Object MUTEX_CALLBACKS = new Object();
    public static Set<ParseCallbacks> callbacks = new HashSet();
    public static ParseEventuallyQueue eventuallyQueue;
    public static boolean isLocalDatastoreEnabled;
    public static OfflineStore offlineStore;

    public static final class Configuration {
        public final String applicationId;
        public final C6921.C6922 clientBuilder;
        public final String clientKey;
        public final Context context;
        public final boolean localDataStoreEnabled;
        public final int maxRetries;
        public final String server;

        public static final class Builder {
            public String applicationId;
            public C6921.C6922 clientBuilder;
            public String clientKey;
            public Context context;
            public boolean localDataStoreEnabled;
            public int maxRetries = 4;
            public String server;

            public Builder(Context context) {
                this.context = context;
            }
        }

        public /* synthetic */ Configuration(Builder builder, AnonymousClass1 anonymousClass1) {
            this.context = builder.context;
            this.applicationId = builder.applicationId;
            String str = builder.clientKey;
            this.clientKey = "xxx";
            this.server = builder.server;
            this.localDataStoreEnabled = builder.localDataStoreEnabled;
            this.clientBuilder = builder.clientBuilder;
            this.maxRetries = builder.maxRetries;
        }
    }

    public interface ParseCallbacks {
        void onParseInitialized();
    }

    public static /* synthetic */ String access$800(String str) {
        return (str == null || str.endsWith("/")) ? str : C2803.m4879(str, "/");
    }

    public static void checkCacheApplicationId() {
        synchronized (MUTEX) {
            String str = ParsePlugins.get().configuration.applicationId;
            if (str != null) {
                File cacheDir = ParsePlugins.get().getCacheDir();
                File file = new File(cacheDir, "applicationId");
                if (file.exists()) {
                    boolean zEquals = false;
                    try {
                        RandomAccessFile randomAccessFile = new RandomAccessFile(file, "r");
                        byte[] bArr = new byte[(int) randomAccessFile.length()];
                        randomAccessFile.readFully(bArr);
                        randomAccessFile.close();
                        zEquals = new String(bArr, "UTF-8").equals(str);
                    } catch (IOException unused) {
                    }
                    if (!zEquals) {
                        try {
                            C4303.deleteDirectory(cacheDir);
                        } catch (IOException unused2) {
                        }
                    }
                }
                try {
                    FileOutputStream fileOutputStream = new FileOutputStream(new File(cacheDir, "applicationId"));
                    fileOutputStream.write(str.getBytes("UTF-8"));
                    fileOutputStream.close();
                } catch (IOException unused3) {
                }
            }
        }
    }

    public static ParseCallbacks[] collectParseCallbacks() {
        synchronized (MUTEX_CALLBACKS) {
            if (callbacks == null) {
                return null;
            }
            ParseCallbacks[] parseCallbacksArr = new ParseCallbacks[callbacks.size()];
            if (callbacks.size() > 0) {
                parseCallbacksArr = (ParseCallbacks[]) callbacks.toArray(parseCallbacksArr);
            }
            return parseCallbacksArr;
        }
    }

    public static Context getApplicationContext() {
        if (ParsePlugins.get().applicationContext != null) {
            return ParsePlugins.get().applicationContext;
        }
        throw new RuntimeException("applicationContext is null. You must call Parse.initialize(Context) before using the Parse library.");
    }

    public static ParseEventuallyQueue getEventuallyQueue() {
        return getEventuallyQueue(ParsePlugins.get().applicationContext);
    }

    public static ParseEventuallyQueue getEventuallyQueue(Context context) {
        ParseEventuallyQueue parseEventuallyQueue;
        synchronized (MUTEX) {
            boolean z = isLocalDatastoreEnabled;
            if (eventuallyQueue == null || ((z && (eventuallyQueue instanceof ParseCommandCache)) || (!z && (eventuallyQueue instanceof ParsePinningEventuallyQueue)))) {
                if (ParsePlugins.get().applicationContext == null) {
                    throw new RuntimeException("applicationContext is null. You must call Parse.initialize(Context) before using the Parse library.");
                }
                ParseHttpClient parseHttpClientRestClient = ParsePlugins.get().restClient();
                eventuallyQueue = z ? new ParsePinningEventuallyQueue(context, parseHttpClientRestClient) : new ParseCommandCache(context, parseHttpClientRestClient);
                if (z && ParseCommandCache.getPendingCount() > 0) {
                    new ParseCommandCache(context, parseHttpClientRestClient);
                }
            }
            parseEventuallyQueue = eventuallyQueue;
        }
        return parseEventuallyQueue;
    }

    public static int getLogLevel() {
        return Integer.MAX_VALUE;
    }

    public static File getParseCacheDir(String str) {
        File file;
        synchronized (MUTEX) {
            file = new File(ParsePlugins.get().getCacheDir(), str);
            if (!file.exists()) {
                file.mkdirs();
            }
        }
        return file;
    }

    @Deprecated
    public static File getParseDir() {
        return ParsePlugins.get().getParseDir();
    }

    public static void initialize(Configuration configuration, ParsePlugins parsePlugins) {
        boolean z = true;
        if (ParsePlugins.get() != null) {
            PLog.w("com.parse.Parse", "Parse is already initialized");
            return;
        }
        isLocalDatastoreEnabled = configuration.localDataStoreEnabled;
        if (parsePlugins == null) {
            ParsePlugins.set(new ParsePlugins(configuration.context, configuration));
        } else {
            ParsePlugins.set(parsePlugins);
        }
        try {
            ParseRESTCommand.server = new URL(configuration.server);
            ParseObject.registerParseSubclasses();
            if (configuration.localDataStoreEnabled) {
                offlineStore = new OfflineStore(configuration.context);
            } else {
                ParseKeyValueCache.initialize(configuration.context);
            }
            checkCacheApplicationId();
            final Context context = configuration.context;
            C2742.m4803(new Callable<Void>() { // from class: com.parse.Parse.1
                @Override // java.util.concurrent.Callable
                public Void call() {
                    Parse.getEventuallyQueue(context);
                    return null;
                }
            }, C2742.f8454, (C2739) null);
            ParseFieldOperations.opDecoderMap.put("Batch", new ParseFieldOperations.ParseFieldOperationFactory() { // from class: com.parse.ParseFieldOperations.1
                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(Parcel parcel, ParseParcelDecoder parseParcelDecoder) {
                    return ParseFieldOperations.decode(parcel, parseParcelDecoder).mergeWithPrevious(ParseFieldOperations.decode(parcel, parseParcelDecoder));
                }

                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(JSONObject jSONObject, ParseDecoder parseDecoder) throws JSONException {
                    JSONArray jSONArray = jSONObject.getJSONArray("ops");
                    ParseFieldOperation parseFieldOperationMergeWithPrevious = null;
                    for (int i = 0; i < jSONArray.length(); i++) {
                        parseFieldOperationMergeWithPrevious = ParseFieldOperations.decode(jSONArray.getJSONObject(i), parseDecoder).mergeWithPrevious(parseFieldOperationMergeWithPrevious);
                    }
                    return parseFieldOperationMergeWithPrevious;
                }
            });
            ParseFieldOperations.opDecoderMap.put("Delete", new ParseFieldOperations.ParseFieldOperationFactory() { // from class: com.parse.ParseFieldOperations.2
                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(Parcel parcel, ParseParcelDecoder parseParcelDecoder) {
                    return ParseDeleteOperation.defaultInstance;
                }

                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(JSONObject jSONObject, ParseDecoder parseDecoder) {
                    return ParseDeleteOperation.defaultInstance;
                }
            });
            ParseFieldOperations.opDecoderMap.put("Increment", new ParseFieldOperations.ParseFieldOperationFactory() { // from class: com.parse.ParseFieldOperations.3
                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(Parcel parcel, ParseParcelDecoder parseParcelDecoder) {
                    return new ParseIncrementOperation((Number) parseParcelDecoder.decode(parcel));
                }

                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(JSONObject jSONObject, ParseDecoder parseDecoder) {
                    return new ParseIncrementOperation((Number) parseDecoder.decode(jSONObject.opt("amount")));
                }
            });
            ParseFieldOperations.opDecoderMap.put("Add", new ParseFieldOperations.ParseFieldOperationFactory() { // from class: com.parse.ParseFieldOperations.4
                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(Parcel parcel, ParseParcelDecoder parseParcelDecoder) {
                    int i = parcel.readInt();
                    ArrayList arrayList = new ArrayList(i);
                    for (int i2 = 0; i2 < i; i2++) {
                        arrayList.add(i2, parseParcelDecoder.decode(parcel));
                    }
                    return new ParseAddOperation(arrayList);
                }

                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(JSONObject jSONObject, ParseDecoder parseDecoder) {
                    return new ParseAddOperation((Collection) parseDecoder.decode(jSONObject.opt("objects")));
                }
            });
            ParseFieldOperations.opDecoderMap.put("AddUnique", new ParseFieldOperations.ParseFieldOperationFactory() { // from class: com.parse.ParseFieldOperations.5
                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(Parcel parcel, ParseParcelDecoder parseParcelDecoder) {
                    int i = parcel.readInt();
                    ArrayList arrayList = new ArrayList(i);
                    for (int i2 = 0; i2 < i; i2++) {
                        arrayList.add(i2, parseParcelDecoder.decode(parcel));
                    }
                    return new ParseAddUniqueOperation(arrayList);
                }

                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(JSONObject jSONObject, ParseDecoder parseDecoder) {
                    return new ParseAddUniqueOperation((Collection) parseDecoder.decode(jSONObject.opt("objects")));
                }
            });
            ParseFieldOperations.opDecoderMap.put("Remove", new ParseFieldOperations.ParseFieldOperationFactory() { // from class: com.parse.ParseFieldOperations.6
                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(Parcel parcel, ParseParcelDecoder parseParcelDecoder) {
                    int i = parcel.readInt();
                    ArrayList arrayList = new ArrayList(i);
                    for (int i2 = 0; i2 < i; i2++) {
                        arrayList.add(i2, parseParcelDecoder.decode(parcel));
                    }
                    return new ParseRemoveOperation(arrayList);
                }

                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(JSONObject jSONObject, ParseDecoder parseDecoder) {
                    return new ParseRemoveOperation((Collection) parseDecoder.decode(jSONObject.opt("objects")));
                }
            });
            ParseFieldOperations.opDecoderMap.put("AddRelation", new ParseFieldOperations.ParseFieldOperationFactory() { // from class: com.parse.ParseFieldOperations.7
                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(Parcel parcel, ParseParcelDecoder parseParcelDecoder) {
                    int i = parcel.readInt();
                    HashSet hashSet = new HashSet(i);
                    for (int i2 = 0; i2 < i; i2++) {
                        hashSet.add((ParseObject) parseParcelDecoder.decode(parcel));
                    }
                    return new ParseRelationOperation(hashSet, null);
                }

                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(JSONObject jSONObject, ParseDecoder parseDecoder) {
                    return new ParseRelationOperation(new HashSet((List) parseDecoder.decode(jSONObject.optJSONArray("objects"))), null);
                }
            });
            ParseFieldOperations.opDecoderMap.put("RemoveRelation", new ParseFieldOperations.ParseFieldOperationFactory() { // from class: com.parse.ParseFieldOperations.8
                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(Parcel parcel, ParseParcelDecoder parseParcelDecoder) {
                    int i = parcel.readInt();
                    HashSet hashSet = new HashSet(i);
                    for (int i2 = 0; i2 < i; i2++) {
                        hashSet.add((ParseObject) parseParcelDecoder.decode(parcel));
                    }
                    return new ParseRelationOperation(null, hashSet);
                }

                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(JSONObject jSONObject, ParseDecoder parseDecoder) {
                    return new ParseRelationOperation(null, new HashSet((List) parseDecoder.decode(jSONObject.optJSONArray("objects"))));
                }
            });
            ParseFieldOperations.opDecoderMap.put("Set", new ParseFieldOperations.ParseFieldOperationFactory() { // from class: com.parse.ParseFieldOperations.9
                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(Parcel parcel, ParseParcelDecoder parseParcelDecoder) {
                    return new ParseSetOperation(parseParcelDecoder.decode(parcel));
                }

                @Override // com.parse.ParseFieldOperations.ParseFieldOperationFactory
                public ParseFieldOperation decode(JSONObject jSONObject, ParseDecoder parseDecoder) {
                    return null;
                }
            });
            Iterator it = ((ArrayList) ManifestInfo.getIntentReceivers("com.parse.push.intent.RECEIVE", "com.parse.push.intent.DELETE", "com.parse.push.intent.OPEN")).iterator();
            while (true) {
                if (it.hasNext()) {
                    if (((ResolveInfo) it.next()).activityInfo.exported) {
                        z = false;
                        break;
                    }
                } else {
                    break;
                }
            }
            if (!z) {
                throw new SecurityException("To prevent external tampering to your app's notifications, all receivers registered to handle the following actions must have their exported attributes set to false: com.parse.push.intent.RECEIVE, com.parse.push.intent.OPEN, com.parse.push.intent.DELETE");
            }
            ParseUser.getCurrentUserAsync().m4821().m4809((InterfaceC2741<Void, TContinuationResult>) new InterfaceC2741<Void, Void>() { // from class: com.parse.Parse.2
                @Override // p137.InterfaceC2741
                public Void then(C2742<Void> c2742) {
                    ParseConfig.getCurrentConfig();
                    return null;
                }
            }, C2742.f8454, (C2739) null);
            ParseCallbacks[] parseCallbacksArrCollectParseCallbacks = collectParseCallbacks();
            if (parseCallbacksArrCollectParseCallbacks != null) {
                for (ParseCallbacks parseCallbacks : parseCallbacksArrCollectParseCallbacks) {
                    parseCallbacks.onParseInitialized();
                }
            }
            synchronized (MUTEX_CALLBACKS) {
                callbacks = null;
            }
        } catch (MalformedURLException e) {
            throw new RuntimeException(e);
        }
    }
}