package org.webslinger.ext.bsf.rhino;

 import java.util.HashMap;

 import org.apache.bsf.BSFDeclaredBean;

 import org.apache.bsf.BSFException;

 import org.apache.bsf.util.BSFFunctions;

 import org.mozilla.javascript.Context;

 import org.mozilla.javascript.Function;

 import org.mozilla.javascript.Scriptable;

 import org.webslinger.bsf.ApplyKey;

 import org.webslinger.bsf.Compiler;

 import org.webslinger.bsf.EvalKey;

 import org.webslinger.bsf.ExecKey;

 import org.webslinger.bsf.Key;

 import org.webslinger.util.GeneratedResult;

 public final class RhinoCompiler extends Compiler<Function, Function> {

     private static final HashMap<Class, String> compiledMethodNamesMap = new HashMap<Class, String>();

     static {

         compiledMethodNamesMap.put(ApplyKey.class, "_BSF_Rhino_Apply_");

         compiledMethodNamesMap.put(EvalKey.class, "_BSF_Rhino_Eval_");

         compiledMethodNamesMap.put(ExecKey.class, "_BSF_Rhino_Exec_");

     }

     public class RhinoContext extends CompilerContext {

         protected final org.mozilla.javascript.Context cx = org.mozilla.javascript.Context.getCurrentContext();

         protected RhinoContext(Key<Function> key) throws BSFException {

             super(key);

         }

     }

     private final RhinoEngine rhinoEngine;

     public RhinoCompiler(RhinoEngine engine) {

         super(engine);

         this.rhinoEngine = engine;

         Context.enter();

         try {

             Scriptable scope = rhinoEngine.getScope();

             scope.put("bsf", scope, engine.getBSFFunctions());

         } finally {

             Context.exit();

         }

     }

     public void declareBean(BSFDeclaredBean bean) throws BSFException {

         Context.enter();

         try {

             Scriptable scope = rhinoEngine.getScope();

             scope.put(bean.name, scope, bean.bean);

         } finally {

             Context.exit();

         }

     }

     public void undeclareBean(BSFDeclaredBean bean) throws BSFException {

         Context.enter();

         try {

             rhinoEngine.getScope().delete(bean.name);

         } finally {

             Context.exit();

         }

     }

     public GeneratedResult<Function> regen(Key<Function> key) throws BSFException {

         Context.enter();

         try {

             return super.regen(key);

         } finally {

             Context.exit();

         }

     }

     // called under synchronized (beans)

     protected Function compile(CompilerContext context) throws Throwable {

         return compile((RhinoContext) context);

     }

     protected CompilerContext newContext(Key<Function> key) throws BSFException {

         return new RhinoContext(key);

     }

     protected Function compile(RhinoContext context) throws Throwable {

         String methodName = compiledMethodNamesMap.get(context.key.getClass());

         StringBuilder code = context.code;

         code.append("function ").append(methodName);

         super.compile(context);

         code.append(methodName);

         if (engine.isDebugOn()) System.err.println(code);

         try {

             return (Function) context.cx.evaluateString(rhinoEngine.getScope(), code.toString(), context.key.getId().toString(), 1, null);

         } catch (Exception e) {

             throw (BSFException) new BSFException(BSFException.REASON_EXECUTION_ERROR, e.getMessage(), e).initCause(e);

         }

     }

     protected Function init(CompilerContext context, Function compiled) throws Throwable {

         return compiled;

     }

     public Function compileKey(ApplyKey<Function> key, CompilerContext context) throws BSFException {

         StringBuilder code = context.code;

         code.append('(');

         String[] names = key.getNames();

         Class[] types = key.getTypes();

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

             if (i != 0) code.append(", ");

             Class type = types[i];

             code.append(names[i]);

         }

         code.append(") {");

         code.append(context.text);

         code.append('}');

         return null;

     }

     public Function compileKey(EvalKey<Function> key, CompilerContext context) throws BSFException {

         context.code.append("() {");

         context.code.append(context.text);

         context.code.append('}');

         return null;

     }

     public Function compileKey(ExecKey<Function> key, CompilerContext context) throws BSFException {

         context.code.append("() {");

         context.code.append(context.text);

         context.code.append('}');

         return null;

     }

 }