package org.webslinger.ext.quercus.bsf;

 import java.io.OutputStreamWriter;

 import java.util.HashMap;

 import org.apache.bsf.BSFDeclaredBean;

 import org.apache.bsf.BSFException;

 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.program.QuercusProgram;

 import com.caucho.quercus.program.ClassDef;

 import com.caucho.quercus.program.AbstractFunction;

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

 public final class QuercusCompiler extends Compiler<Value, QuercusClass> {

     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 QuercusEngine phpEngine;

     public QuercusCompiler(QuercusEngine engine) {

         super(engine);

         phpEngine = engine;

     }

     public Quercus getQuercus() {

         return phpEngine.getQuercus();

     }

     public void declareBean(BSFDeclaredBean bean) throws BSFException {

         clear();

     }

     public void undeclareBean(BSFDeclaredBean bean) throws BSFException {

         clear();

     }

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

         return new CompilerContext(key);

     }

     public QuercusClass compile(CompilerContext context) throws Throwable {

         String className = compiledClassNamesMap.get(context.key.getClass());

         StringBuilder code = context.code;

         code.append("class ").append(className).append(" {");

         code.append("var $bsf;");

         for (BSFDeclaredBean bean: context.beans) {

             code.append("var $").append(bean.name).append(';');

         }

         code.append("public function __construct($engine, $beans) {");

         code.append("$this->bsf = $engine->getBSFFunctions();");

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

             BSFDeclaredBean bean = context.beans[i];

             code.append("$this->").append(bean.name).append(" = $beans[").append(i).append("];");

         }

         code.append('}');

         code.append("public function method");

         super.compile(context);

         code.append('}');

         code.append('}');

         if (engine.isDebugOn()) System.err.println(code);

         Quercus php = getQuercus();

         synchronized (php) {

             LocalEnv env = newEnv();

             try {

                 QuercusProgram program = php.parseCode(code.toString());

                 program.execute(env);

                 return new QuercusClass((ClassDef) program.getClasses().iterator().next(), null);

             } finally {

                 env.getOriginalOut().flush();

                 env.close();

             }

         }

     }

     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;

     }

     public Value init(CompilerContext context, QuercusClass compiled) throws Throwable {

         LocalEnv env = newEnv();

         try {

             Value[] args = new Value[] {

                 (Value) wrap(engine, QuercusEngine.class),

                 (Value) wrap(context.beans, context.beans.getClass())

             };

             return compiled.callNew(env, args);

         } finally {

             env.getOriginalOut().flush();

             env.close();

         }

     }

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

         StringBuilder code = context.code;

         code.append('(');

         String[] names = key.getNames();

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

             if (i != 0) code.append(", ");

             code.append('$').append(names[i]);

         }

         code.append(") {");

         code.append(context.text);

         return null;

     }

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

         context.code.append("() {");

         context.code.append(context.text);

         return null;

     }

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

         context.code.append("() {");

         context.code.append(context.text);

         return null;

     }

     public Object[] newWrapArray(int length) {

         return new Value[length];

     }

     public Object[] newWrapArray(Object[] array) {

         return new Value[array.length];

     }

     public Object wrap(Object object, Class type) {

         return getGlobalEnv().wrapJava(object);

     }

     public Object unwrap(Object object) {

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

     }

 }