package com.platform.rpc.util.json;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.*;

/**
 *
 * @author AllDataDC
 * @date 2023/3/26 11:14
 * JsonWriter的父类
 **/
public class BasicJsonwriter {
	private static Logger logger = LoggerFactory.getLogger(BasicJsonwriter.class);


	private static final String STR_SLASH = "\"";
	private static final String STR_SLASH_STR = "\":";
	private static final String STR_COMMA = ",";
	private static final String STR_OBJECT_LEFT = "{";
	private static final String STR_OBJECT_RIGHT = "}";
	private static final String STR_ARRAY_LEFT = "[";
	private static final String STR_ARRAY_RIGHT = "]";

	private static final Map<String, Field[]> cacheFields = new HashMap<>();


	/**
	 *
	 * @param object
	 * @return 将JSON转换为String字符串
	 */
	public String toJson(Object object) {
		StringBuilder json = new StringBuilder();
		try {
			writeObjItem(null, object, json);
		} catch (Exception e) {
			logger.error(e.getMessage(), e);
		}

		String str = json.toString();
		if (str.contains("\n")) {
			str = str.replaceAll("\\n", "\\\\n");
		}
		if (str.contains("\t")) {
			str = str.replaceAll("\\t", "\\\\t");
		}
		if (str.contains("\r")) {
			str = str.replaceAll("\\r", "\\\\r");
		}
		return str;
	}

	/**
	 * 返回json格式的键值对
	 * @param key   :键
	 * @param value :值
	 * @param json  :返回值 "key":value or value
	 */
	private void writeObjItem(String key, Object value, StringBuilder json) {

		// "key:"
		if (key != null) {
			json.append(STR_SLASH).append(key).append(STR_SLASH_STR);
		}

		// val
		if (value == null) {
			json.append("null");
		} else if (value instanceof String || value instanceof Byte || value instanceof CharSequence) {
			// string
			json.append(STR_SLASH).append(value.toString()).append(STR_SLASH);
		} else if (value instanceof Boolean || value instanceof Short || value instanceof Integer
				|| value instanceof Long || value instanceof Float || value instanceof Double) {
			// number
			json.append(value);
		} else if (value instanceof Object[] || value instanceof Collection) {
			// collection | array     //  Array.getLength(array);   // Array.get(array, i);
			Collection valueColl = null;
			if (value instanceof Object[]) {
				Object[] valueArr = (Object[]) value;
				valueColl = Arrays.asList(valueArr);
			} else if (value instanceof Collection) {
				valueColl = (Collection) value;
			}

			json.append(STR_ARRAY_LEFT);
			if (valueColl.size() > 0) {
				for (Object obj : valueColl) {
					writeObjItem(null, obj, json);
					json.append(STR_COMMA);
				}
				json.delete(json.length() - 1, json.length());
			}
			json.append(STR_ARRAY_RIGHT);

		} else if (value instanceof Map) {
			// map

			Map<?, ?> valueMap = (Map<?, ?>) value;

			json.append(STR_OBJECT_LEFT);
			if (!valueMap.isEmpty()) {
				Set<?> keys = valueMap.keySet();
				for (Object valueMapItemKey : keys) {
					writeObjItem(valueMapItemKey.toString(), valueMap.get(valueMapItemKey), json);
					json.append(STR_COMMA);
				}
				json.delete(json.length() - 1, json.length());
			}
			json.append(STR_OBJECT_RIGHT);
		} else {
			json.append(STR_OBJECT_LEFT);
			Field[] fields = getDeclaredFields(value.getClass());
			if (fields.length > 0) {
				for (Field field : fields) {
					Object fieldObj = getFieldObject(field, value);
					writeObjItem(field.getName(), fieldObj, json);
					json.append(STR_COMMA);
				}
				json.delete(json.length() - 1, json.length());
			}

			json.append(STR_OBJECT_RIGHT);
		}
	}

	/**
	 *
	 * @param clazz 类
	 * @return 返回类的字段名数组，并缓存
	 */
	public synchronized Field[] getDeclaredFields(Class<?> clazz) {
		String cacheKey = clazz.getName();
		if (cacheFields.containsKey(cacheKey)) {
			return cacheFields.get(cacheKey);
		}
		Field[] fields = getAllDeclaredFields(clazz);    //clazz.getDeclaredFields();
		cacheFields.put(cacheKey, fields);
		return fields;
	}

	/**
	 *
	 * @param clazz
	 * @return 通过反射返回类的字段名数组
	 */
	private Field[] getAllDeclaredFields(Class<?> clazz) {
		List<Field> list = new ArrayList<Field>();
		Class<?> current = clazz;

		while (current != null && current != Object.class) {
			Field[] fields = current.getDeclaredFields();

			for (Field field : fields) {
				if (Modifier.isStatic(field.getModifiers())) {
					continue;
				}
				list.add(field);
			}

			current = current.getSuperclass();
		}

		return list.toArray(new Field[list.size()]);
	}

	/**
	 *
	 * @param field
	 * @param obj
	 * @return 反射获取字段对象
	 */
	private synchronized Object getFieldObject(Field field, Object obj) {
		try {
			field.setAccessible(true);
			return field.get(obj);
		} catch (IllegalArgumentException | IllegalAccessException e) {
			logger.error(e.getMessage(), e);
			return null;
		} finally {
			field.setAccessible(false);
		}
	}
}
