package io.netty.util.internal;

import g.a.a.a.a;
import io.netty.handler.codec.dns.DnsRecord;
import java.io.IOException;

/* JADX INFO: loaded from: classes.dex */
public final class StringUtil {
    public static final /* synthetic */ boolean $assertionsDisabled = false;
    public static final char CARRIAGE_RETURN = '\r';
    public static final char COMMA = ',';
    private static final int CSV_NUMBER_ESCAPE_CHARACTERS = 7;
    public static final char DOUBLE_QUOTE = '\"';
    public static final String EMPTY_STRING = "";
    public static final char LINE_FEED = '\n';
    private static final char PACKAGE_SEPARATOR_CHAR = '.';
    public static final char SPACE = ' ';
    public static final char TAB = '\t';
    public static final String NEWLINE = SystemPropertyUtil.get("line.separator", "\n");
    private static final String[] BYTE2HEX_PAD = new String[256];
    private static final String[] BYTE2HEX_NOPAD = new String[256];

    static {
        String str;
        int i2 = 0;
        while (true) {
            String[] strArr = BYTE2HEX_PAD;
            if (i2 >= strArr.length) {
                return;
            }
            String hexString = Integer.toHexString(i2);
            if (i2 > 15) {
                str = hexString;
            } else {
                str = '0' + hexString;
            }
            strArr[i2] = str;
            BYTE2HEX_NOPAD[i2] = hexString;
            i2++;
        }
    }

    private StringUtil() {
    }

    public static <T extends Appendable> T byteToHexString(T t2, int i2) {
        try {
            t2.append(byteToHexString(i2));
        } catch (IOException e2) {
            PlatformDependent.throwException(e2);
        }
        return t2;
    }

    public static String byteToHexString(int i2) {
        return BYTE2HEX_NOPAD[i2 & DnsRecord.CLASS_ANY];
    }

    public static <T extends Appendable> T byteToHexStringPadded(T t2, int i2) {
        try {
            t2.append(byteToHexStringPadded(i2));
        } catch (IOException e2) {
            PlatformDependent.throwException(e2);
        }
        return t2;
    }

    public static String byteToHexStringPadded(int i2) {
        return BYTE2HEX_PAD[i2 & DnsRecord.CLASS_ANY];
    }

    public static boolean commonSuffixOfLength(String str, String str2, int i2) {
        return str != null && str2 != null && i2 >= 0 && str.regionMatches(str.length() - i2, str2, str2.length() - i2, i2);
    }

    public static byte decodeHexByte(CharSequence charSequence, int i2) {
        int iDecodeHexNibble = decodeHexNibble(charSequence.charAt(i2));
        int iDecodeHexNibble2 = decodeHexNibble(charSequence.charAt(i2 + 1));
        if (iDecodeHexNibble == -1 || iDecodeHexNibble2 == -1) {
            throw new IllegalArgumentException(String.format("invalid hex byte '%s' at index %d of '%s'", charSequence.subSequence(i2, i2 + 2), Integer.valueOf(i2), charSequence));
        }
        return (byte) ((iDecodeHexNibble << 4) + iDecodeHexNibble2);
    }

    public static byte[] decodeHexDump(CharSequence charSequence) {
        return decodeHexDump(charSequence, 0, charSequence.length());
    }

    public static byte[] decodeHexDump(CharSequence charSequence, int i2, int i3) {
        if (i3 < 0 || (i3 & 1) != 0) {
            throw new IllegalArgumentException(a.l("length: ", i3));
        }
        if (i3 == 0) {
            return EmptyArrays.EMPTY_BYTES;
        }
        byte[] bArr = new byte[i3 >>> 1];
        for (int i4 = 0; i4 < i3; i4 += 2) {
            bArr[i4 >>> 1] = decodeHexByte(charSequence, i2 + i4);
        }
        return bArr;
    }

    public static int decodeHexNibble(char c2) {
        if (c2 >= '0' && c2 <= '9') {
            return c2 - '0';
        }
        if (c2 >= 'A' && c2 <= 'F') {
            return c2 - '7';
        }
        if (c2 < 'a' || c2 > 'f') {
            return -1;
        }
        return c2 - 'W';
    }

    public static boolean endsWith(CharSequence charSequence, char c2) {
        int length = charSequence.length();
        return length > 0 && charSequence.charAt(length - 1) == c2;
    }

    public static CharSequence escapeCsv(CharSequence charSequence) {
        return escapeCsv(charSequence, false);
    }

    /* JADX WARN: Removed duplicated region for block: B:49:0x0098  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public static java.lang.CharSequence escapeCsv(java.lang.CharSequence r7, boolean r8) {
        /*
            Method dump skipped, instruction units count: 221
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: io.netty.util.internal.StringUtil.escapeCsv(java.lang.CharSequence, boolean):java.lang.CharSequence");
    }

    private static int indexOfFirstNonOwsChar(CharSequence charSequence, int i2) {
        int i3 = 0;
        while (i3 < i2 && isOws(charSequence.charAt(i3))) {
            i3++;
        }
        return i3;
    }

    private static int indexOfLastNonOwsChar(CharSequence charSequence, int i2, int i3) {
        int i4 = i3 - 1;
        while (i4 > i2 && isOws(charSequence.charAt(i4))) {
            i4--;
        }
        return i4;
    }

    public static int indexOfNonWhiteSpace(CharSequence charSequence, int i2) {
        while (i2 < charSequence.length()) {
            if (!Character.isWhitespace(charSequence.charAt(i2))) {
                return i2;
            }
            i2++;
        }
        return -1;
    }

    private static boolean isDoubleQuote(char c2) {
        return c2 == '\"';
    }

    public static boolean isNullOrEmpty(String str) {
        return str == null || str.isEmpty();
    }

    private static boolean isOws(char c2) {
        return c2 == ' ' || c2 == '\t';
    }

    public static boolean isSurrogate(char c2) {
        return c2 >= 55296 && c2 <= 57343;
    }

    public static int length(String str) {
        if (str == null) {
            return 0;
        }
        return str.length();
    }

    private static IllegalArgumentException newInvalidEscapedCsvFieldException(CharSequence charSequence, int i2) {
        return new IllegalArgumentException("invalid escaped CSV field: " + ((Object) charSequence) + " index: " + i2);
    }

    public static String simpleClassName(Class<?> cls) {
        String name = ((Class) ObjectUtil.checkNotNull(cls, "clazz")).getName();
        int iLastIndexOf = name.lastIndexOf(46);
        return iLastIndexOf > -1 ? name.substring(iLastIndexOf + 1) : name;
    }

    public static String simpleClassName(Object obj) {
        return obj == null ? "null_object" : simpleClassName(obj.getClass());
    }

    public static String substringAfter(String str, char c2) {
        int iIndexOf = str.indexOf(c2);
        if (iIndexOf >= 0) {
            return str.substring(iIndexOf + 1);
        }
        return null;
    }

    public static <T extends Appendable> T toHexString(T t2, byte[] bArr) {
        return (T) toHexString(t2, bArr, 0, bArr.length);
    }

    public static <T extends Appendable> T toHexString(T t2, byte[] bArr, int i2, int i3) {
        if (i3 == 0) {
            return t2;
        }
        int i4 = i3 + i2;
        int i5 = i4 - 1;
        while (i2 < i5 && bArr[i2] == 0) {
            i2++;
        }
        int i6 = i2 + 1;
        byteToHexString(t2, bArr[i2]);
        toHexStringPadded(t2, bArr, i6, i4 - i6);
        return t2;
    }

    public static String toHexString(byte[] bArr) {
        return toHexString(bArr, 0, bArr.length);
    }

    public static String toHexString(byte[] bArr, int i2, int i3) {
        return ((StringBuilder) toHexString(new StringBuilder(i3 << 1), bArr, i2, i3)).toString();
    }

    public static <T extends Appendable> T toHexStringPadded(T t2, byte[] bArr) {
        return (T) toHexStringPadded(t2, bArr, 0, bArr.length);
    }

    public static <T extends Appendable> T toHexStringPadded(T t2, byte[] bArr, int i2, int i3) {
        int i4 = i3 + i2;
        while (i2 < i4) {
            byteToHexStringPadded(t2, bArr[i2]);
            i2++;
        }
        return t2;
    }

    public static String toHexStringPadded(byte[] bArr) {
        return toHexStringPadded(bArr, 0, bArr.length);
    }

    public static String toHexStringPadded(byte[] bArr, int i2, int i3) {
        return ((StringBuilder) toHexStringPadded(new StringBuilder(i3 << 1), bArr, i2, i3)).toString();
    }

    public static CharSequence trimOws(CharSequence charSequence) {
        int length = charSequence.length();
        if (length == 0) {
            return charSequence;
        }
        int iIndexOfFirstNonOwsChar = indexOfFirstNonOwsChar(charSequence, length);
        int iIndexOfLastNonOwsChar = indexOfLastNonOwsChar(charSequence, iIndexOfFirstNonOwsChar, length);
        return (iIndexOfFirstNonOwsChar == 0 && iIndexOfLastNonOwsChar == length + (-1)) ? charSequence : charSequence.subSequence(iIndexOfFirstNonOwsChar, iIndexOfLastNonOwsChar + 1);
    }

    public static CharSequence unescapeCsv(CharSequence charSequence) {
        int length = ((CharSequence) ObjectUtil.checkNotNull(charSequence, "value")).length();
        if (length == 0) {
            return charSequence;
        }
        int i2 = length - 1;
        boolean z2 = false;
        if (isDoubleQuote(charSequence.charAt(0)) && isDoubleQuote(charSequence.charAt(i2)) && length != 1) {
            z2 = true;
        }
        if (!z2) {
            validateCsvFormat(charSequence);
            return charSequence;
        }
        StringBuilder sbStringBuilder = InternalThreadLocalMap.get().stringBuilder();
        int i3 = 1;
        while (i3 < i2) {
            char cCharAt = charSequence.charAt(i3);
            if (cCharAt == '\"') {
                int i4 = i3 + 1;
                if (!isDoubleQuote(charSequence.charAt(i4)) || i4 == i2) {
                    throw newInvalidEscapedCsvFieldException(charSequence, i3);
                }
                i3 = i4;
            }
            sbStringBuilder.append(cCharAt);
            i3++;
        }
        return sbStringBuilder.toString();
    }

    /* JADX WARN: Code restructure failed: missing block: B:10:0x002f, code lost:
    
        return r0;
     */
    /* JADX WARN: Code restructure failed: missing block: B:9:0x0028, code lost:
    
        r0.add(r1.toString());
     */
    /* JADX WARN: Removed duplicated region for block: B:24:0x005c  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public static java.util.List<java.lang.CharSequence> unescapeCsvFields(java.lang.CharSequence r11) {
        /*
            java.util.ArrayList r0 = new java.util.ArrayList
            r1 = 2
            r0.<init>(r1)
            io.netty.util.internal.InternalThreadLocalMap r1 = io.netty.util.internal.InternalThreadLocalMap.get()
            java.lang.StringBuilder r1 = r1.stringBuilder()
            int r2 = r11.length()
            r3 = 1
            int r2 = r2 - r3
            r4 = 0
            r5 = r4
            r6 = r5
        L17:
            if (r5 > r2) goto L79
            char r7 = r11.charAt(r5)
            r8 = 44
            r9 = 34
            if (r6 == 0) goto L50
            if (r7 == r9) goto L26
            goto L5c
        L26:
            if (r5 != r2) goto L30
        L28:
            java.lang.String r11 = r1.toString()
            r0.add(r11)
            return r0
        L30:
            int r5 = r5 + 1
            char r7 = r11.charAt(r5)
            if (r7 != r9) goto L3c
            r1.append(r9)
            goto L72
        L3c:
            if (r7 != r8) goto L4a
            java.lang.String r6 = r1.toString()
            r0.add(r6)
            r1.setLength(r4)
            r6 = r4
            goto L72
        L4a:
            int r5 = r5 - r3
            java.lang.IllegalArgumentException r11 = newInvalidEscapedCsvFieldException(r11, r5)
            throw r11
        L50:
            r10 = 10
            if (r7 == r10) goto L74
            r10 = 13
            if (r7 == r10) goto L74
            if (r7 == r9) goto L6b
            if (r7 == r8) goto L60
        L5c:
            r1.append(r7)
            goto L72
        L60:
            java.lang.String r7 = r1.toString()
            r0.add(r7)
            r1.setLength(r4)
            goto L72
        L6b:
            int r6 = r1.length()
            if (r6 != 0) goto L74
            r6 = r3
        L72:
            int r5 = r5 + r3
            goto L17
        L74:
            java.lang.IllegalArgumentException r11 = newInvalidEscapedCsvFieldException(r11, r5)
            throw r11
        L79:
            if (r6 != 0) goto L7c
            goto L28
        L7c:
            java.lang.IllegalArgumentException r11 = newInvalidEscapedCsvFieldException(r11, r2)
            throw r11
        */
        throw new UnsupportedOperationException("Method not decompiled: io.netty.util.internal.StringUtil.unescapeCsvFields(java.lang.CharSequence):java.util.List");
    }

    private static void validateCsvFormat(CharSequence charSequence) {
        int length = charSequence.length();
        for (int i2 = 0; i2 < length; i2++) {
            char cCharAt = charSequence.charAt(i2);
            if (cCharAt == '\n' || cCharAt == '\r' || cCharAt == '\"' || cCharAt == ',') {
                throw newInvalidEscapedCsvFieldException(charSequence, i2);
            }
        }
    }
}