package org.andromda.scriptwrappers;
   
   import java.lang.reflect.Method;
   import java.util.Arrays;
   import java.util.Iterator;
   import java.util.LinkedHashSet;
   import java.util.Set;
   import bsh.EvalError;
   import bsh.Interpreter;
  import bsh.Primitive;
  
  /**
   * This is a wrapper class for a BeanShell script. The generated Java classes contain a private
   * final copy of this wrapper and delegates all methods to this class so that their BeanShell-counterparts
   * can be executed.
   *
   * @author Chad Brandon
   */
  public class BshScriptWrapper
  {
      private final Interpreter interpreter;
      private String scriptPath;
      private Object stub;
  
      /**
       * StubClass is always the generated class (not any subclasses),
       * while stub may be an instance of a subclassed scripted class.
       * @param stub
       * @param scriptPath
       * @throws InstantiationError
       */
      public BshScriptWrapper(
          Object stub,
          String scriptPath)
          throws InstantiationError
      {
          this.stub = stub;
          this.scriptPath = scriptPath;
          this.interpreter = initialize(
                  stub,
                  scriptPath);
      }
  
      @SuppressWarnings("unused")
      private BshScriptWrapper()
      {
          this.interpreter = null;
      }
  
      /**
       * Initializes the interpreter.
       *
       * @param stub the stub class.
       * @param scriptPath the path to the script file.
       * @return the initialized interpreter.
       */
      private final Interpreter initialize(
          Object stub,
          String scriptPath)
      {
          final Interpreter interpreter = new Interpreter();
          interpreter.setClassLoader(stub.getClass().getClassLoader());
          return interpreter;
      }
  
      /**
       * Invokes the method with the given <code>methodName</code> on the  instance.
       *
       * @param methodName the name of the method to invoke.
       * @param args the arguments to pass to the method.
       * @return the return result of invoking the operation.
       */
      public Object invoke(
          String methodName,
          Object[] args)
      {
          try
          {
              try
              {
                  final Class stubClass = stub.getClass();
                  this.interpreter.source(scriptPath);
                  this.interpreter.set(
                      "instance",
                      interpreter.eval(" new " + stubClass.getName() + "();"));
                  this.interpreter.set(
                      "stub",
                      stub);
  
                  // - copy any properties
                  this.interpreter.eval(BshScriptWrapper.class.getName() + ".copyProperties(stub, instance);");
              }
              catch (final Exception exception)
              {
                  exception.printStackTrace();
                  throw new InstantiationError("Problems instantiating script '" + scriptPath + "':" + exception);
              }
              final StringBuilder arguments = new StringBuilder();
              if (args != null)
             {
                 for (int ctr = 1; ctr <= args.length; ctr++)
                 {
                     final String argument = "$" + ctr;
                     this.interpreter.set(
                         argument,
                         args[ctr - 1]);
                     arguments.append(argument);
                     if (ctr != args.length)
                     {
                         arguments.append(", ");
                     }
                 }
             }
 
             Object returnValue = this.interpreter.eval("instance." + methodName + '(' + arguments + ");");
 
             if (returnValue instanceof bsh.Primitive)
             {
                 returnValue = Primitive.unwrap(returnValue);
             }
 
             return returnValue;
         }
         catch (EvalError exception)
         {
             throw new RuntimeException(exception);
         }
     }
 
     /**
      * Copies all properties from the given <code>from</code> instance to the given
      * <code>to</code> instance.
      *
      * @param from the instance from which to copy all properties.
      * @param to the instance of which to copy all properties.
      * @throws Exception
      */
     protected static void copyProperties(
         final Object from,
         final Object to)
         throws Exception
     {
         final Set<Method> methods = new LinkedHashSet<Method>();
         loadSuperMethods(
             from.getClass(),
             methods);
         for (final Iterator iterator = methods.iterator(); iterator.hasNext();)
         {
             final Method method = (Method)iterator.next();
 
             final String methodName = method.getName();
             final String getPrefix = "get";
             if (methodName.startsWith(getPrefix) && method.getParameterTypes().length == 0)
             {
                 String propertyName = methodName.replaceAll(
                         getPrefix,
                         "");
 
                 Method setterMethod = null;
                 try
                 {
                     setterMethod =
                         from.getClass().getMethod(
                             "set" + propertyName,
                             new Class[] {method.getReturnType()});
                 }
                 catch (final Exception exception)
                 {
                     // - ignore
                 }
                 if (setterMethod != null)
                 {
                     method.setAccessible(true);
                     final Object value = method.invoke(from);
                     setterMethod.invoke(
                         to,
                         value);
                 }
             }
         }
     }
 
     /**
      * Loads all methods from the clazz's super classes.
      *
      * @param methods the list to load full of methods.
      * @param clazz the class to retrieve the methods.
      * @return the loaded methods.
      */
     private static Set loadSuperMethods(
         final Class clazz,
         final Set methods)
     {
         if (clazz.getSuperclass() != null)
         {
             methods.addAll(Arrays.asList(clazz.getSuperclass().getDeclaredMethods()));
             methods.addAll(loadSuperMethods(
                     clazz.getSuperclass(),
                     methods));
         }
         return methods;
     }
 }