/*
    * 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);
    }
 
   //-------------------------------------
 }