package com.walker.common.util;

import com.fasterxml.jackson.databind.node.ObjectNode;
import com.walker.infrastructure.ApplicationRuntimeException;
import com.walker.infrastructure.utils.JsonUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
import org.springframework.beans.NotReadablePropertyException;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 转换工具类
 *
 * @author 时克英
 */
public class ConvertUtil {
    private static final Logger logger = LoggerFactory.getLogger(ConvertUtil.class);

    /**
     * 根据对象属性的类型转换value为目标对象
     *
     * @param value 输入数据
     * @param clazz 类型
     * @return 转换后的对象
     */
    public static <T> Object convert(String value, Class<T> clazz) {
        try {
            String typeName = clazz.getCanonicalName();
            if (typeName.equals("java.lang.String")) {
                return value;
            }
            if (value == null || value.equals("") || value.equals("null") || value.equals("undefined")) {
                return null;
            } else if (typeName.equals("boolean") || typeName.equals("java.lang.Boolean")) {
                return Boolean.parseBoolean(value);
            } else if (typeName.equals("int") || typeName.equals("java.lang.Integer")) {
                return Integer.parseInt(value);
            } else if (typeName.equals("short") || typeName.equals("java.lang.Short")) {
                return Short.parseShort(value);
            } else if (typeName.equals("long") || typeName.equals("java.lang.Long")) {
                return Long.parseLong(value);
            } else if (typeName.equals("double") || typeName.equals("java.lang.Double")) {
                return Double.parseDouble(value);
            } else if (typeName.equals("float") || typeName.equals("java.lang.Float")) {
                return Float.parseFloat(value);
            } else if (typeName.equals("java.math.BigInteger")) {
                return new java.math.BigInteger(value);
            } else if (typeName.equals("java.math.BigDecimal")) {
                return new BigDecimal(value);
            } else if (typeName.equals("java.sql.Date")) {
                return java.sql.Date.valueOf(value.substring(0, 10));    //yyyy-mm-dd
            } else if (typeName.equals("java.sql.Time")) {
                return java.sql.Time.valueOf(value);
            } else if (typeName.equals("java.sql.Timestamp")) {
                if (value.trim().length() == 10) {
                    return java.sql.Timestamp.valueOf(value.trim() + " 00:00:00");
                }
                return java.sql.Timestamp.valueOf(value);
            }
            return null;
        } catch (Exception e) {
            logger.error("convert exception : value -> {}, type -> {}", new Object[]{value, clazz});
            logger.error(e.getMessage(), e);
            return null;
        }
    }

    /**
     * 根据对象属性的类型转换value为目标对象
     *
     * @param value 输入数据
     * @param clazz 类型
     * @return 转换后的对象
     */
    public static <T> Object convert(Object value, Class<T> clazz) {
        return convert(createString(value), clazz);
    }

    /**
     * 将map的key转成小写
     *
     * @param sourceMap
     * @return
     */
    public static Map<String, Object> convertKeyToLowerCase(Map<String, Object> sourceMap) {
        if (sourceMap == null) {
            return null;
        } else {
            try {
                Map mapDest = sourceMap.getClass().newInstance();
                for (Map.Entry<String, Object> entry : sourceMap.entrySet()) {
                    mapDest.put(entry.getKey().toLowerCase(), entry.getValue());
                }
                return mapDest;
            } catch (Exception e) {
                throw new ApplicationRuntimeException(e.getMessage(), e);
            }
        }
    }

    /**
     * obj转换为 int， 默认值为Integer.MIN_VALUE
     *
     * @param obj 待转换对象
     * @return int
     */
    public static int toInt(Object obj) {
        if (obj == null) {
            return Integer.MIN_VALUE;
        } else {
            return createInteger(obj);
        }
    }

    /**
     * obj转换为 int， 默认值为defaultValue
     *
     * @param obj 待转换对象
     * @return int
     */
    public static int toInt(Object obj, int defaultValue) {
        if (obj == null) {
            return defaultValue;
        } else {
            return createInteger(obj);
        }
    }

    /**
     * obj转换为 long， 默认值为Long.MIN_VALUE
     *
     * @param obj 待转换对象
     * @return long
     */
    public static long toLong(Object obj) {
        if (obj == null) {
            return Long.MIN_VALUE;
        } else {
            return createLong(obj);
        }
    }

    /**
     * obj转换为 long， 默认值为defaultValue
     *
     * @param obj 待转换对象
     * @return long
     */
    public static long toLong(Object obj, long defaultValue) {
        if (obj == null) {
            return defaultValue;
        } else {
            return createLong(obj);
        }
    }

    /**
     * obj转换为 double， 默认值为Double.MIN_VALUE
     *
     * @param obj 待转换对象
     * @return double
     */
    public static double toDouble(Object obj) {
        if (obj == null) {
            return Double.MIN_VALUE;
        } else {
            return createDouble(obj);
        }
    }

    /**
     * obj转换为 double， 默认值为defaultValue
     *
     * @param obj 待转换对象
     * @return double
     */
    public static double toDouble(Object obj, double defaultValue) {
        if (obj == null) {
            return defaultValue;
        } else {
            return createDouble(obj);
        }
    }

    /**
     * obj转换为 boolean， 默认值为false
     *
     * @param obj 待转换对象
     * @return boolean
     */
    public static boolean toBoolean(Object obj) {
        return obj != null && createBoolean(obj);
    }

    /**
     * obj转换为 boolean， 默认值为defaultValue
     *
     * @param obj 待转换对象
     * @return boolean
     */
    public static boolean toBoolean(Object obj, boolean defaultValue) {
        if (obj == null) {
            return defaultValue;
        } else {
            return createBoolean(obj);
        }
    }

    /**
     * 将obj转换为String
     *
     * @param obj 待转换对象
     * @return string
     */
    public static String createString(Object obj) {
        if (obj == null) {
            return null;
        } else {
            if (obj instanceof String) {
                return (String) obj;
            } else {
                return obj.toString();
            }
        }
    }

    /**
     * 将obj转换为Integer
     *
     * @param obj 待转换对象
     * @return Integer
     */
    public static Integer createInteger(Object obj) {
        if (obj == null) {
            return null;
        } else {
            if (obj instanceof Integer) {
                return (Integer) obj;
            } else {
                return Integer.valueOf(createString(obj));
            }
        }
    }

    /**
     * 将obj转换为Long
     *
     * @param obj 待转换对象
     * @return Long
     */
    public static Long createLong(Object obj) {
        if (obj == null) {
            return null;
        } else {
            if (obj instanceof Long) {
                return (Long) obj;
            } else {
                return Long.valueOf(createString(obj));
            }
        }
    }

    /**
     * 将obj转换为Double
     *
     * @param obj 待转换对象
     * @return Double
     */
    public static Double createDouble(Object obj) {
        if (obj == null) {
            return null;
        } else {
            if (obj instanceof Double) {
                return (Double) obj;
            } else {
                return Double.valueOf(createString(obj));
            }
        }
    }

    /**
     * 将obj转换为BigDecimal
     *
     * @param obj 待转换对象
     * @return BigDecimal
     */
    public static BigDecimal createBigDecimal(Object obj) {
        if (obj == null) {
            return null;
        } else {
            if (obj instanceof BigDecimal) {
                return (BigDecimal) obj;
            } else {
                return new BigDecimal(createString(obj));
            }
        }
    }

    /**
     * 将obj转换为Boolean
     *
     * @param obj 待转换对象
     * @return Boolean
     */
    public static Boolean createBoolean(Object obj) {
        if (obj == null) {
            return null;
        } else {
            if (obj instanceof Boolean) {
                return (Boolean) obj;
            } else {
                return Boolean.parseBoolean(createString(obj));
            }
        }
    }

    /**
     * 将源对象转化为targetClass类型的目标对象
     *
     * @param source      源对象
     * @param targetClass 目标对象
     * @param <T>         返回对象泛型
     * @return 转化后的对象
     */
    public static <T> T toObject(Object source, Class<T> targetClass) {
        if (source == null) {
            return null;
        }
        try {
            String typeName = targetClass.getCanonicalName();
            if (typeName.equals("java.util.Map") || typeName.equals("java.util.HashMap")) {
                Map t = new HashMap();
                copyProperties(source, t);
                return (T) t;
            } else if (typeName.equals("java.util.LinkedHashMap")) {
                Map t = new LinkedHashMap();
                copyProperties(source, t);
                return (T) t;
            } else {
                T t = targetClass.newInstance();
                copyProperties(source, t);
                return t;
            }
        } catch (Exception e) {
            throw new ApplicationRuntimeException(e);
        }
    }

    /**
     * 将源对象的属性拷贝到目标对象
     *
     * @param source 源对象
     * @param target 目标对象
     */
    public static void copyProperties(Object source, Object target) {
        if (source == null || target == null) {
            return;
        }
        if (source instanceof Map) {
            PropertyDescriptor[] propertyDescriptors = BeanUtils.getPropertyDescriptors(target.getClass());
            Map map = (Map) source;
            try {
                for (PropertyDescriptor descriptor : propertyDescriptors) {
                    if (map.containsKey(descriptor.getName())) {
                        Method writeMethod = descriptor.getWriteMethod();
                        Object value = map.get(descriptor.getName());
                        writeMethod.invoke(target, convert(value, writeMethod.getParameterTypes()[0]));
                    }
                }
            } catch (Exception e) {
                throw new ApplicationRuntimeException(e);
            }
        } else if (target instanceof Map) {
            try {
                PropertyDescriptor[] propertyDescriptors = BeanUtils.getPropertyDescriptors(source.getClass());
                Map<String, Object> map = (Map) target;
                for (PropertyDescriptor descriptor : propertyDescriptors) {
                    Method readMethod = descriptor.getReadMethod();
                    map.put(descriptor.getName(), readMethod.invoke(source, new Object[]{}));
                }
            } catch (Exception e) {
                throw new ApplicationRuntimeException(e);
            }
        } else {
            BeanUtils.copyProperties(source, target);
        }
    }


    /**
     * 将源对象的属性拷贝到目标对象,忽略为空的属性
     *
     * @param source 源对象
     * @param target 目标对象
     */
    public static void copyPropertiesIgnoreNull(Object source, Object target) {
        if (source == null || target == null) {
            return;
        }
        if (source instanceof Map) {
            PropertyDescriptor[] propertyDescriptors = BeanUtils.getPropertyDescriptors(target.getClass());
            Map map = (Map) source;
            try {
                for (PropertyDescriptor descriptor : propertyDescriptors) {
                    if (map.containsKey(descriptor.getName())) {
                        Method writeMethod = descriptor.getWriteMethod();
                        Object value = map.get(descriptor.getName());
                        writeMethod.invoke(target, convert(value, writeMethod.getParameterTypes()[0]));
                    }
                }
            } catch (Exception e) {
                throw new ApplicationRuntimeException(e);
            }
        } else if (target instanceof Map) {
            try {
                PropertyDescriptor[] propertyDescriptors = BeanUtils.getPropertyDescriptors(source.getClass());
                Map<String, Object> map = (Map) target;
                for (PropertyDescriptor descriptor : propertyDescriptors) {
                    Method readMethod = descriptor.getReadMethod();
                    map.put(descriptor.getName(), readMethod.invoke(source, new Object[]{}));
                }
            } catch (Exception e) {
                throw new ApplicationRuntimeException(e);
            }
        } else {
            BeanUtils.copyProperties(source, target, getNullPropertyNames(source));
        }
    }

    /**
     * 获取为空的属性名
     *
     * @param source 原对象
     * @return 源对象为空的属性名
     */
    private static String[] getNullPropertyNames(Object source) {
        final BeanWrapper src = new BeanWrapperImpl(source);
        PropertyDescriptor[] pds = src.getPropertyDescriptors();

        Set<String> emptyNames = new HashSet<>();
        for (PropertyDescriptor pd : pds) {
            Object srcValue = null;
            try {
                srcValue = src.getPropertyValue(pd.getName());
            } catch (NotReadablePropertyException e) {
                logger.error(pd.getName() + "属性获取出错", e);
            }
            if (srcValue == null) {
                emptyNames.add(pd.getName());
            }
        }
        String[] result = new String[emptyNames.size()];
        return emptyNames.toArray(result);
    }

    /**
     * 将源对象列表转化为目标对象列表
     *
     * @param list        源对象列表
     * @param targetClass 目标对象类型
     * @param <T>         返回对象泛型
     * @return
     */
    public static <T> List<T> toList(List<?> list, Class<T> targetClass) {
        if (list == null) {
            return null;
        }
        List<T> result = new ArrayList<>();
        for (Object obj : list) {
            result.add(toObject(obj, targetClass));
        }
        return result;
    }

    /**
     * 将list 按 chunkSize 切片
     *
     * @param list      待切片数据
     * @param chunkSize 分片大小
     * @param <T>       返回对象泛型
     * @return
     */
    public static <T> List<List<T>> partition(List<T> list, int chunkSize) {
        if (list == null) {
            return null;
        }
        if (chunkSize <= 0) {
            throw new ApplicationRuntimeException("chunkSize 必须大于0.");
        }
        List<List<T>> result = new ArrayList<>();
        int index = 0;
        while (index < list.size()) {
            int nextInc = Math.min(list.size() - index, chunkSize);
            result.add(list.subList(index, index + nextInc));
            index += nextInc;
        }
        return result;
    }

    /**
     * 将多个业务信息转换为json数组
     *
     * @param datas "项目编号","BH001","项目预算","500w"
     * @return [{"name":"项目编号","value":"BH001"},{"name":"项目预算","value":"500w"}]
     * @throws Exception
     */
    public static String convert(String... datas) throws Exception {
        if (datas == null || datas.length < 0 || datas.length % 2 == 1) {
            throw new ApplicationRuntimeException("请确保参数数量大于0且为偶数！");
        }
//        String jsonData = null;
        int dataSize = datas.length / 2;
//        JSONArray jsonArray = new JSONArray();
//        for (int i = 0; i < dataSize; i++) {
//            int dataIndex = i * 2;
//            JSONObject jsonObject = new JSONObject();
//            jsonObject.put("name", datas[dataIndex]);
//            jsonObject.put("value", datas[dataIndex + 1]);
//            jsonArray.put(jsonObject);
//        }
//        jsonData = jsonArray.toString();
        List<ObjectNode> resultList = new ArrayList<>(4);
        int dataIndex = -1;
        Map<String, Object> map = null;
        for (int i = 0; i < dataSize; i++){
            dataIndex = i * 2;
            map = new HashMap<>(8);
            map.put("name", datas[dataIndex]);
            map.put("value", datas[dataIndex + 1]);
            resultList.add(JsonUtils.mapToObjectNode(map));
        }
        return JsonUtils.toJsonArray(resultList);
    }

    /**
     * 将多个业务信息转换为json数组
     *
     * @param datas "xmid","1001",0,"项目编号","BH001",1,"项目预算","500w",1
     * @return [{"name":"xmid","value":"1001","show":0},{"name":"项目编号","value":"BH001","show":1},{"name":"项目预算","value":"500w","show":1}]
     * @throws Exception
     */
    public static String convert3(String... datas) throws Exception {
        if (datas == null || datas.length < 0 || datas.length % 3 != 0) {
            throw new ApplicationRuntimeException("请确保参数数量大于0且为3的倍数！");
        }
        String jsonData = null;
        int dataSize = datas.length / 3;
//        JSONArray jsonArray = new JSONArray();
//        for (int i = 0; i < dataSize; i++) {
//            int dataIndex = i * 3;
//            JSONObject jsonObject = new JSONObject();
//            jsonObject.put("name", datas[dataIndex]);
//            jsonObject.put("value", datas[dataIndex + 1]);
//            jsonObject.put("show", datas[dataIndex + 2]);
//            jsonArray.put(jsonObject);
//        }
//        jsonData = jsonArray.toString();
        List<ObjectNode> resultList = new ArrayList<>(4);
        int dataIndex = -1;
        Map<String, Object> map = null;
        for (int i = 0; i < dataSize; i++){
            dataIndex = i * 3;
            map = new HashMap<>(8);
            map.put("name", datas[dataIndex]);
            map.put("value", datas[dataIndex + 1]);
            map.put("show", datas[dataIndex + 2]);
            resultList.add(JsonUtils.mapToObjectNode(map));
        }
        return JsonUtils.toJsonArray(resultList);
    }

    /**
     * 将bean的Stirng类型赋值为""
     *
     * @param bean
     * @param <T>
     * @return
     */
    public static <T> T convertStrPropBlank(T bean) {
        if (bean != null) {
            PropertyDescriptor[] propertyDescriptors = BeanUtils.getPropertyDescriptors(bean.getClass());
            for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
                if (propertyDescriptor.getPropertyType().getName().equals("java.lang.String")) {
                    try {
                        if (propertyDescriptor.getReadMethod().invoke(bean) == null) {
                            propertyDescriptor.getWriteMethod().invoke(bean, "");
                        }
                    } catch (IllegalAccessException e) {
                        logger.error(e.getMessage(), e);
                    } catch (InvocationTargetException e) {
                        logger.error(e.getMessage(), e);
                    }
                }
            }
        }
        return bean;
    }

    /**
     * 把JavaBean转化为map
     *
     * @param bean
     * @return
     */
    public static Map<String, Object> beanTomap(Object bean) throws Exception {
        Map<String, Object> map = new HashMap<>();
        //获取JavaBean的描述器
        BeanInfo b = Introspector.getBeanInfo(bean.getClass(), Object.class);
        //获取属性描述器
        PropertyDescriptor[] pds = b.getPropertyDescriptors();
        //对属性迭代
        for (PropertyDescriptor pd : pds) {
            //属性名称
            String propertyName = pd.getName();
            //属性值,用getter方法获取
            Method m = pd.getReadMethod();
            Object properValue = m.invoke(bean);//用对象执行getter方法获得属性值

            //把属性名-属性值 存到Map中
            map.put(propertyName, properValue);
        }
        return map;
    }

    /**
     * 把Map转化为JavaBean
     *
     * @param map
     * @return
     */
    /*public static <T> T mapTobean(Map<String,Object> map,Class<T> clz) throws Exception{
        //创建一个需要转换为的类型的对象
        T obj = clz.newInstance();
        //从Map中获取和属性名称一样的值，把值设置给对象(setter方法)

        //得到属性的描述器
        BeanInfo b = Introspector.getBeanInfo(clz,Object.class);
        PropertyDescriptor[] pds = b.getPropertyDescriptors();
        for (PropertyDescriptor pd : pds) {
            //得到属性的setter方法
            Method setter = pd.getWriteMethod();
            //得到key名字和属性名字相同的value设置给属性
            setter.invoke(obj, map.get(pd.getName()));
        }
        return obj;
    }*/
    public static <T> T mapToBean(Map<String, Object> map, Class<?> clazz) throws Exception {
        Object obj = clazz.newInstance();
        if (map != null && !map.isEmpty() && map.size() > 0) {
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                String propertyName = entry.getKey();    // 属性名
                Object value = entry.getValue();        // 属性值
                String setMethodName = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
                Field field = getClassField(clazz, propertyName);    //获取和map的key匹配的属性名称
                if (field == null) {
                    continue;
                }
                Class<?> fieldTypeClass = field.getType();
                value = convertValType(value, fieldTypeClass);
                try {
                    clazz.getMethod(setMethodName, field.getType()).invoke(obj, value);
                } catch (NoSuchMethodException e) {
                    logger.error(e.getMessage(), e);
                }
            }
        }
        return (T) obj;
    }

    /**
     * 根据给定对象类匹配对象中的特定字段
     *
     * @param clazz
     * @param fieldName
     * @return
     */
    private static Field getClassField(Class<?> clazz, String fieldName) {
        if (Object.class.getName().equals(clazz.getName())) {
            return null;
        }
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field field : declaredFields) {
            if (field.getName().equals(fieldName)) {
                return field;
            }
        }
        Class<?> superClass = clazz.getSuperclass();    //如果该类还有父类，将父类对象中的字段也取出
        if (superClass != null) {                        //递归获取
            return getClassField(superClass, fieldName);
        }
        return null;
    }

    /**
     * 将map的value值转为实体类中字段类型匹配的方法
     *
     * @param value
     * @param fieldTypeClass
     * @return
     */
    private static Object convertValType(Object value, Class<?> fieldTypeClass) {
        Object retVal = null;

        if (Long.class.getName().equals(fieldTypeClass.getName())
                || long.class.getName().equals(fieldTypeClass.getName())) {
            retVal = Long.parseLong(value.toString());
        } else if (Integer.class.getName().equals(fieldTypeClass.getName())
                || int.class.getName().equals(fieldTypeClass.getName())) {
            retVal = Integer.parseInt(value.toString());
        } else if (Float.class.getName().equals(fieldTypeClass.getName())
                || float.class.getName().equals(fieldTypeClass.getName())) {
            retVal = Float.parseFloat(value.toString());
        } else if (Double.class.getName().equals(fieldTypeClass.getName())
                || double.class.getName().equals(fieldTypeClass.getName())) {
            retVal = Double.parseDouble(value.toString());
        } else {
            retVal = value;
        }
        return retVal;
    }
}