package com.google.firebase.firestore.local;

import c4.C1241a;
import c4.C1243c;
import c4.C1245e;
import c4.C1247g;
import c4.EnumC1244d;
import com.google.firebase.Timestamp;
import com.google.firebase.firestore.bundle.BundledQuery;
import com.google.firebase.firestore.core.Query;
import com.google.firebase.firestore.model.Document;
import com.google.firebase.firestore.model.FieldIndex;
import com.google.firebase.firestore.model.FieldPath;
import com.google.firebase.firestore.model.MutableDocument;
import com.google.firebase.firestore.model.ObjectValue;
import com.google.firebase.firestore.model.SnapshotVersion;
import com.google.firebase.firestore.model.mutation.Mutation;
import com.google.firebase.firestore.model.mutation.MutationBatch;
import com.google.firebase.firestore.proto.MaybeDocument;
import com.google.firebase.firestore.proto.NoDocument;
import com.google.firebase.firestore.proto.Target;
import com.google.firebase.firestore.proto.UnknownDocument;
import com.google.firebase.firestore.proto.WriteBatch;
import com.google.firebase.firestore.remote.RemoteSerializer;
import com.google.firebase.firestore.util.Assert;
import com.google.protobuf.AbstractC1320n;
import d4.C1945a;
import d4.EnumC1946b;
import e4.C1999p;
import e4.C2010z;
import e4.I0;
import e4.K0;
import e4.z0;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import m1.AbstractC2464a;

/* JADX INFO: loaded from: classes3.dex */
public final class LocalSerializer {
    private final RemoteSerializer rpcSerializer;

    /* JADX INFO: renamed from: com.google.firebase.firestore.local.LocalSerializer$1, reason: invalid class name */
    public static /* synthetic */ class AnonymousClass1 {
        static final /* synthetic */ int[] $SwitchMap$com$google$firebase$firestore$proto$MaybeDocument$DocumentTypeCase;
        static final /* synthetic */ int[] $SwitchMap$com$google$firebase$firestore$proto$Target$TargetTypeCase;

        static {
            int[] iArr = new int[Target.TargetTypeCase.values().length];
            $SwitchMap$com$google$firebase$firestore$proto$Target$TargetTypeCase = iArr;
            try {
                iArr[Target.TargetTypeCase.DOCUMENTS.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$com$google$firebase$firestore$proto$Target$TargetTypeCase[Target.TargetTypeCase.QUERY.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            int[] iArr2 = new int[MaybeDocument.DocumentTypeCase.values().length];
            $SwitchMap$com$google$firebase$firestore$proto$MaybeDocument$DocumentTypeCase = iArr2;
            try {
                iArr2[MaybeDocument.DocumentTypeCase.DOCUMENT.ordinal()] = 1;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                $SwitchMap$com$google$firebase$firestore$proto$MaybeDocument$DocumentTypeCase[MaybeDocument.DocumentTypeCase.NO_DOCUMENT.ordinal()] = 2;
            } catch (NoSuchFieldError unused4) {
            }
            try {
                $SwitchMap$com$google$firebase$firestore$proto$MaybeDocument$DocumentTypeCase[MaybeDocument.DocumentTypeCase.UNKNOWN_DOCUMENT.ordinal()] = 3;
            } catch (NoSuchFieldError unused5) {
            }
        }
    }

    public LocalSerializer(RemoteSerializer remoteSerializer) {
        this.rpcSerializer = remoteSerializer;
    }

    private MutableDocument decodeDocument(e4.r rVar, boolean z6) {
        MutableDocument mutableDocumentNewFoundDocument = MutableDocument.newFoundDocument(this.rpcSerializer.decodeKey(rVar.getName()), this.rpcSerializer.decodeVersion(rVar.k()), ObjectValue.fromMap(rVar.j()));
        return z6 ? mutableDocumentNewFoundDocument.setHasCommittedMutations() : mutableDocumentNewFoundDocument;
    }

    private MutableDocument decodeNoDocument(NoDocument noDocument, boolean z6) {
        MutableDocument mutableDocumentNewNoDocument = MutableDocument.newNoDocument(this.rpcSerializer.decodeKey(noDocument.getName()), this.rpcSerializer.decodeVersion(noDocument.getReadTime()));
        return z6 ? mutableDocumentNewNoDocument.setHasCommittedMutations() : mutableDocumentNewNoDocument;
    }

    private MutableDocument decodeUnknownDocument(UnknownDocument unknownDocument) {
        return MutableDocument.newUnknownDocument(this.rpcSerializer.decodeKey(unknownDocument.getName()), this.rpcSerializer.decodeVersion(unknownDocument.getVersion()));
    }

    private e4.r encodeDocument(Document document) {
        C1999p c1999pL = e4.r.l();
        c1999pL.d(this.rpcSerializer.encodeKey(document.getKey()));
        c1999pL.c(document.getData().getFieldsMap());
        c1999pL.e(this.rpcSerializer.encodeTimestamp(document.getVersion().getTimestamp()));
        return (e4.r) c1999pL.m359build();
    }

    private NoDocument encodeNoDocument(Document document) {
        NoDocument.Builder builderNewBuilder = NoDocument.newBuilder();
        builderNewBuilder.setName(this.rpcSerializer.encodeKey(document.getKey()));
        builderNewBuilder.setReadTime(this.rpcSerializer.encodeTimestamp(document.getVersion().getTimestamp()));
        return (NoDocument) builderNewBuilder.m359build();
    }

    private UnknownDocument encodeUnknownDocument(Document document) {
        UnknownDocument.Builder builderNewBuilder = UnknownDocument.newBuilder();
        builderNewBuilder.setName(this.rpcSerializer.encodeKey(document.getKey()));
        builderNewBuilder.setVersion(this.rpcSerializer.encodeTimestamp(document.getVersion().getTimestamp()));
        return (UnknownDocument) builderNewBuilder.m359build();
    }

    public BundledQuery decodeBundledQuery(d4.c cVar) {
        return new BundledQuery(this.rpcSerializer.decodeQueryTarget(cVar.j(), cVar.k()), cVar.i().equals(EnumC1946b.FIRST) ? Query.LimitType.LIMIT_TO_FIRST : Query.LimitType.LIMIT_TO_LAST);
    }

    public List<FieldIndex.Segment> decodeFieldIndexSegments(C1247g c1247g) {
        ArrayList arrayList = new ArrayList();
        for (C1245e c1245e : c1247g.h()) {
            arrayList.add(FieldIndex.Segment.create(FieldPath.fromServerFormat(c1245e.i()), AbstractC2464a.a(c1245e.k(), 2) ? FieldIndex.Segment.Kind.CONTAINS : c1245e.j().equals(EnumC1244d.ASCENDING) ? FieldIndex.Segment.Kind.ASCENDING : FieldIndex.Segment.Kind.DESCENDING));
        }
        return arrayList;
    }

    public MutableDocument decodeMaybeDocument(MaybeDocument maybeDocument) {
        int i6 = AnonymousClass1.$SwitchMap$com$google$firebase$firestore$proto$MaybeDocument$DocumentTypeCase[maybeDocument.getDocumentTypeCase().ordinal()];
        if (i6 == 1) {
            return decodeDocument(maybeDocument.getDocument(), maybeDocument.getHasCommittedMutations());
        }
        if (i6 == 2) {
            return decodeNoDocument(maybeDocument.getNoDocument(), maybeDocument.getHasCommittedMutations());
        }
        if (i6 == 3) {
            return decodeUnknownDocument(maybeDocument.getUnknownDocument());
        }
        throw Assert.fail("Unknown MaybeDocument %s", maybeDocument);
    }

    public Mutation decodeMutation(K0 k02) {
        return this.rpcSerializer.decodeMutation(k02);
    }

    public MutationBatch decodeMutationBatch(WriteBatch writeBatch) {
        int batchId = writeBatch.getBatchId();
        Timestamp timestampDecodeTimestamp = this.rpcSerializer.decodeTimestamp(writeBatch.getLocalWriteTime());
        int baseWritesCount = writeBatch.getBaseWritesCount();
        ArrayList arrayList = new ArrayList(baseWritesCount);
        for (int i6 = 0; i6 < baseWritesCount; i6++) {
            arrayList.add(this.rpcSerializer.decodeMutation(writeBatch.getBaseWrites(i6)));
        }
        ArrayList arrayList2 = new ArrayList(writeBatch.getWritesCount());
        int i7 = 0;
        while (i7 < writeBatch.getWritesCount()) {
            K0 writes = writeBatch.getWrites(i7);
            int i8 = i7 + 1;
            if (i8 >= writeBatch.getWritesCount() || !writeBatch.getWrites(i8).u()) {
                arrayList2.add(this.rpcSerializer.decodeMutation(writes));
            } else {
                Assert.hardAssert(writeBatch.getWrites(i7).v(), "TransformMutation should be preceded by a patch or set mutation", new Object[0]);
                I0 i0Y = K0.y(writes);
                Iterator it = writeBatch.getWrites(i8).o().g().iterator();
                while (it.hasNext()) {
                    i0Y.c((C2010z) it.next());
                }
                arrayList2.add(this.rpcSerializer.decodeMutation((K0) i0Y.m359build()));
                i7 = i8;
            }
            i7++;
        }
        return new MutationBatch(batchId, timestampDecodeTimestamp, arrayList, arrayList2);
    }

    public TargetData decodeTargetData(Target target) {
        com.google.firebase.firestore.core.Target targetDecodeDocumentsTarget;
        int targetId = target.getTargetId();
        SnapshotVersion snapshotVersionDecodeVersion = this.rpcSerializer.decodeVersion(target.getSnapshotVersion());
        SnapshotVersion snapshotVersionDecodeVersion2 = this.rpcSerializer.decodeVersion(target.getLastLimboFreeSnapshotVersion());
        AbstractC1320n resumeToken = target.getResumeToken();
        long lastListenSequenceNumber = target.getLastListenSequenceNumber();
        int i6 = AnonymousClass1.$SwitchMap$com$google$firebase$firestore$proto$Target$TargetTypeCase[target.getTargetTypeCase().ordinal()];
        if (i6 == 1) {
            targetDecodeDocumentsTarget = this.rpcSerializer.decodeDocumentsTarget(target.getDocuments());
        } else {
            if (i6 != 2) {
                throw Assert.fail("Unknown targetType %d", target.getTargetTypeCase());
            }
            targetDecodeDocumentsTarget = this.rpcSerializer.decodeQueryTarget(target.getQuery());
        }
        return new TargetData(targetDecodeDocumentsTarget, targetId, lastListenSequenceNumber, QueryPurpose.LISTEN, snapshotVersionDecodeVersion, snapshotVersionDecodeVersion2, resumeToken, null);
    }

    public d4.c encodeBundledQuery(BundledQuery bundledQuery) {
        z0 z0VarEncodeQueryTarget = this.rpcSerializer.encodeQueryTarget(bundledQuery.getTarget());
        C1945a c1945aL = d4.c.l();
        c1945aL.c(bundledQuery.getLimitType().equals(Query.LimitType.LIMIT_TO_FIRST) ? EnumC1946b.FIRST : EnumC1946b.LAST);
        c1945aL.d(z0VarEncodeQueryTarget.i());
        c1945aL.e(z0VarEncodeQueryTarget.j());
        return (d4.c) c1945aL.m359build();
    }

    public C1247g encodeFieldIndexSegments(List<FieldIndex.Segment> list) {
        C1241a c1241aI = C1247g.i();
        c1241aI.d();
        for (FieldIndex.Segment segment : list) {
            C1243c c1243cL = C1245e.l();
            c1243cL.d(segment.getFieldPath().canonicalString());
            if (segment.getKind() == FieldIndex.Segment.Kind.CONTAINS) {
                c1243cL.c();
            } else if (segment.getKind() == FieldIndex.Segment.Kind.ASCENDING) {
                c1243cL.e(EnumC1244d.ASCENDING);
            } else {
                c1243cL.e(EnumC1244d.DESCENDING);
            }
            c1241aI.c(c1243cL);
        }
        return (C1247g) c1241aI.m359build();
    }

    public MaybeDocument encodeMaybeDocument(Document document) {
        MaybeDocument.Builder builderNewBuilder = MaybeDocument.newBuilder();
        if (document.isNoDocument()) {
            builderNewBuilder.setNoDocument(encodeNoDocument(document));
        } else if (document.isFoundDocument()) {
            builderNewBuilder.setDocument(encodeDocument(document));
        } else {
            if (!document.isUnknownDocument()) {
                throw Assert.fail("Cannot encode invalid document %s", document);
            }
            builderNewBuilder.setUnknownDocument(encodeUnknownDocument(document));
        }
        builderNewBuilder.setHasCommittedMutations(document.hasCommittedMutations());
        return (MaybeDocument) builderNewBuilder.m359build();
    }

    public K0 encodeMutation(Mutation mutation) {
        return this.rpcSerializer.encodeMutation(mutation);
    }

    public WriteBatch encodeMutationBatch(MutationBatch mutationBatch) {
        WriteBatch.Builder builderNewBuilder = WriteBatch.newBuilder();
        builderNewBuilder.setBatchId(mutationBatch.getBatchId());
        builderNewBuilder.setLocalWriteTime(this.rpcSerializer.encodeTimestamp(mutationBatch.getLocalWriteTime()));
        Iterator<Mutation> it = mutationBatch.getBaseMutations().iterator();
        while (it.hasNext()) {
            builderNewBuilder.addBaseWrites(this.rpcSerializer.encodeMutation(it.next()));
        }
        Iterator<Mutation> it2 = mutationBatch.getMutations().iterator();
        while (it2.hasNext()) {
            builderNewBuilder.addWrites(this.rpcSerializer.encodeMutation(it2.next()));
        }
        return (WriteBatch) builderNewBuilder.m359build();
    }

    public Target encodeTargetData(TargetData targetData) {
        QueryPurpose queryPurpose = QueryPurpose.LISTEN;
        Assert.hardAssert(queryPurpose.equals(targetData.getPurpose()), "Only queries with purpose %s may be stored, got %s", queryPurpose, targetData.getPurpose());
        Target.Builder builderNewBuilder = Target.newBuilder();
        builderNewBuilder.setTargetId(targetData.getTargetId()).setLastListenSequenceNumber(targetData.getSequenceNumber()).setLastLimboFreeSnapshotVersion(this.rpcSerializer.encodeVersion(targetData.getLastLimboFreeSnapshotVersion())).setSnapshotVersion(this.rpcSerializer.encodeVersion(targetData.getSnapshotVersion())).setResumeToken(targetData.getResumeToken());
        com.google.firebase.firestore.core.Target target = targetData.getTarget();
        if (target.isDocumentQuery()) {
            builderNewBuilder.setDocuments(this.rpcSerializer.encodeDocumentsTarget(target));
        } else {
            builderNewBuilder.setQuery(this.rpcSerializer.encodeQueryTarget(target));
        }
        return (Target) builderNewBuilder.m359build();
    }
}