package okio;

import com.seewo.sdk.model.SDKKeyboardCode;
import java.io.Serializable;
import java.nio.charset.Charset;
import java.security.MessageDigest;
import java.util.Arrays;
import o1.AbstractC0668d;

/* JADX INFO: loaded from: classes2.dex */
public class i implements Serializable, Comparable {

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    private transient int f6033b;

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

    /* JADX INFO: renamed from: r, reason: collision with root package name */
    private final byte[] f6035r;

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

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

    public static final class a {
        private a() {
        }

        public static /* synthetic */ i f(a aVar, byte[] bArr, int i2, int i3, int i4, Object obj) {
            if ((i4 & 1) != 0) {
                i2 = 0;
            }
            if ((i4 & 2) != 0) {
                i3 = bArr.length;
            }
            return aVar.e(bArr, i2, i3);
        }

        public final i a(String decodeBase64) {
            kotlin.jvm.internal.l.e(decodeBase64, "$this$decodeBase64");
            byte[] bArrA = AbstractC0683a.a(decodeBase64);
            if (bArrA != null) {
                return new i(bArrA);
            }
            return null;
        }

        public final i b(String decodeHex) {
            kotlin.jvm.internal.l.e(decodeHex, "$this$decodeHex");
            if (!(decodeHex.length() % 2 == 0)) {
                throw new IllegalArgumentException(("Unexpected hex string: " + decodeHex).toString());
            }
            int length = decodeHex.length() / 2;
            byte[] bArr = new byte[length];
            for (int i2 = 0; i2 < length; i2++) {
                int i3 = i2 * 2;
                bArr[i2] = (byte) ((I1.b.e(decodeHex.charAt(i3)) << 4) + I1.b.e(decodeHex.charAt(i3 + 1)));
            }
            return new i(bArr);
        }

        public final i c(String encode, Charset charset) {
            kotlin.jvm.internal.l.e(encode, "$this$encode");
            kotlin.jvm.internal.l.e(charset, "charset");
            byte[] bytes = encode.getBytes(charset);
            kotlin.jvm.internal.l.d(bytes, "(this as java.lang.String).getBytes(charset)");
            return new i(bytes);
        }

        public final i d(String encodeUtf8) {
            kotlin.jvm.internal.l.e(encodeUtf8, "$this$encodeUtf8");
            i iVar = new i(AbstractC0684b.a(encodeUtf8));
            iVar.p(encodeUtf8);
            return iVar;
        }

        public final i e(byte[] toByteString, int i2, int i3) {
            kotlin.jvm.internal.l.e(toByteString, "$this$toByteString");
            AbstractC0685c.b(toByteString.length, i2, i3);
            return new i(AbstractC0668d.g(toByteString, i2, i3 + i2));
        }

        public /* synthetic */ a(kotlin.jvm.internal.g gVar) {
            this();
        }
    }

    public i(byte[] data) {
        kotlin.jvm.internal.l.e(data, "data");
        this.f6035r = data;
    }

    public String a() {
        return AbstractC0683a.c(e(), null, 1, null);
    }

    /* JADX WARN: Code restructure failed: missing block: B:13:0x0031, code lost:
    
        if (r0 < r1) goto L9;
     */
    /* JADX WARN: Code restructure failed: missing block: B:15:0x0034, 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:0x0028, code lost:
    
        if (r7 < r8) goto L9;
     */
    @Override // java.lang.Comparable
    /* JADX INFO: renamed from: b, reason: merged with bridge method [inline-methods] */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public int compareTo(okio.i r10) {
        /*
            r9 = this;
            java.lang.String r0 = "other"
            kotlin.jvm.internal.l.e(r10, r0)
            int r0 = r9.s()
            int r1 = r10.s()
            int r2 = java.lang.Math.min(r0, r1)
            r3 = 0
            r4 = r3
        L13:
            r5 = -1
            r6 = 1
            if (r4 >= r2) goto L2e
            byte r7 = r9.d(r4)
            r7 = r7 & 255(0xff, float:3.57E-43)
            byte r8 = r10.d(r4)
            r8 = r8 & 255(0xff, float:3.57E-43)
            if (r7 != r8) goto L28
            int r4 = r4 + 1
            goto L13
        L28:
            if (r7 >= r8) goto L2c
        L2a:
            r3 = r5
            goto L34
        L2c:
            r3 = r6
            goto L34
        L2e:
            if (r0 != r1) goto L31
            goto L34
        L31:
            if (r0 >= r1) goto L2c
            goto L2a
        L34:
            return r3
        */
        throw new UnsupportedOperationException("Method not decompiled: okio.i.compareTo(okio.i):int");
    }

    public i c(String algorithm) {
        kotlin.jvm.internal.l.e(algorithm, "algorithm");
        byte[] bArrDigest = MessageDigest.getInstance(algorithm).digest(this.f6035r);
        kotlin.jvm.internal.l.d(bArrDigest, "MessageDigest.getInstance(algorithm).digest(data)");
        return new i(bArrDigest);
    }

    public final byte d(int i2) {
        return k(i2);
    }

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

    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj instanceof i) {
            i iVar = (i) obj;
            if (iVar.s() == e().length && iVar.n(0, e(), 0, e().length)) {
                return true;
            }
        }
        return false;
    }

    public final int f() {
        return this.f6033b;
    }

    public int g() {
        return e().length;
    }

    public final String h() {
        return this.f6034g;
    }

    public int hashCode() {
        int iF = f();
        if (iF != 0) {
            return iF;
        }
        int iHashCode = Arrays.hashCode(e());
        o(iHashCode);
        return iHashCode;
    }

    public String i() {
        char[] cArr = new char[e().length * 2];
        int i2 = 0;
        for (byte b2 : e()) {
            int i3 = i2 + 1;
            cArr[i2] = I1.b.f()[(b2 >> 4) & 15];
            i2 += 2;
            cArr[i3] = I1.b.f()[b2 & SDKKeyboardCode.FUNCTION_KEY_BOARD_L];
        }
        return new String(cArr);
    }

    public byte[] j() {
        return e();
    }

    public byte k(int i2) {
        return e()[i2];
    }

    public i l() {
        return c("MD5");
    }

    public boolean m(int i2, i other, int i3, int i4) {
        kotlin.jvm.internal.l.e(other, "other");
        return other.n(i3, e(), i2, i4);
    }

    public boolean n(int i2, byte[] other, int i3, int i4) {
        kotlin.jvm.internal.l.e(other, "other");
        return i2 >= 0 && i2 <= e().length - i4 && i3 >= 0 && i3 <= other.length - i4 && AbstractC0685c.a(e(), i2, other, i3, i4);
    }

    public final void o(int i2) {
        this.f6033b = i2;
    }

    public final void p(String str) {
        this.f6034g = str;
    }

    public i q() {
        return c("SHA-1");
    }

    public i r() {
        return c("SHA-256");
    }

    public final int s() {
        return g();
    }

    public final boolean t(i prefix) {
        kotlin.jvm.internal.l.e(prefix, "prefix");
        return m(0, prefix, 0, prefix.s());
    }

    public String toString() {
        if (e().length == 0) {
            return "[size=0]";
        }
        int iC = I1.b.c(e(), 64);
        if (iC == -1) {
            if (e().length <= 64) {
                return "[hex=" + i() + ']';
            }
            StringBuilder sb = new StringBuilder();
            sb.append("[size=");
            sb.append(e().length);
            sb.append(" hex=");
            if (64 <= e().length) {
                sb.append((64 == e().length ? this : new i(AbstractC0668d.g(e(), 0, 64))).i());
                sb.append("…]");
                return sb.toString();
            }
            throw new IllegalArgumentException(("endIndex > length(" + e().length + ')').toString());
        }
        String strW = w();
        if (strW == null) {
            throw new NullPointerException("null cannot be cast to non-null type java.lang.String");
        }
        String strSubstring = strW.substring(0, iC);
        kotlin.jvm.internal.l.d(strSubstring, "(this as java.lang.Strin…ing(startIndex, endIndex)");
        String strU = E1.g.u(E1.g.u(E1.g.u(strSubstring, "\\", "\\\\", false, 4, null), "\n", "\\n", false, 4, null), "\r", "\\r", false, 4, null);
        if (iC >= strW.length()) {
            return "[text=" + strU + ']';
        }
        return "[size=" + e().length + " text=" + strU + "…]";
    }

    public i u() {
        byte b2;
        for (int i2 = 0; i2 < e().length; i2++) {
            byte b3 = e()[i2];
            byte b4 = (byte) 65;
            if (b3 >= b4 && b3 <= (b2 = (byte) 90)) {
                byte[] bArrE = e();
                byte[] bArrCopyOf = Arrays.copyOf(bArrE, bArrE.length);
                kotlin.jvm.internal.l.d(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 i(bArrCopyOf);
            }
        }
        return this;
    }

    public byte[] v() {
        byte[] bArrE = e();
        byte[] bArrCopyOf = Arrays.copyOf(bArrE, bArrE.length);
        kotlin.jvm.internal.l.d(bArrCopyOf, "java.util.Arrays.copyOf(this, size)");
        return bArrCopyOf;
    }

    public String w() {
        String strH = h();
        if (strH != null) {
            return strH;
        }
        String strB = AbstractC0684b.b(j());
        p(strB);
        return strB;
    }

    public void x(C0688f buffer, int i2, int i3) {
        kotlin.jvm.internal.l.e(buffer, "buffer");
        I1.b.d(this, buffer, i2, i3);
    }
}