/*
 * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * - Redistribution of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * - Redistribution in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * Neither the name of Sun Microsystems, Inc. or the names of
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
 * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
 * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
 * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
 * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
 * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
 * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
 * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
 * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that this software is not designed or intended for use
 * in the design, construction, operation or maintenance of any nuclear
 * facility.
 *
 * Sun gratefully acknowledges that this software was originally authored
 * and developed by Kenneth Bradley Russell and Christopher John Kline.
 */

package com.jogamp.gluegen;

import com.jogamp.gluegen.cgram.types.FunctionSymbol;
import com.jogamp.gluegen.cgram.types.Type;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;

/** Represents the binding of a C function to a Java method. Also used
    to represent calls through function pointers contained in
    structs. */

public class MethodBinding {

  private final FunctionSymbol sym;
  private String         renamedMethodName;
  private final HashSet<String> aliasedNames;
  private JavaType       javaReturnType;
  private List<JavaType> javaArgumentTypes;
  private boolean        computedSignatureProperties;
  private boolean        argumentsUseNIO;
  private boolean        signatureUsesNIO;
  private boolean        signatureCanUseIndirectNIO;
  private boolean        signatureUsesCompoundTypeWrappers;
  private boolean        signatureUsesArraysOfCompoundTypeWrappers;
  private boolean        signatureUsesCVoidPointers;
  private boolean        signatureUsesCPrimitivePointers;
  private boolean        signatureUsesCArrays;
  private boolean        signatureUsesJavaPrimitiveArrays;
  private boolean        signatureRequiresStaticInitialization;
  private JavaType       containingType;
  private Type           containingCType;
  private int            thisPointerIndex = -1;

  /**
   * Constructs a new MethodBinding that is an exact clone of the
   * argument, including the java return type and java argument
   * types. It's safe to modify this binding after construction.
   */
  public MethodBinding(final MethodBinding bindingToCopy) {
    this.sym = bindingToCopy.sym;

    this.renamedMethodName                = bindingToCopy.renamedMethodName;
    this.aliasedNames                     = new HashSet<String>(bindingToCopy.aliasedNames);
    this.containingType                   = bindingToCopy.containingType;
    this.containingCType                  = bindingToCopy.containingCType;
    this.javaReturnType                   = bindingToCopy.javaReturnType;
    this.javaArgumentTypes                = ( null != bindingToCopy.javaArgumentTypes ) ? new ArrayList<JavaType>(bindingToCopy.javaArgumentTypes) : null;
    this.computedSignatureProperties      = bindingToCopy.computedSignatureProperties;
    this.argumentsUseNIO                  = bindingToCopy.argumentsUseNIO;
    this.signatureUsesNIO                 = bindingToCopy.signatureUsesNIO;
    this.signatureCanUseIndirectNIO       = bindingToCopy.signatureCanUseIndirectNIO;
    this.signatureUsesCompoundTypeWrappers = bindingToCopy.signatureUsesCompoundTypeWrappers;
    this.signatureUsesArraysOfCompoundTypeWrappers = bindingToCopy.signatureUsesArraysOfCompoundTypeWrappers;
    this.signatureUsesCVoidPointers       = bindingToCopy.signatureUsesCVoidPointers;
    this.signatureUsesCPrimitivePointers  = bindingToCopy.signatureUsesCPrimitivePointers;
    this.signatureUsesCArrays             = bindingToCopy.signatureUsesCArrays;
    this.signatureUsesJavaPrimitiveArrays = bindingToCopy.signatureUsesJavaPrimitiveArrays;
    this.signatureRequiresStaticInitialization = bindingToCopy.signatureRequiresStaticInitialization;
    this.thisPointerIndex                 = bindingToCopy.thisPointerIndex;
  }

  /** Constructor for calling a C function. */
  public MethodBinding(final FunctionSymbol sym) {
    this.sym = sym;
    this.aliasedNames = new HashSet<String>();
  }

  /** Constructor for calling a function pointer contained in a
      struct. */
  public MethodBinding(final FunctionSymbol sym, final JavaType containingType, final Type containingCType) {
    this.sym = sym;
    this.containingType = containingType;
    this.containingCType = containingCType;
    this.aliasedNames = new HashSet<String>();
  }

    public void setJavaReturnType(final JavaType type) {
        javaReturnType = type;
        computedSignatureProperties = false;
    }

    public void addJavaArgumentType(final JavaType type) {
        if (javaArgumentTypes == null) {
            javaArgumentTypes = new ArrayList<JavaType>();
        }
        javaArgumentTypes.add(type);
        computedSignatureProperties = false;
    }

    public JavaType getJavaReturnType() {
        return javaReturnType;
    }

    public int getNumArguments() {
        return sym.getNumArguments();
    }

    public JavaType getJavaArgumentType(final int i) {
        return javaArgumentTypes.get(i);
    }

    public Type getCReturnType() {
        return sym.getReturnType();
    }

    public Type getCArgumentType(final int i) {
        return sym.getArgumentType(i);
    }

    public FunctionSymbol getCSymbol() {
        return sym;
    }

    /** Returns either the argument name specified by the underlying
    FunctionSymbol or a fabricated argument name based on the
    position. Note that it is currently not guaranteed that there
    are no namespace clashes with these fabricated argument
    names. */
    public String getArgumentName(final int i) {
        final String ret = sym.getArgumentName(i);
        if ( null != ret ) {
            return ret;
        }
        return "arg" + i;
    }

    public String getOrigName() {
        return sym.getName();
    }

    public String getName() {
        // Defaults to same as C symbol unless renamed
        if (renamedMethodName != null) {
            return renamedMethodName;
        }
        return sym.getName();
    }

    /** Supports renaming C function in Java binding. */
    public void renameMethodName(final String name) {
        if (null != name) {
            renamedMethodName = name;
            aliasedNames.add(sym.getName());
        }
    }

    public void addAliasedName(final String name) {
        aliasedNames.add(name);
    }

    public Collection<String> getAliasedNames() {
        return aliasedNames;
    }

  /** Creates a new MethodBinding replacing the specified Java
      argument type with a new argument type. If argumentNumber is
      less than 0 then replaces the return type. */
  public MethodBinding replaceJavaArgumentType(final int argumentNumber, final JavaType newArgType) {

    final MethodBinding binding = new MethodBinding(this);
    binding.javaArgumentTypes = null;
    if (argumentNumber < 0) {
      binding.setJavaReturnType(newArgType);
    } else {
      binding.setJavaReturnType(javaReturnType);
    }
    for (int i = 0; i < getNumArguments(); i++) {
      JavaType type = getJavaArgumentType(i);
      if (i == argumentNumber) {
        type = newArgType;
      }
      binding.addJavaArgumentType(type);
    }
    return binding;
  }

  /**
   * Returns true if any of the outgoing arguments in the method's
   * signature require conversion or checking due to the use of New
   * I/O.
   */
  public boolean argumentsUseNIO() {
    computeSignatureProperties();
    return argumentsUseNIO;
  }

  /**
   * Returns true if the return type or any of the outgoing arguments
   * in the method's signature require conversion or checking due to
   * the use of New I/O.
   */
  public boolean signatureUsesNIO() {
    computeSignatureProperties();
    return signatureUsesNIO;
  }

  /**
   * Returns true if it is possible for any of the outgoing arguments
   * to be indirect NIO buffers.
   */
  public boolean signatureCanUseIndirectNIO() {
    computeSignatureProperties();
    return signatureCanUseIndirectNIO;
  }

  /**
   * Returns true if the return type or any of the outgoing arguments
   * in the method's signature use "compound type wrappers", or
   * NIO-based wrappers for C data structures.
   */
  public boolean signatureUsesCompoundTypeWrappers() {
    computeSignatureProperties();
    return signatureUsesCompoundTypeWrappers;
  }

  /**
   * Returns true if the wrapper implementation requires
   * static native code to be initialized, see {@link JavaConfiguration#forceStaticInitCode(String)}.
   * <p>
   * Currently triggered by:
   * <ul>
   *   <li>Return type is a "compound type" and not a pointer</li>
   * </ul>
   * </p>
   */
  public boolean signatureRequiresStaticInitialization() {
    computeSignatureProperties();
    return signatureRequiresStaticInitialization;
  }

  /**
   * Returns true if the return type or any of the outgoing arguments
   * in the method's signature use arrays of "compound type wrappers",
   * or NIO-based wrappers for C data structures.
   */
  public boolean signatureUsesArraysOfCompoundTypeWrappers() {
    computeSignatureProperties();
    return signatureUsesArraysOfCompoundTypeWrappers;
  }

  /**
   * Returns true if the function needs NIO-related
   * wrapping/unwrapping or conversion of various arguments. Currently
   * this returns the logical OR of signatureUsesNIO(),
   * signatureUsesCompoundTypeWrappers() and signatureUsesArraysOfCompoundTypeWrappers().
   */
  public boolean needsNIOWrappingOrUnwrapping() {
    return (signatureUsesNIO() || signatureUsesCompoundTypeWrappers() || signatureUsesArraysOfCompoundTypeWrappers() );
  }

  /**
   * Returns true if the return type or any of the outgoing arguments
   * in the method's signature represent C void* pointers.
   */
  public boolean signatureUsesCVoidPointers() {
    computeSignatureProperties();
    return signatureUsesCVoidPointers;
  }

  /**
   * Returns true if the return type or any of the outgoing arguments
   * in the method's signature represent C primitive pointers.
   */
  public boolean signatureUsesCPrimitivePointers() {
    computeSignatureProperties();
    return signatureUsesCPrimitivePointers;
  }

  /**
   * Returns true if the return type or any of the outgoing arguments
   * in the method's signature represent C arrays.
   */
  public boolean signatureUsesCArrays() {
    computeSignatureProperties();
    return signatureUsesCArrays;
  }

  /**
   * Returns true if the return type or any of the outgoing arguments
   * in the method's signature represent Java primitive arrays.
   */
  public boolean signatureUsesJavaPrimitiveArrays() {
    computeSignatureProperties();
    return signatureUsesJavaPrimitiveArrays;
  }

  /**
   * Computes summary information about the method's C and Java
   * signatures.
   */
  protected void computeSignatureProperties() {
    if (computedSignatureProperties)
      return;

    argumentsUseNIO = false;
    signatureUsesNIO = false;
    signatureCanUseIndirectNIO = false;
    signatureUsesCompoundTypeWrappers = false;
    signatureUsesArraysOfCompoundTypeWrappers = false;
    signatureUsesCVoidPointers = false;
    signatureUsesCPrimitivePointers = false;
    signatureUsesCArrays = false;
    signatureUsesJavaPrimitiveArrays = false;
    signatureRequiresStaticInitialization = false;

    if ( javaReturnType.isCompoundTypeWrapper() ) {
      // Needs wrapping and/or setting of byte order (neither of which
      // can be done easily from native code)
      signatureUsesCompoundTypeWrappers = true;

      final Type cReturnType = getCReturnType();
      if ( !cReturnType.isPointer() ) { // FIXME: Compound call-by-value
          signatureRequiresStaticInitialization = true;
      }
    }

    if (javaReturnType.isNIOBuffer() ||
        javaReturnType.isArrayOfCompoundTypeWrappers()) {
      // Needs setting of byte order and possibly viewing as a
      // different buffer type which can't be done easily from native
      // code
      signatureUsesNIO = true;
    }

    final Type cRetType = sym.getReturnType();
    if (cRetType.isArray()) {
      // Needs checking of array lengths
      signatureUsesCArrays = true;
      if (cRetType.asArray().getElementType().isPrimitive()) {
        signatureUsesCPrimitivePointers = true;
      }
    }

    if (cRetType.isPointer()) {
      if (cRetType.asPointer().getTargetType().isPrimitive()) {
        signatureUsesCPrimitivePointers = true;
      } else if (cRetType.asPointer().getTargetType().isVoid()) {
        signatureUsesCVoidPointers = true;
      }
    }

    for (int i = 0; i < getNumArguments(); i++) {
      final JavaType javaArgType = getJavaArgumentType(i);
      final Type cArgType = getCArgumentType(i);
      if (javaArgType.isCompoundTypeWrapper()) {
        // Needs unwrapping of accessors
        signatureUsesCompoundTypeWrappers = true;
      }

      if (javaArgType.isArrayOfCompoundTypeWrappers()) {
        // Needs to be duplicated and this array lowered to an array
        // of Buffers for code emission
        signatureUsesArraysOfCompoundTypeWrappers = true;
      }

      if (javaArgType.isNIOBuffer() ||
          javaArgType.isNIOBufferArray()) {
        // Needs checking of direct buffer property
        signatureUsesNIO = true;
        argumentsUseNIO = true;

        if (javaArgType.isNIOBuffer()) {
          // Potential conversion to indirect buffer
          signatureCanUseIndirectNIO = true;
        }
      }

      if (cArgType.isArray()) {
        // Needs checking of array lengths
        signatureUsesCArrays = true;
        if (cArgType.asArray().getElementType().isPrimitive()) {
          signatureUsesCPrimitivePointers = true;
        }
      }

      if (cArgType.isPointer()) {
        // Handle both real C primitive pointers and any constructions
        // due to opaque directives
        if (cArgType.asPointer().getTargetType().isPrimitive() ||
            javaArgType.isCPrimitivePointerType()) {
          signatureUsesCPrimitivePointers = true;
        } else if (cArgType.asPointer().getTargetType().isVoid()) {
          signatureUsesCVoidPointers = true;
        }
      }

      if (javaArgType.isPrimitiveArray()) {
        // Needs getPrimitiveArrayCritical or similar construct
        // depending on native code calling convention
        signatureUsesJavaPrimitiveArrays = true;
      }
    }

    computedSignatureProperties = true;
  }

  /**
   * Indicates whether this MethodBinding is for a function pointer
   * contained in a struct, or to access array- or pointer-data from a struct.
   * <p>
   * The native calling convention, i.e. via a 'this' function pointer
   * or by a static native function must be decided in the
   * {@link JavaEmitter} handling structs and
   * passed to the {@link CMethodBindingEmitter#setIsCStructFunctionPointer(boolean)}.
   * </p>
   */
  public boolean hasContainingType() {
    return (getContainingType() != null);
  }

  /** Retrieves the containing type of this MethodBinding if it is for
      a function pointer contained in a struct. */
  public JavaType getContainingType() {
    return containingType;
  }

  /** Retrieves the containing C type of this MethodBinding if it is for
      a function pointer contained in a struct. */
  public Type getContainingCType() {
    return containingCType;
  }

  /** Find the leftmost argument matching the type of the containing
      type (for function pointer MethodBindings) and record that as a
      "this" pointer, meaning that it does not need to be explicitly
      passed at the Java level. */
  public void findThisPointer() {
    clearThisPointer();
    for (int i = 0; i < getNumArguments(); i++) {
      final JavaType arg = getJavaArgumentType(i);
      if (arg.equals(containingType)) {
        thisPointerIndex = i;
        break;
      }

      if (!arg.isJNIEnv()) {
        break; // this pointer must be leftmost argument excluding JNIEnvs
      }
    }
  }

  /** Clears any record of a this pointer for this MethodBinding. */
  public void clearThisPointer() {
    thisPointerIndex = -1;
  }

  /** Indicates whether the <i>i</i>th argument to this MethodBinding
      is actually a "this" pointer. */
  public boolean isArgumentThisPointer(final int i) {
    return (thisPointerIndex == i);
  }
  @Override
  public boolean equals(final Object obj) {
    if (obj == this) {
      return true;
    }

    if (obj == null || ! (obj instanceof MethodBinding)) {
      return false;
    }

    final MethodBinding other = (MethodBinding)obj;
    if ( !getName().equals(other.getName()) ||
         !sym.getType().equals(other.sym.getType()) ) { return false; }
    if (!(javaReturnType.equals(other.getJavaReturnType()))) { return false; }
    if (containingCType != null &&
        other.getContainingCType() != null &&
        (!(containingCType.equals(other.getContainingCType())))) {
        return false;
      }
    if (javaArgumentTypes.size() != other.javaArgumentTypes.size()) {
      return false;
    }

    for (int i = 0; i < javaArgumentTypes.size(); ++i) {
      final Object typeThis = javaArgumentTypes.get(i);
      final Object typeOther = other.getJavaArgumentType(i);
      if (!(typeThis.equals(typeOther))) {
        return false;
      }
    }

    return true;
  }

  @Override
  public int hashCode() {
    final StringBuilder buf = new StringBuilder(200);
    buf.append(getName());
    buf.append(sym.getType().getName(true));
    buf.append(getJavaReturnType().getName());
    if (containingCType != null) {
        buf.append(containingCType.getName(true));
    }

    for (int i = 0; i < getNumArguments(); i++) {
      final JavaType type = getJavaArgumentType(i);
      if (type.isVoid()) {
        // Make sure this is the only param to the method; if it isn't,
        // there's something wrong with our parsing of the headers.
        assert(getNumArguments() == 1);
        continue;
      }

      buf.append(type.getName());
    }
    return buf.toString().hashCode();
  }

  /** Returns the signature of this binding. */
  @Override
  public String toString() {
    final StringBuilder buf = new StringBuilder(200);
    buf.append(getJavaReturnType().getName());
    buf.append(' ');
    buf.append(getName());
    buf.append('(');
    boolean needComma = false;
    for (int i = 0; i < getNumArguments(); i++) {
      final JavaType type = getJavaArgumentType(i);
      if (type.isVoid()) {
        // Make sure this is the only param to the method; if it isn't,
        // there's something wrong with our parsing of the headers.
        assert(getNumArguments() == 1);
        continue;
      }
      if (type.isJNIEnv() || isArgumentThisPointer(i)) {
        // Don't need to expose these at the Java level
        continue;
      }

      if (needComma) {
        buf.append(", ");
      }

      buf.append(type.getName());
      buf.append(' ');
      buf.append(getArgumentName(i));
      needComma = true;
    }
    buf.append(')');
    return buf.toString();
  }

  /** Returns a String containing the descriptor (signature in
      internal format) of this MethodBinding as it will be
      emitted. This is used to disambiguate between overloadings when
      manually specifying prologue and epilogue code, for example. */
  public String getDescriptor(final boolean forImplementingMethodCall,
                              final boolean eraseBufferAndArrayTypes) {
    final StringBuilder buf = new StringBuilder();

    buf.append('(');

    if (forImplementingMethodCall && hasContainingType()) {
      // Always emit outgoing "this" argument
      buf.append("Ljava/nio/ByteBuffer;");
    }

    for (int i = 0; i < getNumArguments(); i++) {
      final JavaType type = getJavaArgumentType(i);
      if (type.isVoid()) {
        // Make sure this is the only param to the method; if it isn't,
        // there's something wrong with our parsing of the headers.
        if (getNumArguments() != 1) {
          throw new InternalError(
            "\"void\" argument type found in " +
            "multi-argument function \"" + this + "\"");
        }
        continue;
      }

      if (type.isJNIEnv() || isArgumentThisPointer(i)) {
        // Don't need to expose these at the Java level
        continue;
      }

      buf.append(erasedTypeDescriptor(type, eraseBufferAndArrayTypes, false));

      // Add Buffer and array index offset arguments after each associated argument
      if (forImplementingMethodCall) {
        if (type.isNIOBuffer()) {
          buf.append('I');
        } else if (type.isNIOBufferArray()) {
          buf.append("[I");
        }
      }

      // Add offset argument after each primitive array
      if (type.isPrimitiveArray()) {
        buf.append('I');
      }
    }

    buf.append(')');

    // Emit return type for completeness even though we can't overload
    // based solely on return type
    buf.append(erasedTypeDescriptor(getJavaReturnType(), eraseBufferAndArrayTypes, false));

    return buf.toString();
  }

  protected String erasedTypeDescriptor(final JavaType type, final boolean eraseBufferAndArrayTypes, final boolean skipBuffers) {
    if (eraseBufferAndArrayTypes) {
      if (type.isNIOBuffer() ||
          type.isPrimitiveArray()) {
        if (!skipBuffers) {
          // Direct buffers and arrays sent down as Object (but
          // returned as e.g. ByteBuffer)
          return "Ljava/lang/Object;";
        }
      } else if (type.isCompoundTypeWrapper()) {
        // Compound type wrappers are unwrapped to ByteBuffer
        return "Ljava/nio/ByteBuffer;";
      } else if (type.isArrayOfCompoundTypeWrappers()) {
        return "Ljava/nio/ByteBuffer;";
      }
    }
    return type.getDescriptor();
  }
}