package com.lesingle.edu.common.util;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.alibaba.fastjson2.TypeReference;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;

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

/**
 * JSON 工具类
 * <p>
 * 封装 FastJSON 的序列化和反序列化方法
 * 提供便捷的 JSON 转换工具
 * </p>
 *
 * @author reading-platform
 * @since 2026-03-13
 */
@Slf4j
public class JsonUtils {

    /**
     * 对象转 JSON 字符串
     *
     * @param object 对象
     * @return JSON 字符串
     */
    public static String toJson(Object object) {
        if (object == null) {
            return null;
        }
        try {
            return JSONObject.toJSONString(object);
        } catch (Exception e) {
            log.error("对象转 JSON 失败：{}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * 对象转格式化的 JSON 字符串
     *
     * @param object 对象
     * @return 格式化的 JSON 字符串
     */
    public static String toPrettyJson(Object object) {
        if (object == null) {
            return null;
        }
        try {
            return JSONObject.toJSONString(object, com.alibaba.fastjson2.JSONWriter.Feature.PrettyFormat);
        } catch (Exception e) {
            log.error("对象转格式化 JSON 失败：{}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * JSON 字符串转对象
     *
     * @param json  JSON 字符串
     * @param clazz 目标类型
     * @param <T>   类型参数
     * @return 对象
     */
    public static <T> T fromJson(String json, Class<T> clazz) {
        if (json == null || json.isEmpty()) {
            return null;
        }
        try {
            return JSONObject.parseObject(json, clazz);
        } catch (Exception e) {
            log.error("JSON 转对象失败：{}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * JSON 字符串转对象（支持泛型）
     *
     * @param json         JSON 字符串
     * @param typeReference 类型引用（用于泛型）
     * @param <T>          类型参数
     * @return 对象
     */
    public static <T> T fromJson(String json, TypeReference<T> typeReference) {
        if (json == null || json.isEmpty()) {
            return null;
        }
        try {
            return JSONObject.parseObject(json, typeReference);
        } catch (Exception e) {
            log.error("JSON 转对象失败：{}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * JSON 字符串转 JSONObject
     *
     * @param json JSON 字符串
     * @return JSONObject
     */
    public static JSONObject parseObject(String json) {
        if (json == null || json.isEmpty()) {
            return null;
        }
        try {
            return JSONObject.parseObject(json);
        } catch (Exception e) {
            log.error("JSON 转 JSONObject 失败：{}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * JSON 字符串转 JSONArray
     *
     * @param json JSON 字符串
     * @return JSONArray
     */
    public static JSONArray parseArray(String json) {
        if (json == null || json.isEmpty()) {
            return null;
        }
        try {
            return JSONArray.parseArray(json);
        } catch (Exception e) {
            log.error("JSON 转 JSONArray 失败：{}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * JSON 字符串转 List
     *
     * @param json  JSON 字符串
     * @param clazz 元素类型
     * @param <T>   类型参数
     * @return List
     */
    public static <T> List<T> parseList(String json, Class<T> clazz) {
        if (json == null || json.isEmpty()) {
            return null;
        }
        try {
            return JSONArray.parseArray(json, clazz);
        } catch (Exception e) {
            log.error("JSON 转 List 失败：{}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * 对象转 Map
     *
     * @param object 对象
     * @return Map
     */
    @SuppressWarnings("unchecked")
    public static Map<String, Object> toMap(Object object) {
        if (object == null) {
            return null;
        }
        try {
            String json = toJson(object);
            return JSONObject.parseObject(json, HashMap.class);
        } catch (Exception e) {
            log.error("对象转 Map 失败：{}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * Map 转对象
     *
     * @param map   Map
     * @param clazz 目标类型
     * @param <T>   类型参数
     * @return 对象
     */
    public static <T> T fromMap(Map<?, ?> map, Class<T> clazz) {
        if (map == null) {
            return null;
        }
        try {
            Map<String, Object> stringMap = new HashMap<>();
            for (Map.Entry<?, ?> entry : map.entrySet()) {
                stringMap.put(String.valueOf(entry.getKey()), entry.getValue());
            }
            String json = toJson(stringMap);
            return fromJson(json, clazz);
        } catch (Exception e) {
            log.error("Map 转对象失败：{}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * 判断字符串是否是有效的 JSON
     *
     * @param json JSON 字符串
     * @return 是否有效
     */
    public static boolean isValidJson(String json) {
        if (json == null || json.isEmpty()) {
            return false;
        }
        try {
            JSONObject.parseObject(json);
            return true;
        } catch (Exception e) {
            try {
                JSONArray.parseArray(json);
                return true;
            } catch (Exception ex) {
                return false;
            }
        }
    }

    /**
     * 解析 JSON 数组为 String[]（与套餐管理 gradeLevels 对齐）
     * 支持 ["小班","中班"] 或 小班,中班 格式
     */
    public static String[] parseStringArray(String json) {
        if (!StringUtils.hasText(json)) {
            return new String[0];
        }
        try {
            if (json.trim().startsWith("[")) {
                return JSON.parseArray(json, String.class).toArray(new String[0]);
            }
            return json.split(",");
        } catch (Exception e) {
            log.warn("解析 JSON 数组失败: {}", json, e);
            return new String[0];
        }
    }

    /**
     * 创建空的 JSONObject
     *
     * @return JSONObject
     */
    public static JSONObject createObject() {
        return new JSONObject();
    }

    /**
     * 创建空的 JSONArray
     *
     * @return JSONArray
     */
    public static JSONArray createArray() {
        return new JSONArray();
    }

    /**
     * 创建 JSONObject 并添加键值对
     *
     * @param key   键
     * @param value 值
     * @return JSONObject
     */
    public static JSONObject createObject(String key, Object value) {
        JSONObject object = new JSONObject();
        object.put(key, value);
        return object;
    }

    /**
     * 合并多个 JSONObject
     *
     * @param objects JSONObject 数组
     * @return 合并后的 JSONObject
     */
    public static JSONObject merge(JSONObject... objects) {
        JSONObject result = new JSONObject();
        if (objects != null) {
            for (JSONObject object : objects) {
                if (object != null) {
                    result.putAll(object);
                }
            }
        }
        return result;
    }
}
