package com.google.firebase.firestore;

import com.google.firebase.Timestamp;
import com.google.firebase.firestore.FieldValue;
import com.google.firebase.firestore.core.UserData;
import com.google.firebase.firestore.model.DatabaseId;
import com.google.firebase.firestore.model.ObjectValue;
import com.google.firebase.firestore.model.Values;
import com.google.firebase.firestore.model.mutation.ArrayTransformOperation;
import com.google.firebase.firestore.model.mutation.FieldMask;
import com.google.firebase.firestore.model.mutation.NumericIncrementTransformOperation;
import com.google.firebase.firestore.model.mutation.ServerTimestampOperation;
import com.google.firebase.firestore.util.Assert;
import com.google.firebase.firestore.util.CustomClassMapper;
import com.google.firebase.firestore.util.Preconditions;
import com.google.firebase.firestore.util.Util;
import com.google.firebase.sessions.settings.RemoteSettings;
import com.google.protobuf.Q0;
import com.google.protobuf.R0;
import e4.C1973c;
import e4.C1975d;
import e4.G0;
import e4.H;
import e4.H0;
import e4.J;
import i4.C2281a;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import q.AbstractC2761L;

/* JADX INFO: loaded from: classes3.dex */
public final class UserDataReader {
    private final DatabaseId databaseId;

    public UserDataReader(DatabaseId databaseId) {
        this.databaseId = databaseId;
    }

    private ObjectValue convertAndParseDocumentData(Object obj, UserData.ParseContext parseContext) {
        if (obj.getClass().isArray()) {
            throw new IllegalArgumentException("Invalid data. Data must be a Map<String, Object> or a suitable POJO object, but it was an array");
        }
        H0 data = parseData(CustomClassMapper.convertToPlainJavaTypes(obj), parseContext);
        if (data.B() == 11) {
            return new ObjectValue(data);
        }
        throw new IllegalArgumentException("Invalid data. Data must be a Map<String, Object> or a suitable POJO object, but it was of type: " + Util.typeName(obj));
    }

    private List<H0> parseArrayTransformElements(List<Object> list) {
        UserData.ParseAccumulator parseAccumulator = new UserData.ParseAccumulator(UserData.Source.Argument);
        ArrayList arrayList = new ArrayList(list.size());
        for (int i6 = 0; i6 < list.size(); i6++) {
            arrayList.add(convertAndParseFieldData(list.get(i6), parseAccumulator.rootContext().childContext(i6)));
        }
        return arrayList;
    }

    private H0 parseData(Object obj, UserData.ParseContext parseContext) {
        if (obj instanceof Map) {
            return parseMap((Map) obj, parseContext);
        }
        if (obj instanceof FieldValue) {
            parseSentinelFieldValue((FieldValue) obj, parseContext);
            return null;
        }
        if (parseContext.getPath() != null) {
            parseContext.addToFieldMask(parseContext.getPath());
        }
        if (!(obj instanceof List)) {
            return parseScalarValue(obj, parseContext);
        }
        if (!parseContext.isArrayElement() || parseContext.getDataSource() == UserData.Source.ArrayArgument) {
            return parseList((List) obj, parseContext);
        }
        throw parseContext.createError("Nested arrays are not supported");
    }

    private <T> H0 parseList(List<T> list, UserData.ParseContext parseContext) {
        C1973c c1973cL = C1975d.l();
        Iterator<T> it = list.iterator();
        int i6 = 0;
        while (it.hasNext()) {
            H0 data = parseData(it.next(), parseContext.childContext(i6));
            if (data == null) {
                G0 g0C = H0.C();
                g0C.n();
                data = (H0) g0C.m359build();
            }
            c1973cL.d(data);
            i6++;
        }
        G0 g0C2 = H0.C();
        g0C2.d(c1973cL);
        return (H0) g0C2.m359build();
    }

    private <K, V> H0 parseMap(Map<K, V> map, UserData.ParseContext parseContext) {
        if (map.isEmpty()) {
            if (parseContext.getPath() != null && !parseContext.getPath().isEmpty()) {
                parseContext.addToFieldMask(parseContext.getPath());
            }
            G0 g0C = H0.C();
            g0C.m(J.g());
            return (H0) g0C.m359build();
        }
        H hL = J.l();
        for (Map.Entry<K, V> entry : map.entrySet()) {
            if (!(entry.getKey() instanceof String)) {
                throw parseContext.createError(String.format("Non-String Map key (%s) is not allowed", entry.getValue()));
            }
            String str = (String) entry.getKey();
            H0 data = parseData(entry.getValue(), parseContext.childContext(str));
            if (data != null) {
                hL.e(data, str);
            }
        }
        G0 g0C2 = H0.C();
        g0C2.l(hL);
        return (H0) g0C2.m359build();
    }

    private H0 parseScalarValue(Object obj, UserData.ParseContext parseContext) {
        if (obj == null) {
            G0 g0C = H0.C();
            g0C.n();
            return (H0) g0C.m359build();
        }
        if (obj instanceof Integer) {
            G0 g0C2 = H0.C();
            g0C2.k(((Integer) obj).intValue());
            return (H0) g0C2.m359build();
        }
        if (obj instanceof Long) {
            G0 g0C3 = H0.C();
            g0C3.k(((Long) obj).longValue());
            return (H0) g0C3.m359build();
        }
        if (obj instanceof Float) {
            G0 g0C4 = H0.C();
            g0C4.i(((Float) obj).doubleValue());
            return (H0) g0C4.m359build();
        }
        if (obj instanceof Double) {
            G0 g0C5 = H0.C();
            g0C5.i(((Double) obj).doubleValue());
            return (H0) g0C5.m359build();
        }
        if (obj instanceof Boolean) {
            G0 g0C6 = H0.C();
            g0C6.f(((Boolean) obj).booleanValue());
            return (H0) g0C6.m359build();
        }
        if (obj instanceof String) {
            G0 g0C7 = H0.C();
            g0C7.p((String) obj);
            return (H0) g0C7.m359build();
        }
        if (obj instanceof Date) {
            return parseTimestamp(new Timestamp((Date) obj));
        }
        if (obj instanceof Timestamp) {
            return parseTimestamp((Timestamp) obj);
        }
        if (obj instanceof GeoPoint) {
            GeoPoint geoPoint = (GeoPoint) obj;
            G0 g0C8 = H0.C();
            C2281a c2281aK = i4.b.k();
            c2281aK.c(geoPoint.getLatitude());
            c2281aK.d(geoPoint.getLongitude());
            g0C8.j(c2281aK);
            return (H0) g0C8.m359build();
        }
        if (obj instanceof Blob) {
            G0 g0C9 = H0.C();
            g0C9.h(((Blob) obj).toByteString());
            return (H0) g0C9.m359build();
        }
        if (!(obj instanceof DocumentReference)) {
            if (obj instanceof VectorValue) {
                return parseVectorValue((VectorValue) obj, parseContext);
            }
            if (obj.getClass().isArray()) {
                throw parseContext.createError("Arrays are not supported; use a List instead");
            }
            throw parseContext.createError("Unsupported type: " + Util.typeName(obj));
        }
        DocumentReference documentReference = (DocumentReference) obj;
        if (documentReference.getFirestore() != null) {
            DatabaseId databaseId = documentReference.getFirestore().getDatabaseId();
            if (!databaseId.equals(this.databaseId)) {
                String projectId = databaseId.getProjectId();
                String databaseId2 = databaseId.getDatabaseId();
                String projectId2 = this.databaseId.getProjectId();
                String databaseId3 = this.databaseId.getDatabaseId();
                StringBuilder sbI = AbstractC2761L.i("Document reference is for database ", projectId, RemoteSettings.FORWARD_SLASH_STRING, databaseId2, " but should be for database ");
                sbI.append(projectId2);
                sbI.append(RemoteSettings.FORWARD_SLASH_STRING);
                sbI.append(databaseId3);
                throw parseContext.createError(sbI.toString());
            }
        }
        G0 g0C10 = H0.C();
        String projectId3 = this.databaseId.getProjectId();
        String databaseId4 = this.databaseId.getDatabaseId();
        String path = documentReference.getPath();
        StringBuilder sbI2 = AbstractC2761L.i("projects/", projectId3, "/databases/", databaseId4, "/documents/");
        sbI2.append(path);
        g0C10.o(sbI2.toString());
        return (H0) g0C10.m359build();
    }

    private void parseSentinelFieldValue(FieldValue fieldValue, UserData.ParseContext parseContext) {
        if (!parseContext.isWrite()) {
            throw parseContext.createError(fieldValue.getMethodName() + "() can only be used with set() and update()");
        }
        if (parseContext.getPath() == null) {
            throw parseContext.createError(fieldValue.getMethodName() + "() is not currently supported inside arrays");
        }
        if (fieldValue instanceof FieldValue.DeleteFieldValue) {
            if (parseContext.getDataSource() == UserData.Source.MergeSet) {
                parseContext.addToFieldMask(parseContext.getPath());
                return;
            } else {
                if (parseContext.getDataSource() != UserData.Source.Update) {
                    throw parseContext.createError("FieldValue.delete() can only be used with update() and set() with SetOptions.merge()");
                }
                Assert.hardAssert(parseContext.getPath().length() > 0, "FieldValue.delete() at the top level should have already been handled.", new Object[0]);
                throw parseContext.createError("FieldValue.delete() can only appear at the top level of your update data");
            }
        }
        if (fieldValue instanceof FieldValue.ServerTimestampFieldValue) {
            parseContext.addToFieldTransforms(parseContext.getPath(), ServerTimestampOperation.getInstance());
            return;
        }
        if (fieldValue instanceof FieldValue.ArrayUnionFieldValue) {
            parseContext.addToFieldTransforms(parseContext.getPath(), new ArrayTransformOperation.Union(parseArrayTransformElements(((FieldValue.ArrayUnionFieldValue) fieldValue).getElements())));
        } else if (fieldValue instanceof FieldValue.ArrayRemoveFieldValue) {
            parseContext.addToFieldTransforms(parseContext.getPath(), new ArrayTransformOperation.Remove(parseArrayTransformElements(((FieldValue.ArrayRemoveFieldValue) fieldValue).getElements())));
        } else {
            if (!(fieldValue instanceof FieldValue.NumericIncrementFieldValue)) {
                throw Assert.fail("Unknown FieldValue type: %s", Util.typeName(fieldValue));
            }
            parseContext.addToFieldTransforms(parseContext.getPath(), new NumericIncrementTransformOperation(parseQueryValue(((FieldValue.NumericIncrementFieldValue) fieldValue).getOperand())));
        }
    }

    private H0 parseTimestamp(Timestamp timestamp) {
        int nanoseconds = (timestamp.getNanoseconds() / 1000) * 1000;
        G0 g0C = H0.C();
        Q0 q0K = R0.k();
        q0K.d(timestamp.getSeconds());
        q0K.c(nanoseconds);
        g0C.q(q0K);
        return (H0) g0C.m359build();
    }

    private H0 parseVectorValue(VectorValue vectorValue, UserData.ParseContext parseContext) {
        H hL = J.l();
        hL.e(Values.VECTOR_VALUE_TYPE, Values.TYPE_KEY);
        hL.e(parseData(vectorValue.toList(), parseContext), "value");
        G0 g0C = H0.C();
        g0C.l(hL);
        return (H0) g0C.m359build();
    }

    public H0 convertAndParseFieldData(Object obj, UserData.ParseContext parseContext) {
        return parseData(CustomClassMapper.convertToPlainJavaTypes(obj), parseContext);
    }

    public UserData.ParsedSetData parseMergeData(Object obj, FieldMask fieldMask) {
        UserData.ParseAccumulator parseAccumulator = new UserData.ParseAccumulator(UserData.Source.MergeSet);
        ObjectValue objectValueConvertAndParseDocumentData = convertAndParseDocumentData(obj, parseAccumulator.rootContext());
        if (fieldMask == null) {
            return parseAccumulator.toMergeData(objectValueConvertAndParseDocumentData);
        }
        for (com.google.firebase.firestore.model.FieldPath fieldPath : fieldMask.getMask()) {
            if (!parseAccumulator.contains(fieldPath)) {
                throw new IllegalArgumentException("Field '" + fieldPath.toString() + "' is specified in your field mask but not in your input data.");
            }
        }
        return parseAccumulator.toMergeData(objectValueConvertAndParseDocumentData, fieldMask);
    }

    public H0 parseQueryValue(Object obj) {
        return parseQueryValue(obj, false);
    }

    public UserData.ParsedSetData parseSetData(Object obj) {
        UserData.ParseAccumulator parseAccumulator = new UserData.ParseAccumulator(UserData.Source.Set);
        return parseAccumulator.toSetData(convertAndParseDocumentData(obj, parseAccumulator.rootContext()));
    }

    public UserData.ParsedUpdateData parseUpdateData(Map<String, Object> map) {
        Preconditions.checkNotNull(map, "Provided update data must not be null.");
        UserData.ParseAccumulator parseAccumulator = new UserData.ParseAccumulator(UserData.Source.Update);
        UserData.ParseContext parseContextRootContext = parseAccumulator.rootContext();
        ObjectValue objectValue = new ObjectValue();
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            com.google.firebase.firestore.model.FieldPath internalPath = FieldPath.fromDotSeparatedPath(entry.getKey()).getInternalPath();
            Object value = entry.getValue();
            if (value instanceof FieldValue.DeleteFieldValue) {
                parseContextRootContext.addToFieldMask(internalPath);
            } else {
                H0 h0ConvertAndParseFieldData = convertAndParseFieldData(value, parseContextRootContext.childContext(internalPath));
                if (h0ConvertAndParseFieldData != null) {
                    parseContextRootContext.addToFieldMask(internalPath);
                    objectValue.set(internalPath, h0ConvertAndParseFieldData);
                }
            }
        }
        return parseAccumulator.toUpdateData(objectValue);
    }

    public H0 parseQueryValue(Object obj, boolean z6) {
        UserData.ParseAccumulator parseAccumulator = new UserData.ParseAccumulator(z6 ? UserData.Source.ArrayArgument : UserData.Source.Argument);
        H0 h0ConvertAndParseFieldData = convertAndParseFieldData(obj, parseAccumulator.rootContext());
        Assert.hardAssert(h0ConvertAndParseFieldData != null, "Parsed data should not be null.", new Object[0]);
        Assert.hardAssert(parseAccumulator.getFieldTransforms().isEmpty(), "Field transforms should have been disallowed.", new Object[0]);
        return h0ConvertAndParseFieldData;
    }

    public UserData.ParsedUpdateData parseUpdateData(List<Object> list) {
        com.google.firebase.firestore.model.FieldPath internalPath;
        Assert.hardAssert(list.size() % 2 == 0, "Expected fieldAndValues to contain an even number of elements", new Object[0]);
        UserData.ParseAccumulator parseAccumulator = new UserData.ParseAccumulator(UserData.Source.Update);
        UserData.ParseContext parseContextRootContext = parseAccumulator.rootContext();
        ObjectValue objectValue = new ObjectValue();
        Iterator<Object> it = list.iterator();
        while (it.hasNext()) {
            Object next = it.next();
            Object next2 = it.next();
            boolean z6 = next instanceof String;
            Assert.hardAssert(z6 || (next instanceof FieldPath), "Expected argument to be String or FieldPath.", new Object[0]);
            if (z6) {
                internalPath = FieldPath.fromDotSeparatedPath((String) next).getInternalPath();
            } else {
                internalPath = ((FieldPath) next).getInternalPath();
            }
            if (next2 instanceof FieldValue.DeleteFieldValue) {
                parseContextRootContext.addToFieldMask(internalPath);
            } else {
                H0 h0ConvertAndParseFieldData = convertAndParseFieldData(next2, parseContextRootContext.childContext(internalPath));
                if (h0ConvertAndParseFieldData != null) {
                    parseContextRootContext.addToFieldMask(internalPath);
                    objectValue.set(internalPath, h0ConvertAndParseFieldData);
                }
            }
        }
        return parseAccumulator.toUpdateData(objectValue);
    }
}