package com.example.system.utils;

/**
 * 自定义字符串工具类，代替 org.apache.commons.lang3.StringUtils
 */
public class StringUtils {

    /**
     * 检查字符串是否为空白（null、空字符串或只包含空白字符）
     *
     * @param str 待检查的字符串
     * @return 如果字符串为空白，则返回true
     */
    public static boolean isBlank(String str) {
        if (str == null) {
            return true;
        }
        for (int i = 0; i < str.length(); i++) {
            if (!Character.isWhitespace(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /**
     * 检查字符串是否不为空白
     *
     * @param str 待检查的字符串
     * @return 如果字符串不为空白，则返回true
     */
    public static boolean isNotBlank(String str) {
        return !isBlank(str);
    }

    /**
     * 检查字符串是否为空（null或空字符串）
     *
     * @param str 待检查的字符串
     * @return 如果字符串为空，则返回true
     */
    public static boolean isEmpty(String str) {
        return str == null || str.length() == 0;
    }

    /**
     * 检查字符串是否不为空
     *
     * @param str 待检查的字符串
     * @return 如果字符串不为空，则返回true
     */
    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    /**
     * 安全地获取字符串长度，如果为null则返回0
     *
     * @param str 待检查的字符串
     * @return 字符串长度，如果为null则返回0
     */
    public static int length(String str) {
        return str == null ? 0 : str.length();
    }

    /**
     * 将null字符串转为空字符串
     *
     * @param str 待处理的字符串
     * @return 处理后的字符串，如果为null则返回空字符串
     */
    public static String nullToEmpty(String str) {
        return str == null ? "" : str;
    }

    /**
     * 截取字符串，处理各种边界情况
     *
     * @param str 待处理的字符串
     * @param start 起始位置
     * @return 截取后的字符串
     */
    public static String substring(String str, int start) {
        if (str == null) {
            return null;
        }

        // 处理负数索引
        if (start < 0) {
            start = str.length() + start;
        }

        if (start < 0) {
            start = 0;
        }
        if (start > str.length()) {
            return "";
        }

        return str.substring(start);
    }

    /**
     * 截取字符串，处理各种边界情况
     *
     * @param str 待处理的字符串
     * @param start 起始位置
     * @param end 结束位置
     * @return 截取后的字符串
     */
    public static String substring(String str, int start, int end) {
        if (str == null) {
            return null;
        }

        // 处理负数索引
        if (start < 0) {
            start = str.length() + start;
        }
        if (end < 0) {
            end = str.length() + end;
        }

        // 处理边界情况
        if (end > str.length()) {
            end = str.length();
        }

        if (start > end) {
            return "";
        }

        if (start < 0) {
            start = 0;
        }
        if (end < 0) {
            end = 0;
        }

        return str.substring(start, end);
    }

    /**
     * 去除字符串两端的空白字符
     *
     * @param str 待处理的字符串
     * @return 处理后的字符串
     */
    public static String trim(String str) {
        return str == null ? null : str.trim();
    }

    /**
     * 判断字符串是否以指定前缀开始，忽略大小写
     *
     * @param str 待检查的字符串
     * @param prefix 前缀
     * @return 如果以指定前缀开始，则返回true
     */
    public static boolean startsWithIgnoreCase(String str, String prefix) {
        if (str == null || prefix == null) {
            return str == null && prefix == null;
        }
        if (prefix.length() > str.length()) {
            return false;
        }
        return str.regionMatches(true, 0, prefix, 0, prefix.length());
    }

    /**
     * 判断字符串是否以指定后缀结束，忽略大小写
     *
     * @param str 待检查的字符串
     * @param suffix 后缀
     * @return 如果以指定后缀结束，则返回true
     */
    public static boolean endsWithIgnoreCase(String str, String suffix) {
        if (str == null || suffix == null) {
            return str == null && suffix == null;
        }
        if (suffix.length() > str.length()) {
            return false;
        }
        return str.regionMatches(true, str.length() - suffix.length(), suffix, 0, suffix.length());
    }

    /**
     * 判断字符串是否包含另一个字符串，忽略大小写
     *
     * @param str 待检查的字符串
     * @param searchStr 待查找的字符串
     * @return 如果包含，则返回true
     */
    public static boolean containsIgnoreCase(String str, String searchStr) {
        if (str == null || searchStr == null) {
            return false;
        }
        int len = searchStr.length();
        int max = str.length() - len;
        for (int i = 0; i <= max; i++) {
            if (str.regionMatches(true, i, searchStr, 0, len)) {
                return true;
            }
        }
        return false;
    }
}