package org.webslinger.bsf;

 import java.util.Arrays;

 import java.util.Iterator;

 import java.util.Vector;

 import org.apache.bsf.BSFDeclaredBean;

 import org.apache.bsf.BSFException;

 import org.apache.bsf.BSFManager;

 import org.apache.bsf.util.CodeBuffer;

 public abstract class CompilingLanguageEngineImpl<V, C> extends LanguageEngineImpl {

     protected Compiler<V, C> compiler;

     public void initialize(BSFManager manager, String lang, Vector declaredBeans) throws BSFException {

         super.initialize(manager, lang, declaredBeans);

         if (compiler != null) {

             compiler.initialize(manager);

             Iterator it = declaredBeans.iterator();

             while (it.hasNext()) {

                 BSFDeclaredBean bean = (BSFDeclaredBean) it.next();

                 compiler.declareBean(bean);

             }

         }

     }

     public Object call(Object object, String name, Object[] args) throws BSFException {

         throw new BSFException(BSFException.REASON_UNSUPPORTED_FEATURE, object + "." + name + "(" + Arrays.asList(args) + ")");

     }

     public Object apply(String source, int lineNo, int columnNo, Object body, String[] names, Object[] args) throws BSFException {

         try {

             ApplyKeyDynamic<C> key = new ApplyKeyDynamic<C>(getId(body), names, args);

             return compiler.unwrap(apply(body, compiler.getObject(key), key.getArgs(compiler)));

         } catch (BSFException e) {

             throw e;

         } catch (RuntimeException e) {

             throw e;

         } catch (Error e) {

             throw e;

         } catch (Throwable t) {

             throw (RuntimeException) new RuntimeException(t.getMessage(), t);

         }

     }

     public Object apply(String source, int lineNo, int columnNo, Object body, String[] names, Object[] args, Class[] types) throws BSFException {

         //System.err.println(this + ".apply(" + body + ", " + paramNames + ", " + argVector + ", " + typeVector + ")");

         try {

             ApplyKey<C> key = new ApplyKey<C>(getId(body), names, types);

             V compiled = compiler.getObject(key);

             Object[] wrappedArgs = compiler.newWrapArray(args);

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

                 wrappedArgs[i] = compiler.wrapForArgs(i, args[i], types[i]);

             }

             return compiler.unwrap(apply(body, compiled, names, wrappedArgs));

         } catch (BSFException e) {

             throw e;

         } catch (RuntimeException e) {

             throw e;

         } catch (Error e) {

             throw e;

         } catch (Throwable t) {

             throw (RuntimeException) new RuntimeException(t.getMessage(), t);

         }

     }

     public void compileApply(String source, int lineNo, int columnNo, Object body, Vector paramNames, Vector args, CodeBuffer cb) throws BSFException {

         throw new IllegalArgumentException(body.toString());

     }

     public void compileExpr(String source, int lineNo, int columnNo, Object expr, CodeBuffer cb) throws BSFException {

         throw new IllegalArgumentException(expr.toString());

     }

     public void compileScript(String source, int lineNo, int columnNo, Object script, CodeBuffer cb) throws BSFException {

         throw new IllegalArgumentException(script.toString());

     }

     public Object eval(String source, int lineNo, int columnNo, Object expr) throws BSFException {

         try {

             return compiler.unwrap(eval(expr, compiler.getObject(new EvalKey<C>(getId(expr)))));

         } catch (BSFException e) {

             throw e;

         } catch (RuntimeException e) {

             throw e;

         } catch (Error e) {

             throw e;

         } catch (Throwable t) {

             throw (RuntimeException) new RuntimeException(t.getMessage(), t);

         }

     }

     public void exec(String source, int lineNo, int columnNo, Object script) throws BSFException {

         try {

             exec(script, compiler.getObject(new ExecKey<C>(getId(script))));

         } catch (BSFException e) {

             throw e;

         } catch (RuntimeException e) {

             throw e;

         } catch (Error e) {

             throw e;

         } catch (Throwable t) {

             throw (RuntimeException) new RuntimeException(t.getMessage(), t);

         }

     }

     public void iexec(String source, int lineNo, int columnNo, Object script) throws BSFException {

         throw new IllegalArgumentException(script.toString());

     }

     public void undeclareBean(BSFDeclaredBean bean) throws BSFException {

         super.undeclareBean(bean);

         if (compiler != null) compiler.undeclareBean(bean);

     }

     public void declareBean(BSFDeclaredBean bean) throws BSFException {

         super.declareBean(bean);

         if (compiler != null) compiler.declareBean(bean);

     }

     protected void reset() {

         super.reset();

         if (compiler != null) compiler.clear();

     }

     protected Object apply(Object body, V object, String[] names, Object[] args) throws Throwable {

         return apply(body, object, args);

     }

     protected abstract Object apply(Object body, V compiled, Object[] args) throws Throwable;

     protected abstract Object eval(Object expr, V compiled) throws Throwable;

     protected abstract void exec(Object script, V compiled) throws Throwable;

 }