/*

  * 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.

  */

 package org.apache.commons.el;

 import java.lang.reflect.InvocationTargetException;

 import java.lang.reflect.Method;

 import java.util.Iterator;

 import java.util.List;

 import java.util.ArrayList;

 import javax.servlet.jsp.el.ELException;

 import javax.servlet.jsp.el.FunctionMapper;

 import javax.servlet.jsp.el.VariableResolver;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 /**

  *

  * <p>Represents a function call.</p>

  * 

  * @author Shawn Bayern (in the style of Nathan's other classes)

  **/

 public class FunctionInvocation

   extends Expression

 {

     //-------------------------------------

     // Constants

     //-------------------------------------

     private static Log log = LogFactory.getLog(FunctionInvocation.class);

   //-------------------------------------

   // Properties

   //-------------------------------------

   // property index

   private String functionName;

   private List argumentList;

   public String getFunctionName() { return functionName; }

   public void setFunctionName(String f) { functionName = f; }

   public List getArgumentList() { return argumentList; }

   public void setArgumentList(List l) { argumentList = l; }

   //-------------------------------------

   /**

    * Constructor

    **/

   public FunctionInvocation (String functionName, List argumentList)

   {

     this.functionName = functionName;

     this.argumentList = argumentList;

   }

   //-------------------------------------

   // Expression methods

   //-------------------------------------

   /**

    * Returns the expression in the expression language syntax

    **/

   public String getExpressionString ()

   {

     StringBuffer b = new StringBuffer();

     b.append(functionName);

     b.append("(");

     Iterator i = argumentList.iterator();

     while (i.hasNext()) {

       b.append(((Expression) i.next()).getExpressionString());

       if (i.hasNext())

         b.append(", ");

     }

     b.append(")");

     return b.toString();

   }

   //-------------------------------------

   /**

    *

    * Evaluates by looking up the name in the VariableResolver

    **/

   public Object evaluate (VariableResolver pResolver,

                           FunctionMapper functions)

     throws ELException

   {

     Method target = resolveFunction(functions);

     if (target == null) {

         if (log.isErrorEnabled()) {

             String message = MessageUtil.getMessageWithArgs(

                 Constants.UNKNOWN_FUNCTION, functionName);

             log.error(message);

             throw new ELException(message);

         }

     }      

     // ensure that the number of arguments matches the number of parameters

     Class[] params = target.getParameterTypes();

     if (params.length != argumentList.size()) {

         if (log.isErrorEnabled()) {

             String message = MessageUtil.getMessageWithArgs(

                 Constants.INAPPROPRIATE_FUNCTION_ARG_COUNT,

                 functionName, new Integer(params.length),

                 new Integer(argumentList.size()));

             log.error(message);

             throw new ELException(message);

         }      

     }

     // now, walk through each parameter, evaluating and casting its argument

     Object[] arguments = new Object[argumentList.size()];

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

       // evaluate

       arguments[i] = ((Expression) argumentList.get(i)).evaluate(pResolver,

                                                                  functions);

       // coerce

       arguments[i] = Coercions.coerce(arguments[i], params[i]);

     }

     // finally, invoke the target method, which we know to be static

     try {

       return (target.invoke(null, arguments));

     } catch (InvocationTargetException ex) {

         if (log.isErrorEnabled()) {

             String message = MessageUtil.getMessageWithArgs(

                 Constants.FUNCTION_INVOCATION_ERROR,

                 functionName);

             Throwable t = ex.getTargetException();

             log.error(message, t);

             throw new ELException(message, t);

         }      

       return null;

     } catch (Throwable t) {

         if (log.isErrorEnabled()) {

             String message = MessageUtil.getMessageWithArgs(

                 Constants.FUNCTION_INVOCATION_ERROR,

                 functionName);            

             log.error(message, t);

             throw new ELException(message, t); 

         }      

       return null;

     }

   }

   /**

    * Returns the <code>Method</code> which is mapped to the function

    * name used by this <code>FunctionInvocation</code>.

    * @param functions The function mappings in use for this evaluation

    * @return the <code>Method</code> to execute 

    * @throws ELException

    */

   protected Method resolveFunction(FunctionMapper functions) throws ELException {

       // if the Map is null, then the function is invalid 

       if (functions == null) { 

           return null;

       }                    

       // normalize function name

       String prefix = null; 

       String localName = null; 

       int index = functionName.indexOf( ':' );

       if (index == -1) {

         prefix = "";

         localName = functionName;

       } else {

         prefix = functionName.substring( 0, index );

         localName = functionName.substring( index + 1 );

       }       

       // ensure that the function's name is mapped

       Method target = (Method) functions.resolveFunction(prefix, localName);

        return target; 

    }

    public Expression bindFunctions(final FunctionMapper functions)

            throws ELException {

        final List argList = new ArrayList(argumentList.size());

        for (Iterator argIter = argumentList.iterator(); argIter.hasNext();) {

            Expression arg = (Expression) argIter.next();

            argList.add(arg.bindFunctions(functions));

        }

        return new BoundFunctionInvocation(

                resolveFunction(functions),

                functionName,

                argList);

    }

   //-------------------------------------

 }