import java.lang.reflect.Method;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.Iterator;
import java.util.HashMap;

public class ObjectWrapper {

	protected Object wrappedObject = null;
	protected InvocationTargetException lastThrownException = null;
	protected boolean primitive = false;

	protected static HashMap staticExceptions = new HashMap();

	protected ObjectWrapper() {
	}

	protected ObjectWrapper ( Object wrapMe ) {
		wrappedObject = wrapMe;
	}

	protected ObjectWrapper ( Object wrapMe, boolean isPrimitive ) {
		wrappedObject = wrapMe;
		primitive = isPrimitive;
	}

	protected void finalize() {
	}

	public Object getWrappedObject (  ) {
		return wrappedObject;
	}

	protected Class getObjectType (  ) {
		if ( primitive ) {
			return (Class) this.getField("TYPE").getWrappedObject();
		} else {
			return wrappedObject.getClass();
		}
	}

	public boolean isArray (  ) {
		return wrappedObject.getClass().isArray();
	}

	//public ArrayWrapper getAsArray (  ) {
	//}

	public ObjectWrapper getField ( String fieldName ) {
		try {
			Field thisField = wrappedObject.getClass().getField(fieldName);
			return new ObjectWrapper(thisField.get(wrappedObject));
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return null;
	}

	public void setField ( String fieldName, ObjectWrapper value ) {
		try {
			Field thisField = wrappedObject.getClass().getField(fieldName);
			thisField.set(wrappedObject, value.getWrappedObject());
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
	}

	public boolean perl_isa ( String javaClassName ) {
		//System.out.println("ISA CALLED IN JAVA");
		//System.out.println("The class being asked about is: ." + javaClassName + ".");
		boolean temp;
		try {
			temp = Class.forName(javaClassName).isAssignableFrom(wrappedObject.getClass());
			//System.out.println("perl_isa is returning: " + temp);
			return temp;
		} catch (ClassNotFoundException e) {
			return false;
		}
	}

	public boolean can ( String methodName ) {
		Method[] methods = wrappedObject.getClass().getMethods();
		for ( int i = 0; i < methods.length; i++ ) {
			if ( methods[i].getName().equals(methodName) ) {
				return true;
			}
		}
		return false;
	}
	
	public String toString (  ) {
		return wrappedObject.toString();
	}

	private static void getArguments ( ArgumentArray wrapped, Class[] types, Object[] values ) {
		if ( wrapped != null ) {
			Iterator itr = wrapped.getIterator();
			ObjectWrapper curr = null;
			//int i = 0;
			for ( int i = 0; itr.hasNext(); i++ ) {
			//while ( itr.hasNext() ) {
				curr = (ObjectWrapper) itr.next();
				values[i] = curr.getWrappedObject();
				//argClasses[i] = args[i].getClass();
				types[i] = curr.getObjectType();
				i++;
			}
		}
	}

	public ObjectWrapper invokeMethod ( String methodName, ArgumentArray inputArgs ) {
		Class[] argClasses = null;
		Object[] args = null;
		if ( inputArgs != null ) {
			argClasses = new Class[inputArgs.getSize()];
			args = new Object[inputArgs.getSize()];	
		}
		getArguments(inputArgs, argClasses, args);
		
		try {
			Method thisMethod = wrappedObject.getClass().getMethod(methodName, argClasses);
			Object returnValue = thisMethod.invoke(wrappedObject, args);
			if ( returnValue.getClass().isArray() ) {
				return new ArrayWrapper(returnValue);
			}
			return new ObjectWrapper(returnValue);
		} catch (InvocationTargetException e) {
			lastThrownException = e;
		} catch ( Exception e ) {
			lastThrownException = new InvocationTargetException(e);
		}
		return null;
	}

	public ObjectWrapper getLastThrownException (  ) {
		//System.out.println("Called getLastThrownException");
		Exception lastException = lastThrownException;
		lastThrownException = null;
		if ( lastException == null ) {
			return null;
		} else {
			return new ObjectWrapper(lastException);
		}
	}

	public static ObjectWrapper getLastStaticThrownException (  ) {
		Exception lastException = (Exception) staticExceptions.get(Thread.currentThread().getName());
		staticExceptions.put(Thread.currentThread().getName(), null);
		if ( lastException == null ) {
			return null;
		} else {
			return new ObjectWrapper(lastException);
		}
	}

	public static ObjectWrapper invokeStaticMethod ( String className, String staticMethodName, ArgumentArray inputArgs ) {
		Class[] argClasses = null;
                Object[] args = null;
		if ( inputArgs != null ) {
                        argClasses = new Class[inputArgs.getSize()];
                        args = new Object[inputArgs.getSize()];
		}
		getArguments(inputArgs, argClasses, args);

                try {
                        Method thisMethod = Class.forName(className).getMethod(staticMethodName, argClasses);
			Object returnValue = thisMethod.invoke(null, args);
			if ( returnValue.getClass().isArray() ) {
				return new ArrayWrapper(returnValue);
			}
                        return new ObjectWrapper(returnValue);
                } catch (InvocationTargetException e) {
			//index the exception based on the result of Thread.currentThread()
			staticExceptions.put(Thread.currentThread().getName(), e);
                } catch (Exception e) {
			staticExceptions.put(Thread.currentThread().getName(), new InvocationTargetException(e));
		}
                return null;
	}

	public static ObjectWrapper newClassInstance ( String javaClassName, ArgumentArray inputArgs ) {
		Class[] argClasses = null;
                Object[] args = null;
		if ( inputArgs != null ) {
                        argClasses = new Class[inputArgs.getSize()];
                        args = new Object[inputArgs.getSize()];
		}
		getArguments(inputArgs, argClasses, args);

		try {
			Class thisClass = Class.forName(javaClassName);
			Constructor thisConstructor = thisClass.getConstructor(argClasses);
			return new ObjectWrapper(thisConstructor.newInstance(args));
		} catch (InvocationTargetException e ) {
			//propagate this to Perl and die a standard message
			//index the exception based on the result of Thread.currentThread()
			staticExceptions.put(Thread.currentThread().getName(), e);
			//e.printStackTrace();
		} catch (Exception e) {
			staticExceptions.put(Thread.currentThread().getName(), new InvocationTargetException(e));
		}
		return null;
	}

	public static ArrayWrapper newJavaArray ( String javaClassName, int size ) {
		return new ArrayWrapper(javaClassName, size);
	}

	public static ObjectWrapper wrapInt ( int wrapMe ) {
		return new ObjectWrapper(new Integer(wrapMe), true);
	}

	public static ObjectWrapper wrapString ( String wrapMe ) {
		return new ObjectWrapper(wrapMe);
	}

	public static ObjectWrapper wrapBoolean ( boolean wrapMe ) {
		return new ObjectWrapper(new Boolean(wrapMe), true);
	}

	public static ObjectWrapper wrapShort ( short wrapMe ) {
		return new ObjectWrapper(new Short(wrapMe), true);
	}

	public static ObjectWrapper wrapLong ( long wrapMe ) {
		return new ObjectWrapper(new Long(wrapMe), true);
	}

	public static ObjectWrapper wrapFloat ( float wrapMe ) {
		return new ObjectWrapper(new Float(wrapMe), true);
	}
	
	public static ObjectWrapper wrapDouble ( double wrapMe ) {
		return new ObjectWrapper(new Double(wrapMe), true);
	}

	public static ObjectWrapper wrapByte ( byte wrapMe ) {
		return new ObjectWrapper(new Byte(wrapMe), true);
	}

	public static ObjectWrapper wrapChar ( char wrapMe ) {
		return new ObjectWrapper(new Character(wrapMe), true);
	}

}