package org.webslinger.bsf.janino;

 import org.apache.bsf.BSFException;

 import org.webslinger.bsf.ApplyKey;

 import org.webslinger.bsf.EvalKey;

 import org.webslinger.bsf.ExecKey;

 public final class JaninoCompiler extends AbstractJaninoCompiler<Object, Class<Object>> {

     public interface Apply {

         Object apply(Object[] args) throws Exception;

     }

     public interface Exec {

         void exec() throws Exception;

     }

     public interface Eval {

         Object eval() throws Exception;

     }

     public JaninoCompiler(JaninoEngine engine) {

         super(engine);

         implementsMap.put(ApplyKey.class, Apply.class);

         implementsMap.put(EvalKey.class, Eval.class);

         implementsMap.put(ExecKey.class, Exec.class);

     }

     protected Class<Object> compileKey(ApplyKey<Class<Object>> key, JaninoCompilerContext context) throws BSFException {

         StringBuilder code = context.code;

         code.append("public Object apply(Object[] args) throws Exception {");

         String[] names = key.getNames();

         Class[] types = key.getTypes();

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

             Class type = types[i];

             String typeName, prefix, postfix;

             if (type == Boolean.TYPE || type == Boolean.class) {

                 typeName = "boolean";

                 prefix = "((Boolean) ";

                 postfix = ").booleanValue()";

             } else if (type == Byte.TYPE || type == Byte.class) {

                 typeName = "byte";

                 prefix = "((Byte) ";

                 postfix = ").byteValue()";

             } else if (type == Double.TYPE || type == Double.class) {

                 typeName = "double";

                 prefix = "((Double) ";

                 postfix = ").doubleValue()";

             } else if (type == Float.TYPE || type == Float.class) {

                 typeName = "float";

                 prefix = "((Float) ";

                 postfix = ").floatValue()";

             } else if (type == Integer.TYPE || type == Integer.class) {

                 typeName = "int";

                 prefix = "((Integer) ";

                 postfix = ").intValue()";

             } else if (type == Long.TYPE || type == Long.class) {

                 typeName = "long";

                 prefix = "((Long) ";

                 postfix = ").longValue()";

             } else if (type == Short.TYPE || type == Short.class) {

                 typeName = "short";

                 prefix = "((Short) ";

                 postfix = ").shortValue()";

             } else {

                 typeName = type.getName();

                 prefix = '(' + typeName + ')';

                 postfix = "";

             }

             code.append(' ').append(typeName).append(' ').append(names[i]).append(" = ").append(prefix).append("args[").append(i).append(']').append(postfix).append(';');

         }

         code.append(context.text);

         code.append(" }");

         return null;

     }

     protected Class<Object> compileKey(EvalKey<Class<Object>> key, JaninoCompilerContext context) throws BSFException {

         StringBuilder code = context.code;

         code.append("public Object eval() throws Exception {");

         code.append("return org.codehaus.janino.util.PrimitiveWrapper.wrap(");

         code.append(context.text);

         code.append(");");

         code.append('}');

         return null;

     }

     protected Class<Object> compileKey(ExecKey<Class<Object>> key, JaninoCompilerContext context) throws BSFException {

         StringBuilder code = context.code;

         code.append("public void exec() throws Exception {");

         code.append(context.text);

         code.append('}');

         return null;

     }

 }