package d0.g0;

import c.d.b.a.a;
import d0.d0.f;
import d0.t.c0;
import d0.z.d.d0;
import d0.z.d.m;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Locale;
import java.util.Objects;
import kotlin.ranges.IntRange;
/* compiled from: StringsJVM.kt */
public class t extends s {
    public static final String capitalize(String str) {
        m.checkNotNullParameter(str, "$this$capitalize");
        Locale locale = Locale.getDefault();
        m.checkNotNullExpressionValue(locale, "Locale.getDefault()");
        return capitalize(str, locale);
    }

    public static final String capitalize(String str, Locale locale) {
        m.checkNotNullParameter(str, "$this$capitalize");
        m.checkNotNullParameter(locale, "locale");
        if (!(str.length() > 0)) {
            return str;
        }
        char charAt = str.charAt(0);
        if (!Character.isLowerCase(charAt)) {
            return str;
        }
        StringBuilder sb = new StringBuilder();
        char titleCase = Character.toTitleCase(charAt);
        if (titleCase != Character.toUpperCase(charAt)) {
            sb.append(titleCase);
        } else {
            String substring = str.substring(0, 1);
            m.checkNotNullExpressionValue(substring, "(this as java.lang.Strin…ing(startIndex, endIndex)");
            Objects.requireNonNull(substring, "null cannot be cast to non-null type java.lang.String");
            String upperCase = substring.toUpperCase(locale);
            m.checkNotNullExpressionValue(upperCase, "(this as java.lang.String).toUpperCase(locale)");
            sb.append(upperCase);
        }
        String substring2 = str.substring(1);
        m.checkNotNullExpressionValue(substring2, "(this as java.lang.String).substring(startIndex)");
        sb.append(substring2);
        String sb2 = sb.toString();
        m.checkNotNullExpressionValue(sb2, "StringBuilder().apply(builderAction).toString()");
        return sb2;
    }

    public static final int compareTo(String str, String str2, boolean z2) {
        m.checkNotNullParameter(str, "$this$compareTo");
        m.checkNotNullParameter(str2, "other");
        return z2 ? str.compareToIgnoreCase(str2) : str.compareTo(str2);
    }

    public static final String decapitalize(String str) {
        m.checkNotNullParameter(str, "$this$decapitalize");
        if (!(str.length() > 0) || Character.isLowerCase(str.charAt(0))) {
            return str;
        }
        StringBuilder sb = new StringBuilder();
        String substring = str.substring(0, 1);
        m.checkNotNullExpressionValue(substring, "(this as java.lang.Strin…ing(startIndex, endIndex)");
        Objects.requireNonNull(substring, "null cannot be cast to non-null type java.lang.String");
        String lowerCase = substring.toLowerCase();
        m.checkNotNullExpressionValue(lowerCase, "(this as java.lang.String).toLowerCase()");
        sb.append(lowerCase);
        String substring2 = str.substring(1);
        m.checkNotNullExpressionValue(substring2, "(this as java.lang.String).substring(startIndex)");
        sb.append(substring2);
        return sb.toString();
    }

    public static final boolean endsWith(String str, String str2, boolean z2) {
        m.checkNotNullParameter(str, "$this$endsWith");
        m.checkNotNullParameter(str2, "suffix");
        return !z2 ? str.endsWith(str2) : regionMatches(str, str.length() - str2.length(), str2, 0, str2.length(), true);
    }

    public static /* synthetic */ boolean endsWith$default(String str, String str2, boolean z2, int i, Object obj) {
        if ((i & 2) != 0) {
            z2 = false;
        }
        return endsWith(str, str2, z2);
    }

    public static final boolean equals(String str, String str2, boolean z2) {
        return str == null ? str2 == null : !z2 ? str.equals(str2) : str.equalsIgnoreCase(str2);
    }

    public static /* synthetic */ boolean equals$default(String str, String str2, boolean z2, int i, Object obj) {
        if ((i & 2) != 0) {
            z2 = false;
        }
        return equals(str, str2, z2);
    }

    public static final Comparator<String> getCASE_INSENSITIVE_ORDER(d0 d0Var) {
        m.checkNotNullParameter(d0Var, "$this$CASE_INSENSITIVE_ORDER");
        Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
        m.checkNotNullExpressionValue(comparator, "java.lang.String.CASE_INSENSITIVE_ORDER");
        return comparator;
    }

    /* JADX WARNING: Removed duplicated region for block: B:17:? A[RETURN, SYNTHETIC] */
    public static final boolean isBlank(CharSequence charSequence) {
        boolean z2;
        m.checkNotNullParameter(charSequence, "$this$isBlank");
        if (charSequence.length() != 0) {
            IntRange indices = w.getIndices(charSequence);
            if (!(indices instanceof Collection) || !((Collection) indices).isEmpty()) {
                Iterator<Integer> it = indices.iterator();
                while (true) {
                    if (it.hasNext()) {
                        if (!a.isWhitespace(charSequence.charAt(((c0) it).nextInt()))) {
                            z2 = false;
                            break;
                        }
                    } else {
                        break;
                    }
                }
                if (z2) {
                    return false;
                }
            }
            z2 = true;
            if (z2) {
            }
        }
        return true;
    }

    public static final boolean regionMatches(String str, int i, String str2, int i2, int i3, boolean z2) {
        m.checkNotNullParameter(str, "$this$regionMatches");
        m.checkNotNullParameter(str2, "other");
        return !z2 ? str.regionMatches(i, str2, i2, i3) : str.regionMatches(z2, i, str2, i2, i3);
    }

    public static final String repeat(CharSequence charSequence, int i) {
        m.checkNotNullParameter(charSequence, "$this$repeat");
        int i2 = 1;
        if (!(i >= 0)) {
            throw new IllegalArgumentException(("Count 'n' must be non-negative, but was " + i + '.').toString());
        } else if (i == 0) {
            return "";
        } else {
            if (i == 1) {
                return charSequence.toString();
            }
            int length = charSequence.length();
            if (length == 0) {
                return "";
            }
            if (length != 1) {
                StringBuilder sb = new StringBuilder(charSequence.length() * i);
                if (1 <= i) {
                    while (true) {
                        sb.append(charSequence);
                        if (i2 == i) {
                            break;
                        }
                        i2++;
                    }
                }
                String sb2 = sb.toString();
                m.checkNotNullExpressionValue(sb2, "sb.toString()");
                return sb2;
            }
            char charAt = charSequence.charAt(0);
            char[] cArr = new char[i];
            for (int i3 = 0; i3 < i; i3++) {
                cArr[i3] = charAt;
            }
            return new String(cArr);
        }
    }

    public static final String replace(String str, char c2, char c3, boolean z2) {
        m.checkNotNullParameter(str, "$this$replace");
        if (!z2) {
            String replace = str.replace(c2, c3);
            m.checkNotNullExpressionValue(replace, "(this as java.lang.Strin…replace(oldChar, newChar)");
            return replace;
        }
        StringBuilder sb = new StringBuilder(str.length());
        for (int i = 0; i < str.length(); i++) {
            char charAt = str.charAt(i);
            if (b.equals(charAt, c2, z2)) {
                charAt = c3;
            }
            sb.append(charAt);
        }
        String sb2 = sb.toString();
        m.checkNotNullExpressionValue(sb2, "StringBuilder(capacity).…builderAction).toString()");
        return sb2;
    }

    public static final String replace(String str, String str2, String str3, boolean z2) {
        m.checkNotNullParameter(str, "$this$replace");
        m.checkNotNullParameter(str2, "oldValue");
        m.checkNotNullParameter(str3, "newValue");
        int i = 0;
        int indexOf = w.indexOf(str, str2, 0, z2);
        if (indexOf < 0) {
            return str;
        }
        int length = str2.length();
        int coerceAtLeast = f.coerceAtLeast(length, 1);
        int length2 = str3.length() + (str.length() - length);
        if (length2 >= 0) {
            StringBuilder sb = new StringBuilder(length2);
            do {
                sb.append((CharSequence) str, i, indexOf);
                sb.append(str3);
                i = indexOf + length;
                if (indexOf >= str.length()) {
                    break;
                }
                indexOf = w.indexOf(str, str2, indexOf + coerceAtLeast, z2);
            } while (indexOf > 0);
            sb.append((CharSequence) str, i, str.length());
            String sb2 = sb.toString();
            m.checkNotNullExpressionValue(sb2, "stringBuilder.append(this, i, length).toString()");
            return sb2;
        }
        throw new OutOfMemoryError();
    }

    public static /* synthetic */ String replace$default(String str, char c2, char c3, boolean z2, int i, Object obj) {
        if ((i & 4) != 0) {
            z2 = false;
        }
        return replace(str, c2, c3, z2);
    }

    public static /* synthetic */ String replace$default(String str, String str2, String str3, boolean z2, int i, Object obj) {
        if ((i & 4) != 0) {
            z2 = false;
        }
        return replace(str, str2, str3, z2);
    }

    public static final String replaceFirst(String str, String str2, String str3, boolean z2) {
        a.h0(str, "$this$replaceFirst", str2, "oldValue", str3, "newValue");
        int indexOf$default = w.indexOf$default(str, str2, 0, z2, 2, (Object) null);
        return indexOf$default < 0 ? str : w.replaceRange(str, indexOf$default, str2.length() + indexOf$default, str3).toString();
    }

    public static /* synthetic */ String replaceFirst$default(String str, String str2, String str3, boolean z2, int i, Object obj) {
        if ((i & 4) != 0) {
            z2 = false;
        }
        return replaceFirst(str, str2, str3, z2);
    }

    public static final boolean startsWith(String str, String str2, int i, boolean z2) {
        m.checkNotNullParameter(str, "$this$startsWith");
        m.checkNotNullParameter(str2, "prefix");
        return !z2 ? str.startsWith(str2, i) : regionMatches(str, i, str2, 0, str2.length(), z2);
    }

    public static final boolean startsWith(String str, String str2, boolean z2) {
        m.checkNotNullParameter(str, "$this$startsWith");
        m.checkNotNullParameter(str2, "prefix");
        return !z2 ? str.startsWith(str2) : regionMatches(str, 0, str2, 0, str2.length(), z2);
    }

    public static /* synthetic */ boolean startsWith$default(String str, String str2, int i, boolean z2, int i2, Object obj) {
        if ((i2 & 4) != 0) {
            z2 = false;
        }
        return startsWith(str, str2, i, z2);
    }

    public static /* synthetic */ boolean startsWith$default(String str, String str2, boolean z2, int i, Object obj) {
        if ((i & 2) != 0) {
            z2 = false;
        }
        return startsWith(str, str2, z2);
    }
}