package org.webslinger.ext.bsf.beanshell;

 import java.util.HashMap;

 import org.apache.bsf.BSFDeclaredBean;

 import org.apache.bsf.BSFException;

 //import org.python.core.Py;

 //import org.python.core.PyException;

 //import org.python.core.PyObject;

 //import org.python.util.InteractiveInterpreter;

 import bsh.Interpreter;

 import bsh.BshMethod;

 import bsh.EvalError;

 import bsh.Primitive;

 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;

 public final class BeanShellCompiler extends Compiler<BeanShellCompiled, BeanShellCompiled> {

     public class BeanShellCompilerContext extends CompilerContext {

         protected final Interpreter interpreter = new Interpreter();

         protected BeanShellCompilerContext(Key<BeanShellCompiled> key) throws BSFException {

             super(key);

         }

     }

     public BeanShellCompiler(BeanShellEngine engine) {

         super(engine);

     }

     public void declareBean(BSFDeclaredBean bean) throws BSFException {

         clear();

     }

     public void undeclareBean(BSFDeclaredBean bean) throws BSFException {

         clear();

     }

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

         return new BeanShellCompilerContext(key);

     }

     protected BeanShellCompiled init(CompilerContext context, BeanShellCompiled compiled) {

         return compiled;

     }

     protected BeanShellCompiled compileBeanShell(CompilerContext context, String methodName) throws BSFException {

         StringBuilder code = context.code;

         BeanShellCompilerContext bscc = (BeanShellCompilerContext) context;

         Interpreter interpreter = bscc.interpreter;

         try {

             interpreter.set("bsf", engine.getBSFFunctions());

             for (BSFDeclaredBean bean: context.beans) {

                 interpreter.set(bean.name, bean.bean);

             }

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

             interpreter.eval(code.toString());

         } catch (EvalError e) {

             throw (BSFException) new BSFException(BSFException.REASON_OTHER_ERROR, "unable to compile context for BeanShell: " + context).initCause(e);

         }

         for (BshMethod method: interpreter.getNameSpace().getMethods()) {

             if (methodName.equals(method.getName())) return new BeanShellCompiled(interpreter, method);

         }

         throw new InternalError("Method [" + methodName + "] not found");

     }

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

         StringBuilder code = context.code;

         String[] names = key.getNames();

         Class[] types = key.getTypes();

         code.append("Object _BSF_BeanShell_Apply_(Object[] _BSF_BeanShell_Apply_Args_) {\n");

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

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

             code.append(types[i].getName()).append(' ').append(names[i]).append(" = (").append(types[i].getName()).append(") _BSF_BeanShell_Apply_Args_[").append(i).append("];\n");

         }

         appendText(code, "\t", context.text);

         context.code.append('}');

         return compileBeanShell(context, "_BSF_BeanShell_Apply_");

     }

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

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

         appendText(context.code, "\t", context.text);

         context.code.append('}');

         return compileBeanShell(context, "_BSF_BeanShell_Eval_");

     }

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

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

         appendText(context.code, "\t", context.text);

         context.code.append('}');

         return compileBeanShell(context, "_BSF_BeanShell_Exec_");

     }

     public Object wrap(Object value, Class type) {

         if (type == Void.TYPE) return Primitive.VOID;

         if (value == null) return Primitive.NULL;

         if (type == Boolean.TYPE) return new Primitive((Boolean) value);

         if (type == Byte.TYPE) return new Primitive((Byte) value);

         if (type == Short.TYPE) return new Primitive((Short) value);

         if (type == Character.TYPE) return new Primitive((Character) value);

         if (type == Integer.TYPE) return new Primitive((Integer) value);

         if (type == Long.TYPE) return new Primitive((Long) value);

         if (type == Float.TYPE) return new Primitive((Float) value);

         if (type == Double.TYPE) return new Primitive((Double) value);

         return value;

     }

     public Object unwrap(Object value) {

         return Primitive.unwrap(value);

     }

 }