package com.google.firebase.firestore.index;

import com.google.android.recaptcha.internal.a;
import com.google.firebase.firestore.model.ResourcePath;
import com.google.firebase.firestore.model.Values;
import com.google.protobuf.R0;
import e4.C1975d;
import e4.H0;
import e4.J;
import i4.b;
import java.util.Iterator;
import java.util.Map;
import m1.AbstractC2464a;

/* JADX INFO: loaded from: classes3.dex */
public class FirestoreIndexValueWriter {
    public static final int DOCUMENT_NAME_OFFSET = 5;
    public static final int INDEX_TYPE_ARRAY = 50;
    public static final int INDEX_TYPE_BLOB = 30;
    public static final int INDEX_TYPE_BOOLEAN = 10;
    public static final int INDEX_TYPE_GEOPOINT = 45;
    public static final int INDEX_TYPE_MAP = 55;
    public static final int INDEX_TYPE_NAN = 13;
    public static final int INDEX_TYPE_NULL = 5;
    public static final int INDEX_TYPE_NUMBER = 15;
    public static final int INDEX_TYPE_REFERENCE = 37;
    public static final int INDEX_TYPE_REFERENCE_SEGMENT = 60;
    public static final int INDEX_TYPE_STRING = 25;
    public static final int INDEX_TYPE_TIMESTAMP = 20;
    public static final int INDEX_TYPE_VECTOR = 53;
    public static final FirestoreIndexValueWriter INSTANCE = new FirestoreIndexValueWriter();
    public static final int NOT_TRUNCATED = 2;

    /* JADX INFO: renamed from: com.google.firebase.firestore.index.FirestoreIndexValueWriter$1, reason: invalid class name */
    public static /* synthetic */ class AnonymousClass1 {
        static final /* synthetic */ int[] $SwitchMap$com$google$firestore$v1$Value$ValueTypeCase;

        static {
            int[] iArr = new int[AbstractC2464a.d(12).length];
            $SwitchMap$com$google$firestore$v1$Value$ValueTypeCase = iArr;
            try {
                iArr[0] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$com$google$firestore$v1$Value$ValueTypeCase[1] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                $SwitchMap$com$google$firestore$v1$Value$ValueTypeCase[3] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                $SwitchMap$com$google$firestore$v1$Value$ValueTypeCase[2] = 4;
            } catch (NoSuchFieldError unused4) {
            }
            try {
                $SwitchMap$com$google$firestore$v1$Value$ValueTypeCase[4] = 5;
            } catch (NoSuchFieldError unused5) {
            }
            try {
                $SwitchMap$com$google$firestore$v1$Value$ValueTypeCase[5] = 6;
            } catch (NoSuchFieldError unused6) {
            }
            try {
                $SwitchMap$com$google$firestore$v1$Value$ValueTypeCase[6] = 7;
            } catch (NoSuchFieldError unused7) {
            }
            try {
                $SwitchMap$com$google$firestore$v1$Value$ValueTypeCase[7] = 8;
            } catch (NoSuchFieldError unused8) {
            }
            try {
                $SwitchMap$com$google$firestore$v1$Value$ValueTypeCase[8] = 9;
            } catch (NoSuchFieldError unused9) {
            }
            try {
                $SwitchMap$com$google$firestore$v1$Value$ValueTypeCase[10] = 10;
            } catch (NoSuchFieldError unused10) {
            }
            try {
                $SwitchMap$com$google$firestore$v1$Value$ValueTypeCase[9] = 11;
            } catch (NoSuchFieldError unused11) {
            }
        }
    }

    private FirestoreIndexValueWriter() {
    }

    private void writeIndexArray(C1975d c1975d, DirectionalIndexByteEncoder directionalIndexByteEncoder) {
        writeValueTypeLabel(directionalIndexByteEncoder, 50);
        Iterator it = c1975d.a().iterator();
        while (it.hasNext()) {
            writeIndexValueAux((H0) it.next(), directionalIndexByteEncoder);
        }
    }

    private void writeIndexEntityRef(String str, DirectionalIndexByteEncoder directionalIndexByteEncoder) {
        writeValueTypeLabel(directionalIndexByteEncoder, 37);
        ResourcePath resourcePathFromString = ResourcePath.fromString(str);
        int length = resourcePathFromString.length();
        for (int i6 = 5; i6 < length; i6++) {
            String segment = resourcePathFromString.getSegment(i6);
            writeValueTypeLabel(directionalIndexByteEncoder, 60);
            writeUnlabeledIndexString(segment, directionalIndexByteEncoder);
        }
    }

    private void writeIndexMap(J j4, DirectionalIndexByteEncoder directionalIndexByteEncoder) {
        writeValueTypeLabel(directionalIndexByteEncoder, 55);
        for (Map.Entry entry : j4.i().entrySet()) {
            String str = (String) entry.getKey();
            H0 h0 = (H0) entry.getValue();
            writeIndexString(str, directionalIndexByteEncoder);
            writeIndexValueAux(h0, directionalIndexByteEncoder);
        }
    }

    private void writeIndexString(String str, DirectionalIndexByteEncoder directionalIndexByteEncoder) {
        writeValueTypeLabel(directionalIndexByteEncoder, 25);
        writeUnlabeledIndexString(str, directionalIndexByteEncoder);
    }

    private void writeIndexValueAux(H0 h0, DirectionalIndexByteEncoder directionalIndexByteEncoder) {
        switch (AbstractC2464a.c(h0.B())) {
            case 0:
                writeValueTypeLabel(directionalIndexByteEncoder, 5);
                return;
            case 1:
                writeValueTypeLabel(directionalIndexByteEncoder, 10);
                directionalIndexByteEncoder.writeLong(h0.r() ? 1L : 0L);
                return;
            case 2:
                writeValueTypeLabel(directionalIndexByteEncoder, 15);
                directionalIndexByteEncoder.writeDouble(h0.w());
                return;
            case 3:
                double dU = h0.u();
                if (Double.isNaN(dU)) {
                    writeValueTypeLabel(directionalIndexByteEncoder, 13);
                    return;
                }
                writeValueTypeLabel(directionalIndexByteEncoder, 15);
                if (dU == -0.0d) {
                    directionalIndexByteEncoder.writeDouble(0.0d);
                    return;
                } else {
                    directionalIndexByteEncoder.writeDouble(dU);
                    return;
                }
            case 4:
                R0 r0A = h0.A();
                writeValueTypeLabel(directionalIndexByteEncoder, 20);
                directionalIndexByteEncoder.writeLong(r0A.j());
                directionalIndexByteEncoder.writeLong(r0A.i());
                return;
            case 5:
                writeIndexString(h0.z(), directionalIndexByteEncoder);
                writeTruncationMarker(directionalIndexByteEncoder);
                return;
            case 6:
                writeValueTypeLabel(directionalIndexByteEncoder, 30);
                directionalIndexByteEncoder.writeBytes(h0.s());
                writeTruncationMarker(directionalIndexByteEncoder);
                return;
            case 7:
                writeIndexEntityRef(h0.y(), directionalIndexByteEncoder);
                return;
            case 8:
                b bVarV = h0.v();
                writeValueTypeLabel(directionalIndexByteEncoder, 45);
                directionalIndexByteEncoder.writeDouble(bVarV.i());
                directionalIndexByteEncoder.writeDouble(bVarV.j());
                return;
            case 9:
                writeIndexArray(h0.q(), directionalIndexByteEncoder);
                writeTruncationMarker(directionalIndexByteEncoder);
                return;
            case 10:
                if (Values.isMaxValue(h0)) {
                    writeValueTypeLabel(directionalIndexByteEncoder, Integer.MAX_VALUE);
                    return;
                } else if (Values.isVectorValue(h0)) {
                    writeIndexVector(h0.x(), directionalIndexByteEncoder);
                    return;
                } else {
                    writeIndexMap(h0.x(), directionalIndexByteEncoder);
                    writeTruncationMarker(directionalIndexByteEncoder);
                    return;
                }
            default:
                throw new IllegalArgumentException("unknown index value type ".concat(a.x(h0.B())));
        }
    }

    private void writeIndexVector(J j4, DirectionalIndexByteEncoder directionalIndexByteEncoder) {
        Map mapI = j4.i();
        writeValueTypeLabel(directionalIndexByteEncoder, 53);
        int iK = ((H0) mapI.get("value")).q().k();
        writeValueTypeLabel(directionalIndexByteEncoder, 15);
        directionalIndexByteEncoder.writeLong(iK);
        writeIndexString("value", directionalIndexByteEncoder);
        writeIndexValueAux((H0) mapI.get("value"), directionalIndexByteEncoder);
    }

    private void writeTruncationMarker(DirectionalIndexByteEncoder directionalIndexByteEncoder) {
        directionalIndexByteEncoder.writeLong(2L);
    }

    private void writeUnlabeledIndexString(String str, DirectionalIndexByteEncoder directionalIndexByteEncoder) {
        directionalIndexByteEncoder.writeString(str);
    }

    private void writeValueTypeLabel(DirectionalIndexByteEncoder directionalIndexByteEncoder, int i6) {
        directionalIndexByteEncoder.writeLong(i6);
    }

    public void writeIndexValue(H0 h0, DirectionalIndexByteEncoder directionalIndexByteEncoder) {
        writeIndexValueAux(h0, directionalIndexByteEncoder);
        directionalIndexByteEncoder.writeInfinity();
    }
}