package org.webslinger.ext.quercus.template;

 import java.io.IOException;

 import java.io.OutputStreamWriter;

 import java.io.StringWriter;

 import java.io.Writer;

 import java.util.Arrays;

 import java.util.List;

 import java.util.Map;

 import java.util.Vector;

 import org.apache.bsf.BSFException;

 import org.apache.bsf.BSFManager;

 import com.caucho.quercus.Quercus;

 import com.caucho.quercus.env.Env;

 import com.caucho.quercus.env.MethodMap;

 import com.caucho.quercus.env.Value;

 import com.caucho.quercus.page.QuercusPage;

 import com.caucho.vfs.WriterStreamImpl;

 import com.caucho.vfs.WriteStream;

 import org.webslinger.bsf.CompilingLanguageEngineImpl;

 import org.webslinger.bsf.LanguageEngineInfo;

 import org.webslinger.ext.quercus.LocalEnv;

 public class QuercusTemplateEngine extends CompilingLanguageEngineImpl<QuercusPage, QuercusPage> {

     protected final Quercus php = new Quercus();

     protected final LocalEnv globalEnv;

     protected final ThreadLocal<LocalEnv> tl = new ThreadLocal<LocalEnv>();

     protected final int _methodHash = MethodMap.hash("method");

     protected final char[] _methodArray = "method".toCharArray();

     protected Value managerValue;

     public QuercusTemplateEngine() {

         super();

         compiler = new QuercusTemplateCompiler(this);

         php.setCompile(true);

         php.setLazyCompile(false);

         globalEnv = newLocalEnv();

     }

     public LanguageEngineInfo getLanguageEngineInfo() {

         return QuercusTemplateInfo.INSTANCE;

     }

     public void initialize(BSFManager manager, String lang, Vector declaredBeans) throws BSFException {

         super.initialize(manager, lang, declaredBeans);

         managerValue = (Value) compiler.wrap(manager, BSFManager.class);

         getQuercus().addModule(new WebslingerTemplateModule());

     }

     public void terminate() {

         globalEnv.close();

     }

     public Quercus getQuercus() {

         return php;

     }

     public Object apply(Object body, QuercusPage page, String[] names, Object[] args) throws Throwable {

         WriterStreamImpl writerImpl = new WriterStreamImpl();

         writerImpl.setWriter((Writer) args[0]);

         LocalEnv env = new LocalEnv(getQuercus(), page, writerImpl, null, null);

         for (int i = 2; i < args.length; i++) {

             env.setValue(names[i], (Value) args[i]);

         }

         env.setValue("bsf", managerValue);

         env.setValue("BSFParent", (Value) compiler.wrap(body, body.getClass()));

         Map<String, Object> context = (Map<String, Object>) args[1];

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

             Object value = entry.getValue();

             env.setValue(entry.getKey(), value != null ? (Value) compiler.wrap(value, value.getClass()) : null);

         }

         env.start();

         try {

             return page.execute(env);

         } finally {

             env.close();

             env.getOriginalOut().flush();

         }

     }

     public Object apply(Object body, QuercusPage page, Object[] args) throws Throwable {

         throw new InternalError("Should not be called.");

     }

     public Object eval(Object body, QuercusPage page) throws Throwable {

         throw new InternalError();

     }

     public void exec(Object body, QuercusPage page) throws Throwable {

         throw new InternalError();

     }

     public LocalEnv getLocalEnv() {

         LocalEnv env = tl.get();

         if (env == null) {

             env = newLocalEnv();

             tl.set(env);

         }

         return env;

     }

     public LocalEnv getGlobalEnv() {

         return globalEnv;

     }

     public LocalEnv newLocalEnv() {

         return newLocalEnv(new OutputStreamWriter(System.err));

     }

     public LocalEnv newLocalEnv(Writer writer) {

         LocalEnv env = new LocalEnv(getQuercus(), null, null, null);

         WriteStream writeStream = env.getOriginalOut();

         env.getWriterStreamImpl().setWriter(new OutputStreamWriter(System.err));

         return env;

     }

 }