package biz.xsoftware.impl.mock;

 import java.lang.reflect.InvocationHandler;

 import java.lang.reflect.InvocationTargetException;

 import java.lang.reflect.Method;

 import java.lang.reflect.Type;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Map;

 import java.util.Set;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import biz.xsoftware.mock.MockObject;

 /**

  * This is the implementation of the MockObject interface and the default object

  * returned by the {@link biz.xsoftware.mock.MockObjectFactory}.  This implements the invoke method

  * used by the Java Reflection {@link java.lang.reflect.Proxy}

  * 

  * @author Dean Hiller

  * @author Brian Freeman

  */

 public final class MockObjectImpl extends MockSuperclass implements InvocationHandler {

     private static final Logger log =

             Logger.getLogger(MockObjectImpl.class.getName());

     private static Set<Method> isMethodInSuper = new HashSet<Method>();

     private static Map<Type, Class<?>> primitiveToClass =

             new HashMap<Type, Class<?>>();

     private Class<?>[] classes;

     static {

         // reflect and find all the methods of the superclass.

         Class<?> c = MockObject.class;

         Method[] m = c.getMethods();

         for (int i = 0; i < m.length; i++) {

             isMethodInSuper.add(m[i]);

         }

         c = Object.class;

         m = c.getMethods();

         for (int i = 0; i < m.length; i++) {

             isMethodInSuper.add(m[i]);

         }

         primitiveToClass.put(Integer.TYPE, Integer.class);

         primitiveToClass.put(Double.TYPE, Double.class);

         primitiveToClass.put(Float.TYPE, Float.class);

         primitiveToClass.put(Boolean.TYPE, Boolean.class);

         primitiveToClass.put(Character.TYPE, Character.class);

         primitiveToClass.put(Byte.TYPE, Byte.class);

         primitiveToClass.put(Short.TYPE, Short.class);

         primitiveToClass.put(Long.TYPE, Long.class);

     }

     public MockObjectImpl(String id, Class<?>[] interfaces) {

         super(id);

         // copy the array of interface classes

         classes = new Class<?>[interfaces.length];

         System.arraycopy(interfaces, 0, classes, 0, interfaces.length);

     }

     /*

      * (non-Javadoc)

      * 

      * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object,

      *      java.lang.reflect.Method, java.lang.Object[])

      */

     public Object invoke(Object proxy, Method method, Object[] args)

             throws Throwable {

         if (log.isLoggable(Level.FINEST)) {

             StringBuilder sb = new StringBuilder();

             sb.append(proxy.getClass().getSimpleName()).append("> ");

             sb.append(method.getName()).append("(");

             if (args != null) {

                 int i = 0;

                 for (; i < args.length - 1; i++) {

                     if (args[i] != null)

                         sb.append(args[i].getClass().getSimpleName()).append(

                                 ", ");

                     else

                         sb.append("null, ");

                 }

                 if (args[i] != null)

                     sb.append(args[i].getClass().getSimpleName());

                 else

                     sb.append("null");

             }

             sb.append(")");

             log.finest(sb.toString());

         }

         if (shouldCallSuperMethod(method)) {

             return callSuperMethod(proxy, method, args);

         }

         Object o = methodCalledImpl(method, args);

         Class<?> returnType = method.getReturnType();

         if (returnType == null)

             throw new RuntimeException("This is a bug or something");

         String methodString = getCleanMethodString(method);

         if (returnType.equals(void.class)) {

             // The return type is void

             if (o != null)

                 throw new IllegalArgumentException(

                         "You are trying to return something on a method that returns void.\n"

                                 + "Method=" + methodString

                                 + " value you tried to return=" + o);

         } else {

             // Return type is not void...(could be primitive or Object)

             if (o == null) {

                 if (returnType.isPrimitive()) {

                     throw new IllegalArgumentException(

                             "Must call addReturnValue and "

                                     + "specify a non-null value as method="

                                     + methodString

                                     + " returns a primitive value");

                 }

             } else if (returnType.isPrimitive()) {

                 // TODO: this is not working correctly no matter what I do

                 // here.....

                 Class<?> primitiveClass = primitiveToClass.get(returnType);

                 if (!primitiveClass.isInstance(o)) {

                     throw new IllegalArgumentException(

                             "You specified an incorrect return type on method\n="

                                     + methodString + "\n"

                                     + "You specified a return type of="

                                     + o.getClass()

                                     + " which needs to be or extend type="

                                     + returnType);

                 }

             } else if (!returnType.isInstance(o)) {

                 // if not a primitive, make sure is assignable....

                 throw new IllegalArgumentException(

                         "You specified an incorrect return type on method\n="

                                 + methodString + "\n"

                                 + "You specified a return type of="

                                 + o.getClass()

                                 + " which needs to be or extend type="

                                 + returnType);

             }

         }

         return o;

     }

     private boolean shouldCallSuperMethod(Method method) {

         return isMethodInSuper.contains(method)

                 && !methodToReturnVal.containsKey(method)

                 && !methodToDefaultRetVal.containsKey(method);

     }

     /**

      * @param method

      * @return

      */

     private String getCleanMethodString(Method method) {

         String retType = method.getReturnType().getName();

         String methodArgs = retType + " " + method.getName() + "(";

         Class<?>[] parameterTypes = method.getParameterTypes();

         for (int ii = 0; ii < parameterTypes.length; ii++) {

             Class<?> arg = method.getParameterTypes()[ii];

             methodArgs += arg.getName();

             if (ii < parameterTypes.length - 1)

                 methodArgs += ", ";

         }

         return methodArgs + ")";

     }

     /**

      * 

      * @param proxy The method was invoked on this object. This is the dynamicly

      *            created class

      * @param m This is the method that was invoked

      * @param args These are the arguments that were passed to the method

      * @throws Throwable

      */

     private Object callSuperMethod(Object proxy, Method m, Object[] args)

             throws Throwable {

         try {

             if ("equals".equals(m.getName()))

                 return Boolean.valueOf(proxy == args[0]);

             else if ("toString".equals(m.getName()))

                 return "" + this;

             return m.invoke(this, args);

         } catch (InvocationTargetException e) {

             if (e.getCause() != null)

                 throw e.getCause();

             throw e;

         }

     }

     /*

      * (non-Javadoc)

      * 

      * @see biz.xsoftware.mock.MockSuperclass#getClasses()

      */

     @Override

     public Class<?>[] getClasses() {

         // copy the array of interface classes

         Class<?>[] result = new Class<?>[classes.length];

         System.arraycopy(classes, 0, result, 0, classes.length);

         return result;

     }

     public Object inst() {

         // TODO Auto-generated method stub

         return null;

     }

 }