import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.Serializable;
import java.lang.reflect.Method;
 
/**
 * Shows odd behavior when using an introspector from the java.beans api
 */
public class IntrospectorPossibleBugTest {
 
	/**
	 * Marker interface for all locations
	 */
	interface Location {
	}
 
	/**
	 * A City is a location
	 */
	class City implements Location {
	}
 
	/**
	 * Marker interface for people, a person must have a location assigned
	 */
	interface Person {
		Location getLocation();
	}
 
	/**
	 * A worker is a Person and should have a location that is actually a City
	 */
	static class Worker implements Person, Serializable {
 
		private City location;
 
		public City getLocation() {
			return location;
		}
 
		public void setLocation(City location) {
			this.location = location;
		}
 
	}
 
	/**
	 * This small test cases shows the odd behavior.
	 * Even though Worker conforms with the getters and setters for the javabean spec the
	 * Introspector seems to not be able to find any setter for the property location.
	 * Seems like instead of following a bottom up loockup for property accessors it starts and stops once it
	 * finds a compatible property in one of the implemented interfaces.
	 */
	public static void main(String... args) throws IntrospectionException {
		BeanInfo info = Introspector.getBeanInfo(Worker.class);
		PropertyDescriptor[] descriptors = info.getPropertyDescriptors();
		for (PropertyDescriptor descriptor : descriptors) {
			if (!descriptor.getName().equals("class")) {
				System.out.println("property: \t\t\t\t\t\t" + descriptor.getName());
				System.out.println("getter: \t\t\t\t\t\t" + descriptor.getReadMethod());
				System.out.println("getter returns: \t\t\t\t" + descriptor.getReadMethod().getReturnType());
				System.out.println("setter: \t\t\t\t\t\t" + descriptor.getWriteMethod());
				String propertyName = descriptor.getName();
				String setterName = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
				Method setter = findMethodImplFirst(Worker.class, setterName, City.class);
				System.out.println("setter with reflection: \t\t" + setter);
			}
		}
 
	}
 
	/**
	 * workaround for introspector odd behavior with javabeans that implement interfaces with comaptible return types
	 * but instrospection is unable to find the right accessors
	 *
	 * @param currentTargetClass the class being evaluated
	 * @param methodName		 the method name we are looking for
	 * @param argTypes		   the arg types for the method name
	 * @return a method if found
	 */
	public static Method findMethodImplFirst(Class<?> currentTargetClass, String methodName, Class<?>... argTypes) {
		Method method = null;
		if (currentTargetClass != null && methodName != null) {
			try {
				method = currentTargetClass.getMethod(methodName, argTypes);
			} catch (Throwable t) {
				// nothing we can do but continue
			}
			//Is the method in one of our parent classes
			if (method == null) {
				Class<?> superclass = currentTargetClass.getSuperclass();
				if (!superclass.equals(Object.class)) {
					method = findMethodImplFirst(superclass, methodName, argTypes);
				}
			}
		}
		return method;
	}
 
}