package com.google.firebase.firestore.index;

import androidx.media3.extractor.ts.PsExtractor;
import com.google.protobuf.AbstractC1320n;
import java.math.RoundingMode;
import java.util.Arrays;

/* JADX INFO: loaded from: classes3.dex */
public class OrderedCodeWriter {
    private static final int DEFAULT_BUFFER_SIZE = 1024;
    public static final long DOUBLE_ALL_BITS = -1;
    public static final long DOUBLE_SIGN_MASK = Long.MIN_VALUE;
    public static final byte ESCAPE1 = 0;
    public static final byte ESCAPE2 = -1;
    public static final byte FF_BYTE = 0;
    public static final byte INFINITY = -1;
    private static final byte[][] LENGTH_TO_HEADER_BITS = {new byte[]{0, 0}, new byte[]{-128, 0}, new byte[]{-64, 0}, new byte[]{-32, 0}, new byte[]{-16, 0}, new byte[]{-8, 0}, new byte[]{-4, 0}, new byte[]{-2, 0}, new byte[]{-1, 0}, new byte[]{-1, -128}, new byte[]{-1, -64}};
    public static final byte NULL_BYTE = -1;
    public static final byte SEPARATOR = 1;
    private int position = 0;
    private byte[] buffer = new byte[1024];

    private void ensureAvailable(int i6) {
        int i7 = i6 + this.position;
        byte[] bArr = this.buffer;
        if (i7 <= bArr.length) {
            return;
        }
        int length = bArr.length * 2;
        if (length >= i7) {
            i7 = length;
        }
        this.buffer = Arrays.copyOf(bArr, i7);
    }

    private int signedNumLength(long j4) {
        if (j4 < 0) {
            j4 = ~j4;
        }
        return IntMath.divide(65 - Long.numberOfLeadingZeros(j4), 7, RoundingMode.UP);
    }

    private int unsignedNumLength(long j4) {
        return IntMath.divide(64 - Long.numberOfLeadingZeros(j4), 8, RoundingMode.UP);
    }

    private void writeByteAscending(byte b5) {
        if (b5 == 0) {
            writeEscapedByteAscending((byte) 0);
            writeEscapedByteAscending((byte) -1);
        } else if (b5 != -1) {
            writeEscapedByteAscending(b5);
        } else {
            writeEscapedByteAscending((byte) -1);
            writeEscapedByteAscending((byte) 0);
        }
    }

    private void writeByteDescending(byte b5) {
        if (b5 == 0) {
            writeEscapedByteDescending((byte) 0);
            writeEscapedByteDescending((byte) -1);
        } else if (b5 != -1) {
            writeEscapedByteDescending(b5);
        } else {
            writeEscapedByteDescending((byte) -1);
            writeEscapedByteDescending((byte) 0);
        }
    }

    private void writeEscapedByteAscending(byte b5) {
        ensureAvailable(1);
        byte[] bArr = this.buffer;
        int i6 = this.position;
        this.position = i6 + 1;
        bArr[i6] = b5;
    }

    private void writeEscapedByteDescending(byte b5) {
        ensureAvailable(1);
        byte[] bArr = this.buffer;
        int i6 = this.position;
        this.position = i6 + 1;
        bArr[i6] = (byte) (~b5);
    }

    private void writeSeparatorAscending() {
        writeEscapedByteAscending((byte) 0);
        writeEscapedByteAscending((byte) 1);
    }

    private void writeSeparatorDescending() {
        writeEscapedByteDescending((byte) 0);
        writeEscapedByteDescending((byte) 1);
    }

    public byte[] encodedBytes() {
        return Arrays.copyOf(this.buffer, this.position);
    }

    public void reset() {
        this.position = 0;
    }

    public void seed(byte[] bArr) {
        ensureAvailable(bArr.length);
        for (byte b5 : bArr) {
            byte[] bArr2 = this.buffer;
            int i6 = this.position;
            this.position = i6 + 1;
            bArr2[i6] = b5;
        }
    }

    public void writeBytesAscending(AbstractC1320n abstractC1320n) {
        for (int i6 = 0; i6 < abstractC1320n.size(); i6++) {
            writeByteAscending(abstractC1320n.h(i6));
        }
        writeSeparatorAscending();
    }

    public void writeBytesDescending(AbstractC1320n abstractC1320n) {
        for (int i6 = 0; i6 < abstractC1320n.size(); i6++) {
            writeByteDescending(abstractC1320n.h(i6));
        }
        writeSeparatorDescending();
    }

    public void writeDoubleAscending(double d6) {
        long jDoubleToLongBits = Double.doubleToLongBits(d6);
        writeUnsignedLongAscending(jDoubleToLongBits ^ (jDoubleToLongBits < 0 ? -1L : Long.MIN_VALUE));
    }

    public void writeDoubleDescending(double d6) {
        long jDoubleToLongBits = Double.doubleToLongBits(d6);
        writeUnsignedLongDescending(jDoubleToLongBits ^ (jDoubleToLongBits < 0 ? -1L : Long.MIN_VALUE));
    }

    public void writeInfinityAscending() {
        writeEscapedByteAscending((byte) -1);
        writeEscapedByteAscending((byte) -1);
    }

    public void writeInfinityDescending() {
        writeEscapedByteDescending((byte) -1);
        writeEscapedByteDescending((byte) -1);
    }

    public void writeSignedLongAscending(long j4) {
        int i6;
        long j6 = j4 < 0 ? ~j4 : j4;
        if (j6 < 64) {
            ensureAvailable(1);
            byte[] bArr = this.buffer;
            int i7 = this.position;
            this.position = i7 + 1;
            bArr[i7] = (byte) (j4 ^ ((long) LENGTH_TO_HEADER_BITS[1][0]));
            return;
        }
        int iSignedNumLength = signedNumLength(j6);
        ensureAvailable(iSignedNumLength);
        if (iSignedNumLength < 2) {
            throw new AssertionError(String.format("Invalid length (%d) returned by signedNumLength", Integer.valueOf(iSignedNumLength)));
        }
        byte b5 = j4 < 0 ? (byte) -1 : (byte) 0;
        int i8 = this.position;
        if (iSignedNumLength == 10) {
            i6 = i8 + 2;
            byte[] bArr2 = this.buffer;
            bArr2[i8] = b5;
            bArr2[i8 + 1] = b5;
        } else if (iSignedNumLength == 9) {
            i6 = i8 + 1;
            this.buffer[i8] = b5;
        } else {
            i6 = i8;
        }
        for (int i9 = (iSignedNumLength - 1) + i8; i9 >= i6; i9--) {
            this.buffer[i9] = (byte) (255 & j4);
            j4 >>= 8;
        }
        byte[] bArr3 = this.buffer;
        int i10 = this.position;
        byte b6 = bArr3[i10];
        byte[] bArr4 = LENGTH_TO_HEADER_BITS[iSignedNumLength];
        bArr3[i10] = (byte) (b6 ^ bArr4[0]);
        int i11 = i10 + 1;
        bArr3[i11] = (byte) (bArr4[1] ^ bArr3[i11]);
        this.position = i10 + iSignedNumLength;
    }

    public void writeSignedLongDescending(long j4) {
        writeSignedLongAscending(~j4);
    }

    public void writeUnsignedLongAscending(long j4) {
        int iUnsignedNumLength = unsignedNumLength(j4);
        ensureAvailable(iUnsignedNumLength + 1);
        byte[] bArr = this.buffer;
        int i6 = this.position;
        int i7 = i6 + 1;
        this.position = i7;
        bArr[i6] = (byte) iUnsignedNumLength;
        int i8 = i7 + iUnsignedNumLength;
        while (true) {
            i8--;
            int i9 = this.position;
            if (i8 < i9) {
                this.position = i9 + iUnsignedNumLength;
                return;
            } else {
                this.buffer[i8] = (byte) (255 & j4);
                j4 >>>= 8;
            }
        }
    }

    public void writeUnsignedLongDescending(long j4) {
        int iUnsignedNumLength = unsignedNumLength(j4);
        ensureAvailable(iUnsignedNumLength + 1);
        byte[] bArr = this.buffer;
        int i6 = this.position;
        int i7 = i6 + 1;
        this.position = i7;
        bArr[i6] = (byte) (~iUnsignedNumLength);
        int i8 = i7 + iUnsignedNumLength;
        while (true) {
            i8--;
            int i9 = this.position;
            if (i8 < i9) {
                this.position = i9 + iUnsignedNumLength;
                return;
            } else {
                this.buffer[i8] = (byte) (~(255 & j4));
                j4 >>>= 8;
            }
        }
    }

    public void writeUtf8Ascending(CharSequence charSequence) {
        int length = charSequence.length();
        int i6 = 0;
        while (i6 < length) {
            char cCharAt = charSequence.charAt(i6);
            if (cCharAt < 128) {
                writeByteAscending((byte) cCharAt);
            } else if (cCharAt < 2048) {
                writeByteAscending((byte) ((cCharAt >>> 6) | 960));
                writeByteAscending((byte) ((cCharAt & '?') | 128));
            } else if (cCharAt < 55296 || 57343 < cCharAt) {
                writeByteAscending((byte) ((cCharAt >>> '\f') | 480));
                writeByteAscending((byte) (((cCharAt >>> 6) & 63) | 128));
                writeByteAscending((byte) ((cCharAt & '?') | 128));
            } else {
                int iCodePointAt = Character.codePointAt(charSequence, i6);
                i6++;
                writeByteAscending((byte) ((iCodePointAt >>> 18) | PsExtractor.VIDEO_STREAM_MASK));
                writeByteAscending((byte) (((iCodePointAt >>> 12) & 63) | 128));
                writeByteAscending((byte) (((iCodePointAt >>> 6) & 63) | 128));
                writeByteAscending((byte) ((iCodePointAt & 63) | 128));
            }
            i6++;
        }
        writeSeparatorAscending();
    }

    public void writeUtf8Descending(CharSequence charSequence) {
        int length = charSequence.length();
        int i6 = 0;
        while (i6 < length) {
            char cCharAt = charSequence.charAt(i6);
            if (cCharAt < 128) {
                writeByteDescending((byte) cCharAt);
            } else if (cCharAt < 2048) {
                writeByteDescending((byte) ((cCharAt >>> 6) | 960));
                writeByteDescending((byte) ((cCharAt & '?') | 128));
            } else if (cCharAt < 55296 || 57343 < cCharAt) {
                writeByteDescending((byte) ((cCharAt >>> '\f') | 480));
                writeByteDescending((byte) (((cCharAt >>> 6) & 63) | 128));
                writeByteDescending((byte) ((cCharAt & '?') | 128));
            } else {
                int iCodePointAt = Character.codePointAt(charSequence, i6);
                i6++;
                writeByteDescending((byte) ((iCodePointAt >>> 18) | PsExtractor.VIDEO_STREAM_MASK));
                writeByteDescending((byte) (((iCodePointAt >>> 12) & 63) | 128));
                writeByteDescending((byte) (((iCodePointAt >>> 6) & 63) | 128));
                writeByteDescending((byte) ((iCodePointAt & 63) | 128));
            }
            i6++;
        }
        writeSeparatorDescending();
    }
}