/*
   Wotonomy: OpenStep design patterns for pure Java applications.
   Copyright (C) 2001 Intersect Software Corporation
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
   
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, see http://www.gnu.org
  */
  
  package net.wotonomy.web.xml;
  
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.Hashtable;
  
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import net.wotonomy.foundation.NSSelector;
  import net.wotonomy.foundation.internal.WotonomyException;
  
  /***
  * A servlet that can make any java object into an XML-RPC server.
  * Simply pass in the object to the constructor and XML-RPC requests
  * to this servlet will call the appropriate methods and convert
  * the results to an XML-RPC response. <br><br>
  *
  * Depending on your servlet container, it may be necessary to 
  * create a simple subclass that creates your handler object
  * in its constructor and then calls setHandler(). <br><br>
  *
  * Responses are in the specification's standard response format.<br><br>
  *
  * Faults are returned if any exception is thrown in the method,
  * or if the specified method is not found on the object.
  * The fault string is the toString value of the exception,
  * and the fault code is the hasCode value of the exception. <br><br>
  *
  * Remember that this servlet only responds to POSTs, 
  * per the XML-RPC spec.  
  */
  public class XMLRPCServlet extends HttpServlet 
  {
      protected Object handler;
      protected boolean synchronizing;
      private Hashtable selectorCache = new Hashtable(); // thread safe
      private boolean copyStream = false;
      
      /***
      * Default constructor initializes internal state.
      */
      public XMLRPCServlet()
      {
          handler = null;
          synchronizing = false;
      }
      
      /***
      * Constructor takes any java object and allows its methods
      * to be invoked via XMLRPC requests to this servlet.
      * Simply calls setHandler().
      */
      public XMLRPCServlet( Object aHandler )
      {
          this();
          setHandler( aHandler );
      }
      
      /***
      * Gets the object whose methods will be invoked to
      * handle incoming requests.
      */
      public Object getHandler()
      {
          return handler;
      }
      
      /***
      * Sets the object whose methods will be invoked to
      * handle incoming requests.
      */
      public void setHandler( Object aHandler )
      {
          handler = aHandler;
      }
     
     /***
     * Gets whether the servlet should synchonize on the
     * object before invoking methods on it.
     * Defaults to false.
     */
     public boolean isSynchronizing()
     {
         return synchronizing;
     }
     
     /***
     * Sets whether the servlet should synchonize on the
     * object before invoking methods on it.
     * Defaults to false.
     */
     public void setSynchronizing( boolean willSynchronize )
     {
         synchronizing = willSynchronize;
     }
     
     /***
     * Overridden to service the request.
     */
     protected void doPost(
         HttpServletRequest req, HttpServletResponse resp) 
     throws ServletException, IOException
     {
         if ( getHandler() != null )
         {
             InputStream input = req.getInputStream();
             byte[] copyOfRequest = null;
 
             if ( copyStream )
             {
                 ByteArrayOutputStream byteArray =
                     new ByteArrayOutputStream();
                 int b;
                 while ( ( b = input.read() ) != -1 )
                 {
                     byteArray.write( b );
                 }
                 copyOfRequest = byteArray.toByteArray();
                 input = new ByteArrayInputStream( copyOfRequest );
             }
             
             try
             {
                 new XMLRPCDecoder().decode( input, 
                     new Receiver( this, resp ) );
             }
             catch ( WotonomyException exc )
             {
                 if ( copyOfRequest != null )
                 {
                     System.out.println( new String( copyOfRequest ) );
                     exc.printStackTrace();
                 }
                 // catches io exceptions thrown in handleRequest.
                 Throwable t = exc.getWrappedThrowable();
                 if ( t instanceof IOException )
                 {
                     throw (IOException)t;
                 }
                 throw exc;
             }
         }
     }
     
     /***
     * Called by doPost after parsing an incoming request,
     * and is responsible for invoking the specified method
     * with the specified parameters on the handler object.
     * (This implementation calls getOutputStream() on the response.)
     * Override to customize the handling of the request.
     */
     protected void handleRequest( String aMethodName, 
         Object[] aParameterArray, HttpServletResponse aResponse )
     {
         OutputStream output = null;
         
         try 
         {
             output = aResponse.getOutputStream();
             aResponse.setStatus( HttpServletResponse.SC_OK ); // always 200
             aResponse.setContentType( "text/xml" );
         }
         catch ( IOException exc )
         {
             // caught in doPost
             throw new WotonomyException( exc );   
         }
         
         // get the array of types
         XMLRPCEncoder encoder = new XMLRPCEncoder();
         Class[] types = new Class[ aParameterArray.length ];
         for ( int i = 0; i < aParameterArray.length; i++ )
         {
             types[i] = aParameterArray[i].getClass();
         }
         
         //TODO: selectors should be cached if possible
         
         Object handler = getHandler();
         if ( isSynchronizing() )
         {
             synchronized ( handler )
             {
                 execute( encoder, handler, output,
                     new NSSelector( aMethodName, types ), aParameterArray );
             }
         }
         else
         {
             execute( encoder, handler, output,
                 new NSSelector( aMethodName, types ), aParameterArray );
         }
     }
     
     private void execute( XMLRPCEncoder anEncoder, Object aHandler, 
         OutputStream output, NSSelector aSelector, Object[] aParameterArray )
     {
         try 
         {
             Object result = 
                 aSelector.invoke( aHandler, aParameterArray );
             anEncoder.encodeResponse( result, output );
         }
         catch ( Exception exc )
         {
             anEncoder.encodeFault( 
                 exc.hashCode(), exc.toString(), output );
         }
     }
     
     private class Receiver implements XMLRPCReceiver
     {
         XMLRPCServlet controller;
         HttpServletResponse response;
         
         public Receiver( 
             XMLRPCServlet aController,
             HttpServletResponse aResponse )
         {
             controller = aController;
             response = aResponse;
         }
         
         public void request( 
             String aMethodName, Object[] aParameterArray )
         {
             controller.handleRequest( 
                 aMethodName, aParameterArray, response );
         }
         
         public void response( 
             Object aResult ) 
         {
             // does nothing
         }
         
         public void fault( 
             int aFaultCode, String aFaultString)
         {
             // does nothing
         }
     }
 }
 
 /*
  * $Log$
  * Revision 1.1  2006/02/19 01:44:02  cgruber
  * Add xmlrpc files
  * Remove jclark and replace with dom4j and javax.xml.sax stuff
  * Re-work dependencies and imports so it all compiles.
  *
  * Revision 1.1  2006/02/16 13:22:22  cgruber
  * Check in all sources in eclipse-friendly maven-enabled packages.
  *
  * Revision 1.1  2001/02/07 19:24:28  mpowers
  * Moved XML classes to separate package.
  *
  */