package org.sxkj.common.utils;

import com.alibaba.nacos.shaded.com.google.gson.FieldNamingPolicy;
import com.alibaba.nacos.shaded.com.google.gson.Gson;
import com.alibaba.nacos.shaded.com.google.gson.GsonBuilder;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategies;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import org.springframework.core.io.ClassPathResource;

import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;
import java.util.Map;

public class JsonUtils {

	private static final ObjectMapper objectMapper = new ObjectMapper();


	/**
	 * json字符串转驼峰
	 *
	 * @param json String
	 * @return String
	 */
	public static String convertToCamelCaseJson(String json) {
		JsonNode jsonNode = null;
		try {
			jsonNode = objectMapper.readTree(json);
		} catch (JsonProcessingException e) {
			e.printStackTrace();
		}

		jsonNode = convertKeysToCamelCase(jsonNode);

		try {
			return objectMapper.writeValueAsString(jsonNode);
		} catch (JsonProcessingException e) {
			e.printStackTrace();
		}
		return null;
	}


	/**
	 * JsonNode的key转驼峰
	 *
	 * @param jsonNode JsonNode
	 * @return JsonNode
	 */
	public static JsonNode convertKeysToCamelCase(JsonNode jsonNode) {
		if (jsonNode.isObject()) {
			ObjectNode objectNode = objectMapper.createObjectNode();
			jsonNode.fields().forEachRemaining(entry -> {
				objectNode.set(snakeToCamel(entry.getKey()), convertKeysToCamelCase(entry.getValue()));
			});
			return objectNode;
		}

		if (jsonNode.isArray()) {
			ArrayNode arrayNode = objectMapper.createArrayNode();
			jsonNode.elements().forEachRemaining(entry -> {
				arrayNode.add(convertKeysToCamelCase(entry));
			});

			return arrayNode;
		}

		return jsonNode;
	}

	public static JsonNode convertKeysToSnake(JsonNode jsonNode) {
		if (jsonNode.isObject()) {
			ObjectNode objectNode = objectMapper.createObjectNode();
			jsonNode.fields().forEachRemaining(entry -> {
				objectNode.set(camelToSnake(entry.getKey()), convertKeysToCamelCase(entry.getValue()));
			});
			return objectNode;
		}

		if (jsonNode.isArray()) {
			ArrayNode arrayNode = objectMapper.createArrayNode();
			jsonNode.elements().forEachRemaining(entry -> {
				arrayNode.add(convertKeysToSnake(entry));
			});

			return arrayNode;
		}

		return jsonNode;
	}


	/**
	 * 下划线转驼峰
	 *
	 * @param key String
	 * @return String
	 */
	public static String snakeToCamel(String key) {
		if (key.indexOf("_") != 0) {
			String[] s = key.split("_");
			StringBuilder stringBuilder = new StringBuilder(s[0]);
			for (int i = 1; i < s.length; i++) {
				stringBuilder.append(s[i].substring(0, 1).toUpperCase()).
					append(s[i].substring(1));
			}
			return stringBuilder.toString();
		}

		return key;
	}


	/**
	 * 驼峰转下划线
	 *
	 * @param key String
	 * @return String
	 */
	public static String camelToSnake(String key) {
		int length = key.length();
		StringBuilder sb = new StringBuilder(length);
		for (int i = 0; i < length; i++) {
			char current = key.charAt(i);
			if (Character.isUpperCase(current)) {
				if (i > 0) {
					sb.append('_');
				}
				sb.append(Character.toLowerCase(current));
				continue;
			}
			sb.append(current);
		}
		return sb.toString();
	}


	public static String toCamelCaseJson(String json) {
		// 原始 JSON 字符串（驼峰命名）

		// 原始 JSON 字符串（驼峰命名）

		// 创建 ObjectMapper
		ObjectMapper mapper = new ObjectMapper();

		// 将 JSON 字符串转换为 JsonNode
		JsonNode rootNode = null;
		try {
			rootNode = mapper.readTree(json);
		} catch (JsonProcessingException e) {
			throw new RuntimeException(e);
		}

		// 递归处理 JSON 键
		JsonNode convertedNode = convertKeysToSnakeCase(rootNode);

		// 将转换后的 JsonNode 重新序列化为 JSON 字符串
		String convertedJson = null;
		try {
			convertedJson = mapper.writeValueAsString(convertedNode);
		} catch (JsonProcessingException e) {
			throw new RuntimeException(e);
		}
		return convertedJson;
	}

	private static JsonNode convertKeysToSnakeCase(JsonNode node) {
		if (node.isObject()) {
			ObjectNode objectNode = (ObjectNode) node;
			ObjectNode newObjectNode = objectNode.objectNode();

			Iterator<Map.Entry<String, JsonNode>> fields = objectNode.fields();
			while (fields.hasNext()) {
				Map.Entry<String, JsonNode> field = fields.next();
				String newKey = camelToSnakeCase(field.getKey()); // 转换键
				newObjectNode.set(newKey, convertKeysToSnakeCase(field.getValue())); // 递归处理值
			}

			return newObjectNode;
		} else if (node.isArray()) {
			for (int i = 0; i < node.size(); i++) {
				((ObjectNode) node).set(Integer.toString(i), convertKeysToSnakeCase(node.get(i)));
			}
		}

		return node;
	}

	private static String camelToSnakeCase(String camelCase) {
		StringBuilder snakeCase = new StringBuilder();
		for (char ch : camelCase.toCharArray()) {
			if (Character.isUpperCase(ch)) {
				snakeCase.append('_').append(Character.toLowerCase(ch));
			} else {
				snakeCase.append(ch);
			}
		}
		return snakeCase.toString();
	}

	/**
	 * 根据路径获取文件中的json
	 * @param path resource 路径
	 * @return json数据
	 */
	public static JsonNode loadJsonFile(String path) {
		try (InputStream inputStream = new ClassPathResource(path).getInputStream()) {
			ObjectMapper mapper = new ObjectMapper();
			return mapper.readTree(inputStream);
		} catch (IOException e) {

			e.printStackTrace();
		}
		return null;
	}



}