package kotlin.text;

import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;

/* JADX INFO: loaded from: classes.dex */
public abstract class h extends g {
    public static String a0(char[] cArr, int i10, int i11) {
        kotlin.collections.a aVar = kotlin.collections.d.Companion;
        int length = cArr.length;
        aVar.getClass();
        if (i10 < 0 || i11 > length) {
            StringBuilder sbR = defpackage.e.r("startIndex: ", i10, ", endIndex: ", i11, ", size: ");
            sbR.append(length);
            throw new IndexOutOfBoundsException(sbR.toString());
        }
        if (i10 <= i11) {
            return new String(cArr, i10, i11 - i10);
        }
        throw new IllegalArgumentException(defpackage.e.f("startIndex: ", i10, " > endIndex: ", i11));
    }

    public static boolean b0(String str, String str2, boolean z10) {
        nb.g.i(str, "<this>");
        nb.g.i(str2, "suffix");
        return !z10 ? str.endsWith(str2) : f0(str, str.length() - str2.length(), true, str2, 0, str2.length());
    }

    public static boolean c0(String str, String str2) {
        return str == null ? str2 == null : str.equalsIgnoreCase(str2);
    }

    public static Comparator d0() {
        Comparator comparator = String.CASE_INSENSITIVE_ORDER;
        nb.g.h(comparator, "CASE_INSENSITIVE_ORDER");
        return comparator;
    }

    public static boolean e0(CharSequence charSequence) {
        nb.g.i(charSequence, "<this>");
        if (charSequence.length() == 0) {
            return true;
        }
        Iterable cVar = new xd.c(0, charSequence.length() - 1, 1);
        if ((cVar instanceof Collection) && ((Collection) cVar).isEmpty()) {
            return true;
        }
        Iterator it = cVar.iterator();
        while (it.hasNext()) {
            if (!ua.b.C(charSequence.charAt(((xd.b) it).b()))) {
                return false;
            }
        }
        return true;
    }

    public static final boolean f0(String str, int i10, boolean z10, String str2, int i11, int i12) {
        nb.g.i(str, "<this>");
        nb.g.i(str2, "other");
        return !z10 ? str.regionMatches(i10, str2, i11, i12) : str.regionMatches(z10, i10, str2, i11, i12);
    }

    public static String g0(String str, char c6, char c10) {
        nb.g.i(str, "<this>");
        String strReplace = str.replace(c6, c10);
        nb.g.h(strReplace, "this as java.lang.String…replace(oldChar, newChar)");
        return strReplace;
    }

    public static String h0(String str, String str2, String str3) {
        nb.g.i(str, "<this>");
        int iN0 = i.n0(0, str, str2, false);
        if (iN0 < 0) {
            return str;
        }
        int length = str2.length();
        int i10 = length >= 1 ? length : 1;
        int length2 = str3.length() + (str.length() - length);
        if (length2 < 0) {
            throw new OutOfMemoryError();
        }
        StringBuilder sb = new StringBuilder(length2);
        int i11 = 0;
        do {
            sb.append((CharSequence) str, i11, iN0);
            sb.append(str3);
            i11 = iN0 + length;
            if (iN0 >= str.length()) {
                break;
            }
            iN0 = i.n0(iN0 + i10, str, str2, false);
        } while (iN0 > 0);
        sb.append((CharSequence) str, i11, str.length());
        String string = sb.toString();
        nb.g.h(string, "stringBuilder.append(this, i, length).toString()");
        return string;
    }

    public static boolean i0(String str, int i10, String str2, boolean z10) {
        nb.g.i(str, "<this>");
        return !z10 ? str.startsWith(str2, i10) : f0(str, i10, z10, str2, 0, str2.length());
    }

    public static boolean j0(String str, String str2, boolean z10) {
        nb.g.i(str, "<this>");
        nb.g.i(str2, "prefix");
        return !z10 ? str.startsWith(str2) : f0(str, 0, z10, str2, 0, str2.length());
    }
}