package org.webslinger.bsf.groovy;

 import java.util.HashMap;

 import java.util.regex.Pattern;

 import java.util.regex.Matcher;

 import org.apache.bsf.BSFDeclaredBean;

 import org.apache.bsf.BSFException;

 import groovy.lang.GroovyClassLoader;

 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 GroovyCompiler extends Compiler<Object, Class<? extends Object>> {

     protected static final Pattern singleLineCommentPattern = Pattern.compile("^(//(?ms:[^\\r\\n]*$))((?ms).*)");

     protected static final Pattern multiLineCommentPattern = Pattern.compile("^(?ms:(/\\*.*?\\*/))((?ms).*)");

     protected static final Pattern whitespacePattern = Pattern.compile("^((?ms:\\s+))((?ms).*)");

     protected static final Pattern importPattern = Pattern.compile("^import\\b((?ms).*)");

     protected static final Pattern identifierPattern = Pattern.compile("^([a-zA-Z0-9_]+)\\b((?ms).*)");

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

     static {

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

     }

     public class GroovyCompilerContext extends CompilerContext {

         protected StringBuilder imports;

         protected GroovyCompilerContext(Key<Class<? extends Object>> key) throws BSFException {

             super(key);

         }

     }

     public static class NameEncoder extends Compiler.NameEncoder {

         public void encodeChar(StringBuilder target, char c, boolean isStart) {

             if (c != '_' && (isStart ? Character.isJavaIdentifierStart(c) : Character.isJavaIdentifierPart(c))) {

                 target.append(c);

             } else {

                 target.append('_').append((int) c).append('_');

             }

         }

     }

     public GroovyCompiler(GroovyEngine engine) {

         super(engine, new NameEncoder());

     }

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

         return filter((GroovyCompilerContext) context, text);

     }

     protected String filterComments(StringBuilder sb, String text) {

         while (true) {

             Matcher matcher = singleLineCommentPattern.matcher(text);

             if (matcher.matches()) {

                 sb.append(matcher.group(1));

                 text = matcher.group(2);

                 continue;

             }

             matcher = multiLineCommentPattern.matcher(text);

             if (matcher.matches()) {

                 sb.append(matcher.group(1));

                 text = matcher.group(2);

                 continue;

             }

             break;

         }

         return text;

     }

     protected String filterSkippable(StringBuilder sb, String text) {

         while (true) {

             text = filterComments(sb, text);

             Matcher matcher = whitespacePattern.matcher(text);

             if (!matcher.matches()) break;

             sb.append(matcher.group(1));

             text = matcher.group(2);

         }

         return text;

     }

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

         StringBuilder sb = new StringBuilder();

         while (true) {

             text = filterSkippable(sb, text);

             Matcher matcher = importPattern.matcher(text);

             if (!matcher.matches()) break;

             StringBuilder importSb = new StringBuilder();

             importSb.append("import");

             text = filterComments(importSb, matcher.group(1));

             matcher = whitespacePattern.matcher(text);

             if (!matcher.matches()) throw new BSFException("Bad groovy file(missing whitespace after import)");

             importSb.append(matcher.group(1));

             text = filterSkippable(importSb, matcher.group(2));

             matcher = identifierPattern.matcher(text);

             if (!matcher.matches()) throw new BSFException("Bad groovy file(missing identifier part after import)");

             importSb.append(matcher.group(1));

             text = matcher.group(2);

             while (true) {

                 text = filterSkippable(importSb, text);

                 if (!text.startsWith(".")) break;

                 importSb.append('.');

                 matcher = identifierPattern.matcher(text.substring(1));

                 if (!matcher.matches()) throw new BSFException("Bad groovy file(missing identifier part after . in import)");

                 importSb.append(matcher.group(1));

                 text = matcher.group(2);

             }

             while (true) {

                 text = filterSkippable(importSb, text);

                 if (!text.startsWith(";")) break;

                 importSb.append(';');

                 text = text.substring(1);

             }

             sb.append(importSb);

         }

         context.imports = sb;

         return text;

     }

     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<Class<? extends Object>> key) throws BSFException {

         return new GroovyCompilerContext(key);

     }

     protected Class<? extends Object> compile(CompilerContext context) throws Throwable {

         return compile((GroovyCompilerContext) context);

     }

     protected Class<? extends Object> compile(GroovyCompilerContext context) throws Throwable {

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

         StringBuilder classNameBuffer = new StringBuilder();

         nameEncoder.encodeName(classNameBuffer, fileName);

         StringBuilder code = context.code;

         code.append(context.imports);

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

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

         if (implementsClass != null) code.append(" implements ").append(implementsClass.getName());

         code.append(" {");

         super.compile(context);

         code.append('}');

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

         GroovyClassLoader loader = new GroovyClassLoader(getEngine().getManager().getClassLoader());

         Class<?> clz = loader.parseClass(code.toString(), fileName);

         return clz.asSubclass(Object.class);

     }

     protected Object init(CompilerContext context, Class<? extends Object> compiled) throws Throwable {

         return compiled.newInstance();

     }

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

         StringBuilder code = context.code;

         code.append("public Object apply(org.apache.bsf.BSFManager bsf, Object[] args) throws Exception {");

         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(type != null ? type.getName() : "Object").append(' ').append(names[i]);

             code.append(" = args[").append(i).append("];");

         }

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

         code.append("}");

         return null;

     }

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

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

         StringBuilder code = context.code;

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

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

         return null;

     }

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

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

         StringBuilder code = context.code;

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

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

         code.append("}");

         return null;

     }

 }