/*
    * @(#) Interpreter.java Jan 13, 2004
    * 
    * Copyright (c) 2003 Delft University of Technology Jaffalaan 5, 2628 BX Delft,
    * the Netherlands All rights reserved.
    * 
    * This software is proprietary information of Delft University of Technology
    * The code is published under the General Public License
    */
  package nl.tudelft.simulation.dsol.interpreter;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.lang.reflect.AccessibleObject;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Method;
  import java.lang.reflect.Modifier;
  import java.util.Properties;
  import java.util.Stack;
  import java.util.logging.Level;
  
  import nl.tudelft.simulation.dsol.interpreter.classfile.ClassDescriptor;
  import nl.tudelft.simulation.dsol.interpreter.classfile.Constant;
  import nl.tudelft.simulation.dsol.interpreter.classfile.MethodDescriptor;
  import nl.tudelft.simulation.dsol.interpreter.operations.InvokeOperation;
  import nl.tudelft.simulation.dsol.interpreter.operations.JumpOperation;
  import nl.tudelft.simulation.dsol.interpreter.operations.RET;
  import nl.tudelft.simulation.dsol.interpreter.operations.RETURN;
  import nl.tudelft.simulation.dsol.interpreter.operations.ReturnOperation;
  import nl.tudelft.simulation.dsol.interpreter.operations.VoidOperation;
  import nl.tudelft.simulation.dsol.interpreter.operations.WIDE;
  import nl.tudelft.simulation.language.io.URLResource;
  import nl.tudelft.simulation.language.reflection.ClassUtil;
  import nl.tudelft.simulation.logger.Logger;
  
  /***
   * A Interpreter <br>
   * (c) copyright 2003 <a href="http://www.simulation.tudelft.nl">Delft
   * University of Technology </a>, the Netherlands. <br>
   * See for project information <a
   * href="http://www.simulation.tudelft.nl">www.simulation.tudelft.nl </a> <br>
   * License of use: <a href="http://www.gnu.org/copyleft/gpl.html">General Public
   * License (GPL) </a>, no warranty <br>
   * 
   * @version 1.0 Jan 13, 2004 <br>
   * @author <a href="http://www.simulation.tudelft.nl/people/jacobs.html">Peter
   *         Jacobs </a>
   */
  public class Interpreter
  {
  
  	/*** Let's resolve the logLevel to use. */
  	static
  	{
  		try
  		{
  			InputStream stream = URLResource
  					.getResourceAsStream("/interpreter.properties");
  			if (stream != null)
  			{
  				Properties properties = new Properties();
  				properties.load(stream);
  				Logger.setLogLevel(Level.parse(properties
  						.getProperty("interpreter.logLevel")));
  			}
  		} catch (Exception exception)
  		{
  			Logger.warning(MethodDescriptor.class, "<clinit>", exception);
  		}
  	}
  
  	/***
  	 * constructs a new Interpreter
  	 */
  	protected Interpreter()
  	{
  		super();
  	}
  
  	/***
  	 * creates a frame for a method
  	 * 
  	 * @param object the object on which the method must be invoked
  	 * @param method the method or constructor
  	 * @param arguments the arguments
  	 * @return Frame the result
  	 * @throws ClassNotFoundException whenever the classpath is incomplete
  	 * @throws IOException on IOException
  	 */
  	public static Frame createFrame(final Object object,
  			final AccessibleObject method, final Object[] arguments)
  			throws ClassNotFoundException, IOException
  	{
  		Object[] args = new Object[0];
  		if (arguments != null)
  		{
  			args = arguments;
  		}
  		ClassDescriptor classDescriptor = null;
 		int modifiers = -1;
 		Class[] parameterTypes = null;
 		if (method instanceof Method)
 		{
 			parameterTypes = ((Method) method).getParameterTypes();
 			classDescriptor = ClassDescriptor.get(((Method) method)
 					.getDeclaringClass());
 			modifiers = ((Method) method).getModifiers();
 		} else
 		{
 			parameterTypes = ((Constructor) method).getParameterTypes();
 			classDescriptor = ClassDescriptor.get(((Constructor) method)
 					.getDeclaringClass());
 			modifiers = ((Constructor) method).getModifiers();
 		}
 		MethodDescriptor methodDescriptor = classDescriptor.getMethod(method);
 		OperandStack operandStack = new OperandStack(methodDescriptor
 				.getMaxStack());
 		LocalVariable[] localVariables = LocalVariable
 				.newInstance(methodDescriptor.getLocalVariableTable());
 		int counter = 0;
 
 		//If method!=static put object on localVariableTable
 		if (!Modifier.isStatic(modifiers))
 		{
 			localVariables[counter++].setValue(object);
 		}
 
 		// add the call parameters for the method to the stack
 		for (int i = 0; i < args.length; i++)
 		{
 			localVariables[counter++].setValue(arguments[i]);
 			if ((parameterTypes[i].equals(double.class))
 					|| (parameterTypes[i].equals(long.class)))
 			{
 				counter++;
 			}
 		}
 
 		if (Logger.getLogLevel().intValue() <= Level.FINER.intValue())
 		{
 			String logMessage = methodDescriptor.getMethod().toString()
 					+ "\n"
 					+ Operation.toString(methodDescriptor, methodDescriptor
 							.getOperations());
 			Logger.finer(Interpreter.class, "createFrame", logMessage);
 		}
 
 		return new Frame(classDescriptor.getConstantPool(), localVariables,
 				methodDescriptor.getOperations(), operandStack,
 				methodDescriptor);
 	}
 
 	/***
 	 * interprets the frameStack
 	 * 
 	 * @param frameStack the frameStack of the interpreter
 	 * @return Object the return value of the invoked method
 	 * @throws InterpreterException on failure
 	 */
 	public static Object interpret(final Stack frameStack)
 			throws InterpreterException
 	{
 		Frame frame = (Frame) frameStack.peek();
 		OperandStack operandStack = frame.getOperandStack();
 		Constant[] constantPool = frame.getConstantPool();
 		LocalVariable[] localVariables = frame.getLocalVariables();
 		MethodDescriptor methodDescriptor = frame.getMethodDescriptor();
 		int operationIndex = frame.getReturnPosition();
 		boolean log = Logger.getLogLevel().intValue() <= Level.FINEST
 				.intValue();
 
 		while (true)
 		{
 			Operation operation = frame.getOperations()[operationIndex];
 
 			//Let's log
 			if (log)
 			{
 				Logger
 						.finest(Interpreter.class, "interpret", ""
 								+ operandStack);
 				Logger.finest(Interpreter.class, "interpret", ""
 						+ frameStack.size() + " " + operation);
 			}
 
 			//	WIDE is special. We need to get its target
 			if (operation instanceof WIDE)
 			{
 				operation = ((WIDE) operation).getTarget();
 			}
 
 			//	Void operations are executed and done
 			if (operation instanceof VoidOperation)
 			{
 				((VoidOperation) operation).execute(operandStack, constantPool,
 						localVariables);
 				operationIndex++;
 				continue;
 			}
 
 			//	Invoke operations are executed and done
 			if (operation instanceof InvokeOperation)
 			{
 				Frame childFrame = ((InvokeOperation) operation).execute(frame);
 				operationIndex++;
 				if (childFrame != null)
 				{
 					frame.setReturnPosition(operationIndex);
 					if (frame.isPaused())
 					{
 						return frame;
 					}
 					frame = childFrame;
 					frameStack.push(frame);
 					operandStack = frame.getOperandStack();
 					constantPool = frame.getConstantPool();
 					localVariables = frame.getLocalVariables();
 					methodDescriptor = frame.getMethodDescriptor();
 					operationIndex = 0;
 				}
 				continue;
 			}
 
 			//	What to do with jumps
 			if (operation instanceof JumpOperation)
 			{
 				int offset = ((JumpOperation) operation).execute(operandStack,
 						constantPool, localVariables);
 				int bytePosition = offset;
 				if (!(operation instanceof RET))
 				{
 					bytePosition = bytePosition
 							+ methodDescriptor.getBytePosition(operationIndex);
 				}
 				operationIndex = methodDescriptor
 						.getOperationIndex(bytePosition);
 				continue;
 			}
 
 			//Return operations are executed and returned
 			if (operation instanceof ReturnOperation)
 			{
 				Object result = ((ReturnOperation) operation).execute(frame);
 
 				//We destroy this frame
 				frameStack.pop();
 
 				//We take the caller and push
 				if (frameStack.isEmpty())
 				{
 					return result;
 				}
 				frame = (Frame) frameStack.peek();
 				operandStack = frame.getOperandStack();
 				constantPool = frame.getConstantPool();
 				localVariables = frame.getLocalVariables();
 				methodDescriptor = frame.getMethodDescriptor();
 				operationIndex = frame.getReturnPosition();
 
 				if (!(operation instanceof RETURN))
 				{
 					operandStack.push(result);
 				}
 			}
 		}
 	}
 
 	/***
 	 * interpretes the invocation of a method on an object
 	 * 
 	 * @param object the object on which the method must be invoked
 	 * @param methodName the methodName
 	 * @param arguments the arguments
 	 * @param argumentTypes the classes of the arguments
 	 * @return Object the result
 	 */
 	public static Object invoke(final Object object, final String methodName,
 			final Object[] arguments, final Class[] argumentTypes)
 	{
 		try
 		{
 			AccessibleObject method = null;
 			if (!methodName.equals("<init>"))
 			{
 				if (object instanceof Class)
 				{
 					method = ClassUtil.resolveMethod((Class) object,
 							methodName, argumentTypes);
 				} else
 				{
 					method = ClassUtil.resolveMethod(object.getClass(),
 							methodName, argumentTypes);
 				}
 			} else
 			{
 				method = object.getClass()
 						.getDeclaredConstructor(argumentTypes);
 			}
 			return Interpreter.invoke(object, method, arguments);
 		} catch (Exception exception)
 		{
 			throw new InterpreterException(exception);
 		}
 	}
 
 	/***
 	 * interpretes the invocation of a method on an object
 	 * 
 	 * @param object the object on which the method must be invoked
 	 * @param method the method
 	 * @param arguments the arguments
 	 * @return Object the result
 	 * @throws InterpreterException on failure
 	 */
 	public static Object invoke(final Object object,
 			final AccessibleObject method, final Object[] arguments)
 			throws InterpreterException
 	{
 		if (Logger.getLogLevel().intValue() <= Level.FINE.intValue())
 		{
 			Logger.fine(Interpreter.class, "invoke", method.toString());
 		}
 		try
 		{
 			if (method instanceof Constructor
 					&& Modifier.isNative(((Constructor) method).getModifiers()))
 			{
 				return ((Constructor) method).newInstance(arguments);
 			}
 			if (method instanceof Method
 					&& Modifier.isNative(((Method) method).getModifiers()))
 			{
 				return ((Method) method).invoke(object, arguments);
 			}
 			Stack frameStack = new Stack();
 			frameStack.push(Interpreter.createFrame(object, method, arguments));
 			//Now we interprete
 			return Interpreter.interpret(frameStack);
 		} catch (Exception exception)
 		{
 			throw new InterpreterException(exception);
 		}
 	}
 }