package org.webslinger.ext.quercus.bsf;

 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.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.QuercusClass;

 import com.caucho.quercus.env.Value;

 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 QuercusEngine extends CompilingLanguageEngineImpl<Value, QuercusClass> {

     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();

     public QuercusEngine() {

         super();

         compiler = new QuercusCompiler(this);

         php.setCompile(true);

         php.setLazyCompile(false);

         globalEnv = newLocalEnv();

     }

     public LanguageEngineInfo getLanguageEngineInfo() {

         return QuercusInfo.INSTANCE;

     }

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

         super.initialize(manager, lang, declaredBeans);

     }

     public void terminate() {

         globalEnv.close();

     }

     public Quercus getQuercus() {

         return php;

     }

     public Object apply(Object body, Value compiled, Object[] args) throws Throwable {

         WriterStreamImpl writerImpl = new WriterStreamImpl();

         writerImpl.setWriter(new OutputStreamWriter(System.err));

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

         env.start();

         try {

             return compiled.callMethod(env, _methodHash, _methodArray, _methodArray.length, (Value[]) args);

         } finally {

             env.close();

             env.getOriginalOut().flush();

         }

     }

     public Object eval(Object body, Value compiled) throws Throwable {

         LocalEnv env = getLocalEnv();

         env.start();

         try {

             return compiled.callMethod(env, _methodHash, _methodArray, _methodArray.length);

         } finally {

             env.close();

             env.getOriginalOut().flush();

         }

     }

     public void exec(Object body, Value compiled) throws Throwable {

         LocalEnv env = getLocalEnv();

         env.start();

         try {

             compiled.callMethod(env, _methodHash, _methodArray, _methodArray.length);

         } finally {

             env.close();

             env.getOriginalOut().flush();

         }

     }

     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;

     }

 }