package defpackage;

import android.os.Handler;
import android.os.Looper;
import android.util.Log;
import android.util.SparseBooleanArray;
import j$.util.Objects;

/* JADX INFO: renamed from: ⁱᵔ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes3.dex */
public class C5559 implements InterfaceC2067 {

    /* JADX INFO: renamed from: ᵔᵖᵹᵫ, reason: contains not printable characters */
    public static final char[] f20980 = {'+'};

    /* JADX INFO: renamed from: ᵨᵼⁱ, reason: contains not printable characters */
    public static final char[] f20981 = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

    /* JADX INFO: renamed from: ᵯᵷʽ, reason: contains not printable characters */
    public static final C5559 f20982 = new C5559(true, null, null);

    /* JADX INFO: renamed from: ˌᴵ, reason: contains not printable characters */
    public boolean f20983;

    /* JADX INFO: renamed from: ᵜᵪʾ, reason: contains not printable characters */
    public Object f20984;

    public C5559(int i) {
        switch (i) {
            case C5224.DOUBLE_FIELD_NUMBER /* 7 */:
                this.f20984 = new Handler(Looper.getMainLooper(), new C1469());
                break;
            default:
                this.f20984 = new SparseBooleanArray();
                break;
        }
    }

    public /* synthetic */ C5559(Object obj) {
        this.f20984 = obj;
        this.f20983 = true;
    }

    public C5559(String str, boolean z) {
        if (str.matches(".*[0-9A-Za-z].*")) {
            ᵕᵩʽᵲ.ᵮᵣᵗˈ("Alphanumeric characters are always 'safe' and should not be explicitly specified");
            throw null;
        }
        String strConcat = str.concat("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
        if (z && strConcat.contains(" ")) {
            ᵕᵩʽᵲ.ᵮᵣᵗˈ("plusForSpace cannot be specified when space is a 'safe' character");
            throw null;
        }
        this.f20983 = z;
        char[] charArray = strConcat.toCharArray();
        int iMax = -1;
        for (char c : charArray) {
            iMax = Math.max((int) c, iMax);
        }
        boolean[] zArr = new boolean[iMax + 1];
        for (char c2 : charArray) {
            zArr[c2] = true;
        }
        this.f20984 = zArr;
    }

    public C5559(boolean z, String str, Exception exc) {
        this.f20983 = z;
        this.f20984 = exc;
    }

    /* JADX INFO: renamed from: ᵝᵶ, reason: contains not printable characters */
    public static C5559 m11186(String str, Exception exc) {
        return new C5559(false, str, exc);
    }

    /* JADX INFO: renamed from: ᵮᵣᵗˈ, reason: contains not printable characters */
    public static C5559 m11187(String str) {
        return new C5559(false, str, null);
    }

    @Override // defpackage.InterfaceC2067
    /* JADX INFO: renamed from: ʽˈˋ */
    public void mo5510(C2134 c2134, int i) {
        StringBuilder sb = (StringBuilder) this.f20984;
        if (this.f20983) {
            this.f20983 = false;
        } else {
            sb.append(", ");
        }
        sb.append(i);
    }

    /* JADX INFO: renamed from: ˊᵫᵗ, reason: contains not printable characters */
    public void m11188() {
    }

    /* JADX INFO: renamed from: ːˏᵟᵯ, reason: contains not printable characters */
    public C0719 m11189() {
        ᵻᵪ.ˌᴵ(!this.f20983);
        this.f20983 = true;
        return new C0719((SparseBooleanArray) this.f20984);
    }

    /* JADX INFO: renamed from: ᵨᵣ, reason: contains not printable characters */
    public void m11190() {
        this.f20983 = false;
    }

    /* JADX INFO: renamed from: ᵱᵽʡᵚ */
    public void mo3279() {
    }

    /* JADX INFO: renamed from: ᵲᵶᵳˈ, reason: contains not printable characters */
    public void m11191(int i) {
        ᵻᵪ.ˌᴵ(!this.f20983);
        ((SparseBooleanArray) this.f20984).append(i, true);
    }

    /* JADX INFO: renamed from: ᵵᵽ, reason: contains not printable characters */
    public synchronized void m11192(InterfaceC1364 interfaceC1364, boolean z) {
        try {
            if (this.f20983 || z) {
                ((Handler) this.f20984).obtainMessage(1, interfaceC1364).sendToTarget();
            } else {
                this.f20983 = true;
                interfaceC1364.mo2291();
                this.f20983 = false;
            }
        } catch (Throwable th) {
            throw th;
        }
    }

    /* JADX INFO: renamed from: ᵶᵥᵝ, reason: contains not printable characters */
    public void m11193(C3045 c3045) {
        if (this.f20983) {
            int i = AbstractC2252.f8911;
            Log.isLoggable("BillingLogger", 5);
        } else {
            try {
                ((ᵕˁـ) this.f20984).ᵔᵖᵹᵫ(new C0733(c3045, EnumC3785.f14385), new C4468(0));
            } catch (Throwable unused) {
                int i2 = AbstractC2252.f8911;
                Log.isLoggable("BillingLogger", 5);
            }
        }
    }

    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Removed duplicated region for block: B:55:0x01d2  */
    /* JADX WARN: Removed duplicated region for block: B:58:0x01d8  */
    /* JADX WARN: Removed duplicated region for block: B:76:0x020f  */
    /* JADX INFO: renamed from: ᵷᵺʾᵖ, reason: contains not printable characters */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public String m11194(String str) {
        String str2;
        int i;
        int codePoint;
        int i2;
        Object[] objArr;
        Object obj;
        boolean[] zArr = (boolean[]) this.f20984;
        int length = str.length();
        int i3 = 0;
        while (i3 < length) {
            char cCharAt = str.charAt(i3);
            if (cCharAt >= zArr.length || !zArr[cCharAt]) {
                int length2 = str.length();
                char[] cArr = (char[]) AbstractC2090.f8297.get();
                Objects.requireNonNull(cArr);
                int i4 = 0;
                int length3 = 0;
                while (i3 < length2) {
                    if (i3 >= length2) {
                        C1390.m3982("Index exceeds specified range");
                        return null;
                    }
                    int i5 = i3 + 1;
                    char cCharAt2 = str.charAt(i3);
                    if (cCharAt2 < 55296 || cCharAt2 > 57343) {
                        str2 = null;
                        i = 0;
                        codePoint = cCharAt2;
                    } else {
                        str2 = null;
                        i = 0;
                        if (cCharAt2 > 56319) {
                            throw new IllegalArgumentException("Unexpected low surrogate character '" + cCharAt2 + "' with value " + ((int) cCharAt2) + " at index " + i3 + " in '" + ((Object) str) + "'");
                        }
                        if (i5 == length2) {
                            codePoint = -cCharAt2;
                        } else {
                            char cCharAt3 = str.charAt(i5);
                            if (!Character.isLowSurrogate(cCharAt3)) {
                                throw new IllegalArgumentException("Expected low surrogate but got char '" + cCharAt3 + "' with value " + ((int) cCharAt3) + " at index " + i5 + " in '" + ((Object) str) + "'");
                            }
                            codePoint = Character.toCodePoint(cCharAt2, cCharAt3);
                        }
                    }
                    if (codePoint < 0) {
                        ᵕᵩʽᵲ.ᵮᵣᵗˈ("Trailing high surrogate at end of input");
                        return str2;
                    }
                    if (codePoint < zArr.length && zArr[codePoint]) {
                        obj = str2;
                    } else if (codePoint == 32 && this.f20983) {
                        obj = f20980;
                    } else {
                        char[] cArr2 = f20981;
                        i2 = 1;
                        if (codePoint <= 127) {
                            char[] cArr3 = new char[3];
                            cArr3[i] = '%';
                            cArr3[2] = cArr2[codePoint & 15];
                            cArr3[1] = cArr2[codePoint >>> 4];
                            objArr = cArr3;
                        } else if (codePoint <= 2047) {
                            char[] cArr4 = new char[6];
                            cArr4[i] = '%';
                            cArr4[3] = '%';
                            cArr4[5] = cArr2[codePoint & 15];
                            cArr4[4] = cArr2[((codePoint >>> 4) & 3) | 8];
                            cArr4[2] = cArr2[(codePoint >>> 6) & 15];
                            cArr4[1] = cArr2[12 | (codePoint >>> 10)];
                            objArr = cArr4;
                        } else if (codePoint <= 65535) {
                            char[] cArr5 = new char[9];
                            cArr5[i] = '%';
                            cArr5[1] = 'E';
                            cArr5[3] = '%';
                            cArr5[6] = '%';
                            cArr5[8] = cArr2[codePoint & 15];
                            cArr5[7] = cArr2[((codePoint >>> 4) & 3) | 8];
                            cArr5[5] = cArr2[(codePoint >>> 6) & 15];
                            cArr5[4] = cArr2[((codePoint >>> 10) & 3) | 8];
                            cArr5[2] = cArr2[codePoint >>> 12];
                            objArr = cArr5;
                        } else {
                            if (codePoint > 1114111) {
                                ᵕᵩʽᵲ.ᵮᵣᵗˈ(AbstractC2704.m6517(codePoint, "Invalid unicode character value "));
                                return str2;
                            }
                            char[] cArr6 = new char[12];
                            cArr6[i] = '%';
                            cArr6[1] = 'F';
                            cArr6[3] = '%';
                            cArr6[6] = '%';
                            cArr6[9] = '%';
                            cArr6[11] = cArr2[codePoint & 15];
                            cArr6[10] = cArr2[((codePoint >>> 4) & 3) | 8];
                            cArr6[8] = cArr2[(codePoint >>> 6) & 15];
                            cArr6[7] = cArr2[((codePoint >>> 10) & 3) | 8];
                            cArr6[5] = cArr2[(codePoint >>> 12) & 15];
                            cArr6[4] = cArr2[((codePoint >>> 16) & 3) | 8];
                            cArr6[2] = cArr2[(codePoint >>> 18) & 7];
                            objArr = cArr6;
                        }
                        if (Character.isSupplementaryCodePoint(codePoint)) {
                            i2 = 2;
                        }
                        int i6 = i3 + i2;
                        if (objArr != 0) {
                            int i7 = i3 - i4;
                            int i8 = length3 + i7;
                            int length4 = objArr.length + i8;
                            if (cArr.length < length4) {
                                int i9 = (length2 - i3) + length4 + 32;
                                if (i9 < 0) {
                                    throw new AssertionError("Cannot increase internal buffer any further");
                                }
                                char[] cArr7 = new char[i9];
                                if (length3 > 0) {
                                    int i10 = i;
                                    System.arraycopy(cArr, i10, cArr7, i10, length3);
                                }
                                cArr = cArr7;
                            }
                            if (i7 > 0) {
                                str.getChars(i4, i3, cArr, length3);
                                length3 = i8;
                            }
                            if (objArr.length > 0) {
                                System.arraycopy(objArr, 0, cArr, length3, objArr.length);
                                length3 += objArr.length;
                            }
                            i4 = i6;
                        }
                        i3 = i6;
                        while (i3 < length2) {
                            char cCharAt4 = str.charAt(i3);
                            if (cCharAt4 >= zArr.length || !zArr[cCharAt4]) {
                                break;
                            }
                            i3++;
                        }
                    }
                    i2 = 1;
                    objArr = obj;
                    if (Character.isSupplementaryCodePoint(codePoint)) {
                    }
                    int i62 = i3 + i2;
                    if (objArr != 0) {
                    }
                    i3 = i62;
                    while (i3 < length2) {
                    }
                }
                int i11 = length2 - i4;
                if (i11 > 0) {
                    int i12 = i11 + length3;
                    if (cArr.length < i12) {
                        if (i12 < 0) {
                            throw new AssertionError("Cannot increase internal buffer any further");
                        }
                        char[] cArr8 = new char[i12];
                        if (length3 > 0) {
                            System.arraycopy(cArr, 0, cArr8, 0, length3);
                        }
                        cArr = cArr8;
                    }
                    str.getChars(i4, length2, cArr, length3);
                    length3 = i12;
                }
                return new String(cArr, 0, length3);
            }
            i3++;
        }
        return str;
    }

    /* JADX INFO: renamed from: ᵻʽᵯ, reason: contains not printable characters */
    public void m11195() {
    }

    /* JADX INFO: renamed from: ᵻˈᵦʼ, reason: contains not printable characters */
    public void m11196(char c) {
        C1785 c1785 = (C1785) this.f20984;
        c1785.m4926(c1785.f7163, 1);
        char[] cArr = (char[]) c1785.f7162;
        int i = c1785.f7163;
        c1785.f7163 = i + 1;
        cArr[i] = c;
    }
}