package org.webslinger.template.velocity;

 import java.io.InputStream;

 import java.io.InputStreamReader;

 import java.io.IOException;

 import java.io.StringReader;

 import java.io.Writer;

 import java.util.Collections;

 import java.util.Iterator;

 import java.util.Map;

 import java.lang.reflect.Constructor;

 import org.apache.bsf.BSFDeclaredBean;

 import org.apache.bsf.BSFException;

 import org.apache.bsf.BSFManager;

 import org.apache.velocity.Template;

 import org.apache.velocity.VelocityContext;

 import org.apache.velocity.exception.ParseErrorException;

 import org.apache.velocity.exception.ResourceNotFoundException;

 import org.apache.velocity.runtime.RuntimeConstants;

 import org.apache.velocity.runtime.RuntimeInstance;

 import org.codehaus.janino.Scanner;

 import org.webslinger.bsf.ApplyKey;

 import org.webslinger.bsf.Compiler;

 import org.webslinger.bsf.CompilingLanguageEngineImpl;

 import org.webslinger.bsf.EvalKey;

 import org.webslinger.bsf.ExecKey;

 import org.webslinger.bsf.Key;

 import org.webslinger.bsf.janino.AbstractJaninoCompiler;

 import org.webslinger.io.Charsets;

 import org.webslinger.template.TemplateMacro;

 import org.webslinger.template.TemplateManager;

 import org.webslinger.vfs.VFSDelegate;

 public class VelocityCompiler extends AbstractJaninoCompiler<LocalVelocityTemplate, Class<LocalVelocityTemplate>> {

     protected RuntimeInstance ri;

     protected TemplateManager manager;

     public VelocityCompiler(VelocityTemplateEngine engine) throws BSFException {

         super(engine);

     }

     public void initialize(BSFManager manager) throws BSFException {

         this.manager = (TemplateManager) manager;

         ri = new RuntimeInstance();

         ri.addProperty(VelocityCompiler.class.getName(), this);

         //ri.addProperty("resource.loader", "velocity-template");

 //        ri.addProperty("velocity-template.resource.loader.class", VelocityLoader.class.getName());

 //        ri.addProperty("velocity-template.resource.loader.cache", "false");

 //        ri.addProperty("resource.manager.cache.class", VelocityCache.class.getName());

 //        ri.addProperty("velocity-template.resource.loader." + VelocityLoader.class.getName() + ".ENGINE", this);

         //ri.addProperty(VelocityTemplateEngine.class.getName(), this);

         ri.addProperty("directive.set.null.allowed", Boolean.TRUE);

         ri.addProperty("runtime.log.invalid.references", Boolean.FALSE);

         ri.addProperty("velocimacro.permissions.allow.inline", Boolean.TRUE);

         ri.addProperty("velocimacro.permissions.allow.inline.local.scope", Boolean.TRUE);

         ri.addProperty(RuntimeConstants.RUNTIME_LOG_LOGSYSTEM_CLASS, "org.apache.velocity.runtime.log.Log4JLogChute");

         ri.addProperty("runtime.log.logsystem.log4j.logger", VelocityCompiler.class.getName());

         try {

             ri.init();

         } catch (Error e) {

             throw e;

         } catch (RuntimeException e) {

             throw e;

         } catch (Exception e) {

             throw (BSFException) new BSFException("Invalid argument").initCause(e);

         }

     }

     public void declareBean(BSFDeclaredBean bean) throws BSFException {

         if (bean.bean instanceof TemplateMacro) ri.addDirective(new VelocityDirectiveMacro(manager, (TemplateMacro) bean.bean));

         super.declareBean(bean);

     }

     public void undeclareBean(BSFDeclaredBean bean) throws BSFException {

         if (bean.bean instanceof TemplateMacro) ri.removeDirective(bean.name);

         super.undeclareBean(bean);

     }

     protected Map<String, BSFDeclaredBean> getBeans() {

         return Collections.emptyMap();

     }

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

     }

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

     }

     protected void addExtends(JaninoCompilerContext context, StringBuilder code) {

         code.append(" extends org.webslinger.template.velocity.LocalVelocityTemplate");

     }

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

         code.append("\tpublic ").append(className).append("(String[] names, String path, String text) {\n");

         code.append("\t\tsuper(names, path, text);\n");

         code.append("\t}\n");

         code.append('\n');

     }

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

         return text;

     }

     public Class<LocalVelocityTemplate> compileKey(ApplyKey<Class<LocalVelocityTemplate>> key, JaninoCompilerContext context) throws BSFException {

         StringBuilder code = context.code;

         code.append("\tpublic void apply(org.apache.bsf.BSFManager manager, Object body, Object[] args) throws Exception {");

         code.append("\t\tsuper.apply(manager, body, args);\n");

         code.append("\t}\n");

         return null;

     }

     protected LocalVelocityTemplate newInstance(JaninoCompilerContext context, Class<LocalVelocityTemplate> clz) throws Throwable {

         Constructor<? extends LocalVelocityTemplate> constructor = clz.getConstructor(new Class[] {String[].class, String.class, String.class});

         ApplyKey key = (ApplyKey) context.key;

         LocalVelocityTemplate value = constructor.newInstance(new Object[] {key.getNames(), absolutePath(key), context.text});

         constructor = null;

         return init(value);

     }

     public Class<LocalVelocityTemplate> compileKey(EvalKey<Class<LocalVelocityTemplate>> key, JaninoCompilerContext context) throws BSFException {

         if (true) throw new IllegalArgumentException();

         return null;

     }

     public Class<LocalVelocityTemplate> compileKey(ExecKey<Class<LocalVelocityTemplate>> key, JaninoCompilerContext context) throws BSFException {

         if (true) throw new IllegalArgumentException();

         return null;

     }

     protected void initHelper(CompilerContext context, Class<LocalVelocityTemplate> compiled) throws Throwable {

     }

     protected LocalVelocityTemplate init(LocalVelocityTemplate template) throws BSFException {

         template.setRuntimeServices(ri);

         try {

             template.process();

         } catch (Error e) {

             throw e;

         } catch (RuntimeException e) {

             throw e;

         } catch (Exception e) {

             throw (BSFException) new BSFException("Invalid argument").initCause(e);

         }

         return template;

     }

 }