import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.apache.commons.collections.CollectionUtils;
import org.modelmapper.ModelMapper;
import org.modelmapper.convention.MatchingStrategies;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.objenesis.ObjenesisException;

public class BeanConverter {
    private static final ModelMapper modelMapper = new ModelMapper();

    public BeanConverter() {
    }

    public static ModelMapper getModelMapper() {
        return modelMapper;
    }

    public static <T> Map<String, Object> beanToMap(T bean) {
        Map<String, Object> map = Collections.emptyMap();
        if (null != bean) {
            BeanMap beanMap = BeanMap.create(bean);
            map = new HashMap(beanMap.keySet().size());
            Iterator var3 = beanMap.keySet().iterator();

            while(var3.hasNext()) {
                Object key = var3.next();
                ((Map)map).put(String.valueOf(key), beanMap.get(key));
            }
        }

        return (Map)map;
    }

    public static <T> List<Map<String, Object>> beansToMap(List<T> objList) {
        List<Map<String, Object>> list = Collections.emptyList();
        if (CollectionUtils.isNotEmpty(objList)) {
            list = new ArrayList(objList.size());
            Iterator var4 = objList.iterator();

            while(var4.hasNext()) {
                T anObjList = var4.next();
                Map<String, Object> map = beanToMap(anObjList);
                ((List)list).add(map);
            }
        }

        return (List)list;
    }

    public static <T> List<T> mapToBean(List<Map<String, Object>> mapList, Class<T> beanClass) {
        List<T> list = Collections.emptyList();
        if (CollectionUtils.isNotEmpty(mapList)) {
            list = new ArrayList(mapList.size());
            Iterator var5 = mapList.iterator();

            while(var5.hasNext()) {
                Map<String, Object> map1 = (Map)var5.next();
                T bean = mapToBean(map1, beanClass);
                ((List)list).add(bean);
            }
        }

        return (List)list;
    }

    public static <T> T mapToBean(Map<String, Object> map, Class<T> beanClass) {
        T entity = newInstance(beanClass);
        BeanMap beanMap = BeanMap.create(entity);
        beanMap.putAll(map);
        return entity;
    }

    public static <T> List<T> convert(Class<T> clazz, List<?> list) {
        return CollectionUtils.isEmpty(list) ? Collections.emptyList() : (List)list.stream().map((e) -> {
            return convert(clazz, e);
        }).collect(Collectors.toList());
    }

    public static <T> T convert(Class<T> targetClass, Object source) {
        return getModelMapper().map(source, targetClass);
    }

    public static void convert(Object targetClass, Object source) {
        getModelMapper().map(source, targetClass);
    }

    private static <T> T newInstance(Class<T> clazz) {
        try {
            return clazz.newInstance();
        } catch (InstantiationException | IllegalAccessException var2) {
            throw new ObjenesisException(var2);
        }
    }

    static {
        Jsr310ModuleConfig config = Jsr310ModuleConfig.builder().dateTimePattern("yyyy-MM-dd HH:mm:ss").datePattern("yyyy-MM-dd").zoneId(ZoneId.systemDefault()).build();
        modelMapper.registerModule(new Jsr310Module(config)).registerModule(new Jdk8Module());
        modelMapper.getConfiguration().setFullTypeMatchingRequired(true);
        modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
    }
}