// 
// Decompiled by Procyon v0.6.0
// 

package io.sentry.util;

import java.util.Iterator;
import java.security.NoSuchAlgorithmException;
import io.sentry.SentryLevel;
import java.math.BigInteger;
import java.security.MessageDigest;
import io.sentry.ILogger;
import java.text.CharacterIterator;
import java.text.StringCharacterIterator;
import java.util.Locale;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.NotNull;
import java.util.regex.Pattern;
import java.nio.charset.Charset;
import org.jetbrains.annotations.ApiStatus;

@ApiStatus.Internal
public final class StringUtils
{
    private static final Charset UTF_8;
    public static final String PROPER_NIL_UUID = "00000000-0000-0000-0000-000000000000";
    private static final String CORRUPTED_NIL_UUID = "0000-0000";
    @NotNull
    private static final Pattern PATTERN_WORD_SNAKE_CASE;
    
    private StringUtils() {
    }
    
    @Nullable
    public static String getStringAfterDot(@Nullable final String str) {
        if (str == null) {
            return null;
        }
        final int lastDotIndex = str.lastIndexOf(".");
        if (lastDotIndex >= 0 && str.length() > lastDotIndex + 1) {
            return str.substring(lastDotIndex + 1);
        }
        return str;
    }
    
    @Nullable
    public static String capitalize(@Nullable final String str) {
        if (str == null || str.isEmpty()) {
            return str;
        }
        return str.substring(0, 1).toUpperCase(Locale.ROOT) + str.substring(1).toLowerCase(Locale.ROOT);
    }
    
    @Nullable
    public static String camelCase(@Nullable final String str) {
        if (str == null || str.isEmpty()) {
            return str;
        }
        final String[] words = StringUtils.PATTERN_WORD_SNAKE_CASE.split(str, -1);
        final StringBuilder builder = new StringBuilder();
        for (final String w : words) {
            builder.append(capitalize(w));
        }
        return builder.toString();
    }
    
    @Nullable
    public static String removeSurrounding(@Nullable final String str, @Nullable final String delimiter) {
        if (str != null && delimiter != null && str.startsWith(delimiter) && str.endsWith(delimiter)) {
            return str.substring(delimiter.length(), str.length() - delimiter.length());
        }
        return str;
    }
    
    @NotNull
    public static String byteCountToString(long bytes) {
        if (-1000L < bytes && bytes < 1000L) {
            return bytes + " B";
        }
        final CharacterIterator ci = new StringCharacterIterator("kMGTPE");
        while (bytes <= -999950L || bytes >= 999950L) {
            bytes /= 1000L;
            ci.next();
        }
        return String.format(Locale.ROOT, "%.1f %cB", bytes / 1000.0, ci.current());
    }
    
    @Nullable
    public static String calculateStringHash(@Nullable final String str, @NotNull final ILogger logger) {
        if (str == null || str.isEmpty()) {
            return null;
        }
        try {
            final MessageDigest md = MessageDigest.getInstance("SHA-1");
            final byte[] messageDigest = md.digest(str.getBytes(StringUtils.UTF_8));
            final BigInteger no = new BigInteger(1, messageDigest);
            final StringBuilder stringBuilder = new StringBuilder(no.toString(16));
            return stringBuilder.toString();
        }
        catch (final NoSuchAlgorithmException e) {
            logger.log(SentryLevel.INFO, "SHA-1 isn't available to calculate the hash.", e);
        }
        catch (final Throwable e2) {
            logger.log(SentryLevel.INFO, "string: %s could not calculate its hash", e2, str);
        }
        return null;
    }
    
    public static int countOf(@NotNull final String str, final char character) {
        int count = 0;
        for (int i = 0; i < str.length(); ++i) {
            if (str.charAt(i) == character) {
                ++count;
            }
        }
        return count;
    }
    
    public static String normalizeUUID(@NotNull final String uuidString) {
        if (uuidString.equals("0000-0000")) {
            return "00000000-0000-0000-0000-000000000000";
        }
        return uuidString;
    }
    
    public static String join(@NotNull final CharSequence delimiter, @NotNull final Iterable<? extends CharSequence> elements) {
        final StringBuilder stringBuilder = new StringBuilder();
        final Iterator<? extends CharSequence> iterator = elements.iterator();
        if (iterator.hasNext()) {
            stringBuilder.append((CharSequence)iterator.next());
            while (iterator.hasNext()) {
                stringBuilder.append(delimiter);
                stringBuilder.append((CharSequence)iterator.next());
            }
        }
        return stringBuilder.toString();
    }
    
    @Nullable
    public static String toString(@Nullable final Object object) {
        if (object == null) {
            return null;
        }
        return object.toString();
    }
    
    @NotNull
    public static String removePrefix(@Nullable final String string, @NotNull final String prefix) {
        if (string == null) {
            return "";
        }
        final int index = string.indexOf(prefix);
        if (index == 0) {
            return string.substring(prefix.length());
        }
        return string;
    }
    
    @NotNull
    public static String substringBefore(@Nullable final String string, @NotNull final String separator) {
        if (string == null) {
            return "";
        }
        final int index = string.indexOf(separator);
        if (index >= 0) {
            return string.substring(0, index);
        }
        return string;
    }
    
    static {
        UTF_8 = Charset.forName("UTF-8");
        PATTERN_WORD_SNAKE_CASE = Pattern.compile("[\\W_]+");
    }
}