package com.fs.common.utils;

import cn.hutool.core.lang.TypeReference;
import cn.hutool.json.JSONUtil;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class StringToMapUtil {
    public static Map<String, Object> toMap(String input) {
        if (input == null || input.trim().isEmpty()) {
            return new HashMap<>();
        }

        try {
            // 尝试JSON解析
            return JSONUtil.toBean(input, new TypeReference<Map<String, Object>>() {}, false);
        } catch (Exception e) {
            // 如果失败，尝试Map.toString()格式解析
            try {
                // 检查是否是Map.toString()格式
                if (input.trim().startsWith("{") && input.trim().endsWith("}") &&
                        input.contains("=")) {
                    return parseMapToString(input);
                }
            } catch (Exception ex) {
                // 忽略，抛出原始异常
            }
            throw e;
        }
    }
    /**
     * 将Map.toString()格式的字符串转换为Map
     * @param mapString 类似 {data={book_no=10381008622, ...}, msg=success, state=0} 的字符串
     * @return 转换后的Map对象
     */
    private static Map<String, Object> parseMapToString(String mapString) {
        Map<String, Object> resultMap = new HashMap<>();

        // 移除外层大括号
        String content = mapString.trim();
        if (content.startsWith("{") && content.endsWith("}")) {
            content = content.substring(1, content.length() - 1);
        }

        // 分割顶层键值对
        List<String> pairs = splitTopLevelPairs(content);

        for (String pair : pairs) {
            int eqIndex = pair.indexOf('=');
            if (eqIndex > 0) {
                String key = pair.substring(0, eqIndex).trim();
                String value = pair.substring(eqIndex + 1).trim();

                if (value.startsWith("{") && value.endsWith("}")) {
                    // 嵌套Map对象
                    resultMap.put(key, parseNestedMap(value));
                } else {
                    // 简单值
                    resultMap.put(key, value);
                }
            }
        }

        return resultMap;
    }

    /**
     * 分割顶层键值对，避免分割嵌套对象内的逗号
     */
    private static List<String> splitTopLevelPairs(String content) {
        List<String> pairs = new ArrayList<>();
        int level = 0;
        int start = 0;

        for (int i = 0; i < content.length(); i++) {
            char c = content.charAt(i);
            if (c == '{') {
                level++;
            } else if (c == '}') {
                level--;
            } else if (c == ',' && level == 0) {
                pairs.add(content.substring(start, i));
                start = i + 1;
            }
        }

        // 添加最后一个元素
        if (start < content.length()) {
            pairs.add(content.substring(start));
        }

        return pairs;
    }

    /**
     * 解析嵌套的Map对象
     */
    private static Map<String, Object> parseNestedMap(String mapStr) {
        Map<String, Object> nestedMap = new HashMap<>();

        // 移除外层大括号
        String content = mapStr.substring(1, mapStr.length() - 1);

        List<String> pairs = splitTopLevelPairs(content);

        for (String pair : pairs) {
            int eqIndex = pair.indexOf('=');
            if (eqIndex > 0) {
                String key = pair.substring(0, eqIndex).trim();
                String value = pair.substring(eqIndex + 1).trim();

                // 尝试转换为合适的类型
                nestedMap.put(key, convertValueType(value));
            }
        }

        return nestedMap;
    }

    /**
     * 根据值的特点转换为合适的类型
     */
    private static Object convertValueType(String value) {
        // 数字
        if (value.matches("-?\\d+")) {
            try {
                return Integer.parseInt(value);
            } catch (NumberFormatException e) {
                // 忽略，继续处理
            }
        }

        // 布尔值
        if ("true".equalsIgnoreCase(value) || "false".equalsIgnoreCase(value)) {
            return Boolean.parseBoolean(value);
        }

        // 嵌套对象
        if (value.startsWith("{") && value.endsWith("}")) {
            return parseNestedMap(value);
        }

        // 数组或列表（简化处理）
        if (value.startsWith("[") && value.endsWith("]")) {
            return value.substring(1, value.length() - 1).split(",");
        }

        // 默认作为字符串
        return value;
    }
}
