package androidx.datastore.preferences.protobuf;

import androidx.media3.exoplayer.analytics.AnalyticsListener;
import java.nio.charset.Charset;
import java.util.Arrays;
import okio.Utf8;

/* JADX INFO: loaded from: classes.dex */
public final class o1 extends com.bumptech.glide.i {

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public final /* synthetic */ int f2127b;

    /* JADX WARN: Removed duplicated region for block: B:20:0x004a  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final String i(int i10, int i11, byte[] bArr) {
        switch (this.f2127b) {
            case 0:
                if ((i10 | i11 | ((bArr.length - i10) - i11)) < 0) {
                    throw new ArrayIndexOutOfBoundsException(String.format("buffer length=%d, index=%d, size=%d", Integer.valueOf(bArr.length), Integer.valueOf(i10), Integer.valueOf(i11)));
                }
                int i12 = i10 + i11;
                char[] cArr = new char[i11];
                int i13 = 0;
                while (i10 < i12) {
                    byte b10 = bArr[i10];
                    if (b10 < 0) {
                        while (i10 < i12) {
                            int i14 = i10 + 1;
                            byte b11 = bArr[i10];
                            if (b11 >= 0) {
                                int i15 = i13 + 1;
                                cArr[i13] = (char) b11;
                                while (i14 < i12) {
                                    byte b12 = bArr[i14];
                                    if (b12 >= 0) {
                                        i14++;
                                        cArr[i15] = (char) b12;
                                        i15++;
                                    } else {
                                        i13 = i15;
                                        i10 = i14;
                                    }
                                }
                                i13 = i15;
                                i10 = i14;
                            } else if (b11 < -32) {
                                if (i14 >= i12) {
                                    throw InvalidProtocolBufferException.b();
                                }
                                i10 += 2;
                                byte b13 = bArr[i14];
                                int i16 = i13 + 1;
                                if (b11 < -62 || hb.a.i0(b13)) {
                                    throw InvalidProtocolBufferException.b();
                                }
                                cArr[i13] = (char) ((b13 & Utf8.REPLACEMENT_BYTE) | ((b11 & 31) << 6));
                                i13 = i16;
                            } else {
                                if (b11 >= -16) {
                                    if (i14 >= i12 - 2) {
                                        throw InvalidProtocolBufferException.b();
                                    }
                                    byte b14 = bArr[i14];
                                    int i17 = i10 + 3;
                                    byte b15 = bArr[i10 + 2];
                                    i10 += 4;
                                    byte b16 = bArr[i17];
                                    int i18 = i13 + 1;
                                    if (!hb.a.i0(b14)) {
                                        if ((((b14 + 112) + (b11 << 28)) >> 30) == 0 && !hb.a.i0(b15) && !hb.a.i0(b16)) {
                                            int i19 = ((b14 & Utf8.REPLACEMENT_BYTE) << 12) | ((b11 & 7) << 18) | ((b15 & Utf8.REPLACEMENT_BYTE) << 6) | (b16 & Utf8.REPLACEMENT_BYTE);
                                            cArr[i13] = (char) ((i19 >>> 10) + Utf8.HIGH_SURROGATE_HEADER);
                                            cArr[i18] = (char) ((i19 & AnalyticsListener.EVENT_DRM_KEYS_LOADED) + Utf8.LOG_SURROGATE_HEADER);
                                            i13 += 2;
                                        }
                                    }
                                    throw InvalidProtocolBufferException.b();
                                }
                                if (i14 >= i12 - 1) {
                                    throw InvalidProtocolBufferException.b();
                                }
                                int i20 = i10 + 2;
                                byte b17 = bArr[i14];
                                i10 += 3;
                                byte b18 = bArr[i20];
                                int i21 = i13 + 1;
                                if (hb.a.i0(b17) || ((b11 == -32 && b17 < -96) || ((b11 == -19 && b17 >= -96) || hb.a.i0(b18)))) {
                                    throw InvalidProtocolBufferException.b();
                                }
                                cArr[i13] = (char) (((b17 & Utf8.REPLACEMENT_BYTE) << 6) | ((b11 & 15) << 12) | (b18 & Utf8.REPLACEMENT_BYTE));
                                i13 = i21;
                            }
                        }
                        return new String(cArr, 0, i13);
                    }
                    i10++;
                    cArr[i13] = (char) b10;
                    i13++;
                }
                while (i10 < i12) {
                }
                return new String(cArr, 0, i13);
            default:
                Charset charset = b0.f2047a;
                String str = new String(bArr, i10, i11, charset);
                if (str.indexOf(Utf8.REPLACEMENT_CODE_POINT) >= 0 && !Arrays.equals(str.getBytes(charset), Arrays.copyOfRange(bArr, i10, i11 + i10))) {
                    throw InvalidProtocolBufferException.b();
                }
                return str;
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:70:0x018a  */
    /* JADX WARN: Removed duplicated region for block: B:71:0x018e  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final int j(String str, byte[] bArr, int i10, int i11) {
        int i12;
        char cCharAt;
        long j10;
        int i13;
        char cCharAt2;
        char c6 = 2048;
        char c10 = 128;
        switch (this.f2127b) {
            case 0:
                int length = str.length();
                int i14 = i11 + i10;
                int i15 = 0;
                while (i15 < length) {
                    int i16 = i15 + i10;
                    if (i16 >= i14 || (cCharAt = str.charAt(i15)) >= 128) {
                        if (i15 != length) {
                            return i10 + length;
                        }
                        int i17 = i10 + i15;
                        while (i15 < length) {
                            char cCharAt3 = str.charAt(i15);
                            if (cCharAt3 < 128 && i17 < i14) {
                                bArr[i17] = (byte) cCharAt3;
                                i17++;
                            } else if (cCharAt3 < 2048 && i17 <= i14 - 2) {
                                int i18 = i17 + 1;
                                bArr[i17] = (byte) ((cCharAt3 >>> 6) | 960);
                                i17 += 2;
                                bArr[i18] = (byte) ((cCharAt3 & '?') | 128);
                            } else {
                                if ((cCharAt3 >= 55296 && 57343 >= cCharAt3) || i17 > i14 - 3) {
                                    if (i17 > i14 - 4) {
                                        if (55296 <= cCharAt3 && cCharAt3 <= 57343 && ((i12 = i15 + 1) == str.length() || !Character.isSurrogatePair(cCharAt3, str.charAt(i12)))) {
                                            throw new Utf8$UnpairedSurrogateException(i15, length);
                                        }
                                        throw new ArrayIndexOutOfBoundsException("Failed writing " + cCharAt3 + " at index " + i17);
                                    }
                                    int i19 = i15 + 1;
                                    if (i19 != str.length()) {
                                        char cCharAt4 = str.charAt(i19);
                                        if (Character.isSurrogatePair(cCharAt3, cCharAt4)) {
                                            int codePoint = Character.toCodePoint(cCharAt3, cCharAt4);
                                            bArr[i17] = (byte) ((codePoint >>> 18) | 240);
                                            bArr[i17 + 1] = (byte) (((codePoint >>> 12) & 63) | 128);
                                            int i20 = i17 + 3;
                                            bArr[i17 + 2] = (byte) (((codePoint >>> 6) & 63) | 128);
                                            i17 += 4;
                                            bArr[i20] = (byte) ((codePoint & 63) | 128);
                                            i15 = i19;
                                        } else {
                                            i15 = i19;
                                        }
                                    }
                                    throw new Utf8$UnpairedSurrogateException(i15 - 1, length);
                                }
                                bArr[i17] = (byte) ((cCharAt3 >>> '\f') | 480);
                                int i21 = i17 + 2;
                                bArr[i17 + 1] = (byte) (((cCharAt3 >>> 6) & 63) | 128);
                                i17 += 3;
                                bArr[i21] = (byte) ((cCharAt3 & '?') | 128);
                            }
                            i15++;
                        }
                        return i17;
                    }
                    bArr[i16] = (byte) cCharAt;
                    i15++;
                }
                if (i15 != length) {
                }
                break;
            default:
                long j11 = i10;
                long j12 = ((long) i11) + j11;
                int length2 = str.length();
                if (length2 > i11 || bArr.length - i11 < i10) {
                    throw new ArrayIndexOutOfBoundsException("Failed writing " + str.charAt(length2 - 1) + " at index " + (i10 + i11));
                }
                int i22 = 0;
                while (i22 < length2 && (cCharAt2 = str.charAt(i22)) < 128) {
                    n1.j(bArr, j11, (byte) cCharAt2);
                    i22++;
                    j11++;
                }
                if (i22 != length2) {
                    while (i22 < length2) {
                        char cCharAt5 = str.charAt(i22);
                        if (cCharAt5 < c10 && j11 < j12) {
                            n1.j(bArr, j11, (byte) cCharAt5);
                            j10 = j12;
                            j11++;
                        } else if (cCharAt5 < c6 && j11 <= j12 - 2) {
                            long j13 = j11 + 1;
                            n1.j(bArr, j11, (byte) ((cCharAt5 >>> 6) | 960));
                            j11 += 2;
                            n1.j(bArr, j13, (byte) ((cCharAt5 & '?') | c10));
                            j10 = j12;
                        } else {
                            if ((cCharAt5 >= 55296 && 57343 >= cCharAt5) || j11 > j12 - 3) {
                                j10 = j12;
                                if (j11 > j10 - 4) {
                                    if (55296 <= cCharAt5 && cCharAt5 <= 57343 && ((i13 = i22 + 1) == length2 || !Character.isSurrogatePair(cCharAt5, str.charAt(i13)))) {
                                        throw new Utf8$UnpairedSurrogateException(i22, length2);
                                    }
                                    throw new ArrayIndexOutOfBoundsException("Failed writing " + cCharAt5 + " at index " + j11);
                                }
                                int i23 = i22 + 1;
                                if (i23 != length2) {
                                    char cCharAt6 = str.charAt(i23);
                                    if (Character.isSurrogatePair(cCharAt5, cCharAt6)) {
                                        int codePoint2 = Character.toCodePoint(cCharAt5, cCharAt6);
                                        n1.j(bArr, j11, (byte) ((codePoint2 >>> 18) | 240));
                                        n1.j(bArr, j11 + 1, (byte) (((codePoint2 >>> 12) & 63) | 128));
                                        long j14 = 3 + j11;
                                        n1.j(bArr, j11 + 2, (byte) (((codePoint2 >>> 6) & 63) | 128));
                                        j11 += 4;
                                        n1.j(bArr, j14, (byte) ((codePoint2 & 63) | 128));
                                        i22 = i23;
                                    } else {
                                        i22 = i23;
                                    }
                                }
                                throw new Utf8$UnpairedSurrogateException(i22 - 1, length2);
                            }
                            n1.j(bArr, j11, (byte) ((cCharAt5 >>> '\f') | 480));
                            j10 = j12;
                            long j15 = j11 + 2;
                            n1.j(bArr, j11 + 1, (byte) (((cCharAt5 >>> 6) & 63) | 128));
                            j11 += 3;
                            n1.j(bArr, j15, (byte) ((cCharAt5 & '?') | 128));
                        }
                        i22++;
                        j12 = j10;
                        c6 = 2048;
                        c10 = 128;
                    }
                }
                return (int) j11;
        }
    }
}