/*******************************************************************************
 * 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.util.strings;

import static com.ibm.wala.types.TypeName.ArrayMask;
import static com.ibm.wala.types.TypeName.ElementBits;
import static com.ibm.wala.types.TypeName.PointerMask;
import static com.ibm.wala.types.TypeName.ReferenceMask;
import static com.ibm.wala.types.TypeReference.ArrayTypeCode;
import static com.ibm.wala.types.TypeReference.PointerTypeCode;
import static com.ibm.wala.types.TypeReference.ReferenceTypeCode;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;

import com.ibm.wala.classLoader.Language;
import com.ibm.wala.types.ClassLoaderReference;
import com.ibm.wala.types.MethodReference;
import com.ibm.wala.types.TypeName;
import com.ibm.wala.types.TypeReference;
import com.ibm.wala.util.collections.HashMapFactory;

/**
 * Some simple utilities used to manipulate Strings
 */
public class StringStuff {

  final private static HashMap<String, String> primitiveClassNames;

  static {
    primitiveClassNames = HashMapFactory.make(10);
    primitiveClassNames.put("int", "I");
    primitiveClassNames.put("long", "J");
    primitiveClassNames.put("short", "S");
    primitiveClassNames.put("byte", "B");
    primitiveClassNames.put("char", "C");
    primitiveClassNames.put("double", "D");
    primitiveClassNames.put("float", "F");
    primitiveClassNames.put("boolean", "Z");
    primitiveClassNames.put("void", "V");
  }

  public static void padWithSpaces(StringBuffer b, int length) {
    if (b == null) {
      throw new IllegalArgumentException("b is null");
    }
    if (b.length() < length) {
      for (int i = b.length(); i < length; i++) {
        b.append(" ");
      }
    }
  }

  /**
   * Translate a type from a deployment descriptor string into the internal JVM format
   * 
   * eg. [[java/lang/String
   * 
   * @throws IllegalArgumentException if dString is null
   */
  public static String deployment2CanonicalTypeString(String dString) {
    if (dString == null) {
      throw new IllegalArgumentException("dString is null");
    }
    dString = dString.replace('.', '/');
    int arrayIndex = dString.indexOf("[]");
    if (arrayIndex > -1) {
      String baseType = dString.substring(0, arrayIndex);
      int dim = (dString.length() - arrayIndex) / 2;
      baseType = deployment2CanonicalTypeString(baseType);
      StringBuffer result = new StringBuffer("[");
      for (int i = 1; i < dim; i++) {
        result.append("[");
      }
      result.append(baseType);
      return result.toString();
    } else {
      if (primitiveClassNames.get(dString) != null) {
        return primitiveClassNames.get(dString);
      } else {
        return "L" + dString;
      }
    }
  }

  /**
   * Translate a type from a deployment descriptor string into the type expected for use in a method descriptor
   * 
   * eg. [[Ljava.lang.String;
   * 
   * @throws IllegalArgumentException if dString is null
   */
  public static String deployment2CanonicalDescriptorTypeString(String dString) {
    if (dString == null) {
      throw new IllegalArgumentException("dString is null");
    }
    dString = dString.replace('.', '/');
    int arrayIndex = dString.indexOf("[]");
    if (arrayIndex > -1) {
      String baseType = dString.substring(0, arrayIndex);
      int dim = (dString.length() - arrayIndex) / 2;
      baseType = deployment2CanonicalDescriptorTypeString(baseType);
      StringBuffer result = new StringBuffer("[");
      for (int i = 1; i < dim; i++) {
        result.append("[");
      }
      result.append(baseType);
      return result.toString();
    } else {
      if (primitiveClassNames.get(dString) != null) {
        return primitiveClassNames.get(dString);
      } else {
        return "L" + dString + ";";
      }
    }
  }

  public static final TypeName parseForReturnTypeName(String desc) throws IllegalArgumentException {
    return parseForReturnTypeName(Language.JAVA, ImmutableByteArray.make(desc));
  }

  public static final TypeName parseForReturnTypeName(Language l, String desc) throws IllegalArgumentException {
    return parseForReturnTypeName(l, ImmutableByteArray.make(desc));
  }

  /**
   * Parse method descriptor to obtain description of method's return type. TODO: tune this .. probably combine with
   * parseForParameters.
   * 
   * @param b method descriptor - something like "(III)V"
   * @return type description
   * @throws IllegalArgumentException if b is null
   */
  public static final TypeName parseForReturnTypeName(Language l, ImmutableByteArray b) throws IllegalArgumentException {

    if (b == null) {
      throw new IllegalArgumentException("b is null");
    }
    if (b.length() <= 2) {
      throw new IllegalArgumentException("invalid descriptor: " + b);

    }
    if (b.get(0) != '(') {
      throw new IllegalArgumentException("invalid descriptor: " + b);
    }

    int i = 0;
    while (b.get(i++) != ')')
      ;
    if (b.length() < i + 1) {
      throw new IllegalArgumentException("invalid descriptor: " + b);
    }
    switch (b.get(i)) {
    case TypeReference.VoidTypeCode:
      return TypeReference.Void.getName();
    case TypeReference.BooleanTypeCode:
      return TypeReference.Boolean.getName();
    case TypeReference.ByteTypeCode:
      return TypeReference.Byte.getName();
    case TypeReference.ShortTypeCode:
      return TypeReference.Short.getName();
    case TypeReference.IntTypeCode:
      return TypeReference.Int.getName();
    case TypeReference.LongTypeCode:
      return TypeReference.Long.getName();
    case TypeReference.FloatTypeCode:
      return TypeReference.Float.getName();
    case TypeReference.DoubleTypeCode:
      return TypeReference.Double.getName();
    case TypeReference.CharTypeCode:
      return TypeReference.Char.getName();
    case TypeReference.OtherPrimitiveTypeCode:
      if (b.get(b.length() - 1) == ';') {
        return l.lookupPrimitiveType(new String(b.substring(i + 1, b.length() - i - 2)));
      } else {
        return l.lookupPrimitiveType(new String(b.substring(i + 1, b.length() - i - 1)));
      }
    case TypeReference.ClassTypeCode: // fall through
    case TypeReference.ArrayTypeCode:
      if (b.get(b.length() - 1) == ';') {
        return TypeName.findOrCreate(b, i, b.length() - i - 1);
      } else {
        return TypeName.findOrCreate(b, i, b.length() - i);
      }
    default:
      throw new IllegalArgumentException("unexpected type in descriptor " + b);
    }
  }

  public static final TypeName[] parseForParameterNames(String descriptor) throws IllegalArgumentException {
    return parseForParameterNames(Language.JAVA, ImmutableByteArray.make(descriptor));
  }

  public static final TypeName[] parseForParameterNames(Language l, String descriptor) throws IllegalArgumentException {
    return parseForParameterNames(l, ImmutableByteArray.make(descriptor));
  }

  /**
   * Parse method descriptor to obtain descriptions of method's parameters.
   * 
   * @return parameter descriptions, or null if there are no parameters
   * @throws IllegalArgumentException if b is null
   */
  public static final TypeName[] parseForParameterNames(Language l, ImmutableByteArray b) throws IllegalArgumentException {

    if (b == null) {
      throw new IllegalArgumentException("b is null");
    }
    if (b.length() <= 2) {
      throw new IllegalArgumentException("invalid descriptor: " + b);

    }
    if (b.get(0) != '(') {
      throw new IllegalArgumentException("invalid descriptor: " + b);
    }

    ArrayList<TypeName> sigs = new ArrayList<TypeName>(10);

    int i = 1;
    while (true) {
      switch (b.get(i++)) {
      case TypeReference.VoidTypeCode:
        sigs.add(TypeReference.VoidName);
        continue;
      case TypeReference.BooleanTypeCode:
        sigs.add(TypeReference.BooleanName);
        continue;
      case TypeReference.ByteTypeCode:
        sigs.add(TypeReference.ByteName);
        continue;
      case TypeReference.ShortTypeCode:
        sigs.add(TypeReference.ShortName);
        continue;
      case TypeReference.IntTypeCode:
        sigs.add(TypeReference.IntName);
        continue;
      case TypeReference.LongTypeCode:
        sigs.add(TypeReference.LongName);
        continue;
      case TypeReference.FloatTypeCode:
        sigs.add(TypeReference.FloatName);
        continue;
      case TypeReference.DoubleTypeCode:
        sigs.add(TypeReference.DoubleName);
        continue;
      case TypeReference.CharTypeCode:
        sigs.add(TypeReference.CharName);
        continue;
      case TypeReference.OtherPrimitiveTypeCode: {
        int off = i - 1;
        while (b.get(i++) != ';')
          ;
        sigs.add(l.lookupPrimitiveType(new String(b.substring(off + 1, i - off - 2))));

        continue;
      }
      case TypeReference.ClassTypeCode: {
        int off = i - 1;
        while (b.get(i++) != ';')
          ;
        sigs.add(TypeName.findOrCreate(b, off, i - off - 1));

        continue;
      }
      case TypeReference.ArrayTypeCode: 
      case TypeReference.PointerTypeCode: 
      case TypeReference.ReferenceTypeCode: {
        int off = i - 1;
        while (StringStuff.isTypeCodeChar(b, i)) {
           ++i;
        }
        TypeName T = null;
        byte c = b.get(i++);
        if (c == TypeReference.ClassTypeCode || c == TypeReference.OtherPrimitiveTypeCode) {
          while (b.get(i++) != ';')
            ;
          T = TypeName.findOrCreate(b, off, i - off - 1);
        } else {
          T = TypeName.findOrCreate(b, off, i - off);
        }
        sigs.add(T);

        continue;
      }
      case (byte) ')': // end of parameter list
        int size = sigs.size();
        if (size == 0) {
          return null;
        }
        Iterator<TypeName> it = sigs.iterator();
        TypeName[] result = new TypeName[size];
        for (int j = 0; j < size; j++) {
          result[j] = it.next();
        }
        return result;
      default:
        assert false : "bad descriptor " + b;
      }
    }
  }

  public static boolean isTypeCodeChar(ImmutableByteArray name, int i) {
    return name.b[i] == TypeReference.ArrayTypeCode || 
    name.b[i] == TypeReference.PointerTypeCode || 
    name.b[i] == TypeReference.ReferenceTypeCode;
  }
  
  /**
   * Given that name[start:start+length] is a Type name in JVM format, parse it for the package
   * 
   * @return an ImmutableByteArray that represents the package, or null if it's the unnamed package
   * @throws IllegalArgumentException if name == null
   */
  public static ImmutableByteArray parseForPackage(ImmutableByteArray name, int start, int length) throws IllegalArgumentException {
    try {
      if (name == null) {
        throw new IllegalArgumentException("name == null");
      }
      int lastSlash = -1;
      for (int i = start; i < start + length; i++) {
        if (name.b[i] == '/') {
          lastSlash = i;
        }
      }
      if (lastSlash == -1) {
        return null;
      }
      short dim = 0;
      while (isTypeCodeChar(name, start+dim)) {
        dim++;
      }
      return new ImmutableByteArray(name.b, start + 1 + dim, lastSlash - start - 1 - dim);
    } catch (ArrayIndexOutOfBoundsException e) {
      throw new IllegalArgumentException("invalid name " + name + " start: " + start + " length: " + length);
    }
  }

  /**
   * Given that name[start:start+length] is a Type name in JVM format, parse it for the package
   * 
   * @return an ImmutableByteArray that represents the package, or null if it's the unnamed package
   * @throws IllegalArgumentException if name is null
   */
  public static ImmutableByteArray parseForPackage(ImmutableByteArray name) {
    if (name == null) {
      throw new IllegalArgumentException("name is null");
    }
    return parseForPackage(name, 0, name.length());
  }

  /**
   * Given that name[start:start+length] is a Type name in JVM format, strip the package and return the "package-free" class name
   * 
   * TODO: inefficient; needs tuning.
   * 
   * @return an ImmutableByteArray that represents the package, or null if it's the unnamed package
   * @throws IllegalArgumentException if name is null or malformed
   */
  public static ImmutableByteArray parseForClass(ImmutableByteArray name, int start, int length) throws IllegalArgumentException {
    if (name == null) {
      throw new IllegalArgumentException("name is null");
    }
    if (name.length() == 0) {
      throw new IllegalArgumentException("invalid class name: zero length");
    }
    try {
      if (parseForPackage(name, start, length) == null) {
        while (isTypeCodeChar(name, start)) {
          start++;
          length--;
        }
        if (name.b[start] == 'L') {
          start++;
          length--;
        }
        return new ImmutableByteArray(name.b, start, length);
      } else {
        int lastSlash = 0;
        for (int i = start; i < start + length; i++) {
          if (name.b[i] == '/') {
            lastSlash = i;
          }
        }
        int L = length - (lastSlash - start + 1);
        return new ImmutableByteArray(name.b, lastSlash + 1, L);
      }
    } catch (ArrayIndexOutOfBoundsException e) {
      throw new IllegalArgumentException("Malformed name: " + name + " " + start + " " + length);
    }
  }

  /**
   * Given that name[start:start+length] is a Type name in JVM format, strip the package and return the "package-free" class name
   * 
   * @return an ImmutableByteArray that represents the package, or null if it's the unnamed package
   * @throws IllegalArgumentException if name is null
   */
  public static ImmutableByteArray parseForClass(ImmutableByteArray name) throws IllegalArgumentException {
    if (name == null) {
      throw new IllegalArgumentException("name is null");
    }
    return parseForClass(name, 0, name.length());
  }

  /**
   * Parse an array descriptor to obtain number of dimensions in corresponding array type. b: descriptor - something like
   * "[Ljava/lang/String;" or "[[I"
   * 
   * @return dimensionality - something like "1" or "2"
   * @throws IllegalArgumentException if b == null
   */
  public static int parseForArrayDimensionality(ImmutableByteArray b, int start, int length) throws IllegalArgumentException,
      IllegalArgumentException {

    if (b == null) {
      throw new IllegalArgumentException("b == null");
    }
    try {
      int code = 0;
      for (int i = start; i < start + length; ++i) {
        if (isTypeCodeChar(b, i)) {
           code <<= ElementBits;
           switch (b.b[i]) {
           case ArrayTypeCode: code |= ArrayMask; break;
           case PointerTypeCode: code |= PointerMask; break;
           case ReferenceTypeCode: code |= ReferenceMask; break;
           default:
             throw new IllegalArgumentException("ill-formed array descriptor " + b);
           }
        } else {
          // type codes must be at the start of the descriptor; if we see something else, stop
          break;
        }
      }
      return code;
    } catch (ArrayIndexOutOfBoundsException e) {
      throw new IllegalArgumentException("ill-formed array descriptor " + b);
    }
  }

  /**
   * Parse an array descriptor to obtain number of dimensions in corresponding array type. b: descriptor - something like
   * "[Ljava/lang/String;" or "[[I"
   * 
   * @return dimensionality - something like "Ljava/lang/String;" or "I"
   * @throws IllegalArgumentException if b is null
   */
  public static ImmutableByteArray parseForInnermostArrayElementDescriptor(ImmutableByteArray b, int start, int length) {

    if (b == null) {
      throw new IllegalArgumentException("b is null");
    }
    try {
      int i = start;
      for (; i < start + length; ++i) {
        if (! isTypeCodeChar(b, i)) {
          break;
        }
      }
      return new ImmutableByteArray(b.b, i, length - (i - start));
    } catch (ArrayIndexOutOfBoundsException e) {
      throw new IllegalArgumentException("invalid element desciptor: " + b);
    }
  }

  /**
   * Parse an array descriptor to obtain number of dimensions in corresponding array type. b: descriptor - something like
   * "[Ljava/lang/String;" or "[[I"
   * 
   * @return dimensionality - something like "Ljava/lang/String;" or "I"
   * @throws IllegalArgumentException if a is null
   */
  public static ImmutableByteArray parseForInnermostArrayElementDescriptor(Atom a) {
    if (a == null) {
      throw new IllegalArgumentException("a is null");
    }
    ImmutableByteArray b = new ImmutableByteArray(a.getValArray());
    return parseForInnermostArrayElementDescriptor(b, 0, b.length());
  }

  /**
   * @return true iff the class returned by parseForClass is primitive
   * @throws IllegalArgumentException if name is null
   */
  public static boolean classIsPrimitive(ImmutableByteArray name, int start, int length) throws IllegalArgumentException {
    if (name == null) {
      throw new IllegalArgumentException("name is null");
    }
    try {
      while (length > 0 && isTypeCodeChar(name, start)) {
        start++;
        length--;
      }
      if (start >= name.b.length) {
        throw new IllegalArgumentException("ill-formed type name: " + name);
      }

      return name.b[start] != 'L';
    } catch (ArrayIndexOutOfBoundsException e) {
      throw new IllegalArgumentException(name.toString());
    }
  }

  /**
   * @param methodSig something like "java_cup.lexer.advance()V"
   * @throws IllegalArgumentException if methodSig is null
   */
  public static MethodReference makeMethodReference(String methodSig) throws IllegalArgumentException {
    return makeMethodReference(Language.JAVA, methodSig);
  }

  public static MethodReference makeMethodReference(Language l, String methodSig) throws IllegalArgumentException {
    if (methodSig == null) {
      throw new IllegalArgumentException("methodSig is null");
    }
    if (methodSig.lastIndexOf('.') < 0) {
      throw new IllegalArgumentException("ill-formed sig " + methodSig);
    }
    String type = methodSig.substring(0, methodSig.lastIndexOf('.'));
    type = deployment2CanonicalTypeString(type);
    TypeReference t = TypeReference.findOrCreate(ClassLoaderReference.Application, type);

    String methodName = methodSig.substring(methodSig.lastIndexOf('.') + 1, methodSig.indexOf('('));
    String desc = methodSig.substring(methodSig.indexOf('('));

    return MethodReference.findOrCreate(l, t, methodName, desc);
  }

  /**
   * Convert a JVM encoded type name to a readable type name.
   * 
   * @param jvmType a String containing a type name in JVM internal format.
   * @return the same type name in readable (source code) format.
   * @throws IllegalArgumentException if jvmType is null
   */
  public static String jvmToReadableType(final String jvmType) throws IllegalArgumentException {
    if (jvmType == null) {
      throw new IllegalArgumentException("jvmType is null");
    }
    StringBuffer readable = new StringBuffer(); // human readable version
    int numberOfDimensions = 0; // the number of array dimensions

    if (jvmType.length() == 0) {
      throw new IllegalArgumentException("ill-formed type : " + jvmType);
    }

    // cycle through prefixes of '['
    char prefix = jvmType.charAt(0);
    while (prefix == '[') {
      numberOfDimensions++;
      prefix = jvmType.charAt(numberOfDimensions);
    }
    if (prefix == 'V') {
      readable.append("void");
    } else if (prefix == 'B') {
      readable.append("byte");
    } else if (prefix == 'C') {
      readable.append("char");
    } else if (prefix == 'D') {
      readable.append("double");
    } else if (prefix == 'F') {
      readable.append("float");
    } else if (prefix == 'I') {
      readable.append("int");
    } else if (prefix == 'J') {
      readable.append("long");
    } else if (prefix == 'S') {
      readable.append("short");
    } else if (prefix == 'Z') {
      readable.append("boolean");
    } else if (prefix == 'L') {
      readable.append(jvmType.substring(numberOfDimensions + 1, // strip
          // all
          // leading
          // '[' &
          // 'L'
          jvmType.length()) // Trim off the trailing ';'
          );
      // Convert to standard Java dot-notation
      readable = new StringBuffer(slashToDot(readable.toString()));
      readable = new StringBuffer(dollarToDot(readable.toString()));
    }
    // append trailing "[]" for each array dimension
    for (int i = 0; i < numberOfDimensions; ++i) {
      readable.append("[]");
    }
    return readable.toString();
  }

  /**
   * Convert a JVM encoded type name to a binary type name. This version does not call dollarToDot.
   * 
   * @param jvmType a String containing a type name in JVM internal format.
   * @return the same type name in readable (source code) format.
   * @throws IllegalArgumentException if jvmType is null
   */
  public static String jvmToBinaryName(String jvmType) throws IllegalArgumentException {
    if (jvmType == null) {
      throw new IllegalArgumentException("jvmType is null");
    }
    StringBuffer readable = new StringBuffer(); // human readable version
    int numberOfDimensions = 0; // the number of array dimensions

    if (jvmType.length() == 0) {
      throw new IllegalArgumentException("ill-formed type : " + jvmType);
    }

    // cycle through prefixes of '['
    char prefix = jvmType.charAt(0);
    while (prefix == '[') {
      numberOfDimensions++;
      prefix = jvmType.charAt(numberOfDimensions);
    }
    if (prefix == 'V') {
      readable.append("void");
    } else if (prefix == 'B') {
      readable.append("byte");
    } else if (prefix == 'C') {
      readable.append("char");
    } else if (prefix == 'D') {
      readable.append("double");
    } else if (prefix == 'F') {
      readable.append("float");
    } else if (prefix == 'I') {
      readable.append("int");
    } else if (prefix == 'J') {
      readable.append("long");
    } else if (prefix == 'S') {
      readable.append("short");
    } else if (prefix == 'Z') {
      readable.append("boolean");
    } else if (prefix == 'L') {
      readable.append(jvmType.substring(numberOfDimensions + 1, // strip
          // all
          // leading
          // '[' &
          // 'L'
          jvmType.length()) // Trim off the trailing ';'
          );
      // Convert to standard Java dot-notation
      readable = new StringBuffer(slashToDot(readable.toString()));
    }
    // append trailing "[]" for each array dimension
    for (int i = 0; i < numberOfDimensions; ++i) {
      readable.append("[]");
    }
    return readable.toString();
  }

  /**
   * Convert '/' to '.' in names.
   * 
   * @return a String object obtained by replacing the forward slashes ('/') in the String passed as argument with ('.').
   * @throws IllegalArgumentException if path is null
   */
  public static String slashToDot(String path) {
    if (path == null) {
      throw new IllegalArgumentException("path is null");
    }
    StringBuffer dotForm = new StringBuffer(path);
    // replace all '/' in the path with '.'
    for (int i = 0; i < dotForm.length(); ++i) {
      if (dotForm.charAt(i) == '/') {
        dotForm.setCharAt(i, '.'); // replace '/' with '.'
      }
    }
    return dotForm.toString();
  }

  /**
   * Convert '$' to '.' in names.
   * 
   * @param path a string object in which dollar signs('$') must be converted to dots ('.').
   * @return a String object obtained by replacing the dollar signs ('S') in the String passed as argument with ('.').
   * @throws IllegalArgumentException if path is null
   */
  public static String dollarToDot(String path) {
    if (path == null) {
      throw new IllegalArgumentException("path is null");
    }
    StringBuffer dotForm = new StringBuffer(path);
    // replace all '$' in the path with '.'
    for (int i = 0; i < dotForm.length(); ++i) {
      if (dotForm.charAt(i) == '$') {
        dotForm.setCharAt(i, '.'); // replace '$' with '.'
      }
    }
    return dotForm.toString();
  }

  /**
   * Convert '.' to '$' in names.
   * 
   * @param path String object in which dollar signs('$') must be converted to dots ('.').
   * @return a String object obtained by replacing the dollar signs ('S') in the String passed as argument with ('.').
   * @throws IllegalArgumentException if path is null
   */
  public static String dotToDollar(String path) {
    if (path == null) {
      throw new IllegalArgumentException("path is null");
    }
    StringBuffer dotForm = new StringBuffer(path);
    // replace all '.' in the path with '$'
    for (int i = 0; i < dotForm.length(); ++i) {
      if (dotForm.charAt(i) == '.') {
        dotForm.setCharAt(i, '$'); // replace '$' with '.'
      }
    }
    return dotForm.toString();
  }

}
