package org.webslinger.bsf.janino;

 import java.io.IOException;

 import java.io.StringReader;

 import java.io.StringWriter;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import org.apache.bsf.BSFDeclaredBean;

 import org.apache.bsf.BSFException;

 import org.apache.bsf.util.BSFFunctions;

 import org.codehaus.janino.ByteArrayClassLoader;

 import org.codehaus.janino.ClassLoaderIClassLoader;

 import org.codehaus.janino.CompileException;

 import org.codehaus.janino.DebuggingInformation;

 import org.codehaus.janino.Java;

 import org.codehaus.janino.Location;

 import org.codehaus.janino.Mod;

 import org.codehaus.janino.Parser;

 import org.codehaus.janino.Scanner;

 import org.codehaus.janino.UnitCompiler;

 import org.codehaus.janino.UnparseVisitor;

 import org.codehaus.janino.util.ClassFile;

 import org.codehaus.janino.util.enumerator.EnumeratorSet;

 import org.webslinger.bsf.ApplyKey;

 import org.webslinger.bsf.Compiler;

 import org.webslinger.bsf.EvalKey;

 import org.webslinger.bsf.ExecKey;

 import org.webslinger.bsf.LanguageEngine;

 import org.webslinger.bsf.Key;

 import org.webslinger.util.GeneratedResult;

 public abstract class AbstractJaninoCompiler<V extends Object, C extends Class<V>> extends Compiler<V, C> {

     protected interface Init {

         void init(LanguageEngine engine, Object[] beans);

     }

     protected String removeStart(String text, StringBuilder imports, StringBuilder staticDefs) throws IOException, Scanner.LocatedException {

         Scanner textScanner = new Scanner(null, new StringReader(text));

         textScanner.setSwallow(false);

         StringWriter importWriter = new StringWriter();

         StringWriter staticWriter = new StringWriter();

         StringWriter writer = importWriter;

         Parser textParser = new Parser(textScanner);

         do {

             Scanner.Token token = textScanner.peek();

             if (token.isComment()) {

                 textScanner.read();

             } else if (token.isWhitespace()) {

                 textScanner.read();

             } else if (writer == importWriter && token.isKeyword("import")) {

                 textScanner.setSwallow(true);

                 textParser.parseImportDeclaration();

                 textScanner.setSwallow(false);

             } else if (token.isKeyword("static")) {

                 writer = staticWriter;

                 textScanner.read();

                 token = textScanner.peek();

                 textScanner.setSwallow(true);

                 short mod = (short) (Mod.STATIC | textParser.parseModifiersOpt());

                 if (textParser.peekOperator("{")) {

                     textScanner.read();

                     textParser.parseBlock();

                 } else if (textParser.peekKeyword("class")) {

                     textScanner.read();

                     textParser.parseClassDeclarationRest(

                         null,

                         mod,

                         Parser.ClassDeclarationContext.TYPE_DECLARATION

                     );

                 } else if (textParser.peekKeyword("interface")) {

                     textScanner.read();

                     textParser.parseInterfaceDeclarationRest(

                         null,

                         mod,

                         Parser.InterfaceDeclarationContext.NAMED_TYPE_DECLARATION

                     );

                 } else if (textParser.peekKeyword("void")) {

                     textScanner.read();

                     Location location = textParser.location();

                     String name = textParser.readIdentifier();

                     textParser.parseMethodDeclarationRest(

                         null,

                         mod,

                         new Java.BasicType(location, Java.BasicType.VOID),

                         name

                     );

                 } else {

                     Java.Type type = textParser.parseType();

                     Location location = textParser.location();

                     String name = textParser.readIdentifier();

                     if (textParser.peekOperator("(")) {

                         textParser.parseMethodDeclarationRest(

                             null,

                             mod,

                             type,

                             name

                         );

                     } else {

                         new Java.FieldDeclaration(

                             location,

                             null,

                             mod,

                             type,

                             textParser.parseFieldDeclarationRest(name)

                         );

                         textParser.readOperator(";");

                     }

                 }

                 textScanner.setSwallow(false);

             } else {

                 break;

             }

             writer.write(token.toString());

             while (token.getNextToken() != null) {

                 token = token.getNextToken();

                 if (token.getNextToken() == null) break;

                 writer.write(token.toString());

             }

         } while (true);

         imports.append(importWriter.getBuffer());

         staticDefs.append(staticWriter.getBuffer());

         textScanner.setSwallow(false);

         StringBuilder newText = new StringBuilder();

         while (!textScanner.peek().isEOF()) {

             Scanner.Token token = textScanner.read();

             //System.err.println("token=" + token);

             String tokenText = token.toString();

             newText.append(tokenText);

         }

         return newText.toString();

     }

     protected final HashMap<Class, Class> implementsMap = new HashMap<Class, Class>();

     public class JaninoCompilerContext extends CompilerContext {

         protected String imports;

         protected String staticDefs;

         protected Object[] beanObjects;

         protected JaninoCompilerContext(Key<C> key) throws BSFException {

             super(key);

             beanObjects = new Object[beans.length];

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

                 beanObjects[i] = beans[i].bean;

             }

         }

     }

     public AbstractJaninoCompiler(LanguageEngine engine) {

         super(engine);

     }

     protected String filter(CompilerContext context, String text) throws BSFException {

         return filter((JaninoCompilerContext) context, text);

     }

     protected String filter(JaninoCompilerContext context, String text) throws BSFException {

         StringBuilder imports = new StringBuilder();

         StringBuilder staticDefs = new StringBuilder();

         try {

             return removeStart(text, imports, staticDefs);

         } catch (IOException e) {

             throw (BSFException) new BSFException(BSFException.REASON_IO_ERROR, e.getMessage(), e).initCause(e);

         } catch (Scanner.LocatedException e) {

             throw (BSFException) new BSFException(BSFException.REASON_IO_ERROR, e.getMessage(), e).initCause(e);

         } finally {

             context.imports = imports.toString();

             context.staticDefs = staticDefs.toString();

         }

     }

     public void declareBean(BSFDeclaredBean bean) throws BSFException {

         clear();

     }

     public void undeclareBean(BSFDeclaredBean bean) throws BSFException {

         clear();

     }

     // called under synchronized (beans)

     protected C compile(CompilerContext context) throws Throwable {

         return compile((JaninoCompilerContext) context);

     }

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

         return new JaninoCompilerContext(key);

     }

     protected static void addImplementsToCode(StringBuilder code, List<String> implementsList) {

         if (!implementsList.isEmpty()) {

             Iterator<String> it = implementsList.iterator();

             code.append(" implements");

             while (it.hasNext()) {

                 String interfaceName = it.next();

                 code.append(' ').append(interfaceName);

                 if (it.hasNext()) code.append(',');

             }

         }

     }

     protected void addHelperImplements(JaninoCompilerContext context, List<String> implementsList) {

         implementsList.add(Init.class.getName());

     }

     protected void compileHelperVariables(JaninoCompilerContext context, StringBuilder code, String className) {

     }

     protected void compileHelperMethods(JaninoCompilerContext context, StringBuilder code, String className) {

         code.append("public final void init(").append(LanguageEngine.class.getName()).append(" engine, Object[] beans) {");

         code.append(className).append(".bsf = engine.getBSFFunctions();");

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

             BSFDeclaredBean bean = context.beans[i];

             code.append(className).append('.').append(bean.name).append(" = (").append(bean.type.getName()).append(") beans[").append(i).append("];");

         }

         code.append('}');

     }

     protected void compileHelper(JaninoCompilerContext context, StringBuilder code, String className) {

         List<String> implementsList = new ArrayList<String>();

         addHelperImplements(context, implementsList);

         code.append("public final class ").append(className).append("Init");

         addImplementsToCode(code, implementsList);

         code.append(" {");

         compileHelperVariables(context, code, className);

         compileHelperMethods(context, code, className);

         code.append('}');

     }

     protected void addClassImplements(JaninoCompilerContext context, List<String> implementsList) {

         Class keyImplements = implementsMap.get(context.key.getClass());

         if (keyImplements != null) implementsList.add(keyImplements.getName());

     }

     protected void compileClassVariables(JaninoCompilerContext context, StringBuilder code, String className) {

         code.append("static ").append(BSFFunctions.class.getName()).append(" bsf;");

         for (BSFDeclaredBean bean: context.beans) {

             code.append("static ").append(bean.type.getName()).append(' ').append(bean.name).append(';');

         }

     }

     protected void compileClassMethods(JaninoCompilerContext context, StringBuilder code, String className) throws Throwable {

         super.compile(context);

     }

     protected void addExtends(JaninoCompilerContext context, StringBuilder code) {

     }

     protected void compileConstructors(JaninoCompilerContext context, StringBuilder code, String className) {

     }

     protected void compileClass(JaninoCompilerContext context, StringBuilder code, String className) throws Throwable {

         List<String> implementsList = new ArrayList<String>();

         addClassImplements(context, implementsList);

         code.append("public class ").append(className);

         addExtends(context, code);

         addImplementsToCode(code, implementsList);

         code.append(" {");

         compileClassVariables(context, code, className);

         compileConstructors(context, code, className);

         code.append(context.staticDefs);

         compileClassMethods(context, code, className);

         code.append('}');

     }

     protected C compile(JaninoCompilerContext context) throws Throwable {

         String fileName = engine.getVFSDelegate().absolutePath(context.key.getId());

         StringBuilder packageNameBuffer = new StringBuilder();

         StringBuilder classNameBuffer = new StringBuilder();

         nameEncoder.makePackageClassName(packageNameBuffer, classNameBuffer, fileName);

         ClassLoaderIClassLoader classLoaderIClassLoader = new ClassLoaderIClassLoader(context.key.getParentClassLoader(engine));

         StringBuilder code = context.code;

         if (packageNameBuffer.length() > 0) code.append("package ").append(packageNameBuffer).append(';');

         code.append(context.imports);

         String className = classNameBuffer.toString();

         compileHelper(context, code, className);

         compileClass(context, code, className);

         Parser parser = new Parser(new Scanner(fileName, new StringReader(code.toString())));

         //System.err.println(code);

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

         Java.CompilationUnit unit = parser.parseCompilationUnit();

         // next parts copied from janino EvaluatorBase.compileAndLoad

         EnumeratorSet debugInfo = DebuggingInformation.DEFAULT_DEBUGGING_INFORMATION;

         final StringBuilder errorMessage = new StringBuilder();

         UnitCompiler.ErrorHandler errorHandler = new UnitCompiler.ErrorHandler() {

             public void handleError(String message, Location location) {

                 if (errorMessage.length() > 0) errorMessage.append('\n');

                 if (location != null) errorMessage.append(location).append(": ");

                 errorMessage.append(message);

             }

         };

         // Compile compilation unit to class files.

         UnitCompiler uc = new UnitCompiler(unit, classLoaderIClassLoader);

         uc.setCompileErrorHandler(errorHandler);

         ClassFile[] classFiles = null;

         Exception caughtException = null;

         try {

             classFiles = uc.compileUnit(debugInfo);

         } catch (RuntimeException e) {

             caughtException = e;

         } catch (CompileException e) {

             caughtException = e;

             // Ignore, janino throws a final CompileException, complaining

             // about: "X compile errors detected."

         }

         if (errorMessage.length() > 0) throw new CompileException(errorMessage.toString(), null);

         if (caughtException != null) throw new CompileException("Error compiling", null, caughtException);

         // Convert the class files to bytes and store them in a Map.

         HashMap<String, byte[]> classes = new HashMap<String, byte[]>(); // String className => byte[] data

         for (ClassFile cf: classFiles) {

             classes.put(cf.getThisClassName(), cf.toByteArray());

         }

         // Create a ClassLoader that loads the generated classes.

         ClassLoader classLoader = new ByteArrayClassLoader(classes, classLoaderIClassLoader.getClassLoader());

         if (packageNameBuffer.length() > 0) className = packageNameBuffer.append('.').append(className).toString();

         return (C) classLoader.loadClass(className);

     }

     protected V newInstance(JaninoCompilerContext context, C clz) throws Throwable {

         return clz.newInstance();

     }

     protected V init(CompilerContext context, C compiled) throws Throwable {

         initHelper(context, compiled);

         return newInstance((JaninoCompilerContext) context, compiled);

     }

     protected void initHelper(CompilerContext context, C compiled) throws Throwable {

         Init init = (Init) compiled.getClassLoader().loadClass(compiled.getName() + "Init").newInstance();

         init.init(engine, ((JaninoCompilerContext) context).beanObjects);

     }

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

         return compileKey(key, (JaninoCompilerContext) context);

     }

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

         return compileKey(key, (JaninoCompilerContext) context);

     }

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

         return compileKey(key, (JaninoCompilerContext) context);

     }

     protected abstract C compileKey(ApplyKey<C> key, JaninoCompilerContext context) throws BSFException;

     protected abstract C compileKey(EvalKey<C> key, JaninoCompilerContext context) throws BSFException;

     protected abstract C compileKey(ExecKey<C> key, JaninoCompilerContext context) throws BSFException;

 }