package j;

import com.seewo.sdk.model.SDKKeyboardCode;
import java.io.Serializable;
import java.security.MessageDigest;
import java.util.Arrays;

/* JADX INFO: compiled from: ByteString.kt */
/* JADX INFO: loaded from: classes.dex */
public class h implements Serializable, Comparable<h> {

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    public transient int f4613f;

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    public transient String f4614g;

    /* JADX INFO: renamed from: h, reason: collision with root package name */
    public final byte[] f4615h;

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public static final a f4612e = new a(null);

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public static final h f4611b = new h(new byte[0]);

    /* JADX INFO: compiled from: ByteString.kt */
    public static final class a {
        public a(g.h0.c.g gVar) {
        }

        public static h d(a aVar, byte[] bArr, int i2, int i3, int i4) {
            if ((i4 & 1) != 0) {
                i2 = 0;
            }
            if ((i4 & 2) != 0) {
                i3 = bArr.length;
            }
            g.h0.c.l.f(bArr, "$this$toByteString");
            f.a.y.a.z(bArr.length, i2, i3);
            return new h(g.c0.g.h(bArr, i2, i3 + i2));
        }

        public final h a(String str) {
            int i2;
            int i3;
            char cCharAt;
            g.h0.c.l.f(str, "$this$decodeBase64");
            byte[] bArr = j.a.a;
            g.h0.c.l.f(str, "$this$decodeBase64ToArray");
            int length = str.length();
            while (length > 0 && ((cCharAt = str.charAt(length - 1)) == '=' || cCharAt == '\n' || cCharAt == '\r' || cCharAt == ' ' || cCharAt == '\t')) {
                length = i3;
            }
            int i4 = (int) ((((long) length) * 6) / 8);
            byte[] bArrCopyOf = new byte[i4];
            int i5 = 0;
            int i6 = 0;
            int i7 = 0;
            int i8 = 0;
            while (true) {
                if (i5 < length) {
                    char cCharAt2 = str.charAt(i5);
                    if ('A' > cCharAt2 || 'Z' < cCharAt2) {
                        if ('a' > cCharAt2 || 'z' < cCharAt2) {
                            if ('0' > cCharAt2 || '9' < cCharAt2) {
                                if (cCharAt2 != '+' && cCharAt2 != '-') {
                                    if (cCharAt2 != '/' && cCharAt2 != '_') {
                                        if (cCharAt2 != '\n' && cCharAt2 != '\r' && cCharAt2 != ' ' && cCharAt2 != '\t') {
                                            break;
                                        }
                                        i5++;
                                    } else {
                                        i2 = 63;
                                    }
                                } else {
                                    i2 = 62;
                                }
                            } else {
                                i2 = cCharAt2 + 4;
                            }
                        } else {
                            i2 = cCharAt2 - 'G';
                        }
                    } else {
                        i2 = cCharAt2 - 'A';
                    }
                    i7 = (i7 << 6) | i2;
                    i6++;
                    if (i6 % 4 == 0) {
                        int i9 = i8 + 1;
                        bArrCopyOf[i8] = (byte) (i7 >> 16);
                        int i10 = i9 + 1;
                        bArrCopyOf[i9] = (byte) (i7 >> 8);
                        bArrCopyOf[i10] = (byte) i7;
                        i8 = i10 + 1;
                    }
                    i5++;
                } else {
                    int i11 = i6 % 4;
                    if (i11 != 1) {
                        if (i11 == 2) {
                            bArrCopyOf[i8] = (byte) ((i7 << 12) >> 16);
                            i8++;
                        } else if (i11 == 3) {
                            int i12 = i7 << 6;
                            int i13 = i8 + 1;
                            bArrCopyOf[i8] = (byte) (i12 >> 16);
                            i8 = i13 + 1;
                            bArrCopyOf[i13] = (byte) (i12 >> 8);
                        }
                        if (i8 != i4) {
                            bArrCopyOf = Arrays.copyOf(bArrCopyOf, i8);
                            g.h0.c.l.e(bArrCopyOf, "java.util.Arrays.copyOf(this, newSize)");
                        }
                    }
                }
            }
            bArrCopyOf = null;
            if (bArrCopyOf != null) {
                return new h(bArrCopyOf);
            }
            return null;
        }

        public final h b(String str) {
            g.h0.c.l.f(str, "$this$decodeHex");
            if (!(str.length() % 2 == 0)) {
                throw new IllegalArgumentException(d.b.a.a.a.p("Unexpected hex string: ", str).toString());
            }
            int length = str.length() / 2;
            byte[] bArr = new byte[length];
            for (int i2 = 0; i2 < length; i2++) {
                int i3 = i2 * 2;
                bArr[i2] = (byte) (j.d0.b.a(str.charAt(i3 + 1)) + (j.d0.b.a(str.charAt(i3)) << 4));
            }
            return new h(bArr);
        }

        public final h c(String str) {
            g.h0.c.l.f(str, "$this$encodeUtf8");
            g.h0.c.l.f(str, "$this$asUtf8ToByteArray");
            byte[] bytes = str.getBytes(g.m0.a.f4156b);
            g.h0.c.l.e(bytes, "(this as java.lang.String).getBytes(charset)");
            h hVar = new h(bytes);
            hVar.f4614g = str;
            return hVar;
        }
    }

    public h(byte[] bArr) {
        g.h0.c.l.f(bArr, "data");
        this.f4615h = bArr;
    }

    public String a() {
        byte[] bArr = this.f4615h;
        byte[] bArr2 = j.a.a;
        byte[] bArr3 = j.a.a;
        g.h0.c.l.f(bArr, "$this$encodeBase64");
        g.h0.c.l.f(bArr3, "map");
        byte[] bArr4 = new byte[((bArr.length + 2) / 3) * 4];
        int length = bArr.length - (bArr.length % 3);
        int i2 = 0;
        int i3 = 0;
        while (i2 < length) {
            int i4 = i2 + 1;
            byte b2 = bArr[i2];
            int i5 = i4 + 1;
            byte b3 = bArr[i4];
            int i6 = i5 + 1;
            byte b4 = bArr[i5];
            int i7 = i3 + 1;
            bArr4[i3] = bArr3[(b2 & 255) >> 2];
            int i8 = i7 + 1;
            bArr4[i7] = bArr3[((b2 & 3) << 4) | ((b3 & 255) >> 4)];
            int i9 = i8 + 1;
            bArr4[i8] = bArr3[((b3 & SDKKeyboardCode.FUNCTION_KEY_BOARD_L) << 2) | ((b4 & 255) >> 6)];
            i3 = i9 + 1;
            bArr4[i9] = bArr3[b4 & SDKKeyboardCode.FUNCTION_KEY_BOARD_F6];
            i2 = i6;
        }
        int length2 = bArr.length - length;
        if (length2 == 1) {
            byte b5 = bArr[i2];
            int i10 = i3 + 1;
            bArr4[i3] = bArr3[(b5 & 255) >> 2];
            int i11 = i10 + 1;
            bArr4[i10] = bArr3[(b5 & 3) << 4];
            byte b6 = (byte) 61;
            bArr4[i11] = b6;
            bArr4[i11 + 1] = b6;
        } else if (length2 == 2) {
            int i12 = i2 + 1;
            byte b7 = bArr[i2];
            byte b8 = bArr[i12];
            int i13 = i3 + 1;
            bArr4[i3] = bArr3[(b7 & 255) >> 2];
            int i14 = i13 + 1;
            bArr4[i13] = bArr3[((b7 & 3) << 4) | ((b8 & 255) >> 4)];
            bArr4[i14] = bArr3[(b8 & SDKKeyboardCode.FUNCTION_KEY_BOARD_L) << 2];
            bArr4[i14 + 1] = (byte) 61;
        }
        g.h0.c.l.f(bArr4, "$this$toUtf8String");
        return new String(bArr4, g.m0.a.f4156b);
    }

    public h b(String str) {
        g.h0.c.l.f(str, "algorithm");
        byte[] bArrDigest = MessageDigest.getInstance(str).digest(this.f4615h);
        g.h0.c.l.e(bArrDigest, "MessageDigest.getInstance(algorithm).digest(data)");
        return new h(bArrDigest);
    }

    public int c() {
        return this.f4615h.length;
    }

    /* JADX WARN: Code restructure failed: missing block: B:12:0x002f, code lost:
    
        if (r0 < r1) goto L13;
     */
    /* JADX WARN: Code restructure failed: missing block: B:14:0x0033, code lost:
    
        return 1;
     */
    /* JADX WARN: Code restructure failed: missing block: B:18:?, code lost:
    
        return -1;
     */
    /* JADX WARN: Code restructure failed: missing block: B:8:0x0029, code lost:
    
        if (r6 < r7) goto L13;
     */
    @Override // java.lang.Comparable
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public int compareTo(j.h r9) {
        /*
            r8 = this;
            j.h r9 = (j.h) r9
            java.lang.String r0 = "other"
            g.h0.c.l.f(r9, r0)
            int r0 = r8.c()
            int r1 = r9.c()
            int r2 = java.lang.Math.min(r0, r1)
            r3 = 0
            r4 = r3
        L15:
            r5 = -1
            if (r4 >= r2) goto L2c
            byte r6 = r8.f(r4)
            r6 = r6 & 255(0xff, float:3.57E-43)
            byte r7 = r9.f(r4)
            r7 = r7 & 255(0xff, float:3.57E-43)
            if (r6 != r7) goto L29
            int r4 = r4 + 1
            goto L15
        L29:
            if (r6 >= r7) goto L33
            goto L31
        L2c:
            if (r0 != r1) goto L2f
            goto L34
        L2f:
            if (r0 >= r1) goto L33
        L31:
            r3 = r5
            goto L34
        L33:
            r3 = 1
        L34:
            return r3
        */
        throw new UnsupportedOperationException("Method not decompiled: j.h.compareTo(java.lang.Object):int");
    }

    public String d() {
        byte[] bArr = this.f4615h;
        char[] cArr = new char[bArr.length * 2];
        int i2 = 0;
        for (byte b2 : bArr) {
            int i3 = i2 + 1;
            char[] cArr2 = j.d0.b.a;
            cArr[i2] = cArr2[(b2 >> 4) & 15];
            i2 = i3 + 1;
            cArr[i3] = cArr2[b2 & SDKKeyboardCode.FUNCTION_KEY_BOARD_L];
        }
        return new String(cArr);
    }

    public byte[] e() {
        return this.f4615h;
    }

    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj instanceof h) {
            h hVar = (h) obj;
            int iC = hVar.c();
            byte[] bArr = this.f4615h;
            if (iC == bArr.length && hVar.h(0, bArr, 0, bArr.length)) {
                return true;
            }
        }
        return false;
    }

    public byte f(int i2) {
        return this.f4615h[i2];
    }

    public boolean g(int i2, h hVar, int i3, int i4) {
        g.h0.c.l.f(hVar, "other");
        return hVar.h(i3, this.f4615h, i2, i4);
    }

    public boolean h(int i2, byte[] bArr, int i3, int i4) {
        g.h0.c.l.f(bArr, "other");
        if (i2 >= 0) {
            byte[] bArr2 = this.f4615h;
            if (i2 <= bArr2.length - i4 && i3 >= 0 && i3 <= bArr.length - i4 && f.a.y.a.p(bArr2, i2, bArr, i3, i4)) {
                return true;
            }
        }
        return false;
    }

    public int hashCode() {
        int i2 = this.f4613f;
        if (i2 != 0) {
            return i2;
        }
        int iHashCode = Arrays.hashCode(this.f4615h);
        this.f4613f = iHashCode;
        return iHashCode;
    }

    public h i() {
        return b("SHA-1");
    }

    public h j() {
        byte b2;
        int i2 = 0;
        while (true) {
            byte[] bArr = this.f4615h;
            if (i2 >= bArr.length) {
                return this;
            }
            byte b3 = bArr[i2];
            byte b4 = (byte) 65;
            if (b3 >= b4 && b3 <= (b2 = (byte) 90)) {
                byte[] bArrCopyOf = Arrays.copyOf(bArr, bArr.length);
                g.h0.c.l.e(bArrCopyOf, "java.util.Arrays.copyOf(this, size)");
                bArrCopyOf[i2] = (byte) (b3 + SDKKeyboardCode.FUNCTION_KEY_BOARD_3);
                for (int i3 = i2 + 1; i3 < bArrCopyOf.length; i3++) {
                    byte b5 = bArrCopyOf[i3];
                    if (b5 >= b4 && b5 <= b2) {
                        bArrCopyOf[i3] = (byte) (b5 + SDKKeyboardCode.FUNCTION_KEY_BOARD_3);
                    }
                }
                return new h(bArrCopyOf);
            }
            i2++;
        }
    }

    public byte[] k() {
        byte[] bArr = this.f4615h;
        byte[] bArrCopyOf = Arrays.copyOf(bArr, bArr.length);
        g.h0.c.l.e(bArrCopyOf, "java.util.Arrays.copyOf(this, size)");
        return bArrCopyOf;
    }

    public String l() {
        String str = this.f4614g;
        if (str != null) {
            return str;
        }
        byte[] bArrE = e();
        g.h0.c.l.f(bArrE, "$this$toUtf8String");
        String str2 = new String(bArrE, g.m0.a.f4156b);
        this.f4614g = str2;
        return str2;
    }

    public void m(d dVar, int i2, int i3) {
        g.h0.c.l.f(dVar, "buffer");
        g.h0.c.l.f(this, "$this$commonWrite");
        g.h0.c.l.f(dVar, "buffer");
        dVar.A(this.f4615h, i2, i3);
    }

    /* JADX WARN: Removed duplicated region for block: B:138:0x0143  */
    /* JADX WARN: Removed duplicated region for block: B:203:0x01d9  */
    /* JADX WARN: Removed duplicated region for block: B:26:0x0043  */
    /* JADX WARN: Removed duplicated region for block: B:49:0x0073  */
    /* JADX WARN: Removed duplicated region for block: B:85:0x00c2  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public java.lang.String toString() {
        /*
            Method dump skipped, instruction units count: 711
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: j.h.toString():java.lang.String");
    }
}