package com.common.util;

import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.common.entity.RuleContent.kv_paramsType;

@Component
public class KvTextParser {

    /**
     * 解析键值对类型的文本数据
     * @param text 要解析的文本
     * @param params 解析参数配置
     * @return 解析后的Map对象
     */
    public LinkedHashMap<String, Object> parseKvText(String text, kv_paramsType params) {
        LinkedHashMap<String, Object> result = new LinkedHashMap<>();

        if (text == null || text.trim().isEmpty()) {
            return result;
        }

        // 获取分隔符配置
        String internal = params.getInternal(); // KV内部分隔符，如"="
        String external = params.getExternal(); // KV之间分隔符，如空格
        String lTrim = params.getL_trim();     // 左修剪字符
        String rTrim = params.getR_trim();     // 右修剪字符

        // 转义分隔符，用于正则表达式
        String escapedExternal = Pattern.quote(external);
        String escapedInternal = Pattern.quote(internal);

        try {
            // 使用外部KV分隔符分割字符串
            String[] kvPairs = text.split(escapedExternal);

            for (String kvPair : kvPairs) {
                if (kvPair == null || kvPair.trim().isEmpty()) {
                    continue;
                }

                // 使用内部分隔符分割键值对
                String[] parts = kvPair.split(escapedInternal, 2); // 限制分割为2部分

                if (parts.length == 2) {
                    String key = parts[0].trim();
                    String value = parts[1].trim();

                    // 应用修剪
                    key = applyTrim(key, lTrim, rTrim);
                    value = applyTrim(value, lTrim, rTrim);

                    // 移除可能的引号
                    value = removeQuotes(value);

                    result.put(key, value);
                } else if (parts.length == 1) {
                    // 只有key没有value的情况
                    String key = applyTrim(parts[0].trim(), lTrim, rTrim);
                    result.put(key, "");
                }
            }
        } catch (Exception e) {
            throw new RuntimeException("解析键值对文本时发生错误: " + e.getMessage(), e);
        }

        return result;
    }

    /**
     * 应用字符串修剪
     */
    private String applyTrim(String str, String lTrim, String rTrim) {
        if (str == null) return "";

        String result = str;

        // 左修剪
        if (lTrim != null && !lTrim.isEmpty()) {
            result = result.replaceAll("^[" + Pattern.quote(lTrim) + "]+", "");
        }

        // 右修剪
        if (rTrim != null && !rTrim.isEmpty()) {
            result = result.replaceAll("[" + Pattern.quote(rTrim) + "]+$", "");
        }

        return result;
    }

    /**
     * 移除字符串两端的引号
     */
    private String removeQuotes(String str) {
        if (str == null || str.length() < 2) {
            return str;
        }

        // 检查是否被引号包围
        if ((str.startsWith("\"") && str.endsWith("\"")) ||
                (str.startsWith("'") && str.endsWith("'"))) {
            return str.substring(1, str.length() - 1);
        }

        return str;
    }

    /**
     * 使用正则表达式解析更复杂的键值对格式
     * 适用于包含特殊字符的值
     */
    public  LinkedHashMap<String, Object> parseKvTextWithRegex(String text, kv_paramsType params) {
      //  Map<String, String> result = new HashMap<>();
        LinkedHashMap<String, Object> result = new LinkedHashMap<>();
        if (text == null || text.trim().isEmpty()) {
            return result;
        }

        String internal = Pattern.quote(params.getInternal());
        String external = Pattern.quote(params.getExternal());

        // 构建正则表达式模式
        // 匹配格式: key=value 或 key="包含空格的value"
        String patternStr = "(\\w+)" + internal + "(\"[^\"]*\"|[^" + external + "]*)";
        Pattern pattern = Pattern.compile(patternStr);
        Matcher matcher = pattern.matcher(text);

        while (matcher.find()) {
            String key = matcher.group(1);
            String value = matcher.group(2);

            // 移除引号并应用修剪
            value = removeQuotes(value);
            value = applyTrim(value, params.getL_trim(), params.getR_trim());

            result.put(key, value);
        }

        return result;
    }
}