package org.webslinger.ext.bsf.jython;

 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 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 JythonCompiler extends Compiler<PyObject, PyObject> {

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

     static {

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

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

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

     }

     private BSFPythonInterpreter interp = new BSFPythonInterpreter();

     public JythonCompiler(JythonEngine engine) {

         super(engine);

         interp.setErr(System.err);

         interp.setOut(System.out);

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

     }

     public void declareBean(BSFDeclaredBean bean) throws BSFException {

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

     }

     public void undeclareBean(BSFDeclaredBean bean) throws BSFException {

         interp.set(bean.name, null);

     }

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

         return new CompilerContext(key);

     }

     protected PyObject compile(CompilerContext context) throws Throwable {

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

         StringBuilder code = context.code;

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

         super.compile(context);

         code.append(methodName);

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

         synchronized (interp) {

             interp.exec(code.toString());

             return interp.get(methodName);

         }

     }

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

         return compiled;

     }

     public PyObject compileKey(ApplyKey<PyObject> 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];

             String typeName, prefix, postfix;

             code.append(names[i]);

         }

         code.append("):\n");

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

         return null;

     }

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

         context.code.append("():\n");

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

         return null;

     }

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

         context.code.append("():\n");

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

         return null;

     }

     public Object[] newWrapArray(int length) {

         return new PyObject[length];

     }

     public Object[] newWrapArray(Object[] array) {

         return new PyObject[array.length];

     }

     public Object wrap(Object object, Class type) {

         return Py.java2py(object);

     }

     public Object unwrap(Object object) {

         if (object == null) return null;

         Object ret = ((PyObject) object).__tojava__(Object.class);

         if (ret != Py.NoConversion) return ret;

         return object;

     }

     private static class BSFPythonInterpreter extends InteractiveInterpreter {

         public BSFPythonInterpreter() {

             super();

         }

         // Override runcode so as not to print the stack dump

         public void runcode(PyObject code) {

             try {

                 this.exec(code);

             } catch (PyException exc) {

                 throw exc;

             }

         }

     }

 }