/**
    * Copyright (C) 2005-2009 Alfresco Software Limited.
    *
    * This file is part of the Spring Surf Extension project.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
   *  http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.springframework.extensions.webscripts.processor;
  
  import java.io.InputStream;
  import java.io.Writer;
  import java.util.HashMap;
  import java.util.Map;
  
  import org.springframework.extensions.surf.core.processor.ProcessorExtension;
  import org.springframework.extensions.surf.core.scripts.ScriptException;
  import org.springframework.extensions.webscripts.ScriptContent;
  import org.springframework.extensions.webscripts.processor.AbstractScriptProcessor;
  
  import com.caucho.quercus.Quercus;
  import com.caucho.quercus.env.ArrayValue;
  import com.caucho.quercus.env.ArrayValueImpl;
  import com.caucho.quercus.env.BooleanValue;
  import com.caucho.quercus.env.DoubleValue;
  import com.caucho.quercus.env.Env;
  import com.caucho.quercus.env.StringInputStream;
  import com.caucho.quercus.env.StringValue;
  import com.caucho.quercus.env.Value;
  import com.caucho.quercus.module.QuercusModule;
  import com.caucho.quercus.page.QuercusPage;
  import com.caucho.util.CharBuffer;
  import com.caucho.vfs.ReadStream;
  import com.caucho.vfs.StringWriter;
  import com.caucho.vfs.VfsStream;
  import com.caucho.vfs.WriteStream;
  
  /**
   * PHP Script Processor for Alfresco Web Framework
   * 
   * @author Roy Wetherall
   * @author muzquiano
   */
  public class PHPScriptProcessor extends AbstractScriptProcessor
  {	
      /** Key to value found in $_SERVER indicating that the Alfresco API is available */
      public static final String ALF_AVAILABLE = "ALF_AVAILABLE";
          
      /** Quercus engine */
      private Quercus quercus;
      
      /**
       * Constructor
       */
      public PHPScriptProcessor()
      {
      	// Create the quercus engine
      	this.quercus = new Quercus();
      	
      	// Set the ALF_AVAILABLE server value to help with script reuse
      	this.quercus.setServerEnv(PHPScriptProcessor.ALF_AVAILABLE, "true");
      }
         
      /* (non-Javadoc)
       * @see org.alfresco.processor.Processor#getExtension()
       */
      public String getExtension()
      {
          return "php";
      }    
      
      /* (non-Javadoc)
       * @see org.alfresco.processor.Processor#getName()
       */
      public String getName()
      {
      	return "php";
      }
      
      /* (non-Javadoc)
       * @see org.alfresco.web.scripts.processor.AbstractScriptProcessor#init()
       */
      public void init() 
      {
      	super.init();
      	
      	// TODO: any other initialization?
      }
      
             
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.processor.BaseProcessor#registerProcessorExtension(org.alfresco.processor.ProcessorExtension)
      */
     public void registerProcessorExtension(ProcessorExtension processorExtension)
     {
         // Call the base implementation
         super.registerProcessorExtension(processorExtension);
         
         // Deal with adding the extension to the quercus engine
         if (processorExtension instanceof PHPMethodExtension)
         {
             this.quercus.addModule((QuercusModule)processorExtension);    
             ((PHPMethodExtension)processorExtension).initialiseModule(this.quercus.findModule(processorExtension.getClass().getName()));
         }
         else if (processorExtension instanceof PHPObjectExtension)
         {
             try
             {
                 Class clazz = Class.forName(((PHPObjectExtension)processorExtension).getExtensionClass());
                 this.quercus.addJavaClass(processorExtension.getExtensionName(), clazz);
             }
             catch (ClassNotFoundException exception)
             {
                 throw new PHPProcessorException("PHP Object Extension class '" + ((PHPObjectExtension)processorExtension).getExtensionClass() + "' could not be found.", exception);
             }
         }
     }
     
     /**
      * Executes a PHP script using the quercus engine.
      * 
      * @param script    the script as a string
      * @param out       the writer to direct the output of the PHP to.  This can be null if no output is required.
      * @param model     the context model for the script
      * @return          the return result of the executed PHP
      */
     private Object executePHPScript(String script, Writer out, Map<String, Object> model)
     {
         return executePHPScript(new StringInputStream(script), out, model);
     }
     
     /**
      * Executes the PHP script using the quercus engine.
      * 
      * @param is        the input stream containing the PHP to execute
      * @param out       the writer to direct the output of the PHP to.  This can be null if no output is required.
      * @param model     the context model for the script
      * @return Object   the return result of the executed PHP
      */
     private Object executePHPScript(InputStream is, Writer out, Map<String, Object> model)
     {
         try
         {
             // Create the string writer
             StringWriter writer = new StringWriter(new CharBuffer(1024));
             writer.openWrite();
             
             // Parse the page
             VfsStream stream = new VfsStream(is, null);        
             QuercusPage page = this.quercus.parse(new ReadStream(stream));
             
             // Execute the page
             WriteStream ws = new WriteStream(writer);
             Env env = new Env(this.quercus, page, ws, null, null);   
             env.start();
                         
             // Execute the page
             Value value = page.executeTop(env);
             
             // Make sure we flush because otherwise the result does not get written
             ws.flush();
            
             // Write to output
             String result = ((StringWriter)ws.getSource()).getString();            
             if (out != null)
             {
                 out.write(result);
             }            
             
             // Return the result
             return value.toJavaObject();
         }
         catch (Exception exception)
         {
             throw new ScriptException("Error executing script.", exception);
         }
     }
         
     /**
      * 
      * @param model
      * @return
      */
     @SuppressWarnings("unchecked")
     private Map<String, Object> getModel(Object model)
     {
         Map<String, Object> result = null;
         if (model != null && model instanceof Map)
         {
             result = (Map<String, Object>)model;
         }
         else
         {
             result = new HashMap<String, Object>(2);
         }
         return result;
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.ScriptProcessor#findScript(java.lang.String)
      */
     public ScriptContent findScript(String path)
     {
     	return getScriptLoader().getScript(path);    	
     }
     
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.ScriptProcessor#executeScript(java.lang.String, java.util.Map)
      */
     public Object executeScript(String path, Map<String, Object> model)
     {
     	ScriptContent scriptContent = getScriptLoader().getScript(path);
     	return executeScript(scriptContent, model);
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.ScriptProcessor#executeScript(org.alfresco.web.scripts.ScriptContent, java.util.Map)
      */
     public Object executeScript(ScriptContent location, Map<String, Object> model)
     {
     	return executePHPScript(location.getInputStream(), null, model);    	
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.ScriptProcessor#unwrapValue(java.lang.Object)
      */
     public Object unwrapValue(Object value)
     {
         Value result = null;
         
         if (value instanceof String)
         {
             result = StringValue.create(value);
         }
         else if (value instanceof Integer)
         {  
             // TODO could do with a IntegerValue value ...
             result = DoubleValue.create(((Integer)value).doubleValue());
         }
         else if (value instanceof Boolean)
         {
         	result = BooleanValue.create((Boolean)value);
         }
         else if (value instanceof Map)
         {
             Map map = (Map)value;
             ArrayValue arrayValue = new ArrayValueImpl(map.size());
             for (Object objKey : map.keySet())
             {
                 if (objKey instanceof String)
                 {
                     String key = (String)objKey;
                     Object objValue = map.get(key);
                     arrayValue.put(StringValue.create(key), (Value) unwrapValue(objValue));
                 }
             }
             result = arrayValue;
         }
         
         return result;
     }
     
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.ScriptProcessor#reset()
      */
     public void reset()
     {    	
     	init();
     }
 }