package org.webslinger.ext.quercus.template;

 import java.io.File;

 import java.io.OutputStreamWriter;

 import java.util.HashMap;

 import org.apache.bsf.BSFDeclaredBean;

 import org.apache.bsf.BSFException;

 import org.apache.commons.vfs.FileObject;

 import com.caucho.quercus.Quercus;

 import com.caucho.quercus.env.Env;

 import com.caucho.quercus.env.QuercusClass;

 import com.caucho.quercus.env.Value;

 import com.caucho.quercus.page.QuercusPage;

 import com.caucho.quercus.program.QuercusProgram;

 import com.caucho.quercus.program.ClassDef;

 import com.caucho.vfs.Path;

 import com.caucho.vfs.StringPath;

 import com.caucho.vfs.Vfs;

 import org.webslinger.PathContext;

 import org.webslinger.Webslinger;

 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;

 import org.webslinger.ext.quercus.VFSDelegatePath;

 import org.webslinger.ext.quercus.LocalEnv;

 public final class QuercusTemplateCompiler extends Compiler<QuercusPage, QuercusPage> {

     private static final HashMap<Class, String> compiledClassNamesMap = new HashMap<Class, String>();

     static {

         compiledClassNamesMap.put(ApplyKey.class, "BSFQuercusApply");

         compiledClassNamesMap.put(EvalKey.class, "BSFQuercusEval");

         compiledClassNamesMap.put(ExecKey.class, "BSFQuercusExec");

     }

     private final QuercusTemplateEngine phpEngine;

     public QuercusTemplateCompiler(QuercusTemplateEngine engine) {

         super(engine);

         phpEngine = engine;

     }

     public Quercus getQuercus() {

         return phpEngine.getQuercus();

     }

     public void declareBean(BSFDeclaredBean bean) throws BSFException {

     }

     public void undeclareBean(BSFDeclaredBean bean) throws BSFException {

     }

     protected CompilerContext newContext(Key<QuercusPage> key) throws BSFException {

         return new CompilerContext(key);

     }

     public QuercusPage compile(CompilerContext context) throws Throwable {

         Quercus php = getQuercus();

         synchronized (php) {

             return php.parse(getPath(context.key.getId()));

         }

     }

     protected QuercusPage init(CompilerContext context, QuercusPage compiled) {

         return compiled;

     }

     public Env getGlobalEnv() {

         return phpEngine.getGlobalEnv();

     }

     public LocalEnv newEnv() throws Throwable {

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

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

         return env;

     }

     protected Path getPath(Object body) throws Exception {

         return new VFSDelegatePath(phpEngine.getVFSDelegate(), body);

     }

     public QuercusPage compileKey(ApplyKey<QuercusPage> key, CompilerContext context) throws BSFException {

         throw new InternalError();

     }

     public QuercusPage compileKey(EvalKey<QuercusPage> key, CompilerContext context) throws BSFException {

         throw new InternalError();

     }

     public QuercusPage compileKey(ExecKey<QuercusPage> key, CompilerContext context) throws BSFException {

         throw new InternalError();

     }

     public Object wrapForArgs(int i, Object object, Class type) {

         if (i < 2) return object;

         return wrap(object, type);

     }

     public Object wrap(Object object, Class type) {

         return getGlobalEnv().wrapJava(object);

     }

     public Object unwrap(Object object) {

         return ((Value) object).toJavaObject();

     }

 }