package org.webslinger.ext.quercus.template;

 import java.io.IOException;

 import java.io.Writer;

 import java.util.HashMap;

 import java.util.Map;

 import com.caucho.quercus.env.Env;

 import com.caucho.quercus.env.JavaValue;

 import com.caucho.quercus.env.Value;

 import com.caucho.quercus.env.Var;

 import com.caucho.quercus.module.AbstractQuercusModule;

 import com.caucho.quercus.program.AbstractFunction;

 import com.caucho.vfs.StreamPrintWriter;

 import com.caucho.vfs.WriterStreamImpl;

 import org.apache.bsf.BSFManager;

 import org.webslinger.template.TemplateMacro;

 import org.webslinger.template.TemplateManager;

 public class WebslingerTemplateModule extends AbstractQuercusModule {

     public WebslingerTemplateModule() {

     }

     public String[] getLoadedExtensions() {

         return new String[] { "webslinger-template" };

     }

     public void WS_CallMacro(final Env env, String name, Value funcName, Value[] args) {

         BSFManager manager = (BSFManager) ((JavaValue) env.getValue("bsf")).toJavaObject();

         TemplateMacro macro = (TemplateMacro) manager.lookupBean(name);

         if (macro == null) return;

         TemplateMacro.Body body;

         final Object source = env.getValue("BSFParent").toJavaObject();

         if (macro.isBlock()) {

             final AbstractFunction func = env.getFunction(funcName.toString());

             body = new TemplateMacro.Body() {

                 public Object getSource() {

                     return source;

                 }

                 public boolean render(Writer writer, Map<String, Object> context) throws IOException {

                     for (Map.Entry<String, Object> entry: context.entrySet()) {

                         env.setValue(entry.getKey(), env.wrapJava(entry.getValue()));

                     }

                     env.pushOutputBuffer(null, 8192, false);

                     WriterStreamImpl writerImpl = new WriterStreamImpl();

                     writerImpl.setWriter(writer);

                     env.getOut().init(writerImpl);

                     try {

                         func.call(env);

                     } finally {

                         env.popOutputBuffer();

                     }

                     return false;

                 }

             };

         } else {

             body = null;

         }

         Map<String, Object> context = new HashMap<String, Object>();

         for (Map.Entry<String, Var> entry: env.getEnv().entrySet()) {

             context.put(entry.getKey(), entry.getValue().toJavaObject());

         }

         Object[] pList = new Object[args.length];

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

             pList[i] = args[i].toJavaObject();

         }

         try {

             macro.render((TemplateManager) manager, source, new StreamPrintWriter(env.getOut()), new TemplateMacro.Args(pList, null), context, body);

         } catch (RuntimeException e) {

             throw e;

         } catch (Exception e) {

             throw (RuntimeException) new RuntimeException(e.getMessage()).initCause(e);

         }

     }

     public void WS_FunctionBootstrap(Env env) {

         for (Map.Entry<String, Var> entry: env.getGlobalEnv().entrySet()) {

             env.setValue(entry.getKey(), entry.getValue());

         }

     }

 }