package com.ycwl.basic.integration.common.util;

import com.ycwl.basic.utils.JacksonUtil;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;

/**
 * 配置值转换工具类
 * 
 * 提供统一的配置Map值类型转换方法，支持多种数据类型的安全转换
 */
public class ConfigValueUtil {

    /**
     * 从配置Map中获取Integer值
     * 
     * @param config 配置Map
     * @param key 配置键
     * @return Integer值，如果转换失败返回null
     */
    public static Integer getIntValue(Map<String, Object> config, String key) {
        Object value = config.get(key);
        if (value == null) return null;
        if (value instanceof Integer) return (Integer) value;
        if (value instanceof Number) return ((Number) value).intValue();
        if (value instanceof String) {
            try {
                return Integer.parseInt((String) value);
            } catch (NumberFormatException e) {
                return null;
            }
        }
        return null;
    }

    /**
     * 从配置Map中获取Long值
     * 
     * @param config 配置Map
     * @param key 配置键
     * @return Long值，如果转换失败返回null
     */
    public static Long getLongValue(Map<String, Object> config, String key) {
        Object value = config.get(key);
        if (value == null) return null;
        if (value instanceof Long) return (Long) value;
        if (value instanceof Number) return ((Number) value).longValue();
        if (value instanceof String) {
            try {
                return Long.parseLong((String) value);
            } catch (NumberFormatException e) {
                return null;
            }
        }
        return null;
    }

    /**
     * 从配置Map中获取Float值
     * 
     * @param config 配置Map
     * @param key 配置键
     * @return Float值，如果转换失败返回null
     */
    public static Float getFloatValue(Map<String, Object> config, String key) {
        Object value = config.get(key);
        if (value == null) return null;
        if (value instanceof Float) return (Float) value;
        if (value instanceof Double) return ((Double) value).floatValue();
        if (value instanceof Number) return ((Number) value).floatValue();
        if (value instanceof String) {
            try {
                return Float.parseFloat((String) value);
            } catch (NumberFormatException e) {
                return null;
            }
        }
        return null;
    }

    /**
     * 从配置Map中获取Double值
     * 
     * @param config 配置Map
     * @param key 配置键
     * @return Double值，如果转换失败返回null
     */
    public static Double getDoubleValue(Map<String, Object> config, String key) {
        Object value = config.get(key);
        if (value == null) return null;
        if (value instanceof Double) return (Double) value;
        if (value instanceof Number) return ((Number) value).doubleValue();
        if (value instanceof String) {
            try {
                return Double.parseDouble((String) value);
            } catch (NumberFormatException e) {
                return null;
            }
        }
        return null;
    }

    /**
     * 从配置Map中获取BigDecimal值
     * 
     * @param config 配置Map
     * @param key 配置键
     * @return BigDecimal值，如果转换失败返回null
     */
    public static BigDecimal getBigDecimalValue(Map<String, Object> config, String key) {
        Object value = config.get(key);
        if (value == null) return null;
        if (value instanceof BigDecimal) return (BigDecimal) value;
        if (value instanceof String) {
            try {
                return new BigDecimal((String) value);
            } catch (NumberFormatException e) {
                return null;
            }
        }
        if (value instanceof Number) {
            return new BigDecimal(value.toString());
        }
        return null;
    }

    /**
     * 从配置Map中获取String值
     * 如果值是复杂对象(Map/List)，会自动转换为JSON字符串
     * 
     * @param config 配置Map
     * @param key 配置键
     * @return String值，如果value为null返回null
     */
    public static String getStringValue(Map<String, Object> config, String key) {
        Object value = config.get(key);
        if (value == null) return null;
        
        // 如果是基础类型，直接转字符串
        if (value instanceof String || value instanceof Number || value instanceof Boolean) {
            return value.toString();
        }
        
        // 如果是复杂对象(Map, List等)，转换为JSON字符串
        try {
            return JacksonUtil.toJSONString(value);
        } catch (Exception e) {
            // JSON转换失败，降级为toString
            return value.toString();
        }
    }

    /**
     * 从配置Map中获取Boolean值
     * 
     * @param config 配置Map
     * @param key 配置键
     * @return Boolean值，如果转换失败返回null
     */
    public static Boolean getBooleanValue(Map<String, Object> config, String key) {
        Object value = config.get(key);
        if (value == null) return null;
        if (value instanceof Boolean) return (Boolean) value;
        if (value instanceof String) {
            String str = (String) value;
            if ("true".equalsIgnoreCase(str) || "1".equals(str)) return true;
            if ("false".equalsIgnoreCase(str) || "0".equals(str)) return false;
        }
        if (value instanceof Number) {
            return ((Number) value).intValue() != 0;
        }
        return null;
    }

    /**
     * 从配置Map中获取枚举值
     * 
     * @param config 配置Map
     * @param key 配置键
     * @param enumClass 枚举类型
     * @param <T> 枚举类型泛型
     * @return 枚举值，如果转换失败返回null
     */
    public static <T extends Enum<T>> T getEnumValue(Map<String, Object> config, String key, Class<T> enumClass) {
        Object value = config.get(key);
        if (value == null) return null;
        try {
            if (value instanceof String) {
                return Enum.valueOf(enumClass, (String) value);
            }
            return Enum.valueOf(enumClass, value.toString());
        } catch (IllegalArgumentException e) {
            return null;
        }
    }

    /**
     * 从配置Map中获取Integer值，如果为null则返回默认值
     * 
     * @param config 配置Map
     * @param key 配置键
     * @param defaultValue 默认值
     * @return Integer值或默认值
     */
    public static Integer getIntValue(Map<String, Object> config, String key, Integer defaultValue) {
        Integer value = getIntValue(config, key);
        return value != null ? value : defaultValue;
    }

    /**
     * 从配置Map中获取String值，如果为null则返回默认值
     * 
     * @param config 配置Map
     * @param key 配置键
     * @param defaultValue 默认值
     * @return String值或默认值
     */
    public static String getStringValue(Map<String, Object> config, String key, String defaultValue) {
        String value = getStringValue(config, key);
        return value != null ? value : defaultValue;
    }

    /**
     * 从配置Map中获取Boolean值，如果为null则返回默认值
     * 
     * @param config 配置Map
     * @param key 配置键
     * @param defaultValue 默认值
     * @return Boolean值或默认值
     */
    public static Boolean getBooleanValue(Map<String, Object> config, String key, Boolean defaultValue) {
        Boolean value = getBooleanValue(config, key);
        return value != null ? value : defaultValue;
    }

    // ========== 对象和JSON转换方法 ==========

    /**
     * 从配置Map中获取原始对象值
     * 
     * @param config 配置Map
     * @param key 配置键
     * @return 原始Object值
     */
    public static Object getObjectValue(Map<String, Object> config, String key) {
        return config.get(key);
    }

    /**
     * 从配置Map中获取并转换为指定类型的对象
     * 支持JSON字符串自动反序列化
     * 
     * @param config 配置Map
     * @param key 配置键
     * @param clazz 目标类型
     * @param <T> 目标类型泛型
     * @return 转换后的对象，如果转换失败返回null
     */
    @SuppressWarnings("unchecked")
    public static <T> T getObjectValue(Map<String, Object> config, String key, Class<T> clazz) {
        Object value = config.get(key);
        if (value == null) return null;
        
        // 如果类型匹配，直接返回
        if (clazz.isInstance(value)) {
            return (T) value;
        }
        
        // 如果是String类型的JSON，尝试反序列化
        if (value instanceof String && !clazz.equals(String.class)) {
            try {
                return JacksonUtil.parseObject((String) value, clazz);
            } catch (Exception e) {
                return null;
            }
        }
        
        // 如果目标是String，使用增强的字符串转换
        if (clazz.equals(String.class)) {
            return (T) getStringValue(config, key);
        }
        
        // 其他情况尝试JSON转换
        try {
            String json = JacksonUtil.toJSONString(value);
            return JacksonUtil.parseObject(json, clazz);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 从配置Map中获取Map类型的值
     * 
     * @param config 配置Map
     * @param key 配置键
     * @return Map值，如果转换失败返回null
     */
    @SuppressWarnings("unchecked")
    public static Map<String, Object> getMapValue(Map<String, Object> config, String key) {
        Object value = config.get(key);
        if (value == null) return null;
        
        if (value instanceof Map) {
            return (Map<String, Object>) value;
        }
        
        if (value instanceof String) {
            try {
                return JacksonUtil.parseObject((String) value, Map.class);
            } catch (Exception e) {
                return null;
            }
        }
        
        return null;
    }

    /**
     * 从配置Map中获取List类型的值
     * 
     * @param config 配置Map
     * @param key 配置键
     * @return List值，如果转换失败返回null
     */
    @SuppressWarnings("unchecked")
    public static List<Object> getListValue(Map<String, Object> config, String key) {
        Object value = config.get(key);
        if (value == null) return null;
        
        if (value instanceof List) {
            return (List<Object>) value;
        }
        
        if (value instanceof String) {
            try {
                return JacksonUtil.parseObject((String) value, List.class);
            } catch (Exception e) {
                return null;
            }
        }
        
        return null;
    }

    /**
     * 从配置Map中获取指定元素类型的List值
     * 
     * @param config 配置Map
     * @param key 配置键
     * @param elementClass List元素类型
     * @param <T> List元素类型泛型
     * @return 指定类型的List，如果转换失败返回null
     */
    public static <T> List<T> getListValue(Map<String, Object> config, String key, Class<T> elementClass) {
        Object value = config.get(key);
        if (value == null) return null;
        
        if (value instanceof String) {
            try {
                return JacksonUtil.parseArray((String) value, elementClass);
            } catch (Exception e) {
                return null;
            }
        }
        
        try {
            String json = JacksonUtil.toJSONString(value);
            return JacksonUtil.parseArray(json, elementClass);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 检查配置键是否存在
     * 
     * @param config 配置Map
     * @param key 配置键
     * @return true如果键存在，false如果不存在
     */
    public static boolean hasKey(Map<String, Object> config, String key) {
        return config != null && config.containsKey(key);
    }

    /**
     * 检查配置键是否存在且值不为null
     * 
     * @param config 配置Map
     * @param key 配置键
     * @return true如果键存在且值不为null
     */
    public static boolean hasNonNullValue(Map<String, Object> config, String key) {
        return config != null && config.containsKey(key) && config.get(key) != null;
    }
}