package com.common.util;

import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * JSONB字段解析工具类
 * 用于处理PostgreSQL JSONB类型字段的解析
 */
public class JsonbUtil {

    private static final ObjectMapper objectMapper = new ObjectMapper();

    /**
     * 解析JSONB字段值为字符串
     * 适用于JSONB存储的是带引号的字符串，如 "127.0.0.1"
     *
     * @param value JSONB字段的值
     * @return 解析后的字符串
     */
    public static String parseString(Object value) {
        if (value == null) {
            return null;
        }

        // 如果已经是字符串，直接返回
        if (value instanceof String) {
            String strValue = (String) value;
            // 去除可能存在的引号
            if (strValue.startsWith("\"") && strValue.endsWith("\"")) {
                return strValue.substring(1, strValue.length() - 1);
            }
            return strValue;
        }

        // 其他类型转为字符串
        return value.toString();
    }

    /**
     * 解析JSONB字段值为Integer
     *
     * @param value JSONB字段的值
     * @return 解析后的Integer
     */
    public static Integer parseInteger(Object value) {
        if (value == null) {
            return null;
        }

        if (value instanceof Integer) {
            return (Integer) value;
        }

        if (value instanceof Number) {
            return ((Number) value).intValue();
        }

        if (value instanceof String) {
            String strValue = parseString(value);
            try {
                return Integer.parseInt(strValue);
            } catch (NumberFormatException e) {
                return null;
            }
        }

        return null;
    }

    /**
     * 解析JSONB字段值为Long
     *
     * @param value JSONB字段的值
     * @return 解析后的Long
     */
    public static Long parseLong(Object value) {
        if (value == null) {
            return null;
        }

        if (value instanceof Long) {
            return (Long) value;
        }

        if (value instanceof Number) {
            return ((Number) value).longValue();
        }

        if (value instanceof String) {
            String strValue = parseString(value);
            try {
                return Long.parseLong(strValue);
            } catch (NumberFormatException e) {
                return null;
            }
        }

        return null;
    }

    /**
     * 解析JSONB字段值为Boolean
     *
     * @param value JSONB字段的值
     * @return 解析后的Boolean
     */
    public static Boolean parseBoolean(Object value) {
        if (value == null) {
            return null;
        }

        if (value instanceof Boolean) {
            return (Boolean) value;
        }

        if (value instanceof String) {
            String strValue = parseString(value);
            return Boolean.parseBoolean(strValue);
        }

        return null;
    }

    /**
     * 从JSONB Object中解析字符串值
     * 适用于复杂的JSON对象结构
     *
     * @param jsonbValue JSONB字段的值（可能是Map或字符串）
     * @param fieldName  JSON对象中的字段名
     * @return 解析后的字符串
     */
    @SuppressWarnings("unchecked")
    public static String parseStringFromJson(Object jsonbValue, String fieldName) {
        if (jsonbValue == null) {
            return null;
        }

        try {
            if (jsonbValue instanceof java.util.Map) {
                java.util.Map<String, Object> map = (java.util.Map<String, Object>) jsonbValue;
                Object fieldValue = map.get(fieldName);
                return parseString(fieldValue);
            }

            // 如果是JSON字符串，尝试解析
            if (jsonbValue instanceof String) {
                String strValue = (String) jsonbValue;
                if (strValue.startsWith("{")) {
                    java.util.Map<String, Object> map = objectMapper.readValue(strValue, java.util.Map.class);
                    Object fieldValue = map.get(fieldName);
                    return parseString(fieldValue);
                }
            }
        } catch (Exception e) {
            // 解析失败，返回null
            return null;
        }

        return null;
    }
}
