package j9;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import s8.r;
import t8.z;

/* JADX INFO: Access modifiers changed from: package-private */
/* loaded from: classes2.dex */
public abstract class o extends n {

    static final class a extends d9.k implements c9.p {

        /* renamed from: a, reason: collision with root package name */
        final /* synthetic */ char[] f11132a;

        /* renamed from: b, reason: collision with root package name */
        final /* synthetic */ boolean f11133b;

        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
        a(char[] cArr, boolean z10) {
            super(2);
            this.f11132a = cArr;
            this.f11133b = z10;
        }

        public final s8.m a(CharSequence charSequence, int i10) {
            d9.j.e(charSequence, "$this$$receiver");
            int n10 = o.n(charSequence, this.f11132a, i10, this.f11133b);
            if (n10 < 0) {
                return null;
            }
            return r.a(Integer.valueOf(n10), 1);
        }

        @Override // c9.p
        public /* bridge */ /* synthetic */ Object invoke(Object obj, Object obj2) {
            return a((CharSequence) obj, ((Number) obj2).intValue());
        }
    }

    public static /* synthetic */ List A(CharSequence charSequence, char[] cArr, boolean z10, int i10, int i11, Object obj) {
        if ((i11 & 2) != 0) {
            z10 = false;
        }
        if ((i11 & 4) != 0) {
            i10 = 0;
        }
        return y(charSequence, cArr, z10, i10);
    }

    public static final String B(CharSequence charSequence, g9.c cVar) {
        d9.j.e(charSequence, "<this>");
        d9.j.e(cVar, "range");
        return charSequence.subSequence(cVar.h().intValue(), cVar.g().intValue() + 1).toString();
    }

    public static final String C(String str, char c10, String str2) {
        int l10;
        d9.j.e(str, "<this>");
        d9.j.e(str2, "missingDelimiterValue");
        l10 = l(str, c10, 0, false, 6, null);
        if (l10 == -1) {
            return str2;
        }
        String substring = str.substring(l10 + 1, str.length());
        d9.j.d(substring, "this as java.lang.String…ing(startIndex, endIndex)");
        return substring;
    }

    public static final String D(String str, String str2, String str3) {
        d9.j.e(str, "<this>");
        d9.j.e(str2, "delimiter");
        d9.j.e(str3, "missingDelimiterValue");
        int m10 = m(str, str2, 0, false, 6, null);
        if (m10 == -1) {
            return str3;
        }
        String substring = str.substring(m10 + str2.length(), str.length());
        d9.j.d(substring, "this as java.lang.String…ing(startIndex, endIndex)");
        return substring;
    }

    public static /* synthetic */ String E(String str, char c10, String str2, int i10, Object obj) {
        if ((i10 & 2) != 0) {
            str2 = str;
        }
        return C(str, c10, str2);
    }

    public static /* synthetic */ String F(String str, String str2, String str3, int i10, Object obj) {
        if ((i10 & 2) != 0) {
            str3 = str;
        }
        return D(str, str2, str3);
    }

    public static final String G(String str, char c10, String str2) {
        d9.j.e(str, "<this>");
        d9.j.e(str2, "missingDelimiterValue");
        int p10 = p(str, c10, 0, false, 6, null);
        if (p10 == -1) {
            return str2;
        }
        String substring = str.substring(p10 + 1, str.length());
        d9.j.d(substring, "this as java.lang.String…ing(startIndex, endIndex)");
        return substring;
    }

    public static /* synthetic */ String H(String str, char c10, String str2, int i10, Object obj) {
        if ((i10 & 2) != 0) {
            str2 = str;
        }
        return G(str, c10, str2);
    }

    public static final String I(String str, char c10, String str2) {
        int l10;
        d9.j.e(str, "<this>");
        d9.j.e(str2, "missingDelimiterValue");
        l10 = l(str, c10, 0, false, 6, null);
        if (l10 == -1) {
            return str2;
        }
        String substring = str.substring(0, l10);
        d9.j.d(substring, "this as java.lang.String…ing(startIndex, endIndex)");
        return substring;
    }

    public static final String J(String str, String str2, String str3) {
        d9.j.e(str, "<this>");
        d9.j.e(str2, "delimiter");
        d9.j.e(str3, "missingDelimiterValue");
        int m10 = m(str, str2, 0, false, 6, null);
        if (m10 == -1) {
            return str3;
        }
        String substring = str.substring(0, m10);
        d9.j.d(substring, "this as java.lang.String…ing(startIndex, endIndex)");
        return substring;
    }

    public static /* synthetic */ String K(String str, char c10, String str2, int i10, Object obj) {
        if ((i10 & 2) != 0) {
            str2 = str;
        }
        return I(str, c10, str2);
    }

    public static /* synthetic */ String L(String str, String str2, String str3, int i10, Object obj) {
        if ((i10 & 2) != 0) {
            str3 = str;
        }
        return J(str, str2, str3);
    }

    public static CharSequence M(CharSequence charSequence) {
        d9.j.e(charSequence, "<this>");
        int length = charSequence.length() - 1;
        int i10 = 0;
        boolean z10 = false;
        while (i10 <= length) {
            boolean c10 = j9.a.c(charSequence.charAt(!z10 ? i10 : length));
            if (z10) {
                if (!c10) {
                    break;
                }
                length--;
            } else if (c10) {
                i10++;
            } else {
                z10 = true;
            }
        }
        return charSequence.subSequence(i10, length + 1);
    }

    public static final int g(CharSequence charSequence) {
        d9.j.e(charSequence, "<this>");
        return charSequence.length() - 1;
    }

    public static final int h(CharSequence charSequence, char c10, int i10, boolean z10) {
        d9.j.e(charSequence, "<this>");
        return (z10 || !(charSequence instanceof String)) ? n(charSequence, new char[]{c10}, i10, z10) : ((String) charSequence).indexOf(c10, i10);
    }

    public static final int i(CharSequence charSequence, String str, int i10, boolean z10) {
        d9.j.e(charSequence, "<this>");
        d9.j.e(str, "string");
        return (z10 || !(charSequence instanceof String)) ? k(charSequence, str, i10, charSequence.length(), z10, false, 16, null) : ((String) charSequence).indexOf(str, i10);
    }

    private static final int j(CharSequence charSequence, CharSequence charSequence2, int i10, int i11, boolean z10, boolean z11) {
        int c10;
        int a10;
        g9.a f10;
        int a11;
        int c11;
        if (z11) {
            c10 = g9.f.c(i10, g(charSequence));
            a10 = g9.f.a(i11, 0);
            f10 = g9.f.f(c10, a10);
        } else {
            a11 = g9.f.a(i10, 0);
            c11 = g9.f.c(i11, charSequence.length());
            f10 = new g9.c(a11, c11);
        }
        if ((charSequence instanceof String) && (charSequence2 instanceof String)) {
            int a12 = f10.a();
            int b10 = f10.b();
            int c12 = f10.c();
            if ((c12 <= 0 || a12 > b10) && (c12 >= 0 || b10 > a12)) {
                return -1;
            }
            while (!n.d((String) charSequence2, 0, (String) charSequence, a12, charSequence2.length(), z10)) {
                if (a12 == b10) {
                    return -1;
                }
                a12 += c12;
            }
            return a12;
        }
        int a13 = f10.a();
        int b11 = f10.b();
        int c13 = f10.c();
        if ((c13 <= 0 || a13 > b11) && (c13 >= 0 || b11 > a13)) {
            return -1;
        }
        while (!w(charSequence2, 0, charSequence, a13, charSequence2.length(), z10)) {
            if (a13 == b11) {
                return -1;
            }
            a13 += c13;
        }
        return a13;
    }

    static /* synthetic */ int k(CharSequence charSequence, CharSequence charSequence2, int i10, int i11, boolean z10, boolean z11, int i12, Object obj) {
        return j(charSequence, charSequence2, i10, i11, z10, (i12 & 16) != 0 ? false : z11);
    }

    public static /* synthetic */ int l(CharSequence charSequence, char c10, int i10, boolean z10, int i11, Object obj) {
        if ((i11 & 2) != 0) {
            i10 = 0;
        }
        if ((i11 & 4) != 0) {
            z10 = false;
        }
        return h(charSequence, c10, i10, z10);
    }

    public static /* synthetic */ int m(CharSequence charSequence, String str, int i10, boolean z10, int i11, Object obj) {
        if ((i11 & 2) != 0) {
            i10 = 0;
        }
        if ((i11 & 4) != 0) {
            z10 = false;
        }
        return i(charSequence, str, i10, z10);
    }

    public static final int n(CharSequence charSequence, char[] cArr, int i10, boolean z10) {
        int a10;
        boolean z11;
        char z12;
        d9.j.e(charSequence, "<this>");
        d9.j.e(cArr, "chars");
        if (!z10 && cArr.length == 1 && (charSequence instanceof String)) {
            z12 = t8.i.z(cArr);
            return ((String) charSequence).indexOf(z12, i10);
        }
        a10 = g9.f.a(i10, 0);
        z it = new g9.c(a10, g(charSequence)).iterator();
        while (it.hasNext()) {
            int a11 = it.a();
            char charAt = charSequence.charAt(a11);
            int length = cArr.length;
            int i11 = 0;
            while (true) {
                if (i11 >= length) {
                    z11 = false;
                    break;
                }
                if (b.d(cArr[i11], charAt, z10)) {
                    z11 = true;
                    break;
                }
                i11++;
            }
            if (z11) {
                return a11;
            }
        }
        return -1;
    }

    public static final int o(CharSequence charSequence, char c10, int i10, boolean z10) {
        d9.j.e(charSequence, "<this>");
        return (z10 || !(charSequence instanceof String)) ? q(charSequence, new char[]{c10}, i10, z10) : ((String) charSequence).lastIndexOf(c10, i10);
    }

    public static /* synthetic */ int p(CharSequence charSequence, char c10, int i10, boolean z10, int i11, Object obj) {
        if ((i11 & 2) != 0) {
            i10 = g(charSequence);
        }
        if ((i11 & 4) != 0) {
            z10 = false;
        }
        return o(charSequence, c10, i10, z10);
    }

    public static final int q(CharSequence charSequence, char[] cArr, int i10, boolean z10) {
        int c10;
        char z11;
        d9.j.e(charSequence, "<this>");
        d9.j.e(cArr, "chars");
        if (!z10 && cArr.length == 1 && (charSequence instanceof String)) {
            z11 = t8.i.z(cArr);
            return ((String) charSequence).lastIndexOf(z11, i10);
        }
        for (c10 = g9.f.c(i10, g(charSequence)); -1 < c10; c10--) {
            char charAt = charSequence.charAt(c10);
            int length = cArr.length;
            boolean z12 = false;
            int i11 = 0;
            while (true) {
                if (i11 >= length) {
                    break;
                }
                if (b.d(cArr[i11], charAt, z10)) {
                    z12 = true;
                    break;
                }
                i11++;
            }
            if (z12) {
                return c10;
            }
        }
        return -1;
    }

    public static final CharSequence r(CharSequence charSequence, int i10, char c10) {
        d9.j.e(charSequence, "<this>");
        if (i10 < 0) {
            throw new IllegalArgumentException("Desired length " + i10 + " is less than zero.");
        }
        if (i10 <= charSequence.length()) {
            return charSequence.subSequence(0, charSequence.length());
        }
        StringBuilder sb = new StringBuilder(i10);
        sb.append(charSequence);
        z it = new g9.c(1, i10 - charSequence.length()).iterator();
        while (it.hasNext()) {
            it.a();
            sb.append(c10);
        }
        return sb;
    }

    public static final String s(String str, int i10, char c10) {
        d9.j.e(str, "<this>");
        return r(str, i10, c10).toString();
    }

    public static /* synthetic */ String t(String str, int i10, char c10, int i11, Object obj) {
        if ((i11 & 2) != 0) {
            c10 = ' ';
        }
        return s(str, i10, c10);
    }

    private static final i9.b u(CharSequence charSequence, char[] cArr, int i10, boolean z10, int i11) {
        x(i11);
        return new d(charSequence, i10, i11, new a(cArr, z10));
    }

    static /* synthetic */ i9.b v(CharSequence charSequence, char[] cArr, int i10, boolean z10, int i11, int i12, Object obj) {
        if ((i12 & 2) != 0) {
            i10 = 0;
        }
        if ((i12 & 4) != 0) {
            z10 = false;
        }
        if ((i12 & 8) != 0) {
            i11 = 0;
        }
        return u(charSequence, cArr, i10, z10, i11);
    }

    public static final boolean w(CharSequence charSequence, int i10, CharSequence charSequence2, int i11, int i12, boolean z10) {
        d9.j.e(charSequence, "<this>");
        d9.j.e(charSequence2, "other");
        if (i11 < 0 || i10 < 0 || i10 > charSequence.length() - i12 || i11 > charSequence2.length() - i12) {
            return false;
        }
        for (int i13 = 0; i13 < i12; i13++) {
            if (!b.d(charSequence.charAt(i10 + i13), charSequence2.charAt(i11 + i13), z10)) {
                return false;
            }
        }
        return true;
    }

    public static final void x(int i10) {
        if (i10 >= 0) {
            return;
        }
        throw new IllegalArgumentException(("Limit must be non-negative, but was " + i10).toString());
    }

    public static final List y(CharSequence charSequence, char[] cArr, boolean z10, int i10) {
        Iterable e10;
        int h10;
        d9.j.e(charSequence, "<this>");
        d9.j.e(cArr, "delimiters");
        if (cArr.length == 1) {
            return z(charSequence, String.valueOf(cArr[0]), z10, i10);
        }
        e10 = i9.j.e(v(charSequence, cArr, 0, z10, i10, 2, null));
        h10 = t8.n.h(e10, 10);
        ArrayList arrayList = new ArrayList(h10);
        Iterator it = e10.iterator();
        while (it.hasNext()) {
            arrayList.add(B(charSequence, (g9.c) it.next()));
        }
        return arrayList;
    }

    private static final List z(CharSequence charSequence, String str, boolean z10, int i10) {
        x(i10);
        int i11 = 0;
        int i12 = i(charSequence, str, 0, z10);
        if (i12 == -1 || i10 == 1) {
            return t8.l.b(charSequence.toString());
        }
        boolean z11 = i10 > 0;
        ArrayList arrayList = new ArrayList(z11 ? g9.f.c(i10, 10) : 10);
        do {
            arrayList.add(charSequence.subSequence(i11, i12).toString());
            i11 = str.length() + i12;
            if (z11 && arrayList.size() == i10 - 1) {
                break;
            }
            i12 = i(charSequence, str, i11, z10);
        } while (i12 != -1);
        arrayList.add(charSequence.subSequence(i11, charSequence.length()).toString());
        return arrayList;
    }
}