import static org.junit.Assert.assertEquals;

import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

import org.junit.Test;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.FatalBeanException;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.core.ResolvableType;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.ReflectionUtils;

public class TestCopyProperties {

    public static class BaseModel<T> {

        public BaseModel() {
        }

        private T id;
        private String name;

        /**
         * @return the id
         */
        public T getId() {
            return id;
        }

        /**
         * @param id the id to set
         */
        public void setId(T id) {
            this.id = id;
        }

        /**
         * @return the name
         */
        public String getName() {
            return name;
        }

        /**
         * @param name the name to set
         */
        public void setName(String name) {
            this.name = name;
        }
    }

    public static class User extends BaseModel<Integer> {
        private String address;

        public User() {
            super();
        }

        /**
         * @return the address
         */
        public String getAddress() {
            return address;
        }

        /**
         * @param address the address to set
         */
        public void setAddress(String address) {
            this.address = address;
        }

    }

    @Test
    public void testCopyFailed() throws Exception {
        User f = createCglibProxy(User.class);
        f.setId(1);
        f.setName("proxy");
        f.setAddress("addr");

        User copy = new User();

        // copyProperties(f, copy, null, (String[]) null);

        BeanUtils.copyProperties(f, copy);

        assertEquals(f.getName(), copy.getName());
        assertEquals(f.getAddress(), copy.getAddress());
        assertEquals(f.getId(), copy.getId());
    }

    @Test
    public void testCopyPrevious() throws Exception {
        User f = createCglibProxy(User.class);
        f.setId(1);
        f.setName("proxy");
        f.setAddress("addr");

        User copy = new User();

        copyProperties(f, copy, null, (String[]) null);

        assertEquals(f.getName(), copy.getName());
        assertEquals(f.getAddress(), copy.getAddress());
        assertEquals(f.getId(), copy.getId());
    }

    @SuppressWarnings("unchecked")
    private <T> T createCglibProxy(Class<T> clazz)
            throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> {

            return proxy.invokeSuper(obj, args);
        });

        return (T) enhancer.create();

    }

    private static void copyProperties(Object source, Object target, @Nullable Class<?> editable,
            @Nullable String... ignoreProperties) throws BeansException {

        Assert.notNull(source, "Source must not be null");
        Assert.notNull(target, "Target must not be null");

        Class<?> actualEditable = target.getClass();
        if (editable != null) {
            if (!editable.isInstance(target)) {
                throw new IllegalArgumentException("Target class [" + target.getClass().getName() +
                        "] not assignable to editable class [" + editable.getName() + "]");
            }
            actualEditable = editable;
        }
        PropertyDescriptor[] targetPds = BeanUtils.getPropertyDescriptors(actualEditable);
        Set<String> ignoredProps = (ignoreProperties != null ? new HashSet<>(Arrays.asList(ignoreProperties)) : null);

        for (PropertyDescriptor targetPd : targetPds) {
            Method writeMethod = targetPd.getWriteMethod();
            if (writeMethod != null && (ignoredProps == null || !ignoredProps.contains(targetPd.getName()))) {
                PropertyDescriptor sourcePd = BeanUtils.getPropertyDescriptor(source.getClass(), targetPd.getName());

                if (sourcePd != null) {
                    Method readMethod = sourcePd.getReadMethod();
                    if (readMethod != null) {

                        ResolvableType sourceResolvableType = ResolvableType.forMethodReturnType(readMethod);
                        ResolvableType targetResolvableType = ResolvableType.forMethodParameter(writeMethod, 0);

                        boolean isAssignable = (sourceResolvableType.hasUnresolvableGenerics()
                                || targetResolvableType.hasUnresolvableGenerics()
                                        ? ClassUtils.isAssignable(writeMethod.getParameterTypes()[0],
                                                readMethod.getReturnType())
                                        : targetResolvableType.isAssignableFrom(sourceResolvableType));

                        if (isAssignable) {
                            try {
                                ReflectionUtils.makeAccessible(readMethod);
                                Object value = readMethod.invoke(source);
                                ReflectionUtils.makeAccessible(writeMethod);
                                writeMethod.invoke(target, value);
                            } catch (Throwable ex) {
                                throw new FatalBeanException(
                                        "Could not copy property '" + targetPd.getName() + "' from source to target",
                                        ex);
                            }
                        }
                    }
                }
            }
        }
    }

}