package com.ruoyi.rocketmq.utils;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;

public class SwitchJsonDataParser {
    private static final ObjectMapper objectMapper = new ObjectMapper();

    /**
     * 通用JSON解析方法（兼容对象和数组）
     * @param jsonStr JSON字符串
     * @param valueType 目标实体类类型
     * @return 实体类List集合
     */
    public static <T> List<T> parseJsonData(String jsonStr, Class<T> valueType) {
        if (!StringUtils.hasText(jsonStr)) {
            return new ArrayList<>();
        }

        try {
            JsonNode rootNode = objectMapper.readTree(jsonStr);

            if (rootNode.isArray()) {
                // 处理数组格式JSON
                if (isStringArrayContainingJsonObjects((ArrayNode) rootNode)) {
                    // 处理包含JSON对象字符串的数组 - 转换为真正的对象数组
                    ArrayNode processedArray = processStringJsonArrayToObjectArray((ArrayNode) rootNode);
                    return convertJsonArrayToList(processedArray, valueType);
                } else {
                    // 处理普通JSON数组
                    processJsonArray((ArrayNode) rootNode);
                    return convertJsonArrayToList((ArrayNode) rootNode, valueType);
                }
            } else {
                // 处理单个对象格式JSON
                if (rootNode.isObject()) {
                    processJsonObject((ObjectNode) rootNode);
                }
                List<T> result = new ArrayList<>(1);
                result.add(objectMapper.treeToValue(rootNode, valueType));
                return result;
            }
        } catch (Exception e) {
            throw new RuntimeException("JSON解析失败: " + e.getMessage(), e);
        }
    }

    /**
     * 将JsonArray转换为List<T>
     */
    private static <T> List<T> convertJsonArrayToList(ArrayNode arrayNode, Class<T> valueType) throws Exception {
        List<T> result = new ArrayList<>();
        for (int i = 0; i < arrayNode.size(); i++) {
            JsonNode element = arrayNode.get(i);
            result.add(objectMapper.treeToValue(element, valueType));
        }
        return result;
    }

    /**
     * 判断是否是包含JSON对象字符串的字符串数组
     */
    private static boolean isStringArrayContainingJsonObjects(ArrayNode arrayNode) {
        if (arrayNode.size() == 0) return false;

        JsonNode firstElement = arrayNode.get(0);
        if (firstElement.isTextual()) {
            try {
                String strValue = firstElement.textValue();
                // 检查是否是JSON对象格式的字符串
                if (strValue.startsWith("{") && strValue.endsWith("}")) {
                    objectMapper.readTree(strValue);
                    return true;
                }
            } catch (Exception e) {
                return false;
            }
        }
        return false;
    }

    /**
     * 处理包含JSON对象字符串的字符串数组，转换为真正的对象数组
     */
    private static ArrayNode processStringJsonArrayToObjectArray(ArrayNode arrayNode) {
        ArrayNode resultArray = objectMapper.createArrayNode();

        for (int i = 0; i < arrayNode.size(); i++) {
            JsonNode element = arrayNode.get(i);
            if (element.isTextual()) {
                try {
                    String jsonString = element.textValue();
                    JsonNode jsonNode = objectMapper.readTree(jsonString);

                    if (jsonNode.isObject()) {
                        // 处理JSON对象中的 noSuchInstance
                        processJsonObject((ObjectNode) jsonNode);
                        resultArray.add(jsonNode);
                    } else {
                        resultArray.add(element);
                    }
                } catch (Exception e) {
                    // 如果解析失败，保持原样
                    resultArray.add(element);
                }
            } else {
                resultArray.add(element);
            }
        }

        return resultArray;
    }

    /**
     * 处理JSON数组
     */
    private static void processJsonArray(ArrayNode arrayNode) {
        for (int i = 0; i < arrayNode.size(); i++) {
            JsonNode element = arrayNode.get(i);
            if (element.isObject()) {
                processJsonObject((ObjectNode) element);
            } else if (element.isArray()) {
                processJsonArray((ArrayNode) element);
            }
        }
    }

    /**
     * 处理JSON对象
     */
    private static void processJsonObject(ObjectNode objectNode) {
        objectNode.fields().forEachRemaining(entry -> {
            JsonNode value = entry.getValue();
            if (value.isTextual() && "noSuchInstance".equals(value.textValue())) {
                objectNode.putNull(entry.getKey());
            } else if (value.isObject()) {
                processJsonObject((ObjectNode) value);
            } else if (value.isArray()) {
                processJsonArray((ArrayNode) value);
            }
        });
    }
}