package com.chushang.inspection.utils;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.SimpleCache;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.springframework.cglib.beans.BeanCopier;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.cglib.core.Converter;

import java.util.List;
import java.util.Map;


/**
 * <h1>bean深拷贝工具(基于 cglib 性能优异)</h1>
 *
 * @author 单傲
 * @date 2023/1/10 11:15
 */
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class BeanCopyUtils {

    /**
     * <h2>单对象基于class创建拷贝</h2>
     *
     * @param source 数据来源实体
     * @param desc   描述对象 转换后的对象
     * @return desc
     * @author 单傲
     * @date 2023/1/10 11:15
     */
    public static <T, V> V copy(T source, Class<V> desc) {
        if (ObjectUtil.isNull(source)) {
            return null;
        }
        if (ObjectUtil.isNull(desc)) {
            return null;
        }
        final V target = ReflectUtil.newInstanceIfPossible(desc);
        return copy(source, target);
    }


    /**
     * <h2>单对象基于对象创建拷贝</h2>
     *
     * @param source 数据来源实体
     * @param desc   转换后的对象
     * @return desc
     * @author 单傲
     * @date 2023/1/10 11:15
     */
    public static <T, V> V copy(T source, V desc) {
        if (ObjectUtil.isNull(source)) {
            return null;
        }
        if (ObjectUtil.isNull(desc)) {
            return null;
        }
        BeanCopier beanCopier = BeanCopierCache.INSTANCE.get(source.getClass(), desc.getClass(), null);
        beanCopier.copy(source, desc, null);
        return desc;
    }


    /**
     * <h2>列表对象基于class创建拷贝</h2>
     *
     * @param sourceList 数据来源实体列表
     * @param desc       描述对象 转换后的对象
     * @return desc
     * @author 单傲
     * @date 2023/1/10 11:15
     */
    public static <T, V> List<V> copyList(List<T> sourceList, Class<V> desc) {
        if (ObjectUtil.isNull(sourceList)) {
            return null;
        }
        if (CollUtil.isEmpty(sourceList)) {
            return CollUtil.newArrayList();
        }
        return StreamUtils.toList(sourceList, source -> {
            V target = ReflectUtil.newInstanceIfPossible(desc);
            copy(source, target);
            return target;
        });
    }


    /**
     * <h2>bean拷贝到map</h2>
     *
     * @param bean 数据来源实体
     * @return map对象
     * @author 单傲
     * @date 2023/1/10 11:15
     */
    @SuppressWarnings("unchecked")
    public static <T> Map<String, Object> copyToMap(T bean) {
        if (ObjectUtil.isNull(bean)) {
            return null;
        }
        return BeanMap.create(bean);
    }

    /**
     * <h2>map拷贝到bean</h2>
     *
     * @param map       数据来源
     * @param beanClass bean类
     * @return bean对象
     * @author 单傲
     * @date 2023/1/10 11:15
     */
    public static <T> T mapToBean(Map<String, Object> map, Class<T> beanClass) {
        if (MapUtil.isEmpty(map)) {
            return null;
        }
        if (ObjectUtil.isNull(beanClass)) {
            return null;
        }
        T bean = ReflectUtil.newInstanceIfPossible(beanClass);
        return mapToBean(map, bean);
    }


    /**
     * <h2>map拷贝到bean</h2>
     *
     * @param map  数据来源
     * @param bean bean对象
     * @return bean对象
     * @author 单傲
     * @date 2023/1/10 11:15
     */
    public static <T> T mapToBean(Map<String, Object> map, T bean) {
        if (MapUtil.isEmpty(map)) {
            return null;
        }
        if (ObjectUtil.isNull(bean)) {
            return null;
        }
        BeanMap.create(bean).putAll(map);
        return bean;
    }


    /**
     * <h1>BeanCopier属性缓存</h1>
     *
     * <p>
     * 缓存用于防止多次反射造成的性能问题
     * </p>
     *
     * @author 单傲
     * @date 2023/1/10 11:15
     */
    public enum BeanCopierCache {
        /**
         * BeanCopier属性缓存单例
         */
        INSTANCE;

        private final SimpleCache<String, BeanCopier> cache = new SimpleCache<>();


        /**
         * <h2>获得类与转换器生成的key在{@link BeanCopier}的Map中对应的元素</h2>
         *
         * @param srcClass    源Bean的类
         * @param targetClass 目标Bean的类
         * @param converter   转换器
         * @return Map中对应的BeanCopier
         * @author 单傲
         * @date 2023/1/10 11:15
         */
        public BeanCopier get(Class<?> srcClass, Class<?> targetClass, Converter converter) {
            final String key = genKey(srcClass, targetClass, converter);
            return cache.get(key, () -> BeanCopier.create(srcClass, targetClass, converter != null));
        }

        /**
         * <h2>获得类与转换器生成的key</h2>
         *
         * @param srcClass    源Bean的类
         * @param targetClass 目标Bean的类
         * @param converter   转换器
         * @return 属性名和Map映射的key
         * @author 单傲
         * @date 2023/1/10 11:15
         */
        private String genKey(Class<?> srcClass, Class<?> targetClass, Converter converter) {
            final StringBuilder key = StrUtil.builder()
                    .append(srcClass.getName()).append('#').append(targetClass.getName());
            if (null != converter) {
                key.append('#').append(converter.getClass().getName());
            }
            return key.toString();
        }
    }

}
