/*******************************************************************************
 * Copyright (c) 2002 - 2006 IBM Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package com.ibm.wala.ipa.callgraph;

import java.util.Arrays;

import com.ibm.wala.analysis.typeInference.ConeType;
import com.ibm.wala.analysis.typeInference.PrimitiveType;
import com.ibm.wala.analysis.typeInference.TypeAbstraction;
import com.ibm.wala.classLoader.CallSiteReference;
import com.ibm.wala.classLoader.IClass;
import com.ibm.wala.classLoader.IMethod;
import com.ibm.wala.ipa.callgraph.impl.AbstractRootMethod;
import com.ibm.wala.ipa.cha.IClassHierarchy;
import com.ibm.wala.shrikeBT.BytecodeConstants;
import com.ibm.wala.shrikeBT.IInvokeInstruction;
import com.ibm.wala.ssa.SSAAbstractInvokeInstruction;
import com.ibm.wala.ssa.SSANewInstruction;
import com.ibm.wala.types.MethodReference;
import com.ibm.wala.types.TypeReference;
import com.ibm.wala.util.debug.Assertions;

/**
 * A representation of an entrypoint in the call graph.
 */
public abstract class Entrypoint implements BytecodeConstants {

  /**
   * The method to be called
   */
  protected final IMethod method;

  /**
   * @param method the method to be called for this entrypoint
   */
  protected Entrypoint(IMethod method) {
    if (method == null) {
      throw new IllegalArgumentException("method is null");
    }
    this.method = method;
    assert method.getDeclaringClass() != null : "null declaring class";
  }

  protected Entrypoint(MethodReference method, IClassHierarchy cha) {
    if (cha == null) {
      throw new IllegalArgumentException("cha is null");
    }
    IMethod m = cha.resolveMethod(method);
    if (m == null) {
      Assertions.UNREACHABLE("could not resolve " + method);
    }
    this.method = m;
  }

  /**
   * Create a call site reference representing a call to this entrypoint
   * 
   * @param programCounter the bytecode index of the synthesize call
   * @return the call site reference, or null if failed to find entrypoint
   */
  public CallSiteReference makeSite(int programCounter) {

    if (method.getSelector().equals(MethodReference.clinitSelector)) {
      assert method.isStatic();
      return CallSiteReference.make(programCounter, method.getReference(), IInvokeInstruction.Dispatch.STATIC);
    } else if (method.getSelector().equals(MethodReference.initSelector)) {
      assert !method.isStatic();
      return CallSiteReference.make(programCounter, method.getReference(), IInvokeInstruction.Dispatch.SPECIAL);
    } else {
      if (method.getDeclaringClass().isInterface()) {
        return CallSiteReference.make(programCounter, method.getReference(), IInvokeInstruction.Dispatch.INTERFACE);
      } else {
        if (method.isStatic()) {
          return CallSiteReference.make(programCounter, method.getReference(), IInvokeInstruction.Dispatch.STATIC);
        } else {
          return CallSiteReference.make(programCounter, method.getReference(), IInvokeInstruction.Dispatch.VIRTUAL);
        }
      }
    }
  }

  /**
   * Add allocation statements to the fake root method for each possible value of parameter i. If necessary, add a phi to combine
   * the values.
   * 
   * @return value number holding the parameter to the call; -1 if there was some error
   */
  protected int makeArgument(AbstractRootMethod m, int i) {
    TypeReference[] p = getParameterTypes(i);
    if (p.length == 0) {
      return -1;
    } else if (p.length == 1) {
      if (p[0].isPrimitiveType()) {
        return m.addLocal();
      } else {
        SSANewInstruction n = m.addAllocation(p[0]);
        return (n == null) ? -1 : n.getDef();
      }
    } else {
      int[] values = new int[p.length];
      int countErrors = 0;
      for (int j = 0; j < p.length; j++) {
        SSANewInstruction n = m.addAllocation(p[j]);
        int value = (n == null) ? -1 : n.getDef();
        if (value == -1) {
          countErrors++;
        } else {
          values[j - countErrors] = value;
        }
      }
      if (countErrors > 0) {
        int[] oldValues = values;
        values = new int[oldValues.length - countErrors];
        System.arraycopy(oldValues, 0, values, 0, values.length);
      }

      TypeAbstraction a;
      if (p[0].isPrimitiveType()) {
        a = PrimitiveType.getPrimitive(p[0]);
        for (i = 1; i < p.length; i++) {
          a = a.meet(PrimitiveType.getPrimitive(p[i]));
        }
      } else {
        IClassHierarchy cha = m.getClassHierarchy();
        IClass p0 = cha.lookupClass(p[0]);
        a = new ConeType(p0);
        for (i = 1; i < p.length; i++) {
          IClass pi = cha.lookupClass(p[i]);
          a = a.meet(new ConeType(pi));
        }
      }

      return m.addPhi(values);
    }
  }

  @Override
  public boolean equals(Object obj) {
    // assume these are managed canonically
    return this == obj;
  }

  /**
   * Add a call to this entrypoint from the fake root method
   * 
   * @param m the Fake Root Method
   * @return the call instruction added, or null if the operation fails
   */
  public SSAAbstractInvokeInstruction addCall(AbstractRootMethod m) {
    int paramValues[];
    CallSiteReference site = makeSite(0);
    if (site == null) {
      return null;
    }
    paramValues = new int[getNumberOfParameters()];
    for (int j = 0; j < paramValues.length; j++) {
      paramValues[j] = makeArgument(m, j);
      if (paramValues[j] == -1) {
        // there was a problem
        return null;
      }
    }

    return m.addInvocation(paramValues, site);
  }

  /**
   * @return the method this call invokes
   */
  public IMethod getMethod() {
    return method;
  }

  /**
   * @return types to allocate for parameter i; for non-static methods, parameter 0 is "this"
   */
  public abstract TypeReference[] getParameterTypes(int i);

  /**
   * @return number of parameters to this call, including "this" for non-statics
   */
  public abstract int getNumberOfParameters();

  @Override
  public String toString() {
    StringBuffer result = new StringBuffer(method.toString());
    result.append("(");
    for (int i = 0; i < getNumberOfParameters() - 1; i++) {
      result.append(Arrays.toString(getParameterTypes(i)));
      result.append(",");
    }
    if (getNumberOfParameters() > 0) {
      result.append(Arrays.toString(getParameterTypes(getNumberOfParameters() - 1)));
    }
    result.append(")");
    return result.toString();
  }

  @Override
  public int hashCode() {
    return method.hashCode() * 1009;
  }
}
