package com.bytedance.sdk.openadsdk.lse;

import com.bytedance.sdk.openadsdk.lse.dsz;
import com.bytedance.sdk.openadsdk.lse.gqi;
import defpackage.e;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.charset.UnsupportedCharsetException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;

/* JADX INFO: loaded from: classes2.dex */
public final class wsy {
    private static final int[] ro = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 44, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1};
    static final Charset fm = StandardCharsets.ISO_8859_1;

    /* JADX INFO: renamed from: com.bytedance.sdk.openadsdk.lse.wsy$1, reason: invalid class name */
    public static /* synthetic */ class AnonymousClass1 {
        static final /* synthetic */ int[] fm;

        static {
            int[] iArr = new int[onz.values().length];
            fm = iArr;
            try {
                iArr[onz.NUMERIC.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                fm[onz.ALPHANUMERIC.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                fm[onz.BYTE.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                fm[onz.KANJI.ordinal()] = 4;
            } catch (NoSuchFieldError unused4) {
            }
        }
    }

    public static final class fm {
        private final byte[] fm;
        private final byte[] ro;

        public fm(byte[] bArr, byte[] bArr2) {
            this.fm = bArr;
            this.ro = bArr2;
        }

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

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

    private static int fm(lb lbVar) {
        return ku.fm(lbVar) + ku.ro(lbVar) + ku.lb(lbVar) + ku.yz(lbVar);
    }

    public static void ro(CharSequence charSequence, com.bytedance.sdk.openadsdk.lse.fm fmVar) throws wey {
        int length = charSequence.length();
        int i10 = 0;
        while (i10 < length) {
            int iFm = fm(charSequence.charAt(i10));
            if (iFm == -1) {
                throw new wey();
            }
            int i11 = i10 + 1;
            if (i11 < length) {
                int iFm2 = fm(charSequence.charAt(i11));
                if (iFm2 == -1) {
                    throw new wey();
                }
                fmVar.fm((iFm * 45) + iFm2, 11);
                i10 += 2;
            } else {
                fmVar.fm(iFm, 6);
                i10 = i11;
            }
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:16:0x0037  */
    /* JADX WARN: Removed duplicated region for block: B:46:0x00cc  */
    /* JADX WARN: Removed duplicated region for block: B:59:0x0133  */
    /* JADX WARN: Removed duplicated region for block: B:9:0x001c  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static fhx fm(String str, wu wuVar, Map<ajl, ?> map) throws wey {
        boolean z10;
        boolean z11;
        gqi gqiVarFm;
        gqi gqiVarRo;
        com.bytedance.sdk.openadsdk.lse.fm fmVar;
        yz yzVarFm;
        int iFm;
        boolean z12 = false;
        if (map != null) {
            ajl ajlVar = ajl.GS1_FORMAT;
            z10 = map.containsKey(ajlVar) && Boolean.parseBoolean(map.get(ajlVar).toString());
        }
        if (map != null) {
            ajl ajlVar2 = ajl.QR_COMPACT;
            z11 = map.containsKey(ajlVar2) && Boolean.parseBoolean(map.get(ajlVar2).toString());
        }
        Charset charsetForName = fm;
        if (map != null && map.containsKey(ajl.CHARACTER_SET)) {
            z12 = true;
        }
        if (z12) {
            try {
                charsetForName = Charset.forName(map.get(ajl.CHARACTER_SET).toString());
            } catch (UnsupportedCharsetException unused) {
            }
        }
        if (z11) {
            onz onzVar = onz.NUMERIC;
            if (charsetForName.equals(fm)) {
                charsetForName = null;
            }
            dsz.ro roVarFm = dsz.fm(str, null, charsetForName, z10, wuVar);
            fmVar = new com.bytedance.sdk.openadsdk.lse.fm();
            roVarFm.fm(fmVar);
            gqiVarRo = roVarFm.ro();
        } else {
            onz onzVarFm = fm(str, charsetForName);
            com.bytedance.sdk.openadsdk.lse.fm fmVar2 = new com.bytedance.sdk.openadsdk.lse.fm();
            onz onzVar2 = onz.BYTE;
            if (onzVarFm == onzVar2 && z12 && (yzVarFm = yz.fm(charsetForName)) != null) {
                fm(yzVarFm, fmVar2);
            }
            if (z10) {
                fm(onz.FNC1_FIRST_POSITION, fmVar2);
            }
            fm(onzVarFm, fmVar2);
            com.bytedance.sdk.openadsdk.lse.fm fmVar3 = new com.bytedance.sdk.openadsdk.lse.fm();
            fm(str, onzVarFm, fmVar3, charsetForName);
            if (map != null) {
                ajl ajlVar3 = ajl.QR_VERSION;
                if (map.containsKey(ajlVar3)) {
                    gqiVarFm = gqi.fm(Integer.parseInt(map.get(ajlVar3).toString()));
                    if (!fm(fm(onzVarFm, fmVar2, fmVar3, gqiVarFm), gqiVarFm, wuVar)) {
                        throw new wey("Data too big for requested version");
                    }
                } else {
                    gqiVarFm = fm(wuVar, onzVarFm, fmVar2, fmVar3);
                }
                com.bytedance.sdk.openadsdk.lse.fm fmVar4 = new com.bytedance.sdk.openadsdk.lse.fm();
                fmVar4.fm(fmVar2);
                fm(onzVarFm == onzVar2 ? fmVar3.ro() : str.length(), gqiVarFm, onzVarFm, fmVar4);
                fmVar4.fm(fmVar3);
                gqiVarRo = gqiVarFm;
                fmVar = fmVar4;
            }
        }
        gqi.ro roVarFm2 = gqiVarRo.fm(wuVar);
        int iRo = gqiVarRo.ro() - roVarFm2.lb();
        fm(iRo, fmVar);
        com.bytedance.sdk.openadsdk.lse.fm fmVarFm = fm(fmVar, gqiVarRo.ro(), iRo, roVarFm2.ro());
        fhx fhxVar = new fhx();
        int iLb = gqiVarRo.lb();
        lb lbVar = new lb(iLb, iLb);
        if (map != null) {
            ajl ajlVar4 = ajl.QR_MASK_PATTERN;
            if (map.containsKey(ajlVar4)) {
                iFm = Integer.parseInt(map.get(ajlVar4).toString());
                if (!fhx.fm(iFm)) {
                    iFm = -1;
                }
            }
        }
        if (iFm == -1) {
            iFm = fm(fmVarFm, wuVar, gqiVarRo, lbVar);
        }
        duv.fm(fmVarFm, wuVar, gqiVarRo, iFm, lbVar);
        fhxVar.fm(lbVar);
        return fhxVar;
    }

    private static gqi fm(wu wuVar, onz onzVar, com.bytedance.sdk.openadsdk.lse.fm fmVar, com.bytedance.sdk.openadsdk.lse.fm fmVar2) throws wey {
        return fm(fm(onzVar, fmVar, fmVar2, fm(fm(onzVar, fmVar, fmVar2, gqi.fm(1)), wuVar)), wuVar);
    }

    private static int fm(onz onzVar, com.bytedance.sdk.openadsdk.lse.fm fmVar, com.bytedance.sdk.openadsdk.lse.fm fmVar2, gqi gqiVar) {
        return fmVar2.fm() + onzVar.fm(gqiVar) + fmVar.fm();
    }

    public static int fm(int i10) {
        int[] iArr = ro;
        if (i10 < iArr.length) {
            return iArr[i10];
        }
        return -1;
    }

    private static onz fm(String str, Charset charset) {
        Charset charset2 = gof.fm;
        if (charset2 != null && charset2.equals(charset) && fm(str)) {
            return onz.KANJI;
        }
        boolean z10 = false;
        boolean z11 = false;
        for (int i10 = 0; i10 < str.length(); i10++) {
            char cCharAt = str.charAt(i10);
            if (cCharAt >= '0' && cCharAt <= '9') {
                z11 = true;
            } else {
                if (fm(cCharAt) == -1) {
                    return onz.BYTE;
                }
                z10 = true;
            }
        }
        if (z10) {
            return onz.ALPHANUMERIC;
        }
        if (z11) {
            return onz.NUMERIC;
        }
        return onz.BYTE;
    }

    public static boolean fm(String str) {
        byte[] bytes = str.getBytes(gof.fm);
        int length = bytes.length;
        if (length % 2 != 0) {
            return false;
        }
        for (int i10 = 0; i10 < length; i10 += 2) {
            int i11 = bytes[i10] & 255;
            if ((i11 < 129 || i11 > 159) && (i11 < 224 || i11 > 235)) {
                return false;
            }
        }
        return true;
    }

    private static int fm(com.bytedance.sdk.openadsdk.lse.fm fmVar, wu wuVar, gqi gqiVar, lb lbVar) throws wey {
        int i10 = Integer.MAX_VALUE;
        int i11 = -1;
        for (int i12 = 0; i12 < 8; i12++) {
            duv.fm(fmVar, wuVar, gqiVar, i12, lbVar);
            int iFm = fm(lbVar);
            if (iFm < i10) {
                i11 = i12;
                i10 = iFm;
            }
        }
        return i11;
    }

    private static gqi fm(int i10, wu wuVar) throws wey {
        for (int i11 = 1; i11 <= 40; i11++) {
            gqi gqiVarFm = gqi.fm(i11);
            if (fm(i10, gqiVarFm, wuVar)) {
                return gqiVarFm;
            }
        }
        throw new wey("Data too big");
    }

    public static boolean fm(int i10, gqi gqiVar, wu wuVar) {
        return gqiVar.ro() - gqiVar.fm(wuVar).lb() >= (i10 + 7) / 8;
    }

    public static void fm(int i10, com.bytedance.sdk.openadsdk.lse.fm fmVar) throws wey {
        int i11 = i10 * 8;
        if (fmVar.fm() <= i11) {
            for (int i12 = 0; i12 < 4 && fmVar.fm() < i11; i12++) {
                fmVar.fm(false);
            }
            int iFm = fmVar.fm() & 7;
            if (iFm > 0) {
                while (iFm < 8) {
                    fmVar.fm(false);
                    iFm++;
                }
            }
            int iRo = i10 - fmVar.ro();
            for (int i13 = 0; i13 < iRo; i13++) {
                fmVar.fm((i13 & 1) == 0 ? 236 : 17, 8);
            }
            if (fmVar.fm() != i11) {
                throw new wey("Bits size does not equal capacity");
            }
            return;
        }
        throw new wey("data bits cannot fit in the QR Code" + fmVar.fm() + " > " + i11);
    }

    public static void fm(int i10, int i11, int i12, int i13, int[] iArr, int[] iArr2) throws wey {
        if (i13 < i12) {
            int i14 = i10 % i12;
            int i15 = i12 - i14;
            int i16 = i10 / i12;
            int i17 = i16 + 1;
            int i18 = i11 / i12;
            int i19 = i18 + 1;
            int i20 = i16 - i18;
            int i21 = i17 - i19;
            if (i20 != i21) {
                throw new wey("EC bytes mismatch");
            }
            if (i12 != i15 + i14) {
                throw new wey("RS blocks mismatch");
            }
            if (i10 != ((i19 + i21) * i14) + ((i18 + i20) * i15)) {
                throw new wey("Total bytes mismatch");
            }
            if (i13 < i15) {
                iArr[0] = i18;
                iArr2[0] = i20;
                return;
            } else {
                iArr[0] = i19;
                iArr2[0] = i21;
                return;
            }
        }
        throw new wey("Block ID too large");
    }

    public static com.bytedance.sdk.openadsdk.lse.fm fm(com.bytedance.sdk.openadsdk.lse.fm fmVar, int i10, int i11, int i12) throws wey {
        if (fmVar.ro() == i11) {
            ArrayList arrayList = new ArrayList(i12);
            int i13 = 0;
            int iMax = 0;
            int iMax2 = 0;
            for (int i14 = 0; i14 < i12; i14++) {
                int[] iArr = new int[1];
                int[] iArr2 = new int[1];
                fm(i10, i11, i12, i14, iArr, iArr2);
                int i15 = iArr[0];
                byte[] bArr = new byte[i15];
                fmVar.fm(i13 * 8, bArr, 0, i15);
                byte[] bArrFm = fm(bArr, iArr2[0]);
                arrayList.add(new fm(bArr, bArrFm));
                iMax = Math.max(iMax, i15);
                iMax2 = Math.max(iMax2, bArrFm.length);
                i13 += iArr[0];
            }
            if (i11 == i13) {
                com.bytedance.sdk.openadsdk.lse.fm fmVar2 = new com.bytedance.sdk.openadsdk.lse.fm();
                for (int i16 = 0; i16 < iMax; i16++) {
                    Iterator it = arrayList.iterator();
                    while (it.hasNext()) {
                        byte[] bArrFm2 = ((fm) it.next()).fm();
                        if (i16 < bArrFm2.length) {
                            fmVar2.fm(bArrFm2[i16], 8);
                        }
                    }
                }
                for (int i17 = 0; i17 < iMax2; i17++) {
                    Iterator it2 = arrayList.iterator();
                    while (it2.hasNext()) {
                        byte[] bArrRo = ((fm) it2.next()).ro();
                        if (i17 < bArrRo.length) {
                            fmVar2.fm(bArrRo[i17], 8);
                        }
                    }
                }
                if (i10 == fmVar2.ro()) {
                    return fmVar2;
                }
                StringBuilder sbQ = e.q("Interleaving error: ", i10, " and ");
                sbQ.append(fmVar2.ro());
                sbQ.append(" differ.");
                throw new wey(sbQ.toString());
            }
            throw new wey("Data bytes does not match offset");
        }
        throw new wey("Number of bits and data bytes does not match");
    }

    public static byte[] fm(byte[] bArr, int i10) {
        int length = bArr.length;
        int[] iArr = new int[length + i10];
        for (int i11 = 0; i11 < length; i11++) {
            iArr[i11] = bArr[i11] & 255;
        }
        new qhl(ef.fm).fm(iArr, i10);
        byte[] bArr2 = new byte[i10];
        for (int i12 = 0; i12 < i10; i12++) {
            bArr2[i12] = (byte) iArr[length + i12];
        }
        return bArr2;
    }

    public static void fm(onz onzVar, com.bytedance.sdk.openadsdk.lse.fm fmVar) {
        fmVar.fm(onzVar.fm(), 4);
    }

    public static void fm(int i10, gqi gqiVar, onz onzVar, com.bytedance.sdk.openadsdk.lse.fm fmVar) throws wey {
        int iFm = onzVar.fm(gqiVar);
        int i11 = 1 << iFm;
        if (i10 < i11) {
            fmVar.fm(i10, iFm);
            return;
        }
        throw new wey(i10 + " is bigger than " + (i11 - 1));
    }

    public static void fm(String str, onz onzVar, com.bytedance.sdk.openadsdk.lse.fm fmVar, Charset charset) throws wey {
        int i10 = AnonymousClass1.fm[onzVar.ordinal()];
        if (i10 == 1) {
            fm((CharSequence) str, fmVar);
            return;
        }
        if (i10 == 2) {
            ro(str, fmVar);
        } else if (i10 == 3) {
            fm(str, fmVar, charset);
        } else {
            if (i10 == 4) {
                fm(str, fmVar);
                return;
            }
            throw new wey("Invalid mode: ".concat(String.valueOf(onzVar)));
        }
    }

    public static void fm(CharSequence charSequence, com.bytedance.sdk.openadsdk.lse.fm fmVar) {
        int length = charSequence.length();
        int i10 = 0;
        while (i10 < length) {
            int iCharAt = charSequence.charAt(i10) - '0';
            int i11 = i10 + 2;
            if (i11 < length) {
                fmVar.fm(((charSequence.charAt(i10 + 1) - '0') * 10) + (iCharAt * 100) + (charSequence.charAt(i11) - '0'), 10);
                i10 += 3;
            } else {
                i10++;
                if (i10 < length) {
                    fmVar.fm((iCharAt * 10) + (charSequence.charAt(i10) - '0'), 7);
                    i10 = i11;
                } else {
                    fmVar.fm(iCharAt, 4);
                }
            }
        }
    }

    public static void fm(String str, com.bytedance.sdk.openadsdk.lse.fm fmVar, Charset charset) {
        for (byte b10 : str.getBytes(charset)) {
            fmVar.fm(b10, 8);
        }
    }

    public static void fm(String str, com.bytedance.sdk.openadsdk.lse.fm fmVar) throws wey {
        int i10;
        Charset charset = gof.fm;
        if (charset != null) {
            byte[] bytes = str.getBytes(charset);
            if (bytes.length % 2 == 0) {
                int length = bytes.length - 1;
                for (int i11 = 0; i11 < length; i11 += 2) {
                    int i12 = ((bytes[i11] & 255) << 8) | (bytes[i11 + 1] & 255);
                    int i13 = 33088;
                    if (i12 >= 33088 && i12 <= 40956) {
                        i10 = i12 - i13;
                    } else if (i12 < 57408 || i12 > 60351) {
                        i10 = -1;
                    } else {
                        i13 = 49472;
                        i10 = i12 - i13;
                    }
                    if (i10 != -1) {
                        fmVar.fm(((i10 >> 8) * 192) + (i10 & 255), 13);
                    } else {
                        throw new wey("Invalid byte sequence");
                    }
                }
                return;
            }
            throw new wey("Kanji byte size not even");
        }
        throw new wey("SJIS Charset not supported on this platform");
    }

    private static void fm(yz yzVar, com.bytedance.sdk.openadsdk.lse.fm fmVar) {
        fmVar.fm(onz.ECI.fm(), 4);
        fmVar.fm(yzVar.fm(), 8);
    }
}