package org.webslinger.ext.bsf.jruby;

 import java.util.HashMap;

 import org.apache.bsf.BSFDeclaredBean;

 import org.apache.bsf.BSFException;

 import org.apache.bsf.util.BSFFunctions;

 import org.jruby.IRuby;

 import org.jruby.Ruby;

 import org.jruby.RubyClass;

 import org.jruby.RubyMethod;

 import org.jruby.RubyProc;

 import org.jruby.javasupport.JavaObject;

 import org.jruby.javasupport.JavaUtil;

 import org.jruby.runtime.builtin.IRubyObject;

 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 JRubyCompiler extends Compiler<Object, Object> {

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

     static {

         compiledClassNamesMap.put(ApplyKey.class, "BSFJRubyApply");

         compiledClassNamesMap.put(EvalKey.class, "BSFJRubyEval");

         compiledClassNamesMap.put(ExecKey.class, "BSFJRubyExec");

     }

     private final JRubyEngine jrubyEngine;

     public JRubyCompiler(JRubyEngine engine) {

         super(engine);

         jrubyEngine = engine;

         getRuby().defineReadonlyVariable("$bsf", (IRubyObject) wrap(engine.getBSFFunctions(), BSFFunctions.class));

     }

     public IRuby getRuby() {

         return jrubyEngine.getRuby();

     }

     public void declareBean(BSFDeclaredBean bean) throws BSFException {

         getRuby().defineReadonlyVariable('$' + bean.name, (IRubyObject) wrap(bean.bean, bean.type));

     }

     public void undeclareBean(BSFDeclaredBean bean) throws BSFException {

         getRuby().defineReadonlyVariable('$' + bean.name, null);

     }

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

         return new CompilerContext(key);

     }

     private int count = 0;

     protected Object compile(CompilerContext context) throws Throwable {

         String className;

         synchronized (this) {

             className = compiledClassNamesMap.get(context.key.getClass()) + count;

             count++;

         }

         StringBuilder code = context.code;

         if (false) {

         code.append("class \n");//.append(className).append('\n');

         code.append("\tdef method");

         super.compile(context);

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

         code.append("end\n");

         } else {

         code.append("proc {\n");

         super.compile(context);

         code.append("}\n");

         }

         //code.append(className).append('\n');

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

         IRuby ruby = getRuby();

         synchronized (ruby) {

             return ruby.evalScript(code.toString());

         }

     }

     //protected GeneratedResult init(CompilerContext context, Object compiled) throws Throwable {

     //    return super.init(context, ((RubyClass) compiled).newInstance(new IRubyObject[0]));

     //}

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

         return compiled;

     }

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

         StringBuilder code = context.code;

         code.append('|');

         //code.append('(');

         String[] names = key.getNames();

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

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

             code.append(names[i]);

         }

         code.append("|\n");

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

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

         return null;

     }

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

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

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

         return null;

     }

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

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

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

         return null;

     }

     public Object[] newWrapArray(int length) {

         return new IRubyObject[length];

     }

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

         return new IRubyObject[array.length];

     }

     public Object wrap(Object object, Class type) {

         IRubyObject result = JavaUtil.convertJavaToRuby(getRuby(), object);

         if (result instanceof JavaObject) {

             return getRuby().getModule("JavaUtilities").callMethod("wrap", result);

         }

         return result;

     }

     public Object unwrap(Object object) {

         return JavaUtil.convertRubyToJava((IRubyObject) object);

     }

 }