package com.common.util;

public class StringExtractorUtil {

    /**
     * 简化的字符串截取方法
     * @param text 原始文本
     * @param startChar 开始字符
     * @param startOffset 开始偏移量（负数表示向前）
     * @param endChar 结束字符
     * @param endOccurrence 结束字符第几次出现
     * @return 截取的字符串
     */
    public static String extract(String text, char startChar, int startOffset,
                                 char endChar, int endOccurrence) {
        if (text == null) return "";

        int startIndex = text.indexOf(startChar);
        if (startIndex == -1) return "";

        // 计算实际开始位置
        int actualStart = Math.max(0, startIndex + startOffset);
        if (actualStart >= text.length()) return "";

        // 查找结束字符
        int currentIndex = actualStart;
        int count = 0;

        while (currentIndex < text.length()) {
            if (text.charAt(currentIndex) == endChar) {
                count++;
                if (count == endOccurrence) {
                    return text.substring(actualStart, currentIndex);
                }
            }
            currentIndex++;
        }
        return ""; // 未找到足够的结束字符
    }
    /**
     * 从文本中截取字符串，从指定起始字符串的第0位开始，直到文本末尾
     * @param text 原始文本
     * @param startString 起始字符串
     * @return 截取后的字符串，如果起始字符串不存在则返回空字符串
     */
    public static String extractFromStartToEnd(String text, String startString) {
        if (text == null || startString == null) {
            return "";
        }

        // 查找起始字符串的位置
        int startIndex = text.indexOf(startString);
        if (startIndex == -1) {
            return ""; // 起始字符串不存在
        }

        // 从起始字符串的第0位开始截取到文本末尾
        return text.substring(startIndex);
    }

    /**
     * 从文本中截取字符串，从指定起始字符串的指定位置开始，直到文本末尾
     * @param text 原始文本
     * @param startString 起始字符串
     * @param startOffset 起始偏移量（从起始字符串开始计算）
     * @return 截取后的字符串
     */
    public static String extractFromStartToEnd(String text, String startString, int startOffset) {
        if (text == null || startString == null) {
            return "";
        }

        int startIndex = text.indexOf(startString);
        if (startIndex == -1) {
            return "";
        }

        // 计算实际开始位置
        int actualStartIndex = startIndex + startOffset;

        // 确保开始位置在有效范围内
        if (actualStartIndex < 0) {
            actualStartIndex = 0;
        } else if (actualStartIndex >= text.length()) {
            return "";
        }

        return text.substring(actualStartIndex);
    }

    /**
     * 从文本中截取字符串，从指定起始字符串开始，到指定结束字符串为止
     * @param text 原始文本
     * @param startString 起始字符串
     * @param endString 结束字符串
     * @return 截取后的字符串
     */
    public static String extractBetweenStrings(String text, String startString, String endString) {
        if (text == null || startString == null || endString == null) {
            return "";
        }

        int startIndex = text.indexOf(startString);
        if (startIndex == -1) {
            return "";
        }

        // 从起始字符串位置开始查找结束字符串
        int endIndex = text.indexOf(endString, startIndex + startString.length());
        if (endIndex == -1) {
            // 如果找不到结束字符串，则截取到文本末尾
            return text.substring(startIndex);
        }

        return text.substring(startIndex, endIndex + endString.length());
    }

    /**
     * 高级版本：支持多个起始字符串选项和容错处理
     * @param text 原始文本
     * @param possibleStartStrings 可能的起始字符串数组（按优先级排序）
     * @return 截取后的字符串
     */
    public static String extractWithFallback(String text, String[] possibleStartStrings) {
        if (text == null || possibleStartStrings == null || possibleStartStrings.length == 0) {
            return "";
        }

        // 尝试每个可能的起始字符串
        for (String startString : possibleStartStrings) {
            int startIndex = text.indexOf(startString);
            if (startIndex != -1) {
                return text.substring(startIndex);
            }
        }

        return ""; // 所有起始字符串都不存在
    }


    /**
     * 字符串截取方法
     * @param text 原始文本
     * @param startStr 开始字符串
     * @param startOffset 开始偏移量（负数表示向前）
     * @param endStr 结束字符串
     * @param endOffset 结束偏移量（负数表示向前）
     * @return 截取的字符串
     */
    public static String extract(String text, String startStr, int startOffset,
                                 String endStr, int endOffset) {
        if (text == null || text.isEmpty()) {
            return "";
        }

        int startIndex = 0;
        int endIndex = text.length();

        // 处理开始位置
        if (startStr != null && !startStr.isEmpty()) {
            int foundStartIndex = text.indexOf(startStr);
            if (foundStartIndex == -1) {
                return ""; // 未找到开始字符串
            }
            startIndex = foundStartIndex + startStr.length() + startOffset;
            startIndex = Math.max(0, Math.min(startIndex, text.length()));
        } else {
            // 没有开始字符串，直接使用偏移量
            startIndex = Math.max(0, startOffset);
            startIndex = Math.min(startIndex, text.length());
        }

        // 处理结束位置
        if (endStr != null && !endStr.isEmpty()) {
            int foundEndIndex = text.indexOf(endStr, startIndex);
            if (foundEndIndex == -1) {
                return ""; // 未找到结束字符串
            }
            endIndex = foundEndIndex + endOffset;
            endIndex = Math.max(0, Math.min(endIndex, text.length()));
        } else if (endOffset != 0) {
            // 没有结束字符串但有结束偏移量
            endIndex = startIndex + endOffset;
            endIndex = Math.max(0, Math.min(endIndex, text.length()));
        }
        // 如果结束字符串为空且结束偏移量为0，则endIndex保持为文本长度（截取到最后）

        // 验证位置有效性
        if (startIndex >= endIndex || startIndex >= text.length()) {
            return "";
        }

        return text.substring(startIndex, endIndex);
    }

    public static void main(String[] args) {
        // 测试示例
        String text = "这是一段前置文本，然后是我们需要的内容，这是后续文本。";
        String startString = "然后";

        System.out.println("=== 基本用法：从起始字符串第0位开始到文本末尾 ===");
        String result1 = extractFromStartToEnd(text, startString);
        System.out.println("结果1: " + result1);

        System.out.println("\n=== 使用偏移量：从起始字符串第2位开始 ===");
        String result2 = extractFromStartToEnd(text, startString, 2);
        System.out.println("结果2: " + result2);

        System.out.println("\n=== 在两个字符串之间截取 ===");
        String result3 = extractBetweenStrings(text, "然后", "后续");
        System.out.println("结果3: " + result3);

        System.out.println("\n=== 使用多个可能的起始字符串 ===");
        String[] startOptions = {"不存在的字符串", "然后", "这是"};
        String result4 = extractWithFallback(text, startOptions);
        System.out.println("结果4: " + result4);

        System.out.println("\n=== 处理边界情况 ===");
        // 测试起始字符串不存在的情况
        String result5 = extractFromStartToEnd(text, "不存在的字符串");
        System.out.println("起始字符串不存在: '" + result5 + "'");

        // 测试空文本
        String result6 = extractFromStartToEnd("", startString);
        System.out.println("空文本: '" + result6 + "'");

        // 测试实际应用场景
        System.out.println("\n=== 实际应用示例 ===");
        String logText = "2024-01-15 10:30:25 [INFO] User login successful. User ID: 12345, Session: abcdef";
        String logStart = "[INFO]";

        String logResult = extractFromStartToEnd(logText, logStart);
        System.out.println("日志内容: " + logResult);

        // 只提取消息部分（去掉日志级别）
        String messageResult = extractFromStartToEnd(logText, logStart, logStart.length());
        System.out.println("纯消息: " + messageResult.trim());
    }



    /**
     * 简化的文本截取方法
     * @param text 原始文本
     * @param startString 起始字符串
     * @return 从起始字符串开始到文本末尾的内容
     */
    public static String extract(String text, String startString) {
        // 参数检查
        if (text == null || startString == null) {
            return "";
        }

        // 查找起始字符串
        int startIndex = text.indexOf(startString);

        // 如果找到起始字符串，则截取从该位置到末尾的内容
        if (startIndex != -1) {
            return text.substring(startIndex);
        }

        return ""; // 起始字符串不存在
    }

    public static void main22(String[] args) {
        // 示例使用
        String exampleText = "前置内容，这是起始点，这是我们需要的内容，继续到文本结束。";
        String start = "这是起始点";

        String result = extract(exampleText, start);
        System.out.println("截取结果: " + result);

        // 如果起始字符串不存在
        String noResult = extract(exampleText, "不存在的字符串");
        System.out.println("起始不存在: '" + noResult + "'");

        String example = "前置文本{这是要截取的内容}后置文本";

        // 从 { 前1位开始，到第一个 } 结束
      //  String result = extract(example, '{', 0, '}', 0);
        //System.out.println("截取结果: " + result); // 输出: 前置文本{
    }


}