/*
 * Copyright (c) 1998-2006 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source 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, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *   Free SoftwareFoundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.xpath.expr;

import java.util.*;
import java.io.*;
import java.lang.reflect.*;

import org.w3c.dom.*;

import com.caucho.util.*;
import com.caucho.vfs.*;
import com.caucho.xml.*;
import com.caucho.xpath.*;

/**
 * Implements the static java extension functions.
 */
public class StaticJavaExpr extends Expr {
  private static final int J_BOOLEAN = 1;
  private static final int J_BYTE = J_BOOLEAN + 1;
  private static final int J_SHORT = J_BYTE + 1;
  private static final int J_INT = J_SHORT + 1;
  private static final int J_LONG = J_INT + 1;
  private static final int J_FLOAT = J_LONG + 1;
  private static final int J_DOUBLE = J_FLOAT + 1;
  private static final int J_STRING = J_DOUBLE + 1;
  private static final int J_OBJECT = J_STRING + 1;
  
  // Code of the expression defined in Expr
  private Method _method;
  // Arguments for more than 3.
  private ArrayList args;
  private int []argTypes;

  private int retType;

  /**
   * Create a StringExpression with three arguments.
   *
   * @param method Java method
   * @param args the arguments
   */
  public StaticJavaExpr(Method method, ArrayList args)
  {
    _method = method;
    this.args = args;

    argTypes = new int[args.size()];
    Class []paramClasses = _method.getParameterTypes();
    for (int i = 0; i < paramClasses.length; i++)
      argTypes[i] = classToType(paramClasses[i]);
    
    retType = classToType(_method.getReturnType());
  }

  private int classToType(Class cl)
  {
    if (boolean.class.equals(cl) || Boolean.class.equals(cl))
      return J_BOOLEAN;
    else if (byte.class.equals(cl) || Byte.class.equals(cl))
      return J_BYTE;
    else if (short.class.equals(cl) || Short.class.equals(cl))
      return J_SHORT;
    else if (int.class.equals(cl) || Integer.class.equals(cl))
      return J_INT;
    else if (long.class.equals(cl) || Long.class.equals(cl))
      return J_LONG;
    else if (float.class.equals(cl) || Float.class.equals(cl))
      return J_FLOAT;
    else if (double.class.equals(cl) || Double.class.equals(cl))
      return J_DOUBLE;
    else if (String.class.equals(cl))
      return J_STRING;
    else
      return J_OBJECT;
  }

  /**
   * True if it returns a string.
   */
  public boolean isString()
  {
    return retType == J_STRING;
  }

  /**
   * True if this returns a boolean.
   */
  public boolean isBoolean()
  {
    return retType == J_BOOLEAN;
  }

  /**
   * True if this returns a boolean.
   */
  public boolean isNumber()
  {
    return retType >= J_BYTE && retType <= J_DOUBLE;
  }

  /**
   * Evaluates the expression as an string.
   *
   * @param node the current node
   * @param env the variable environment.
   *
   * @return the string representation of the expression.
   */
  public String evalString(Node node, ExprEnvironment env)
    throws XPathException
  {
    Object value = evalObject(node, env);

    return String.valueOf(value);
  }

  /**
   * Evaluate the expression as a boolean, i.e. evaluate it as a string
   * and then convert it to a boolean.
   *
   * @param node the current node
   * @param env the variable environment.
   *
   * @return the boolean representation of the expression.
   */
  public boolean evalBoolean(Node node, ExprEnvironment env)
    throws XPathException
  {
    return toBoolean(evalObject(node, env));
  }

  /**
   * Evaluate the expression as a double, i.e. evaluate it as a string
   * and then convert it to a double.
   *
   * @param node the current node
   * @param env the variable environment.
   *
   * @return the numeric representation of the expression.
   */
  public double evalNumber(Node node, ExprEnvironment env)
    throws XPathException
  {
    return toDouble(evalObject(node, env));
  }

  /**
   * Evaluate the expression as an object, i.e. return the string value.
   *
   * @param node the current node
   * @param env the variable environment.
   *
   * @return the boolean representation of the expression.
   */
  public Object evalObject(Node node, ExprEnvironment env)
    throws XPathException
  {
    Object []argArray = new Object[args.size()];

    for (int i = 0; i < argArray.length; i++) {
      Expr expr = (Expr) args.get(i);

      switch (argTypes[i]) {
      case J_BOOLEAN:
        argArray[i] = new Boolean(expr.evalBoolean(node, env));
        break;
      case J_BYTE:
        argArray[i] = new Byte((byte) expr.evalNumber(node, env));
        break;
      case J_SHORT:
        argArray[i] = new Short((short) expr.evalNumber(node, env));
        break;
      case J_INT:
        argArray[i] = new Integer((int) expr.evalNumber(node, env));
        break;
      case J_LONG:
        argArray[i] = new Long((long) expr.evalNumber(node, env));
        break;
      case J_FLOAT:
        argArray[i] = new Float((float) expr.evalNumber(node, env));
        break;
      case J_DOUBLE:
        argArray[i] = new Double(expr.evalNumber(node, env));
        break;
      case J_STRING:
        argArray[i] = expr.evalString(node, env);
        break;
      default:
        argArray[i] = expr.evalObject(node, env);
        break;
      }
    }

    try {
      return _method.invoke(null, argArray);
    } catch (Exception e) {
      throw new XPathException(e);
    }
  }

  /**
   * Return the expression as a string.  toString() returns a valid
   * XPath expression.  This lets applications like XSLT use toString()
   * to print the string in the generated Java.
   */
  public String toString()
  {
    CharBuffer cb = CharBuffer.allocate();
    cb.append("java:");
    cb.append(_method.getDeclaringClass().getName());
    cb.append(".");
    cb.append(_method.getName());

    cb.append("(");
    for (int i = 0; i < args.size(); i++) {
      if (i != 0)
        cb.append(",");
      cb.append(args.get(i));
    }
    cb.append(")");

    return cb.close();
  }
}

