package kotlin.reflect.jvm.internal.impl.util.capitalizeDecapitalize;

import defpackage.cr4;
import defpackage.dp4;
import defpackage.kp6;
import defpackage.vx8;
import java.util.Iterator;
import java.util.Locale;

/* JADX INFO: loaded from: classes3.dex */
@vx8
public final class CapitalizeDecapitalizeKt {
    @kp6
    public static final String capitalizeAsciiOnly(@kp6 String str) {
        char cCharAt;
        cr4.g(str, "<this>");
        if (str.length() == 0 || 'a' > (cCharAt = str.charAt(0)) || cCharAt >= '{') {
            return str;
        }
        StringBuilder sb = new StringBuilder(str.length());
        sb.append(Character.toUpperCase(cCharAt));
        sb.append((CharSequence) str, 1, str.length());
        return sb.toString();
    }

    @kp6
    public static final String decapitalizeAsciiOnly(@kp6 String str) {
        char cCharAt;
        cr4.g(str, "<this>");
        if (str.length() == 0 || 'A' > (cCharAt = str.charAt(0)) || cCharAt >= '[') {
            return str;
        }
        char lowerCase = Character.toLowerCase(cCharAt);
        String strSubstring = str.substring(1);
        cr4.f(strSubstring, "substring(...)");
        return lowerCase + strSubstring;
    }

    @kp6
    public static final String decapitalizeSmartForCompiler(@kp6 String str, boolean z) {
        Integer next;
        cr4.g(str, "<this>");
        if (str.length() == 0 || !isUpperCaseCharAt(str, 0, z)) {
            return str;
        }
        if (str.length() == 1 || !isUpperCaseCharAt(str, 1, z)) {
            if (z) {
                return decapitalizeAsciiOnly(str);
            }
            if (str.length() <= 0) {
                return str;
            }
            char lowerCase = Character.toLowerCase(str.charAt(0));
            String strSubstring = str.substring(1);
            cr4.f(strSubstring, "substring(...)");
            return lowerCase + strSubstring;
        }
        Iterator<Integer> it = new dp4(0, str.length() - 1, 1).iterator();
        while (true) {
            if (!it.hasNext()) {
                next = null;
                break;
            }
            next = it.next();
            if (!isUpperCaseCharAt(str, next.intValue(), z)) {
                break;
            }
        }
        Integer num = next;
        if (num == null) {
            return toLowerCase(str, z);
        }
        int iIntValue = num.intValue() - 1;
        StringBuilder sb = new StringBuilder();
        String strSubstring2 = str.substring(0, iIntValue);
        cr4.f(strSubstring2, "substring(...)");
        sb.append(toLowerCase(strSubstring2, z));
        String strSubstring3 = str.substring(iIntValue);
        cr4.f(strSubstring3, "substring(...)");
        sb.append(strSubstring3);
        return sb.toString();
    }

    private static final boolean isUpperCaseCharAt(String str, int i, boolean z) {
        char cCharAt = str.charAt(i);
        return z ? 'A' <= cCharAt && cCharAt < '[' : Character.isUpperCase(cCharAt);
    }

    private static final String toLowerCase(String str, boolean z) {
        if (z) {
            return toLowerCaseAsciiOnly(str);
        }
        String lowerCase = str.toLowerCase(Locale.ROOT);
        cr4.f(lowerCase, "toLowerCase(...)");
        return lowerCase;
    }

    @kp6
    public static final String toLowerCaseAsciiOnly(@kp6 String str) {
        cr4.g(str, "<this>");
        StringBuilder sb = new StringBuilder(str.length());
        int length = str.length();
        for (int i = 0; i < length; i++) {
            char cCharAt = str.charAt(i);
            if ('A' <= cCharAt && cCharAt < '[') {
                cCharAt = Character.toLowerCase(cCharAt);
            }
            sb.append(cCharAt);
        }
        String string = sb.toString();
        cr4.f(string, "toString(...)");
        return string;
    }
}