package com.vci.starter.web.util;

import com.vci.starter.web.toolmodel.DateConverter;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cglib.beans.BeanCopier;
import org.springframework.cglib.core.Converter;
import org.springframework.util.CollectionUtils;

import java.lang.reflect.Field;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * 业务类型专用的拷贝工具，这个是浅拷贝，
 * @author weidy
 * @date 2022-1-18
 */
public class BeanUtilForVCI {

    /**
     * 日志
     */
    private static Logger logger = LoggerFactory.getLogger(BeanUtilForVCI.class);

    /**
     * 存放拷贝对象的缓存
     */
    private static final ConcurrentMap<String, BeanCopier> beanCopierMap = new ConcurrentHashMap<>();

    /**
     * 拷贝数据
     * 大小写可以忽略
     * 下划线 _ 被忽略
     * null和空字符串的也会被覆盖
     * @param source 来源属性
     * @param target 目标属性
     */
    public static void copyPropertiesIgnoreCase(Object source, Object target) {
        copyPropertiesIgnoreCase(source,target,false);
    }

    /**
     * 拷贝属性
     * @param source 源对象
     * @param target 目标对象
     * @param fieldMap 属性的映射
     */
    public static void copyPropertiesIgnoreCase(Object source,Object target,Map<String/**原对象的属性名字**/,String/**目标对象的属性名称**/> fieldMap){
        copyPropertiesIgnoreCase(source,target,false,fieldMap);
    }

    /**
     * 拷贝数据
     * 大小写可以忽略
     * 下划线 _ 被忽略
     * @param source 来源属性
     * @param target 目标属性
     * @param ignoreNull 是否忽略控制
     */
    public static void copyPropertiesIgnoreCase(Object source,Object target,boolean ignoreNull){
        copyPropertiesIgnoreCase(source, target, ignoreNull,null);
    }

    /**
     * 拷贝本体的属性内容
     * @param source 来源对象
     * @param target 目标对象
     */
    public static void copyDeclaredIgnoreCase(Object source,Object target){
        copyDeclaredIgnoreCase(source,target,false);
    }

    /**
     * 拷贝本体的属性内容
     * @param source 来源对象
     * @param target 目标对象
     * @param ignoreNull  忽略空值的属性
     */
    public static void copyDeclaredIgnoreCase(Object source,Object target,boolean ignoreNull){
        copyDeclaredIgnoreCase(source,target,ignoreNull,null);
    }

    /**
     * 拷贝本体的属性内容
     * @param source 来源对象
     * @param target 目标对象
     * @param ignoreNull 忽略空值的属性
     * @param fieldMap 字段的映射
     */
    public static void copyDeclaredIgnoreCase(Object source,Object target,boolean ignoreNull,Map<String/**原对象的属性名字**/,String/**目标对象的属性名称**/> fieldMap){
        copyDeclaredIgnoreCase(source,target,ignoreNull,fieldMap,null);
    }

    /**
     * 拷贝本体的属性内容
     * @param source 来源对象
     * @param target 目标对象
     * @param ignoreNull 忽略空值的属性
     * @param fieldMap 字段的映射
     * @param ignoreField 忽略字段
     */
    public static void copyDeclaredIgnoreCase(Object source,Object target,boolean ignoreNull,Map<String/**原对象的属性名字**/,String/**目标对象的属性名称**/> fieldMap,Collection<String> ignoreField){
        Map<String, Field> sourceMap = CacheFieldMap.getDeclaredFieldMap(source.getClass());
        Map<String, Field> targetMap = CacheFieldMap.getDeclaredFieldMap(target.getClass());
        copyPropertiesIgnoreCase(source,target,ignoreNull,fieldMap,ignoreField,sourceMap,targetMap);
    }
    /**
     * 拷贝数据
     * 大小写可以忽略
     * 下划线 _ 被忽略
     * @param source 来源属性
     * @param target 目标属性
     * @param ignoreNull 是否忽略控制
     */
    public static void copyPropertiesIgnoreCase(Object source, Object target, boolean ignoreNull, Map<String/**原对象的属性名字**/,String/**目标对象的属性名称**/> fieldMap, Collection<String> ignoreField) {
        Map<String, Field> sourceMap = CacheFieldMap.getFieldMap(source.getClass());
        Map<String, Field> targetMap = CacheFieldMap.getFieldMap(target.getClass());
        copyPropertiesIgnoreCase(source,target,ignoreNull,fieldMap,ignoreField,sourceMap,targetMap);
    }

    /**
     * 拷贝数据
     * 大小写可以忽略
     * 下划线 _ 被忽略
     * @param source 来源属性
     * @param target 目标属性
     * @param ignoreNull 是否忽略控制
     */
    public static void copyPropertiesIgnoreCase(Object source, Object target, boolean ignoreNull,
                                                Map<String/**原对象的属性名字**/,String/**目标对象的属性名称**/> fieldMap, Collection<String> ignoreField,
                                                Map<String, Field> sourceMap,Map<String, Field> targetMap ) {
        if(fieldMap == null){
            fieldMap = new HashMap<>();
        }
        Map<String, String> finalFieldMap = fieldMap;
        targetMap.values().forEach((it) -> {
            boolean not = false;
            if(ignoreField!=null &&  ignoreField.contains(it.getName())){
                not = true;
            }
            if(!not) {
                String itFieldName = it.getName().toLowerCase().replace("_", "");
                itFieldName = finalFieldMap.getOrDefault(itFieldName, itFieldName);
                Field field = sourceMap.getOrDefault(itFieldName, null);
                if (field != null) {
                    it.setAccessible(true);
                    field.setAccessible(true);
                    try {
                        //忽略null和空字符串
                        //处理boolean和String
                        String sourceClassName = field.getClass().getName();
                        String targetClassName = it.getClass().getName();
                        if (((sourceClassName.equalsIgnoreCase(Boolean.class.getName())
                                || sourceClassName.equalsIgnoreCase(boolean.class.getName())
                        ) && targetClassName.equalsIgnoreCase(String.class.getName()))
                                || ((targetClassName.equalsIgnoreCase(Boolean.class.getName())
                                || targetClassName.equalsIgnoreCase(boolean.class.getName()))
                                && sourceClassName.equalsIgnoreCase(String.class.getName()))) {
                            if (targetClassName.equalsIgnoreCase(String.class.getName())) {
                                it.set(target, String.valueOf((Boolean) field.get(source)));
                            } else {
                                it.set(target, Boolean.valueOf((String) field.get(source)));
                            }
                        } else {
                            if (!ignoreNull) {
                                it.set(target, field.get(source));
                            } else {
                                //需要判断是否为空
                                Object sourceValue = field.get(source);
                                if (sourceValue != null && StringUtils.isNotBlank(sourceValue.toString())) {
                                    it.set(target, sourceValue);
                                }
                            }
                        }
                    } catch (IllegalAccessException e) {
                        if (logger.isErrorEnabled()) {
                            logger.error("拷贝属性出错" + e);
                        }
                    }
                }
            }
        });
    }




        /**
         * 拷贝数据
         * 大小写可以忽略
         * 下划线 _ 被忽略
         * @param source 来源属性
         * @param target 目标属性
         * @param ignoreNull 是否忽略控制
         */
    public static void copyPropertiesIgnoreCase(Object source,Object target,boolean ignoreNull,Map<String/**原对象的属性名字**/,String/**目标对象的属性名称**/> fieldMap){
        copyPropertiesIgnoreCase(source,target,ignoreNull,fieldMap,null);
    }

    /**
     * 缓存对象的属性
     */
    private static class CacheFieldMap {
        /**
         * 对象属性的缓存
         */
        private static Map<String/**类的名字**/, Map<String/**属性的名称小写**/, Field/**属性的对象**/>> cacheMap = new HashMap<>();

        /**
         * 对象的自己类的环境，不包括父类
         */
        private static Map<String/**类的名称**/,Map<String/**属性的名称小写**/,Field/**属性的对象**/>> declaredCacheMap = new HashMap<>();

        /**
         * 获取属性的映射
         * @param clazz 类
         * @return 属性名称小写和属性的映射
         */
        private static Map<String/**属性名称**/, Field> getFieldMap(Class clazz) {
            Map<String, Field> result = cacheMap.get(clazz.getName());
            if (result == null) {
                synchronized (CacheFieldMap.class) {
                    if (result == null) {
                        Map<String, Field> fieldMap = new HashMap<>();
                        List<Field> allFields = VciBaseUtil.getAllFieldForObj(clazz);
                        if(!CollectionUtils.isEmpty(allFields)){
                            allFields.stream().forEach(field -> {
                                fieldMap.put(field.getName().toLowerCase().replace("_", ""), field);
                            });
                        }
                        cacheMap.put(clazz.getName(), fieldMap);
                        result = cacheMap.get(clazz.getName());
                    }
                }
            }
            return result;
        }

        /**
         * 获取属性的映射（不包含父类）
         * @param clazz 类
         * @return 属性名称小写和属性的映射
         */
        private static Map<String/**属性名称**/,Field> getDeclaredFieldMap(Class clazz){
            Map<String, Field> result = declaredCacheMap.get(clazz.getName());
            if(result == null){
                synchronized(CacheFieldMap.class){
                    if (result == null) {
                        Map<String, Field> fieldMap = new HashMap<>();
                        Field[] allFields = clazz.getDeclaredFields();
                        if(allFields!=null && allFields.length>0){
                            Arrays.stream(allFields).forEach(field -> {
                                fieldMap.put(field.getName().toLowerCase().replace("_", ""), field);
                            });
                        }
                        declaredCacheMap.put(clazz.getName(), fieldMap);
                        result = declaredCacheMap.get(clazz.getName());
                    }
                }
            }
            return result;
        }
    }

    /**
     * 获取类拷贝的对象
     * @param source 源对象类
     * @param target 目标对象类
     * @param useConverter 是否使用转换器
     * @return 拷贝对象
     */
    public static BeanCopier getBeanCopier(Class<?> source, Class<?> target,boolean useConverter) {
        String beanCopierKey = generateBeanKey(source, target);
        if (beanCopierMap.containsKey(beanCopierKey)) {
            return beanCopierMap.get(beanCopierKey);
        } else {
            BeanCopier beanCopier = BeanCopier.create(source, target, useConverter);
            beanCopierMap.putIfAbsent(beanCopierKey, beanCopier);
        }
        return beanCopierMap.get(beanCopierKey);
    }

    /**
     * 生成两个类的key,用于存放到缓存之中
     * @param source 源对象类型
     * @param target 目标对象类
     * @return 两个类的名称连接到一起后的名字
     */
    public static String generateBeanKey(Class<?> source, Class<?> target) {
        return source.getName() + "@" + target.getName();
    }

    /**
     * 两个对象之间转换
     * @param source 源对象
     * @param target 目标对象
     * @param useConvert 是否使用默认的转换器，请在出现属性名称相同而类型不同，或者有对象类型，集合属性时才转换
     */
    public static void convert(Object source,Object target,boolean useConvert){
        if(source != null && target !=null){
            BeanCopier beanCopier = getBeanCopier(source.getClass(),target.getClass(),useConvert);
            beanCopier.copy(source,target,useConvert?new DeepCopyConverter(target):null);
        }
    }

    /**
     * 两个对象之间转换
     * @param source 源对象
     * @param target 目标对象
     * @return 目标对象
     */
    public static void convert(Object source,Object target){
        convert(source,target,true);
    }

    /**
     * 深度拷贝转换器
     */
    public static class DeepCopyConverter implements Converter {

        /**
         * 目标对象
         */
        private Object target;

        /**
         * 构造方法
         * @param target 目标对象
         */
        public DeepCopyConverter(Object target) {
            this.target = target;
        }

        /**
         * 执行拷贝
         * @param value 源对象的属性的值
         * @param targetClazz 目标对象的属性的类
         * @param methodName set方法的名字
         * @return 转换后的值
         */
        @Override
        public Object convert(Object value, Class targetClazz, Object methodName) {
            if (value instanceof List) {
                List values = (List) value;
                List retList = new ArrayList<>(values.size());
                copyForCollection(values,retList,methodName);
                return retList;
            } else if(value instanceof Set){
                Set values = (Set) value;
                Set retSet = new HashSet<>();
                copyForCollection(values,retSet,methodName);
            } else if(value instanceof Vector){
                Vector values = (Vector)value;
                Vector retVector = new Vector();
                copyForCollection(values,retVector,methodName);
            }else if (value instanceof Map) {
                Map values = (Map)value;
                Map retMap = new HashMap();
                for (final Object key : values.keySet()) {
                    Object mapValue = values.get(key);
                    String tempFieldName = methodName.toString().replace("set",
                            "");
                    String fieldName = tempFieldName.substring(0, 1)
                            .toLowerCase() + tempFieldName.substring(1);
                    Class clazz = ClassUtilForVCI.getElementType(target.getClass(), fieldName);
                    Object targetAttr = null;
                    try{
                        targetAttr = clazz.newInstance();
                    }catch (Throwable e){
                        //新的对象的属性初始化出错
                    }
                    BeanUtilForVCI.convert(mapValue, targetAttr);
                    retMap.put(key,targetAttr);
                }
            } else if (!ClassUtilForVCI.isPrimitive(targetClazz)) {
                //这个是对象类型
                Object targetAttr = null;
                try{
                    targetAttr = targetClazz.newInstance();
                }catch (Throwable e){
                    //新的对象属性初始化出错
                }
                BeanUtilForVCI.convert(value, targetAttr);
                return targetAttr;
            }
            if(value instanceof Boolean && targetClazz.equals(String.class)){
                //从boolean拷贝到string
                return String.valueOf(value);
            }
            if(value instanceof String && (targetClazz.equals(Boolean.class)
                    || targetClazz.equals(boolean.class))){
                //从String拷贝到boolean
                if("true".equalsIgnoreCase((String)value)){
                    return true;
                }else{
                    return false;
                }
            }
            if(value instanceof Date && targetClazz.equals(String.class)){
                //时间格式
                return VciDateUtil.date2Str((Date)value,VciDateUtil.DateTimeMillFormat);
            }
            if(value instanceof String && targetClazz.equals(Date.class)){
                //转换
                DateConverter dateConverter = new DateConverter();
                dateConverter.setAsText((String)value);
                return dateConverter.getValue();
            }
            return value;
        }

        /**
         * 处理集合属性
         * @param sourceCollection 源对象中集合属性的的值
         * @param targetCollection 目标对象的集合属性的值
         * @param methodName setter方法
         */
        private void copyForCollection(Collection<?> sourceCollection,Collection targetCollection,Object methodName){
            for (final Object source : sourceCollection) {
                if(source instanceof Collection){
                    List<Object> targetValues = new ArrayList<>();
                    copyForCollection((Collection<?>)source,targetValues,methodName);
                    targetCollection.add(targetValues);
                }else if(source instanceof Map){
                    String tempFieldName = methodName.toString().replace("set",
                            "");
                    String fieldName = tempFieldName.substring(0, 1)
                            .toLowerCase() + tempFieldName.substring(1);
                    Class clazz = ClassUtilForVCI.getElementType(target.getClass(), fieldName);
                    Object targetAttr = null;
                    try {
                        targetAttr = clazz.newInstance();
                    } catch (Throwable e) {
                        //新的对象的属性初始化出错
                    }
                    Map map = (Map) source;
                    for(Object key : map.keySet()){
                        VciBaseUtil.setValueForField(key.toString(),targetAttr,VciBaseUtil.getStringValueFromObject(map.get(key)));
                    }
                    targetCollection.add(targetAttr);
                }else  {
                    String tempFieldName = methodName.toString().replace("set",
                            "");
                    String fieldName = tempFieldName.substring(0, 1)
                            .toLowerCase() + tempFieldName.substring(1);
                    Class clazz = ClassUtilForVCI.getElementType(target.getClass(), fieldName);
                    Object targetAttr = null;
                    try {
                        targetAttr = clazz.newInstance();
                    } catch (Throwable e) {
                        //新的对象的属性初始化出错
                    }
                    BeanUtilForVCI.convert(source, targetAttr);
                    targetCollection.add(targetAttr);
                }
            }
        }
    }
}