/**
* @author BNTang
*/
@Slf4j
public class BeanHelper {

    public static <T> T copyProperties(Object source, Class<T> target) {
        if (!ObjectUtils.allNotNull(source, target)) {
            return null;
        }
        try {
            T instance = target.getDeclaredConstructor().newInstance();
            BeanUtils.copyProperties(source, instance);
            return instance;
        } catch (Exception exception) {
            log.error("【对象转换】目标对象{}实例化异常 异常信息:{}", target.getSimpleName(), ExceptionUtils.getStackTrace(exception));
            return null;
        }
    }

    public static <T> Collection<T> copyWithCollection(Collection<Object> source, Class<T> target) {
        if (CollectionUtils.isEmpty(source) || Objects.isNull(target)) {
            return Collections.emptyList();
        }
        return source.stream().filter(Objects::nonNull).map(e -> copyProperties(e, target)).filter(Objects::nonNull).collect(Collectors.toList());
    }

    /**
* 单个对象转换
*
* @param <T> 目标转换类型
* @param source 数据源
* @param createTarget 指定目标对象创建方法, 用于创建目标对象和初始赋值步骤
* @param consumer 转换时的回调函数
* @param callback 转换时的回调函数 Object:source T:target return:target
* @param ignoreProperties 不进行转换的属性, 若createTarget进行了赋值操作，应加上被赋值的属性，避免被覆盖
* @return 目标对象实例
*/
    private static <T> T copyProperties(Object source, Supplier<T> createTarget, BiConsumer<Object, T> consumer, BiFunction<Object, T, T> callback, String... ignoreProperties) {
        if (!ObjectUtils.allNotNull(source, createTarget)) {
            return null;
        }
        T newTarget = null;
        try {
            newTarget = createTarget.get();
            return Optional.ofNullable(newTarget).map(target -> {
                BeanUtils.copyProperties(source, target, ignoreProperties);
                if (Objects.nonNull(consumer)) {
                    consumer.accept(source, target);
                }
                if (Objects.nonNull(callback)) {
                    return callback.apply(source, target);
                }
                return target;
            }).orElse(null);
        } catch (Exception exception) {
            log.error("【对象转换】目标对象{}数据转换异常 异常信息:{}", newTarget, ExceptionUtils.getStackTrace(exception));
            return null;
        }
    }

    /**
* 单个对象转换
*
* @param <T> 目标转换类型
* @param source 数据源
* @param createTarget 指定目标对象创建方法, 用于创建目标对象和初始赋值步骤
* @param callback 转换时的回调函数 Object:source T:target return: target
* @param ignoreProperties 不进行转换的属性, 若createTarget进行了赋值操作，应加上被赋值的属性，避免被覆盖
* @return 目标对象实例
*/
    public static <T> T copyProperties(Object source, Supplier<T> createTarget, BiFunction<Object, T, T> callback, String... ignoreProperties) {
        return copyProperties(source, createTarget, null, callback, ignoreProperties);
    }

    /**
* 单个对象转换
*
* @param <T> 目标转换类型
* @param source 数据源
* @param createTarget 指定目标对象创建方法, 用于创建目标对象和初始赋值步骤
* @param consumer 转换时的回调函数
* @param ignoreProperties 不进行转换的属性, 若createTarget进行了赋值操作，应加上被赋值的属性，避免被覆盖
* @return 目标对象实例
*/
    public static <T> T copyProperties(Object source, Supplier<T> createTarget, BiConsumer<Object, T> consumer, String... ignoreProperties) {
        return copyProperties(source, createTarget, consumer, null, ignoreProperties);
    }

    /**
* 单个对象转换
*
* @param <T> 目标转换类型
* @param source 数据源
* @param createTarget 指定目标对象创建方法, 用于创建目标对象和初始赋值步骤
* @param ignoreProperties 不进行转换的属性, 若createTarget进行了赋值操作，应加上被赋值的属性，避免被覆盖
* @return 目标对象实例
*/
    public static <T> T copyProperties(Object source, Supplier<T> createTarget, String... ignoreProperties) {
        return copyProperties(source, createTarget, null, null, ignoreProperties);
    }

    /**
* 单个对象转换
*
* @param source 数据源
* @param createTarget 指定目标对象创建方法, 用于创建目标对象和初始赋值步骤
* @param <T> 目标转换类型
* @return 目标对象实例
*/
    public static <T> T copyProperties(Object source, Supplier<T> createTarget) {
        return copyProperties(source, createTarget, null, null, (String[]) null);
    }

    /**
* 多对象转换
*
* @param <T> 目标转换类型
* @param source 数据源
* @param createTarget 指定目标对象创建方法, 用于创建目标对象和初始赋值步骤
* @param consumer 转换时的回调函数
* @param callback 转换时的回调函数 Object:source T:target return: target
* @param ignoreProperties 不进行转换的属性, 若createTarget进行了赋值操作，应加上被赋值的属性，避免被覆盖
* @return 目标对象实例集合
*/
    private static <T> List<T> copyWithCollection(Collection<?> source, Supplier<T> createTarget, BiConsumer<Object, T> consumer, BiFunction<Object, T, T> callback, String... ignoreProperties) {
        if (CollectionUtils.isEmpty(source)) {
            return Collections.emptyList();
        }
        return source.stream().filter(Objects::nonNull).map(e -> copyProperties(e, createTarget, consumer, callback, ignoreProperties)).filter(Objects::nonNull).collect(Collectors.toList());
    }

    /**
* 多对象转换
*
* @param source 数据源
* @param createTarget 指定目标对象创建方法, 用于创建目标对象和初始赋值步骤
* @param ignoreProperties 不进行转换的属性, 若createTarget进行了赋值操作，应加上被赋值的属性，避免被覆盖
* @param <T> 目标转换类型
* @return 目标对象实例集合
*/
    public static <T> List<T> copyWithCollection(Collection<?> source, Supplier<T> createTarget, String... ignoreProperties) {
        return copyWithCollection(source, createTarget, null, null, ignoreProperties);
    }

    /**
* 多对象转换
*
* @param source 数据源
* @param createTarget 指定目标对象创建方法, 用于创建目标对象和初始赋值步骤
* @param <T> 目标转换类型
* @return 目标对象实例集合
*/
    public static <T> List<T> copyWithCollection(Collection<?> source, Supplier<T> createTarget) {
        return copyWithCollection(source, createTarget, null, null, (String[]) null);
    }

    /**
* 多对象转换
*
* @param source 数据源
* @param createTarget 指定目标对象创建方法, 用于创建目标对象和初始赋值步骤
* @param consumer 转换时的回调函数
* @param <T> 目标转换类型
* @return 目标对象实例集合
*/
    public static <T> List<T> copyWithCollection(Collection<?> source, Supplier<T> createTarget, BiConsumer<Object, T> consumer) {
        return copyWithCollection(source, createTarget, consumer, null, (String[]) null);
    }

    /**
* 多对象转换
*
* @param source 数据源
* @param createTarget 指定目标对象创建方法, 用于创建目标对象和初始赋值步骤
* @param consumer 转换时的回调函数
* @param ignoreProperties 不进行转换的属性, 若createTarget进行了赋值操作，应加上被赋值的属性，避免被覆盖
* @param <T> 目标转换类型
* @return 目标对象实例集合
*/
    public static <T> List<T> copyWithCollection(Collection<?> source, Supplier<T> createTarget, BiConsumer<Object, T> consumer, String... ignoreProperties) {
        return copyWithCollection(source, createTarget, consumer, null, ignoreProperties);
    }

    /**
* 多对象转换
*
* @param source 数据源
* @param createTarget 指定目标对象创建方法, 用于创建目标对象和初始赋值步骤
* @param callback 转换时的回调函数 Object:source T:target return: target
* @param <T> 目标转换类型
* @return 目标对象实例集合
*/
    public static <T> List<T> copyWithCollection(Collection<?> source, Supplier<T> createTarget, BiFunction<Object, T, T> callback) {
        return copyWithCollection(source, createTarget, null, callback, (String[]) null);
    }

    /**
* 多对象转换
*
* @param source 数据源
* @param createTarget 指定目标对象创建方法, 用于创建目标对象和初始赋值步骤
* @param callback 转换时的回调函数 Object:source T:target return: target
* @param ignoreProperties 不进行转换的属性, 若createTarget进行了赋值操作，应加上被赋值的属性，避免被覆盖
* @param <T> 目标转换类型
* @return 目标对象实例集合
*/
    public static <T> List<T> copyWithCollection(Collection<?> source, Supplier<T> createTarget, BiFunction<Object, T, T> callback, String... ignoreProperties) {
        return copyWithCollection(source, createTarget, null, callback, ignoreProperties);
    }
}