package org.apache.maven.continuum.xmlrpc.server;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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.
   */
  
  import org.apache.xmlrpc.XmlRpcException;
  import org.apache.xmlrpc.XmlRpcHandler;
  import org.apache.xmlrpc.XmlRpcRequest;
  import org.apache.xmlrpc.common.TypeConverter;
  import org.apache.xmlrpc.common.TypeConverterFactory;
  import org.apache.xmlrpc.common.XmlRpcNotAuthorizedException;
  import org.apache.xmlrpc.metadata.Util;
  import org.apache.xmlrpc.server.AbstractReflectiveHandlerMapping;
  import org.apache.xmlrpc.server.RequestProcessorFactoryFactory;
  import org.codehaus.plexus.PlexusContainer;
  import org.codehaus.plexus.component.repository.exception.ComponentLifecycleException;
  
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  
  /**
   * @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
   * @version $Id: ContinuumXmlRpcMetaDataHandler.java 1372267 2012-08-13 05:47:30Z brett $
   */
  public class ContinuumXmlRpcMetaDataHandler
      implements XmlRpcHandler
  {
      private static class MethodData
      {
          final Method method;
  
          final TypeConverter[] typeConverters;
  
          MethodData( Method pMethod, TypeConverterFactory pTypeConverterFactory )
          {
              method = pMethod;
              Class[] paramClasses = method.getParameterTypes();
              typeConverters = new TypeConverter[paramClasses.length];
              for ( int i = 0; i < paramClasses.length; i++ )
              {
                  typeConverters[i] = pTypeConverterFactory.getTypeConverter( paramClasses[i] );
              }
          }
      }
  
      private final AbstractReflectiveHandlerMapping mapping;
  
      private final MethodData[] methods;
  
      private final Class clazz;
  
      private final RequestProcessorFactoryFactory.RequestProcessorFactory requestProcessorFactory;
  
      private final String[][] signatures;
  
      private final String methodHelp;
  
      private final PlexusContainer container;
  
      /**
       * Creates a new instance.
       *
       * @param pMapping   The mapping, which creates this handler.
       * @param pClass     The class, which has been inspected to create
       *                   this handler. Typically, this will be the same as
       *                   <pre>pInstance.getClass()</pre>. It is used for diagnostic
       *                   messages only.
       * @param pMethods   The method, which will be invoked for
       *                   executing the handler.
       * @param signatures The signature, which will be returned by
       *                   {@link #getSignatures()}.
       * @param methodHelp The help string, which will be returned
       *                   by {@link #getMethodHelp()}.
       * @param container  The container that loaded the component
       */
      public ContinuumXmlRpcMetaDataHandler( AbstractReflectiveHandlerMapping pMapping,
                                             TypeConverterFactory pTypeConverterFactory, Class pClass,
                                             RequestProcessorFactoryFactory.RequestProcessorFactory pFactory,
                                             Method[] pMethods, String[][] signatures, String methodHelp,
                                             PlexusContainer container )
      {
          mapping = pMapping;
          clazz = pClass;
         methods = new MethodData[pMethods.length];
         requestProcessorFactory = pFactory;
         for ( int i = 0; i < methods.length; i++ )
         {
             methods[i] = new MethodData( pMethods[i], pTypeConverterFactory );
         }
         this.signatures = signatures;
         this.methodHelp = methodHelp;
         this.container = container;
     }
 
     private Object getInstance( XmlRpcRequest pRequest )
         throws XmlRpcException
     {
         return requestProcessorFactory.getRequestProcessor( pRequest );
     }
 
     public Object execute( XmlRpcRequest pRequest )
         throws XmlRpcException
     {
         AbstractReflectiveHandlerMapping.AuthenticationHandler authHandler = mapping.getAuthenticationHandler();
         if ( authHandler != null && !authHandler.isAuthorized( pRequest ) )
         {
             throw new XmlRpcNotAuthorizedException( "Not authorized" );
         }
         Object[] args = new Object[pRequest.getParameterCount()];
         for ( int j = 0; j < args.length; j++ )
         {
             args[j] = pRequest.getParameter( j );
         }
         Object instance = getInstance( pRequest );
         for ( MethodData methodData : methods )
         {
             TypeConverter[] converters = methodData.typeConverters;
             if ( args.length == converters.length )
             {
                 boolean matching = true;
                 for ( int j = 0; j < args.length; j++ )
                 {
                     if ( !converters[j].isConvertable( args[j] ) )
                     {
                         matching = false;
                         break;
                     }
                 }
                 if ( matching )
                 {
                     for ( int j = 0; j < args.length; j++ )
                     {
                         args[j] = converters[j].convert( args[j] );
                     }
                     return invoke( instance, methodData.method, args );
                 }
             }
         }
         throw new XmlRpcException( "No method matching arguments: " + Util.getSignature( args ) );
     }
 
     private Object invoke( Object pInstance, Method pMethod, Object[] pArgs )
         throws XmlRpcException
     {
         try
         {
             return pMethod.invoke( pInstance, pArgs );
         }
         catch ( IllegalAccessException e )
         {
             throw new XmlRpcException( "Illegal access to method " + pMethod.getName() + " in class " + clazz.getName(),
                                        e );
         }
         catch ( IllegalArgumentException e )
         {
             throw new XmlRpcException(
                 "Illegal argument for method " + pMethod.getName() + " in class " + clazz.getName(), e );
         }
         catch ( InvocationTargetException e )
         {
             Throwable t = e.getTargetException();
             if ( t instanceof XmlRpcException )
             {
                 throw (XmlRpcException) t;
             }
             throw new XmlRpcException(
                 "Failed to invoke method " + pMethod.getName() + " in class " + clazz.getName() + ": " + t.getMessage(),
                 t );
         }
         finally
         {
             try
             {
                 container.release( pInstance );
             }
             catch ( ComponentLifecycleException e )
             {
                 //Do nothing
             }
         }
     }
 
     public String[][] getSignatures()
         throws XmlRpcException
     {
         return signatures;
     }
 
     public String getMethodHelp()
         throws XmlRpcException
     {
         return methodHelp;
     }
 
 }