package com.google.zxing.pdf417.encoder;

import com.google.zxing.WriterException;
import com.google.zxing.common.CharacterSetECI;
import com.seewo.sdk.model.SDKKeyboardCode;
import java.math.BigInteger;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.util.Arrays;

/* JADX INFO: loaded from: classes.dex */
final class PDF417HighLevelEncoder {
    private static final int BYTE_COMPACTION = 1;
    private static final int ECI_CHARSET = 927;
    private static final int ECI_GENERAL_PURPOSE = 926;
    private static final int ECI_USER_DEFINED = 925;
    private static final int LATCH_TO_BYTE = 924;
    private static final int LATCH_TO_BYTE_PADDED = 901;
    private static final int LATCH_TO_NUMERIC = 902;
    private static final int LATCH_TO_TEXT = 900;
    private static final byte[] MIXED;
    private static final int NUMERIC_COMPACTION = 2;
    private static final int SHIFT_TO_BYTE = 913;
    private static final int SUBMODE_ALPHA = 0;
    private static final int SUBMODE_LOWER = 1;
    private static final int SUBMODE_MIXED = 2;
    private static final int SUBMODE_PUNCTUATION = 3;
    private static final int TEXT_COMPACTION = 0;
    private static final byte[] TEXT_MIXED_RAW = {SDKKeyboardCode.FUNCTION_KEY_BOARD_RIGHT_SQUARE_BRACKET, SDKKeyboardCode.FUNCTION_KEY_BOARD_RIGHT_SLASH, 50, SDKKeyboardCode.FUNCTION_KEY_BOARD_SEMICOLON, SDKKeyboardCode.FUNCTION_KEY_BOARD_SINGLE_QUOTE_MARK, SDKKeyboardCode.FUNCTION_KEY_BOARD_GRAVE_ACCENT, SDKKeyboardCode.FUNCTION_KEY_BOARD_COMMA, SDKKeyboardCode.FUNCTION_KEY_BOARD_STOP, SDKKeyboardCode.FUNCTION_KEY_BOARD_LEFT_SLASH, SDKKeyboardCode.FUNCTION_KEY_BOARD_CAPS_LOCK, SDKKeyboardCode.FUNCTION_KEY_BOARD_9, SDKKeyboardCode.FUNCTION_KEY_BOARD_J, 9, SDKKeyboardCode.FUNCTION_KEY_BOARD_SPACE, SDKKeyboardCode.FUNCTION_KEY_BOARD_F1, SDKKeyboardCode.FUNCTION_KEY_BOARD_6, SDKKeyboardCode.FUNCTION_KEY_BOARD_MINUS, SDKKeyboardCode.FUNCTION_KEY_BOARD_PLUS, SDKKeyboardCode.FUNCTION_KEY_BOARD_7, SDKKeyboardCode.FUNCTION_KEY_BOARD_LEFT_SQUARE_BRACKET, SDKKeyboardCode.FUNCTION_KEY_BOARD_TAB, SDKKeyboardCode.FUNCTION_KEY_BOARD_8, SDKKeyboardCode.FUNCTION_KEY_BOARD_BACKSPACE, SDKKeyboardCode.FUNCTION_KEY_BOARD_F4, 94, 0, SDKKeyboardCode.FUNCTION_KEY_BOARD_3, 0, 0, 0};
    private static final byte[] TEXT_PUNCTUATION_RAW = {SDKKeyboardCode.FUNCTION_KEY_BOARD_F2, SDKKeyboardCode.FUNCTION_KEY_BOARD_F3, SDKKeyboardCode.FUNCTION_KEY_BOARD_F5, SDKKeyboardCode.FUNCTION_KEY_BOARD_F7, 91, 92, 93, 95, 96, 126, SDKKeyboardCode.FUNCTION_KEY_BOARD_4, SDKKeyboardCode.FUNCTION_KEY_BOARD_J, 9, SDKKeyboardCode.FUNCTION_KEY_BOARD_SPACE, SDKKeyboardCode.FUNCTION_KEY_BOARD_F1, 10, SDKKeyboardCode.FUNCTION_KEY_BOARD_MINUS, SDKKeyboardCode.FUNCTION_KEY_BOARD_PLUS, SDKKeyboardCode.FUNCTION_KEY_BOARD_7, SDKKeyboardCode.FUNCTION_KEY_BOARD_LEFT_SQUARE_BRACKET, SDKKeyboardCode.FUNCTION_KEY_BOARD_5, 124, SDKKeyboardCode.FUNCTION_KEY_BOARD_BACKSPACE, SDKKeyboardCode.FUNCTION_KEY_BOARD_ENTER, SDKKeyboardCode.FUNCTION_KEY_BOARD_ESC, SDKKeyboardCode.FUNCTION_KEY_BOARD_F6, 123, 125, SDKKeyboardCode.FUNCTION_KEY_BOARD_0, 0};
    private static final byte[] PUNCTUATION = new byte[128];
    private static final Charset DEFAULT_ENCODING = Charset.forName("ISO-8859-1");

    static {
        int i2 = 0;
        byte[] bArr = new byte[128];
        MIXED = bArr;
        Arrays.fill(bArr, (byte) -1);
        int i3 = 0;
        while (true) {
            byte[] bArr2 = TEXT_MIXED_RAW;
            if (i3 >= bArr2.length) {
                break;
            }
            byte b2 = bArr2[i3];
            if (b2 > 0) {
                MIXED[b2] = (byte) i3;
            }
            i3++;
        }
        Arrays.fill(PUNCTUATION, (byte) -1);
        while (true) {
            byte[] bArr3 = TEXT_PUNCTUATION_RAW;
            if (i2 >= bArr3.length) {
                return;
            }
            byte b3 = bArr3[i2];
            if (b3 > 0) {
                PUNCTUATION[b3] = (byte) i2;
            }
            i2++;
        }
    }

    private PDF417HighLevelEncoder() {
    }

    private static int determineConsecutiveBinaryCount(String str, int i2, Charset charset) throws WriterException {
        int i3;
        CharsetEncoder charsetEncoderNewEncoder = charset.newEncoder();
        int length = str.length();
        int i4 = i2;
        while (i4 < length) {
            char cCharAt = str.charAt(i4);
            int i5 = 0;
            while (i5 < 13 && isDigit(cCharAt) && (i3 = i4 + (i5 = i5 + 1)) < length) {
                cCharAt = str.charAt(i3);
            }
            if (i5 >= 13) {
                return i4 - i2;
            }
            char cCharAt2 = str.charAt(i4);
            if (!charsetEncoderNewEncoder.canEncode(cCharAt2)) {
                throw new WriterException("Non-encodable character detected: " + cCharAt2 + " (Unicode: " + ((int) cCharAt2) + ')');
            }
            i4++;
        }
        return i4 - i2;
    }

    private static int determineConsecutiveDigitCount(CharSequence charSequence, int i2) {
        int length = charSequence.length();
        int i3 = 0;
        if (i2 < length) {
            char cCharAt = charSequence.charAt(i2);
            while (isDigit(cCharAt) && i2 < length) {
                i3++;
                i2++;
                if (i2 < length) {
                    cCharAt = charSequence.charAt(i2);
                }
            }
        }
        return i3;
    }

    private static int determineConsecutiveTextCount(CharSequence charSequence, int i2) {
        int length = charSequence.length();
        int i3 = i2;
        while (i3 < length) {
            char cCharAt = charSequence.charAt(i3);
            int i4 = 0;
            while (i4 < 13 && isDigit(cCharAt) && i3 < length) {
                i4++;
                i3++;
                if (i3 < length) {
                    cCharAt = charSequence.charAt(i3);
                }
            }
            if (i4 < 13) {
                if (i4 <= 0) {
                    if (!isText(charSequence.charAt(i3))) {
                        break;
                    }
                    i3++;
                }
            } else {
                return (i3 - i2) - i4;
            }
        }
        return i3 - i2;
    }

    private static void encodeBinary(byte[] bArr, int i2, int i3, int i4, StringBuilder sb) {
        int i5;
        if (i3 == 1 && i4 == 0) {
            sb.append((char) 913);
        } else if (i3 % 6 == 0) {
            sb.append((char) 924);
        } else {
            sb.append((char) 901);
        }
        if (i3 >= 6) {
            char[] cArr = new char[5];
            i5 = i2;
            while ((i2 + i3) - i5 >= 6) {
                long j2 = 0;
                for (int i6 = 0; i6 < 6; i6++) {
                    j2 = (j2 << 8) + ((long) (bArr[i5 + i6] & 255));
                }
                for (int i7 = 0; i7 < 5; i7++) {
                    cArr[i7] = (char) (j2 % 900);
                    j2 /= 900;
                }
                for (int i8 = 4; i8 >= 0; i8--) {
                    sb.append(cArr[i8]);
                }
                i5 += 6;
            }
        } else {
            i5 = i2;
        }
        while (i5 < i2 + i3) {
            sb.append((char) (bArr[i5] & 255));
            i5++;
        }
    }

    static String encodeHighLevel(String str, Compaction compaction, Charset charset) throws WriterException {
        CharacterSetECI characterSetECIByName;
        StringBuilder sb = new StringBuilder(str.length());
        if (charset == null) {
            charset = DEFAULT_ENCODING;
        } else if (!DEFAULT_ENCODING.equals(charset) && (characterSetECIByName = CharacterSetECI.getCharacterSetECIByName(charset.name())) != null) {
            encodingECI(characterSetECIByName.getValue(), sb);
        }
        int length = str.length();
        if (compaction == Compaction.TEXT) {
            encodeText(str, 0, length, sb, 0);
        } else if (compaction == Compaction.BYTE) {
            byte[] bytes = str.getBytes(charset);
            encodeBinary(bytes, 0, bytes.length, 1, sb);
        } else if (compaction == Compaction.NUMERIC) {
            sb.append((char) 902);
            encodeNumeric(str, 0, length, sb);
        } else {
            int i2 = 0;
            int iEncodeText = 0;
            int i3 = 0;
            while (i2 < length) {
                int iDetermineConsecutiveDigitCount = determineConsecutiveDigitCount(str, i2);
                if (iDetermineConsecutiveDigitCount >= 13) {
                    sb.append((char) 902);
                    encodeNumeric(str, i2, iDetermineConsecutiveDigitCount, sb);
                    i2 += iDetermineConsecutiveDigitCount;
                    i3 = 2;
                    iEncodeText = 0;
                } else {
                    int iDetermineConsecutiveTextCount = determineConsecutiveTextCount(str, i2);
                    if (iDetermineConsecutiveTextCount >= 5 || iDetermineConsecutiveDigitCount == length) {
                        if (i3 != 0) {
                            sb.append((char) 900);
                            iEncodeText = 0;
                            i3 = 0;
                        }
                        iEncodeText = encodeText(str, i2, iDetermineConsecutiveTextCount, sb, iEncodeText);
                        i2 += iDetermineConsecutiveTextCount;
                    } else {
                        int iDetermineConsecutiveBinaryCount = determineConsecutiveBinaryCount(str, i2, charset);
                        if (iDetermineConsecutiveBinaryCount == 0) {
                            iDetermineConsecutiveBinaryCount = 1;
                        }
                        int i4 = iDetermineConsecutiveBinaryCount + i2;
                        byte[] bytes2 = str.substring(i2, i4).getBytes(charset);
                        if (bytes2.length == 1 && i3 == 0) {
                            encodeBinary(bytes2, 0, 1, 0, sb);
                        } else {
                            encodeBinary(bytes2, 0, bytes2.length, i3, sb);
                            iEncodeText = 0;
                            i3 = 1;
                        }
                        i2 = i4;
                    }
                }
            }
        }
        return sb.toString();
    }

    private static void encodeNumeric(String str, int i2, int i3, StringBuilder sb) {
        StringBuilder sb2 = new StringBuilder((i3 / 3) + 1);
        BigInteger bigIntegerValueOf = BigInteger.valueOf(900L);
        BigInteger bigIntegerValueOf2 = BigInteger.valueOf(0L);
        int i4 = 0;
        while (i4 < i3) {
            sb2.setLength(0);
            int iMin = Math.min(44, i3 - i4);
            StringBuilder sb3 = new StringBuilder("1");
            int i5 = i2 + i4;
            sb3.append(str.substring(i5, i5 + iMin));
            BigInteger bigInteger = new BigInteger(sb3.toString());
            do {
                sb2.append((char) bigInteger.mod(bigIntegerValueOf).intValue());
                bigInteger = bigInteger.divide(bigIntegerValueOf);
            } while (!bigInteger.equals(bigIntegerValueOf2));
            for (int length = sb2.length() - 1; length >= 0; length--) {
                sb.append(sb2.charAt(length));
            }
            i4 += iMin;
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:73:0x00f4 A[EDGE_INSN: B:73:0x00f4->B:55:0x00f4 BREAK  A[LOOP:0: B:3:0x000f->B:90:0x000f], SYNTHETIC] */
    /* JADX WARN: Removed duplicated region for block: B:92:0x000f A[SYNTHETIC] */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    private static int encodeText(java.lang.CharSequence r16, int r17, int r18, java.lang.StringBuilder r19, int r20) {
        /*
            Method dump skipped, instruction units count: 285
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: com.google.zxing.pdf417.encoder.PDF417HighLevelEncoder.encodeText(java.lang.CharSequence, int, int, java.lang.StringBuilder, int):int");
    }

    private static void encodingECI(int i2, StringBuilder sb) throws WriterException {
        if (i2 >= 0 && i2 < LATCH_TO_TEXT) {
            sb.append((char) 927);
            sb.append((char) i2);
            return;
        }
        if (i2 < 810900) {
            sb.append((char) 926);
            sb.append((char) ((i2 / LATCH_TO_TEXT) - 1));
            sb.append((char) (i2 % LATCH_TO_TEXT));
        } else if (i2 < 811800) {
            sb.append((char) 925);
            sb.append((char) (810900 - i2));
        } else {
            throw new WriterException("ECI number not in valid range from 0..811799, but was " + i2);
        }
    }

    private static boolean isAlphaLower(char c2) {
        if (c2 != ' ') {
            return c2 >= 'a' && c2 <= 'z';
        }
        return true;
    }

    private static boolean isAlphaUpper(char c2) {
        if (c2 != ' ') {
            return c2 >= 'A' && c2 <= 'Z';
        }
        return true;
    }

    private static boolean isDigit(char c2) {
        return c2 >= '0' && c2 <= '9';
    }

    private static boolean isMixed(char c2) {
        return MIXED[c2] != -1;
    }

    private static boolean isPunctuation(char c2) {
        return PUNCTUATION[c2] != -1;
    }

    private static boolean isText(char c2) {
        if (c2 == '\t' || c2 == '\n' || c2 == '\r') {
            return true;
        }
        return c2 >= ' ' && c2 <= '~';
    }
}