/* An actor whose execution is specified by Java code.

Copyright (c) 2014 The Regents of the University of California.
All rights reserved.
Permission is hereby granted, without written agreement and without
license or royalty fees, to use, copy, modify, and distribute this
software and its documentation for any purpose, provided that the above
copyright notice and the following two paragraphs appear in all copies
of this software.

IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
ENHANCEMENTS, OR MODIFICATIONS.

*/
package org.kepler.scriptengine;

import java.lang.reflect.Field;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.script.ScriptContext;
import javax.script.ScriptEngine;
import javax.script.ScriptException;

import org.kepler.scriptengine.java.JavaScriptEngine;
import org.kepler.scriptengine.java.JavaScriptEngineFactory;

import ptolemy.data.StringToken;
import ptolemy.kernel.CompositeEntity;
import ptolemy.kernel.util.IllegalActionException;
import ptolemy.kernel.util.NameDuplicationException;
import ptolemy.kernel.util.Workspace;

/** An actor whose execution is defined by Java code.
 *  The code can be edited by double-clicking on the actor.
 *  <p>There are several differences between this actor and
 *  the BeanShell Java actor. This actor requires:
 *  <ul>
 *  <li>A Java compiler.</li>
 *  <li>All the referenced classes must be imported.</li>
 *  <li>All ports and parameters must be explicitly declared
 *  as fields in the script.</li>
 *  </ul>
 *  There are several Java features supported by this actor but
 *  not the BeanShell actor:
 *  <ul>
 *  <li>Annotations</li>
 *  <li>Generics</li>
 *  </ul>
 *  </p>
 *  <p>The following example defines an actor in Java that
 *  computes factorials:</p>
 *  
<pre>
1. import ptolemy.actor.*;
2. import ptolemy.data.*;
3. import ptolemy.kernel.util.IllegalActionException;
4.
5. import org.kepler.scriptengine.Java;
6.
7. public class Actor {
8.   public void fire() throws IllegalActionException {
9.
10.    int val = ((IntToken)in.get(0)).intValue();
11.    
12.    if(val < 0) {
13.        actor.error("Input must be non-negative.");
14.    }
15.
16.    int total = 1;
17.    while(val > 1) {
18.      total *= val;
19.      val--;
20.    } 
21.  
22.    out.broadcast(new IntToken(total));
23.  }
24.
25.  public TypedIOPort in;
26.  public TypedIOPort out;
27.  public Java actor;
28.}
</pre>
 *
 *  <p>Lines 1-3 import the Java classes used by the actor. Line 7 defines the
 *  Actor object. Lines 8-23 define the fire() method of the actor; this
 *  method is called each time this actor executes in the workflow. Line 10
 *  reads an integer from the input port called "in". A port or parameter
 *  called "foo" can be accessed in the Java code by simply using "foo".
 *  Lines 16-20 compute the factorial of the integer read from the port.
 *  Line 22 writes the result to the output port called "out".
 *  
 *  @author Daniel Crawl
 *  @version $Id: Java.java 34143 2015-10-28 21:16:33Z crawl $
 */
public class Java extends ScriptEngineActor {

    /** Create a new Java in the specified workspace. */
    public Java(Workspace workspace) {
        super(workspace);
    }

    /** Create a new Java with the given container and name. */
    public Java(CompositeEntity container, String name)
            throws IllegalActionException, NameDuplicationException {
        super(container, name);
        
        _invokeMethodWithReflection = true;
        
        _editorFactory.syntaxStyle.setExpression("text/java");

        language.setToken("java");
        
        script.setExpression(
                "import org.kepler.scriptengine.Java;\n" +
                "\n" +
                "public class Actor {\n" +
                "  public void fire() {\n" +
                "     System.out.println(\"in fire\");\n" +
                "  }\n" +
                "}\n");
    }

    /** Clone the actor into the specified workspace. */
    @Override
    public Object clone(Workspace workspace) throws CloneNotSupportedException {
        final Java newObject = (Java) super.clone(workspace);
        
        // register Java ScriptEngine factory with in the ScriptEngineManager
        // since it is not loaded in a jar.
        JavaScriptEngineFactory factory = new JavaScriptEngineFactory();
        newObject._manager.registerEngineName(factory.getEngineName(), factory);
        
        return newObject;
    }

    /** Evaluate the script. This overrides the parent class to set the file name
     *  based on the actor name and set the parent class loader.
     *  @return Returns the object resulting from evaluating the script.
     */
    @Override
    protected Object _evaluateScript() throws ScriptException, IllegalActionException {
        
        String scriptStr = script.getExpression();
        
        // find the name of the class since we need to give the compiler a
        // file name (even though a file is not actually created in the
        // file system).
        
        // find first "public class Name"
        Matcher matcher = CLASS_DECL_NAME.matcher(scriptStr);
        if(!matcher.find()) {
            throw new IllegalActionException(this, "Could not find actor class name.");
        }
        
        String className = matcher.group(1);
        actorClassName.setToken(new StringToken(className));
        
        // set the file name
        _engine.getContext().setAttribute(ScriptEngine.FILENAME,
                className + ".java",
                ScriptContext.ENGINE_SCOPE);

        // set the parent class loader. this is necessary so that we can set fields
        // in the actor class, e.g., set the ports and parameters.
        _engine.getContext().setAttribute(JavaScriptEngine.PARENTLOADER,
                getClass().getClassLoader(),
                ScriptContext.ENGINE_SCOPE);

        // finally evaluate the script
        return _engine.eval(scriptStr);
    }
    
    ///////////////////////////////////////////////////////////////////
    ////                         protected methods                 ////

    /** Create an instance of the actor object in the script.
     *  @return the actor instance.
     */
    @Override
    protected Object _createActorInstance(String actorClassNameStr) throws ScriptException {
        try {            
            return ((Class<?>)_evaluatedScriptObject).newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            throw new ScriptException("Error instantiating class: " + e.getMessage());
        }
    }
    
    /** Put the given object to the actor instance in the script.
     *  @param name the name of the object to put.
     *  @param object the object to put.
     */
    @Override
    protected void _putObjectToActorInstance(String name, Object object) throws ScriptException {
        
        // see if the actor class has this field
        Field field = null;
        try {
            field = _actorObject.getClass().getField(name);
        } catch(Throwable e) {
            // do nothing
        }
                
        if(field == null) {
            System.err.println("WARNING: actor class does not have field '" + 
                    name + "' of type " + object.getClass());
            //throw new ScriptException("Actor class does not have field '" + name + "'.");
        } else {
            /*
            try {

                Object fieldObject = field.get(_actorObject);
                if(Typeable.class.isAssignableFrom(fieldObject.getClass())) {
                    //System.out.println("field " + name + " is typeable.");
                    Typeable typeable = (Typeable) fieldObject;
                    //System.out.println("type = " + typeable.getType());
                    //System.out.println("typeTerm = " + typeable.getTypeTerm());
                    ((Typeable)object).setTypeSameAs(typeable);
                }
            } catch (IllegalArgumentException | IllegalAccessException e) {
                MessageHandler.error("Error getting type", e);
            }
            */
            
            
            try {
                // set the field in the actor instance.
                field.set(_actorObject, object);
            } catch (Exception e) {
                throw new ScriptException("Error setting port/parameter " + name + ": " + e.getMessage());
            }
        }
    }
    
    /** Register the Java ScriptEngine factory with in the
     *  ScriptEngineManager since it is not loaded in a jar.
     */
    @Override
    protected void _registerEngineFactory() {
        super._registerEngineFactory();
        JavaScriptEngineFactory factory = new JavaScriptEngineFactory();
        _manager.registerEngineName(factory.getEngineName(), factory);
    }

    /** The regex pattern to match the class name. */
    private final static Pattern CLASS_DECL_NAME = Pattern.compile("public class (\\w+)");

}