package x7;

import java.io.Serializable;
import java.security.MessageDigest;
import java.util.Arrays;

/* JADX INFO: renamed from: x7.j, reason: case insensitive filesystem */
/* JADX INFO: loaded from: classes.dex */
public class C1734j implements Serializable, Comparable {

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

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

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

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

    public C1734j(byte[] bArr) {
        P6.g.e(bArr, "data");
        this.f18767q = bArr;
    }

    public static int f(C1734j c1734j, C1734j c1734j2) {
        c1734j.getClass();
        P6.g.e(c1734j2, "other");
        return c1734j.e(0, c1734j2.f18767q);
    }

    public static int j(C1734j c1734j, C1734j c1734j2) {
        c1734j.getClass();
        P6.g.e(c1734j2, "other");
        return c1734j.i(c1734j2.f18767q);
    }

    public static /* synthetic */ C1734j n(C1734j c1734j, int i, int i5, int i8) {
        if ((i8 & 1) != 0) {
            i = 0;
        }
        if ((i8 & 2) != 0) {
            i5 = -1234567890;
        }
        return c1734j.m(i, i5);
    }

    @Override // java.lang.Comparable
    /* JADX INFO: renamed from: a, reason: merged with bridge method [inline-methods] */
    public final int compareTo(C1734j c1734j) {
        P6.g.e(c1734j, "other");
        int iC = c();
        int iC2 = c1734j.c();
        int iMin = Math.min(iC, iC2);
        for (int i = 0; i < iMin; i++) {
            int iH = h(i) & 255;
            int iH2 = c1734j.h(i) & 255;
            if (iH != iH2) {
                return iH < iH2 ? -1 : 1;
            }
        }
        if (iC == iC2) {
            return 0;
        }
        return iC < iC2 ? -1 : 1;
    }

    public C1734j b(String str) {
        MessageDigest messageDigest = MessageDigest.getInstance(str);
        messageDigest.update(this.f18767q, 0, c());
        byte[] bArrDigest = messageDigest.digest();
        P6.g.b(bArrDigest);
        return new C1734j(bArrDigest);
    }

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

    public String d() {
        byte[] bArr = this.f18767q;
        char[] cArr = new char[bArr.length * 2];
        int i = 0;
        for (byte b8 : bArr) {
            int i5 = i + 1;
            char[] cArr2 = y7.b.f19040a;
            cArr[i] = cArr2[(b8 >> 4) & 15];
            i += 2;
            cArr[i5] = cArr2[b8 & 15];
        }
        return new String(cArr);
    }

    public int e(int i, byte[] bArr) {
        P6.g.e(bArr, "other");
        byte[] bArr2 = this.f18767q;
        int length = bArr2.length - bArr.length;
        int iMax = Math.max(i, 0);
        if (iMax > length) {
            return -1;
        }
        while (!s7.d.c(iMax, 0, bArr.length, bArr2, bArr)) {
            if (iMax == length) {
                return -1;
            }
            iMax++;
        }
        return iMax;
    }

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

    public byte[] g() {
        return this.f18767q;
    }

    public byte h(int i) {
        return this.f18767q[i];
    }

    public int hashCode() {
        int i = this.f18768r;
        if (i != 0) {
            return i;
        }
        int iHashCode = Arrays.hashCode(this.f18767q);
        this.f18768r = iHashCode;
        return iHashCode;
    }

    public int i(byte[] bArr) {
        P6.g.e(bArr, "other");
        int iC = c();
        byte[] bArr2 = this.f18767q;
        for (int iMin = Math.min(iC, bArr2.length - bArr.length); -1 < iMin; iMin--) {
            if (s7.d.c(iMin, 0, bArr.length, bArr2, bArr)) {
                return iMin;
            }
        }
        return -1;
    }

    public boolean k(int i, int i5, int i8, byte[] bArr) {
        P6.g.e(bArr, "other");
        if (i < 0) {
            return false;
        }
        byte[] bArr2 = this.f18767q;
        return i <= bArr2.length - i8 && i5 >= 0 && i5 <= bArr.length - i8 && s7.d.c(i, i5, i8, bArr2, bArr);
    }

    public boolean l(int i, C1734j c1734j, int i5) {
        P6.g.e(c1734j, "other");
        return c1734j.k(0, i, i5, this.f18767q);
    }

    public C1734j m(int i, int i5) {
        if (i5 == -1234567890) {
            i5 = c();
        }
        if (i < 0) {
            throw new IllegalArgumentException("beginIndex < 0");
        }
        byte[] bArr = this.f18767q;
        if (i5 <= bArr.length) {
            if (i5 - i >= 0) {
                return (i == 0 && i5 == bArr.length) ? this : new C1734j(B6.j.J(bArr, i, i5));
            }
            throw new IllegalArgumentException("endIndex < beginIndex");
        }
        throw new IllegalArgumentException(("endIndex > length(" + bArr.length + ')').toString());
    }

    public C1734j o() {
        int i = 0;
        while (true) {
            byte[] bArr = this.f18767q;
            if (i >= bArr.length) {
                return this;
            }
            byte b8 = bArr[i];
            if (b8 >= 65 && b8 <= 90) {
                byte[] bArrCopyOf = Arrays.copyOf(bArr, bArr.length);
                P6.g.d(bArrCopyOf, "copyOf(...)");
                bArrCopyOf[i] = (byte) (b8 + 32);
                for (int i5 = i + 1; i5 < bArrCopyOf.length; i5++) {
                    byte b9 = bArrCopyOf[i5];
                    if (b9 >= 65 && b9 <= 90) {
                        bArrCopyOf[i5] = (byte) (b9 + 32);
                    }
                }
                return new C1734j(bArrCopyOf);
            }
            i++;
        }
    }

    public final String p() {
        String str = this.f18769s;
        if (str != null) {
            return str;
        }
        byte[] bArrG = g();
        P6.g.e(bArrG, "<this>");
        String str2 = new String(bArrG, X6.a.f7235a);
        this.f18769s = str2;
        return str2;
    }

    public void q(C1731g c1731g, int i) {
        P6.g.e(c1731g, "buffer");
        c1731g.s0(this.f18767q, 0, i);
    }

    public String toString() {
        byte b8;
        int i;
        byte[] bArr = this.f18767q;
        if (bArr.length == 0) {
            return "[size=0]";
        }
        int length = bArr.length;
        int i5 = 0;
        int i8 = 0;
        int i9 = 0;
        loop0: while (true) {
            if (i5 >= length) {
                break;
            }
            byte b9 = bArr[i5];
            if (b9 >= 0) {
                int i10 = i9 + 1;
                if (i9 == 64) {
                    break;
                }
                if ((b9 != 10 && b9 != 13 && ((b9 >= 0 && b9 < 32) || (127 <= b9 && b9 < 160))) || b9 == 65533) {
                    break;
                }
                i8 += b9 < 65536 ? 1 : 2;
                i5++;
                while (true) {
                    i9 = i10;
                    if (i5 < length && (b8 = bArr[i5]) >= 0) {
                        i5++;
                        i10 = i9 + 1;
                        if (i9 == 64) {
                            break loop0;
                        }
                        if ((b8 != 10 && b8 != 13 && ((b8 >= 0 && b8 < 32) || (127 <= b8 && b8 < 160))) || b8 == 65533) {
                            break loop0;
                        }
                        i8 += b8 < 65536 ? 1 : 2;
                    } else {
                        break;
                    }
                }
            } else if ((b9 >> 5) == -2) {
                int i11 = i5 + 1;
                if (length > i11) {
                    byte b10 = bArr[i11];
                    if ((b10 & 192) == 128) {
                        int i12 = (b10 ^ 3968) ^ (b9 << 6);
                        if (i12 >= 128) {
                            i = i9 + 1;
                            if (i9 == 64) {
                                break;
                            }
                            if ((i12 != 10 && i12 != 13 && ((i12 >= 0 && i12 < 32) || (127 <= i12 && i12 < 160))) || i12 == 65533) {
                                break;
                            }
                            i8 += i12 < 65536 ? 1 : 2;
                            i5 += 2;
                            i9 = i;
                        } else if (i9 != 64) {
                            break;
                        }
                    } else if (i9 != 64) {
                        break;
                    }
                } else if (i9 != 64) {
                    break;
                }
            } else if ((b9 >> 4) == -2) {
                int i13 = i5 + 2;
                if (length > i13) {
                    byte b11 = bArr[i5 + 1];
                    if ((b11 & 192) == 128) {
                        byte b12 = bArr[i13];
                        if ((b12 & 192) == 128) {
                            int i14 = ((b12 ^ (-123008)) ^ (b11 << 6)) ^ (b9 << 12);
                            if (i14 < 2048) {
                                if (i9 != 64) {
                                    break;
                                }
                            } else if (55296 > i14 || i14 >= 57344) {
                                i = i9 + 1;
                                if (i9 == 64) {
                                    break;
                                }
                                if ((i14 != 10 && i14 != 13 && ((i14 >= 0 && i14 < 32) || (127 <= i14 && i14 < 160))) || i14 == 65533) {
                                    break;
                                }
                                i8 += i14 < 65536 ? 1 : 2;
                                i5 += 3;
                                i9 = i;
                            } else if (i9 != 64) {
                                break;
                            }
                        } else if (i9 != 64) {
                            break;
                        }
                    } else if (i9 != 64) {
                        break;
                    }
                } else if (i9 != 64) {
                    break;
                }
            } else if ((b9 >> 3) == -2) {
                int i15 = i5 + 3;
                if (length > i15) {
                    byte b13 = bArr[i5 + 1];
                    if ((b13 & 192) == 128) {
                        byte b14 = bArr[i5 + 2];
                        if ((b14 & 192) == 128) {
                            byte b15 = bArr[i15];
                            if ((b15 & 192) == 128) {
                                int i16 = (((b15 ^ 3678080) ^ (b14 << 6)) ^ (b13 << 12)) ^ (b9 << 18);
                                if (i16 > 1114111) {
                                    if (i9 != 64) {
                                        break;
                                    }
                                } else if (55296 > i16 || i16 >= 57344) {
                                    if (i16 >= 65536) {
                                        i = i9 + 1;
                                        if (i9 == 64) {
                                            break;
                                        }
                                        if ((i16 != 10 && i16 != 13 && ((i16 >= 0 && i16 < 32) || (127 <= i16 && i16 < 160))) || i16 == 65533) {
                                            break;
                                        }
                                        i8 += i16 < 65536 ? 1 : 2;
                                        i5 += 4;
                                        i9 = i;
                                    } else if (i9 != 64) {
                                        break;
                                    }
                                } else if (i9 != 64) {
                                    break;
                                }
                            } else if (i9 != 64) {
                                break;
                            }
                        } else if (i9 != 64) {
                            break;
                        }
                    } else if (i9 != 64) {
                        break;
                    }
                } else if (i9 != 64) {
                    break;
                }
            } else if (i9 != 64) {
                break;
            }
        }
        i8 = -1;
        if (i8 != -1) {
            String strP = p();
            String strSubstring = strP.substring(0, i8);
            P6.g.d(strSubstring, "substring(...)");
            String strK = X6.n.K(X6.n.K(X6.n.K(strSubstring, "\\", "\\\\"), "\n", "\\n"), "\r", "\\r");
            if (i8 >= strP.length()) {
                return "[text=" + strK + ']';
            }
            return "[size=" + bArr.length + " text=" + strK + "…]";
        }
        if (bArr.length <= 64) {
            return "[hex=" + d() + ']';
        }
        StringBuilder sb = new StringBuilder("[size=");
        sb.append(bArr.length);
        sb.append(" hex=");
        if (64 <= bArr.length) {
            sb.append((64 == bArr.length ? this : new C1734j(B6.j.J(bArr, 0, 64))).d());
            sb.append("…]");
            return sb.toString();
        }
        throw new IllegalArgumentException(("endIndex > length(" + bArr.length + ')').toString());
    }
}