package com.kingdee.eas.custom.webbeisen.utils;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

import java.util.Arrays;
import java.util.List;

public class JsonFormatConverter {


    /**
     * 转换data数组内指定字段的格式
     * @param originalJson 原始JSON字符串（需为数组格式或包含data数组的对象）
     * @param targetFields 需要转换的字段集合（用户自定义）
     * @return 转换后的JSON字符串
     */
    public static String convertDataFields(String originalJson, List<String> targetFields) {
        // 解析原始JSON
        Object root = JSONObject.parse(originalJson);
        JSONArray dataArray = getRootDataArray(root);

        if (dataArray == null) {
            return originalJson; // 无data数组时直接返回原始数据
        }

        // 处理data数组内的所有元素
        for (int i = 0; i < dataArray.size(); i++) {
            Object item = dataArray.get(i);
            if (item instanceof JSONObject) {
                processJsonObject((JSONObject) item, targetFields);
            }
        }

        return dataArray.toJSONString();
    }

    /**
     * 获取根数据数组（兼容顶层为数组或包含data数组的对象）
     */
    private static JSONArray getRootDataArray(Object root) {
        if (root instanceof JSONArray) {
            return (JSONArray) root;
        } else if (root instanceof JSONObject) {
            return ((JSONObject) root).getJSONArray("data");
        }
        return null;
    }

    /**
     * 递归处理JSONObject，转换指定字段
     */
    private static void processJsonObject(JSONObject obj, List<String> targetFields) {
        // 处理当前对象中的目标字段
        for (String field : targetFields) {
            if (obj.containsKey(field)) {
                Object original = obj.get(field);
                if (original instanceof JSONArray) {
                    // 将数组转换为键值对并直接添加到父对象
                    convertArrayAndMerge(obj, field, (JSONArray) original);
                }
            }
        }

        // 递归处理子节点
        for (String key : obj.keySet()) {
            Object value = obj.get(key);
            if (value instanceof JSONObject) {
                processJsonObject((JSONObject) value, targetFields);
            } else if (value instanceof JSONArray) {
                processJsonArray((JSONArray) value, targetFields);
            }
        }
    }

    /**
     * 递归处理JSONArray，转换其中元素的指定字段
     */
    private static void processJsonArray(JSONArray array, List<String> targetFields) {
        for (int i = 0; i < array.size(); i++) {
            Object item = array.get(i);
            if (item instanceof JSONObject) {
                processJsonObject((JSONObject) item, targetFields);
            } else if (item instanceof JSONArray) {
                processJsonArray((JSONArray) item, targetFields);
            }
        }
    }

    /**
     * 将JSONArray转换为键值对并合并到父对象
     */
    private static void convertArrayAndMerge(JSONObject parent, String originalField, JSONArray array) {
        if (array == null) return;

        // 移除原始字段
        parent.remove(originalField);

        // 处理数组中的每个元素
        for (int i = 0; i < array.size(); i++) {
            Object item = array.get(i);
            if (item instanceof JSONObject) {
                JSONObject jsonItem = (JSONObject) item;
                String primaryKey = extractNameField(jsonItem);
                if (primaryKey != null) {
                    // 创建一个不包含name字段的新对象
                    JSONObject processedItem = new JSONObject(true);
                    for (String key : jsonItem.keySet()) {
                        if (!"name".equals(key)) {
                            processedItem.put(key, jsonItem.get(key));
                        }
                    }
                    // 直接将处理后的对象添加到父对象
                    parent.put(primaryKey, processedItem);
                }
            }
        }
    }

    /**
     * 提取对象的name字段值
     */
    private static String extractNameField(JSONObject obj) {
        if (obj.containsKey("name")) {
            Object nameValue = obj.get("name");
            return nameValue != null ? nameValue.toString() : null;
        }
        return null;
    }

    public static void main(String[] args) {
        // 示例JSON数据
        String originalJson = "[\n" +
                "    {\n" +
                "        \"customField\": [\n" +
                "            {\n" +
                "                \"name\": \"key1\",\n" +
                "                \"text\": \"\",\n" +
                "                \"value\": null\n" +
                "            },\n" +
                "            {\n" +
                "                \"name\": \"key2\",\n" +
                "                \"downloadUrls\": null\n" +
                "            }\n" +
                "        ]\n" +
                "    }\n" +
                "]";

        // 指定需要转换的字段
        List<String> targetFields = Arrays.asList("customField");

        // 执行转换
        String convertedJson = convertDataFields(originalJson, targetFields);
        System.out.println(convertedJson);
    }
}