package com.parse;

import com.parse.ParseQuery;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import p137.C2742;
import p137.InterfaceC2741;

/* JADX INFO: loaded from: classes.dex */
public class OfflineQueryLogic {
    public final OfflineStore store;

    public abstract class ConstraintMatcher<T extends ParseObject> {
        public final ParseUser user;

        public ConstraintMatcher(OfflineQueryLogic offlineQueryLogic, ParseUser parseUser) {
            this.user = parseUser;
        }

        public abstract C2742<Boolean> matchesAsync(T t, ParseSQLiteDatabase parseSQLiteDatabase);
    }

    public interface Decider {
        boolean decide(Object obj, Object obj2);
    }

    public abstract class SubQueryMatcher<T extends ParseObject> extends ConstraintMatcher<T> {
        public final ParseQuery.State<T> subQuery;
        public C2742<List<T>> subQueryResults;

        public SubQueryMatcher(ParseUser parseUser, ParseQuery.State<T> state) {
            super(OfflineQueryLogic.this, parseUser);
            this.subQueryResults = null;
            this.subQuery = state;
        }

        public abstract boolean matches(T t, List<T> list);

        @Override // com.parse.OfflineQueryLogic.ConstraintMatcher
        public C2742<Boolean> matchesAsync(final T t, ParseSQLiteDatabase parseSQLiteDatabase) {
            if (this.subQueryResults == null) {
                this.subQueryResults = OfflineQueryLogic.this.store.findAsync(this.subQuery, this.user, null, false, parseSQLiteDatabase);
            }
            return this.subQueryResults.m4816(new InterfaceC2741<List<T>, Boolean>() { // from class: com.parse.OfflineQueryLogic.SubQueryMatcher.1
                /* JADX WARN: Multi-variable type inference failed */
                @Override // p137.InterfaceC2741
                public Boolean then(C2742 c2742) {
                    return Boolean.valueOf(SubQueryMatcher.this.matches(t, (List) c2742.m4812()));
                }
            });
        }
    }

    public OfflineQueryLogic(OfflineStore offlineStore) {
        this.store = offlineStore;
    }

    public static /* synthetic */ Object access$100(Object obj, String str) {
        return getValue(obj, str, 0);
    }

    public static /* synthetic */ C2742 access$200(final OfflineStore offlineStore, final Object obj, final String str, final ParseSQLiteDatabase parseSQLiteDatabase) {
        C2742 c2742M4805;
        if (obj == null) {
            return C2742.m4805((Object) null);
        }
        if (obj instanceof Collection) {
            c2742M4805 = C2742.m4805((Object) null);
            for (final Object obj2 : (Collection) obj) {
                c2742M4805 = c2742M4805.m4817(new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.OfflineQueryLogic.8
                    @Override // p137.InterfaceC2741
                    public C2742<Void> then(C2742<Void> c2742) {
                        return OfflineQueryLogic.access$200(offlineStore, obj2, str, parseSQLiteDatabase);
                    }
                }, C2742.f8455);
            }
        } else {
            if (!(obj instanceof JSONArray)) {
                if (str == null) {
                    return JSONObject.NULL.equals(obj) ? C2742.m4805((Object) null) : obj instanceof ParseObject ? offlineStore.fetchLocallyAsync((ParseObject) obj, parseSQLiteDatabase).m4821() : C2742.m4804((Exception) new ParseException(121, "include is invalid for non-ParseObjects"));
                }
                String[] strArrSplit = str.split("\\.", 2);
                final String str2 = strArrSplit[0];
                final String str3 = strArrSplit.length > 1 ? strArrSplit[1] : null;
                return C2742.m4805((Object) null).m4815(new InterfaceC2741<Void, C2742<Object>>() { // from class: com.parse.OfflineQueryLogic.11
                    @Override // p137.InterfaceC2741
                    public C2742<Object> then(C2742<Void> c2742) {
                        Object obj3 = obj;
                        if (obj3 instanceof ParseObject) {
                            return OfflineQueryLogic.access$200(offlineStore, obj3, null, parseSQLiteDatabase).m4816(new InterfaceC2741<Void, Object>() { // from class: com.parse.OfflineQueryLogic.11.1
                                @Override // p137.InterfaceC2741
                                public Object then(C2742<Void> c27422) {
                                    AnonymousClass11 anonymousClass11 = AnonymousClass11.this;
                                    return ((ParseObject) obj).get(str2);
                                }
                            });
                        }
                        if (obj3 instanceof Map) {
                            return C2742.m4805(((Map) obj3).get(str2));
                        }
                        if (obj3 instanceof JSONObject) {
                            return C2742.m4805(((JSONObject) obj3).opt(str2));
                        }
                        if (JSONObject.NULL.equals(obj3)) {
                            return null;
                        }
                        return C2742.m4804((Exception) new IllegalStateException("include is invalid"));
                    }
                }, C2742.f8455, null).m4817(new InterfaceC2741<Object, C2742<Void>>() { // from class: com.parse.OfflineQueryLogic.10
                    @Override // p137.InterfaceC2741
                    public C2742<Void> then(C2742<Object> c2742) {
                        return OfflineQueryLogic.access$200(offlineStore, c2742.m4812(), str3, parseSQLiteDatabase);
                    }
                }, C2742.f8455);
            }
            final JSONArray jSONArray = (JSONArray) obj;
            c2742M4805 = C2742.m4805((Object) null);
            for (int i = 0; i < jSONArray.length(); i++) {
                final int i2 = i;
                c2742M4805 = c2742M4805.m4817(new InterfaceC2741<Void, C2742<Void>>() { // from class: com.parse.OfflineQueryLogic.9
                    @Override // p137.InterfaceC2741
                    public C2742<Void> then(C2742<Void> c2742) {
                        return OfflineQueryLogic.access$200(offlineStore, jSONArray.get(i2), str, parseSQLiteDatabase);
                    }
                }, C2742.f8455);
            }
        }
        return c2742M4805;
    }

    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
    /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue */
    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Removed duplicated region for block: B:102:0x01a1  */
    /* JADX WARN: Removed duplicated region for block: B:172:0x02c0  */
    /* JADX WARN: Removed duplicated region for block: B:53:0x00c2  */
    /* JADX WARN: Type inference failed for: r1v0, types: [java.lang.Object] */
    /* JADX WARN: Type inference failed for: r1v11 */
    /* JADX WARN: Type inference failed for: r1v3 */
    /* JADX WARN: Type inference failed for: r1v8, types: [java.util.ArrayList] */
    /* JADX WARN: Type inference failed for: r1v9 */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static /* synthetic */ boolean access$500(String str, Object obj, Object obj2, ParseQuery.KeyConstraints keyConstraints) throws ParseException {
        byte b;
        boolean zMatchesEqualConstraint;
        boolean z;
        ?? arrayList = obj;
        boolean zFind = false;
        switch (str.hashCode()) {
            case -2013624456:
                b = str.equals("$geoWithin") ? (byte) 14 : (byte) -1;
                break;
            case -1622199595:
                if (str.equals("$maxDistance")) {
                    b = 12;
                    break;
                }
                break;
            case -443727559:
                if (str.equals("$nearSphere")) {
                    b = 11;
                    break;
                }
                break;
            case 37905:
                if (str.equals("$gt")) {
                    b = 3;
                    break;
                }
                break;
            case 37961:
                if (str.equals("$in")) {
                    b = 5;
                    break;
                }
                break;
            case 38060:
                if (str.equals("$lt")) {
                    b = 1;
                    break;
                }
                break;
            case 38107:
                if (str.equals("$ne")) {
                    b = 0;
                    break;
                }
                break;
            case 1169149:
                if (str.equals("$all")) {
                    b = 7;
                    break;
                }
                break;
            case 1175156:
                if (str.equals("$gte")) {
                    b = 4;
                    break;
                }
                break;
            case 1179961:
                if (str.equals("$lte")) {
                    b = 2;
                    break;
                }
                break;
            case 1181551:
                if (str.equals("$nin")) {
                    b = 6;
                    break;
                }
                break;
            case 596003200:
                if (str.equals("$exists")) {
                    b = 10;
                    break;
                }
                break;
            case 1097791887:
                if (str.equals("$within")) {
                    b = 13;
                    break;
                }
                break;
            case 1139041955:
                if (str.equals("$regex")) {
                    b = 8;
                    break;
                }
                break;
            case 1362155002:
                if (str.equals("$options")) {
                    b = 9;
                    break;
                }
                break;
            case 1785385921:
                if (str.equals("$geoIntersects")) {
                    b = 15;
                    break;
                }
                break;
        }
        switch (b) {
            case 0:
                zMatchesEqualConstraint = matchesEqualConstraint(obj, obj2);
                return true ^ zMatchesEqualConstraint;
            case 1:
                return compare(arrayList, obj2, new Decider() { // from class: com.parse.OfflineQueryLogic.3
                    @Override // com.parse.OfflineQueryLogic.Decider
                    public boolean decide(Object obj3, Object obj4) {
                        return (obj4 == null || obj4 == JSONObject.NULL || OfflineQueryLogic.compareTo(obj3, obj4) <= 0) ? false : true;
                    }
                });
            case 2:
                return compare(arrayList, obj2, new Decider() { // from class: com.parse.OfflineQueryLogic.4
                    @Override // com.parse.OfflineQueryLogic.Decider
                    public boolean decide(Object obj3, Object obj4) {
                        return (obj4 == null || obj4 == JSONObject.NULL || OfflineQueryLogic.compareTo(obj3, obj4) < 0) ? false : true;
                    }
                });
            case 3:
                return compare(arrayList, obj2, new Decider() { // from class: com.parse.OfflineQueryLogic.5
                    @Override // com.parse.OfflineQueryLogic.Decider
                    public boolean decide(Object obj3, Object obj4) {
                        return (obj4 == null || obj4 == JSONObject.NULL || OfflineQueryLogic.compareTo(obj3, obj4) >= 0) ? false : true;
                    }
                });
            case 4:
                return compare(arrayList, obj2, new Decider() { // from class: com.parse.OfflineQueryLogic.6
                    @Override // com.parse.OfflineQueryLogic.Decider
                    public boolean decide(Object obj3, Object obj4) {
                        return (obj4 == null || obj4 == JSONObject.NULL || OfflineQueryLogic.compareTo(obj3, obj4) > 0) ? false : true;
                    }
                });
            case 5:
                return matchesInConstraint(obj, obj2);
            case 6:
                zMatchesEqualConstraint = matchesInConstraint(obj, obj2);
                return true ^ zMatchesEqualConstraint;
            case 7:
                if (obj2 != null && obj2 != JSONObject.NULL) {
                    if (!(obj2 instanceof Collection)) {
                        throw new IllegalArgumentException("Value type not supported for $all queries.");
                    }
                    if (!(arrayList instanceof Collection)) {
                        throw new IllegalArgumentException("Constraint type not supported for $all queries.");
                    }
                    Collection collection = (Collection) arrayList;
                    Iterator it = collection.iterator();
                    while (true) {
                        if (!it.hasNext()) {
                            z = false;
                        } else if (isStartsWithRegex(it.next())) {
                            z = true;
                        }
                    }
                    if (z) {
                        arrayList = new ArrayList();
                        for (Object obj3 : collection) {
                            if (obj3 instanceof ParseQuery.KeyConstraints) {
                                ParseQuery.KeyConstraints keyConstraints2 = (ParseQuery.KeyConstraints) obj3;
                                if (isStartsWithRegex(keyConstraints2)) {
                                    keyConstraints2.put("$regex", ((String) keyConstraints2.get("$regex")).replaceAll("([^\\\\])(\\\\E)", "$1").replaceAll("([^\\\\])(\\\\Q)", "$1").replaceAll("^\\\\E", "").replaceAll("^\\\\Q", "").replaceAll("([^'])'", "$1''").replaceAll("^'([^'])", "''$1") + ".*");
                                } else {
                                    keyConstraints2 = null;
                                }
                                if (keyConstraints2 != null) {
                                    arrayList.add(keyConstraints2);
                                }
                            }
                            arrayList = 0;
                            if (arrayList == 0) {
                                throw new IllegalArgumentException("All values in $all queries must be of starting with regex or non regex.");
                            }
                        }
                        if (arrayList == 0) {
                        }
                    }
                    Iterator it2 = ((Collection) arrayList).iterator();
                    while (it2.hasNext()) {
                        if (!matchesEqualConstraint(it2.next(), obj2)) {
                        }
                    }
                    zFind = true;
                }
                return zFind;
            case 8:
                String str2 = (String) keyConstraints.get("$options");
                if (obj2 != null && obj2 != JSONObject.NULL) {
                    String str3 = str2 != null ? str2 : "";
                    if (!str3.matches("^[imxs]*$")) {
                        throw new ParseException(102, String.format("Invalid regex options: %s", str3));
                    }
                    int i = str3.contains("i") ? 2 : 0;
                    if (str3.contains("m")) {
                        i |= 8;
                    }
                    if (str3.contains("x")) {
                        i |= 4;
                    }
                    if (str3.contains("s")) {
                        i |= 32;
                    }
                    zFind = Pattern.compile((String) arrayList, i).matcher((String) obj2).find();
                }
                return zFind;
            case 9:
            case 12:
                return true;
            case 10:
                if (arrayList == 0 || !((Boolean) arrayList).booleanValue() ? obj2 == null || obj2 == JSONObject.NULL : obj2 != null && obj2 != JSONObject.NULL) {
                    zFind = true;
                }
                return zFind;
            case 11:
                Double d = (Double) keyConstraints.get("$maxDistance");
                if (obj2 != null && obj2 != JSONObject.NULL) {
                    if (d == null) {
                        return true;
                    }
                    if (((ParseGeoPoint) arrayList).distanceInRadiansTo((ParseGeoPoint) obj2) <= d.doubleValue()) {
                    }
                }
                return zFind;
            case 13:
                if (obj2 != null && obj2 != JSONObject.NULL) {
                    ArrayList arrayList2 = (ArrayList) ((HashMap) arrayList).get("$box");
                    ParseGeoPoint parseGeoPoint = (ParseGeoPoint) arrayList2.get(0);
                    ParseGeoPoint parseGeoPoint2 = (ParseGeoPoint) arrayList2.get(1);
                    ParseGeoPoint parseGeoPoint3 = (ParseGeoPoint) obj2;
                    double d2 = parseGeoPoint2.longitude;
                    double d3 = parseGeoPoint.longitude;
                    if (d2 < d3) {
                        throw new ParseException(102, "whereWithinGeoBox queries cannot cross the International Date Line.");
                    }
                    double d4 = parseGeoPoint2.latitude;
                    double d5 = parseGeoPoint.latitude;
                    if (d4 < d5) {
                        throw new ParseException(102, "The southwest corner of a geo box must be south of the northeast corner.");
                    }
                    if (d2 - d3 > 180.0d) {
                        throw new ParseException(102, "Geo box queries larger than 180 degrees in longitude are not supported. Please check point order.");
                    }
                    double d6 = parseGeoPoint3.latitude;
                    if (d6 >= d5 && d6 <= d4) {
                        double d7 = parseGeoPoint3.longitude;
                        if (d7 >= d3 && d7 <= d2) {
                        }
                    }
                }
                return zFind;
            case 14:
                if (obj2 != null && obj2 != JSONObject.NULL) {
                    zFind = new ParsePolygon((List<ParseGeoPoint>) ((HashMap) arrayList).get("$polygon")).containsPoint((ParseGeoPoint) obj2);
                }
                return zFind;
            case 15:
                if (obj2 != null && obj2 != JSONObject.NULL) {
                    zFind = ((ParsePolygon) obj2).containsPoint((ParseGeoPoint) ((HashMap) arrayList).get("$point"));
                }
                return zFind;
            default:
                throw new UnsupportedOperationException(String.format("The offline store does not yet support the %s operator.", str));
        }
    }

    public static boolean compare(Object obj, Object obj2, Decider decider) {
        if (obj2 instanceof List) {
            Iterator it = ((List) obj2).iterator();
            while (it.hasNext()) {
                if (decider.decide(obj, it.next())) {
                    return true;
                }
            }
            return false;
        }
        if (!(obj2 instanceof JSONArray)) {
            return decider.decide(obj, obj2);
        }
        JSONArray jSONArray = (JSONArray) obj2;
        for (int i = 0; i < jSONArray.length(); i++) {
            try {
                if (decider.decide(obj, jSONArray.get(i))) {
                    return true;
                }
            } catch (JSONException e) {
                throw new RuntimeException(e);
            }
        }
        return false;
    }

    public static int compareTo(Object obj, Object obj2) {
        int iIntValue;
        int iIntValue2;
        int i = 0;
        boolean z = obj == JSONObject.NULL || obj == null;
        boolean z2 = obj2 == JSONObject.NULL || obj2 == null;
        if (z || z2) {
            if (z) {
                return !z2 ? -1 : 0;
            }
            return 1;
        }
        if ((obj instanceof Date) && (obj2 instanceof Date)) {
            return ((Date) obj).compareTo((Date) obj2);
        }
        if ((obj instanceof String) && (obj2 instanceof String)) {
            return ((String) obj).compareTo((String) obj2);
        }
        if (!(obj instanceof Number) || !(obj2 instanceof Number)) {
            throw new IllegalArgumentException(String.format("Cannot compare %s against %s", obj, obj2));
        }
        Number number = (Number) obj;
        Number number2 = (Number) obj2;
        if ((number instanceof Double) || (number2 instanceof Double)) {
            return (int) Math.signum(number.doubleValue() - number2.doubleValue());
        }
        if ((number instanceof Float) || (number2 instanceof Float)) {
            return (int) Math.signum(number.floatValue() - number2.floatValue());
        }
        if ((number instanceof Long) || (number2 instanceof Long)) {
            long jLongValue = number.longValue() - number2.longValue();
            if (jLongValue < 0) {
                i = -1;
            } else if (jLongValue > 0) {
                i = 1;
            }
            return i;
        }
        if ((number instanceof Integer) || (number2 instanceof Integer)) {
            iIntValue = number.intValue();
            iIntValue2 = number2.intValue();
        } else if ((number instanceof Short) || (number2 instanceof Short)) {
            iIntValue = number.shortValue();
            iIntValue2 = number2.shortValue();
        } else {
            if (!(number instanceof Byte) && !(number2 instanceof Byte)) {
                throw new RuntimeException("Unknown number type.");
            }
            iIntValue = number.byteValue();
            iIntValue2 = number2.byteValue();
        }
        return iIntValue - iIntValue2;
    }

    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
    /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue */
    /* JADX WARN: Removed duplicated region for block: B:46:0x00a2  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static Object getValue(Object obj, String str, int i) throws ParseException {
        Object objEncode = null;
        byte b = 0;
        if (str.contains(".")) {
            String[] strArrSplit = str.split("\\.", 2);
            int i2 = i + 1;
            Object value = getValue(obj, strArrSplit[0], i2);
            if (value == null || value == JSONObject.NULL || (value instanceof Map) || (value instanceof JSONObject)) {
                return getValue(value, strArrSplit[1], i2);
            }
            if (i > 0) {
                try {
                    objEncode = PointerEncoder.INSTANCE.encode(value);
                } catch (Exception unused) {
                }
                if (objEncode instanceof JSONObject) {
                    return getValue(objEncode, strArrSplit[1], i2);
                }
            }
            throw new ParseException(102, String.format("Key %s is invalid.", str));
        }
        if (!(obj instanceof ParseObject)) {
            if (obj instanceof JSONObject) {
                return ((JSONObject) obj).opt(str);
            }
            if (obj instanceof Map) {
                return ((Map) obj).get(str);
            }
            if (obj == JSONObject.NULL || obj == null) {
                return null;
            }
            throw new ParseException(121, String.format("Bad key: %s", str));
        }
        ParseObject parseObject = (ParseObject) obj;
        if (!parseObject.isDataAvailable()) {
            throw new ParseException(121, String.format("Bad key: %s", str));
        }
        switch (str.hashCode()) {
            case -1949194674:
                b = !str.equals("updatedAt") ? (byte) -1 : (byte) 3;
                break;
            case -1836974455:
                if (str.equals("_created_at")) {
                    b = 2;
                    break;
                }
                break;
            case 90495162:
                if (!str.equals("objectId")) {
                }
                break;
            case 598371643:
                if (str.equals("createdAt")) {
                    b = 1;
                    break;
                }
                break;
            case 792848342:
                if (str.equals("_updated_at")) {
                    b = 4;
                    break;
                }
                break;
        }
        if (b == 0) {
            return parseObject.getObjectId();
        }
        if (b == 1 || b == 2) {
            long j = parseObject.getState().createdAt;
            if (j > 0) {
                return new Date(j);
            }
            return null;
        }
        if (b != 3 && b != 4) {
            return parseObject.get(str);
        }
        long j2 = parseObject.getState().updatedAt;
        if (j2 > 0) {
            return new Date(j2);
        }
        return null;
    }

    public static boolean isStartsWithRegex(Object obj) {
        if (obj == null || !(obj instanceof ParseQuery.KeyConstraints)) {
            return false;
        }
        ParseQuery.KeyConstraints keyConstraints = (ParseQuery.KeyConstraints) obj;
        return keyConstraints.size() == 1 && keyConstraints.containsKey("$regex") && ((String) keyConstraints.get("$regex")).startsWith("^");
    }

    public static boolean matchesEqualConstraint(Object obj, Object obj2) {
        if (obj == null || obj2 == null) {
            return obj == obj2;
        }
        if ((obj instanceof Number) && (obj2 instanceof Number)) {
            return compareTo(obj, obj2) == 0;
        }
        if ((obj instanceof ParseGeoPoint) && (obj2 instanceof ParseGeoPoint)) {
            ParseGeoPoint parseGeoPoint = (ParseGeoPoint) obj;
            ParseGeoPoint parseGeoPoint2 = (ParseGeoPoint) obj2;
            return parseGeoPoint.latitude == parseGeoPoint2.latitude && parseGeoPoint.longitude == parseGeoPoint2.longitude;
        }
        if ((obj instanceof ParsePolygon) && (obj2 instanceof ParsePolygon)) {
            return ((ParsePolygon) obj).equals((ParsePolygon) obj2);
        }
        return compare(obj, obj2, isStartsWithRegex(obj) ? new Decider() { // from class: com.parse.OfflineQueryLogic.1
            @Override // com.parse.OfflineQueryLogic.Decider
            public boolean decide(Object obj3, Object obj4) {
                return ((String) obj4).matches(((ParseQuery.KeyConstraints) obj3).get("$regex").toString());
            }
        } : new Decider() { // from class: com.parse.OfflineQueryLogic.2
            @Override // com.parse.OfflineQueryLogic.Decider
            public boolean decide(Object obj3, Object obj4) {
                return obj3.equals(obj4);
            }
        });
    }

    public static boolean matchesInConstraint(Object obj, Object obj2) {
        if (!(obj instanceof Collection)) {
            throw new IllegalArgumentException("Constraint type not supported for $in queries.");
        }
        Iterator it = ((Collection) obj).iterator();
        while (it.hasNext()) {
            if (matchesEqualConstraint(it.next(), obj2)) {
                return true;
            }
        }
        return false;
    }

    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
    /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue */
    /* JADX WARN: Removed duplicated region for block: B:32:0x00a0  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final <T extends ParseObject> ConstraintMatcher<T> createMatcher(ParseUser parseUser, ParseQuery.QueryConstraints queryConstraints) {
        byte b;
        ConstraintMatcher constraintMatcherCreateSelectMatcher;
        final ArrayList arrayList = new ArrayList();
        for (final String str : queryConstraints.keySet()) {
            final Object obj = queryConstraints.get(str);
            if (str.equals("$or")) {
                final ArrayList arrayList2 = new ArrayList();
                Iterator it = ((ArrayList) obj).iterator();
                while (it.hasNext()) {
                    arrayList2.add(createMatcher(parseUser, (ParseQuery.QueryConstraints) it.next()));
                }
                arrayList.add(new ConstraintMatcher<T>(this, parseUser) { // from class: com.parse.OfflineQueryLogic.18
                    /* JADX WARN: Incorrect types in method signature: (TT;Lcom/parse/ParseSQLiteDatabase;)Lފ/ރ<Ljava/lang/Boolean;>; */
                    @Override // com.parse.OfflineQueryLogic.ConstraintMatcher
                    public C2742 matchesAsync(final ParseObject parseObject, final ParseSQLiteDatabase parseSQLiteDatabase) {
                        C2742 c2742M4805 = C2742.m4805(false);
                        for (final ConstraintMatcher constraintMatcher : arrayList2) {
                            c2742M4805 = c2742M4805.m4817(new InterfaceC2741<Boolean, C2742<Boolean>>(this) { // from class: com.parse.OfflineQueryLogic.18.1
                                @Override // p137.InterfaceC2741
                                public C2742<Boolean> then(C2742<Boolean> c2742) {
                                    return c2742.m4812().booleanValue() ? c2742 : constraintMatcher.matchesAsync(parseObject, parseSQLiteDatabase);
                                }
                            }, C2742.f8455);
                        }
                        return c2742M4805;
                    }
                });
            } else if (obj instanceof ParseQuery.KeyConstraints) {
                final ParseQuery.KeyConstraints keyConstraints = (ParseQuery.KeyConstraints) obj;
                for (final String str2 : keyConstraints.keySet()) {
                    final Object obj2 = keyConstraints.get(str2);
                    switch (str2.hashCode()) {
                        case -721570031:
                            b = str2.equals("$dontSelect") ? (byte) 3 : (byte) -1;
                            break;
                        case 242866687:
                            if (str2.equals("$inQuery")) {
                                b = 0;
                                break;
                            }
                            break;
                        case 427054964:
                            if (str2.equals("$notInQuery")) {
                                b = 1;
                                break;
                            }
                            break;
                        case 979339808:
                            if (str2.equals("$select")) {
                                b = 2;
                                break;
                            }
                            break;
                    }
                    if (b == 0) {
                        constraintMatcherCreateSelectMatcher = new SubQueryMatcher<T>(this, parseUser, ((ParseQuery.State.Builder) obj2).build()) { // from class: com.parse.OfflineQueryLogic.13
                            /* JADX WARN: Incorrect types in method signature: (TT;Ljava/util/List<TT;>;)Z */
                            @Override // com.parse.OfflineQueryLogic.SubQueryMatcher
                            public boolean matches(ParseObject parseObject, List list) {
                                return OfflineQueryLogic.matchesInConstraint(list, OfflineQueryLogic.access$100(parseObject, str));
                            }
                        };
                    } else if (b == 1) {
                        final ConstraintMatcher constraintMatcher = new SubQueryMatcher<T>(this, parseUser, ((ParseQuery.State.Builder) obj2).build()) { // from class: com.parse.OfflineQueryLogic.13
                            /* JADX WARN: Incorrect types in method signature: (TT;Ljava/util/List<TT;>;)Z */
                            @Override // com.parse.OfflineQueryLogic.SubQueryMatcher
                            public boolean matches(ParseObject parseObject, List list) {
                                return OfflineQueryLogic.matchesInConstraint(list, OfflineQueryLogic.access$100(parseObject, str));
                            }
                        };
                        constraintMatcherCreateSelectMatcher = new ConstraintMatcher<T>(this, parseUser) { // from class: com.parse.OfflineQueryLogic.14
                            /* JADX WARN: Incorrect types in method signature: (TT;Lcom/parse/ParseSQLiteDatabase;)Lފ/ރ<Ljava/lang/Boolean;>; */
                            @Override // com.parse.OfflineQueryLogic.ConstraintMatcher
                            public C2742 matchesAsync(ParseObject parseObject, ParseSQLiteDatabase parseSQLiteDatabase) {
                                return constraintMatcher.matchesAsync(parseObject, parseSQLiteDatabase).m4816(new InterfaceC2741<Boolean, Boolean>(this) { // from class: com.parse.OfflineQueryLogic.14.1
                                    @Override // p137.InterfaceC2741
                                    public Boolean then(C2742<Boolean> c2742) {
                                        return Boolean.valueOf(!c2742.m4812().booleanValue());
                                    }
                                });
                            }
                        };
                    } else if (b == 2) {
                        constraintMatcherCreateSelectMatcher = createSelectMatcher(parseUser, obj2, str);
                    } else if (b != 3) {
                        constraintMatcherCreateSelectMatcher = new ConstraintMatcher<T>(this, parseUser) { // from class: com.parse.OfflineQueryLogic.17
                            /* JADX WARN: Incorrect types in method signature: (TT;Lcom/parse/ParseSQLiteDatabase;)Lފ/ރ<Ljava/lang/Boolean;>; */
                            @Override // com.parse.OfflineQueryLogic.ConstraintMatcher
                            public C2742 matchesAsync(ParseObject parseObject, ParseSQLiteDatabase parseSQLiteDatabase) {
                                try {
                                    return C2742.m4805(Boolean.valueOf(OfflineQueryLogic.access$500(str2, obj2, OfflineQueryLogic.access$100(parseObject, str), keyConstraints)));
                                } catch (ParseException e) {
                                    return C2742.m4804((Exception) e);
                                }
                            }
                        };
                    } else {
                        final ConstraintMatcher<T> constraintMatcherCreateSelectMatcher2 = createSelectMatcher(parseUser, obj2, str);
                        constraintMatcherCreateSelectMatcher = new ConstraintMatcher<T>(this, parseUser) { // from class: com.parse.OfflineQueryLogic.16
                            /* JADX WARN: Incorrect types in method signature: (TT;Lcom/parse/ParseSQLiteDatabase;)Lފ/ރ<Ljava/lang/Boolean;>; */
                            @Override // com.parse.OfflineQueryLogic.ConstraintMatcher
                            public C2742 matchesAsync(ParseObject parseObject, ParseSQLiteDatabase parseSQLiteDatabase) {
                                return constraintMatcherCreateSelectMatcher2.matchesAsync(parseObject, parseSQLiteDatabase).m4816(new InterfaceC2741<Boolean, Boolean>(this) { // from class: com.parse.OfflineQueryLogic.16.1
                                    @Override // p137.InterfaceC2741
                                    public Boolean then(C2742<Boolean> c2742) {
                                        return Boolean.valueOf(!c2742.m4812().booleanValue());
                                    }
                                });
                            }
                        };
                    }
                    arrayList.add(constraintMatcherCreateSelectMatcher);
                }
            } else if (obj instanceof ParseQuery.RelationConstraint) {
                final ParseQuery.RelationConstraint relationConstraint = (ParseQuery.RelationConstraint) obj;
                arrayList.add(new ConstraintMatcher<T>(this, parseUser) { // from class: com.parse.OfflineQueryLogic.19
                    /* JADX WARN: Incorrect types in method signature: (TT;Lcom/parse/ParseSQLiteDatabase;)Lފ/ރ<Ljava/lang/Boolean;>; */
                    @Override // com.parse.OfflineQueryLogic.ConstraintMatcher
                    public C2742 matchesAsync(ParseObject parseObject, ParseSQLiteDatabase parseSQLiteDatabase) {
                        if (relationConstraint != null) {
                            throw null;
                        }
                        throw null;
                    }
                });
            } else {
                arrayList.add(new ConstraintMatcher<T>(this, parseUser) { // from class: com.parse.OfflineQueryLogic.20
                    /* JADX WARN: Incorrect types in method signature: (TT;Lcom/parse/ParseSQLiteDatabase;)Lފ/ރ<Ljava/lang/Boolean;>; */
                    @Override // com.parse.OfflineQueryLogic.ConstraintMatcher
                    public C2742 matchesAsync(ParseObject parseObject, ParseSQLiteDatabase parseSQLiteDatabase) {
                        try {
                            return C2742.m4805(Boolean.valueOf(OfflineQueryLogic.matchesEqualConstraint(obj, OfflineQueryLogic.access$100(parseObject, str))));
                        } catch (ParseException e) {
                            return C2742.m4804((Exception) e);
                        }
                    }
                });
            }
        }
        return (ConstraintMatcher<T>) new ConstraintMatcher<T>(this, parseUser) { // from class: com.parse.OfflineQueryLogic.21
            /* JADX WARN: Incorrect types in method signature: (TT;Lcom/parse/ParseSQLiteDatabase;)Lފ/ރ<Ljava/lang/Boolean;>; */
            @Override // com.parse.OfflineQueryLogic.ConstraintMatcher
            public C2742 matchesAsync(final ParseObject parseObject, final ParseSQLiteDatabase parseSQLiteDatabase) {
                C2742 c2742M4805 = C2742.m4805(true);
                for (final ConstraintMatcher constraintMatcher2 : arrayList) {
                    c2742M4805 = c2742M4805.m4817(new InterfaceC2741<Boolean, C2742<Boolean>>(this) { // from class: com.parse.OfflineQueryLogic.21.1
                        @Override // p137.InterfaceC2741
                        public C2742<Boolean> then(C2742<Boolean> c2742) {
                            return !c2742.m4812().booleanValue() ? c2742 : constraintMatcher2.matchesAsync(parseObject, parseSQLiteDatabase);
                        }
                    }, C2742.f8455);
                }
                return c2742M4805;
            }
        };
    }

    public final <T extends ParseObject> ConstraintMatcher<T> createSelectMatcher(ParseUser parseUser, Object obj, final String str) {
        Map map = (Map) obj;
        ParseQuery.State<T> stateBuild = ((ParseQuery.State.Builder) map.get("query")).build();
        final String str2 = (String) map.get("key");
        return new SubQueryMatcher<T>(this, parseUser, stateBuild) { // from class: com.parse.OfflineQueryLogic.15
            /* JADX WARN: Incorrect types in method signature: (TT;Ljava/util/List<TT;>;)Z */
            @Override // com.parse.OfflineQueryLogic.SubQueryMatcher
            public boolean matches(ParseObject parseObject, List list) {
                Object objAccess$100 = OfflineQueryLogic.access$100(parseObject, str);
                Iterator it = list.iterator();
                while (it.hasNext()) {
                    if (OfflineQueryLogic.matchesEqualConstraint(objAccess$100, OfflineQueryLogic.access$100((ParseObject) it.next(), str2))) {
                        return true;
                    }
                }
                return false;
            }
        };
    }
}