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

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

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaModel;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IPackageDeclaration;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.ITypeParameter;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.NodeFinder;
import org.eclipse.jdt.core.search.IJavaSearchConstants;
import org.eclipse.jdt.core.search.IJavaSearchScope;
import org.eclipse.jdt.core.search.SearchEngine;
import org.eclipse.jdt.core.search.SearchMatch;
import org.eclipse.jdt.core.search.SearchParticipant;
import org.eclipse.jdt.core.search.SearchPattern;
import org.eclipse.jdt.core.search.SearchRequestor;
import org.eclipse.jface.viewers.StructuredSelection;

import com.ibm.wala.types.TypeReference;
import com.ibm.wala.util.collections.HashSetFactory;

/**
 * Convenience methods to get information from JDT {@link IJavaElement} model.
 */
public class JdtUtil {

  public static String getFilePath(IJavaElement javaElt) {
    if (javaElt == null) {
      throw new IllegalArgumentException("javaElt is null");
    }
    try {
      IPath p = javaElt.getPath();
      if (p == null) {
        throw new IllegalArgumentException("javaElt has null path");
      }
      String filePath = p.toString();
      return filePath;
    } catch (Exception e) {
      throw new IllegalArgumentException("malformed javaElt: " + javaElt, e);
    }
  }

  public static String getPackageName(ICompilationUnit cu) {
    if (cu == null) {
      throw new IllegalArgumentException("cu is null");
    }
    try {
      IPackageDeclaration[] pkgDecl = cu.getPackageDeclarations();

      // TODO: handle default package?
      if (pkgDecl != null && pkgDecl.length > 0) {
        String packageName = pkgDecl[0].getElementName();
        return packageName;
      }
    } catch (JavaModelException e) {

    }
    return "";

  }

  public static String getFullyQualifiedClassName(IType type) {
    if (type == null) {
      throw new IllegalArgumentException("type is null");
    }
    ICompilationUnit cu = (ICompilationUnit) type.getParent();
    String packageName = getPackageName(cu);
    String className = type.getElementName();
    String fullyQName = packageName + "." + className;
    return fullyQName;
  }

  public static String getClassName(IType type) {
    if (type == null) {
      throw new IllegalArgumentException("type is null");
    }
    String className = type.getElementName();
    return className;
  }

  /**
   * Return a unique string representing the specified Java element across projects in the workspace. The returned string can be
   * used as a handle to create JavaElement by 'JavaCore.create(String)'
   * 
   * For example, suppose we have the method 'fooPackage.barPackage.FooClass.fooMethod(int)' which is in the 'FooProject' and source
   * folder 'src' the handle would be '=FooProject/src<fooPackage.barPackage{FooClass.java[FooClass~fooMethod~I'
   * 
   * @param javaElt
   * @throws IllegalArgumentException if javaElt is null
   */
  public static String getJdtHandleString(IJavaElement javaElt) {
    if (javaElt == null) {
      throw new IllegalArgumentException("javaElt is null");
    }
    return javaElt.getHandleIdentifier();
  }

  @Deprecated
  public static IJavaElement createJavaElementFromJdtHandle(String jdtHandle) {
    return JavaCore.create(jdtHandle);
  }

  public static IType[] getClasses(ICompilationUnit cu) {
    if (cu == null) {
      throw new IllegalArgumentException("cu is null");
    }
    try {
      return cu.getAllTypes();
    } catch (JavaModelException e) {
    }
    return null;
  }

  public static IJavaProject getProject(IJavaElement javaElt) {
    if (javaElt == null) {
      throw new IllegalArgumentException("javaElt is null");
    }
    IJavaProject javaProject = javaElt.getJavaProject();
    return javaProject;
  }

  public static String getProjectName(IJavaProject javaProject) {
    if (javaProject == null) {
      throw new IllegalArgumentException("javaProject is null");
    }
    return javaProject.getElementName();
  }

  /**
   * @param typeSignature Some of the type signatures examples are "QString;" (String) and "I" (int) The type signatures may be
   *          either unresolved (for source types) or resolved (for binary types), and either basic (for basic types) or rich (for
   *          parameterized types). See {@link Signature} for details.
   */
  public static String getHumanReadableType(String typeSignature) {
    String simpleName = Signature.getSignatureSimpleName(typeSignature);
    return simpleName;
  }

  public static IJavaProject getJavaProject(IFile appJar) {
    if (appJar == null) {
      throw new IllegalArgumentException("appJar is null");
    }
    String projectName = appJar.getProject().getName();
    return getJavaProject(projectName);
  }

  public static IJavaProject getJavaProject(String projectName) {
    if (projectName == null) {
      throw new IllegalArgumentException("null projectName");
    }
    IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
    IJavaModel javaModel = JavaCore.create(workspaceRoot);
    IJavaProject javaProject = javaModel.getJavaProject(projectName);
    return javaProject;
  }

  /**
   * compute the java projects in the active workspace
   */
  public static Collection<IJavaProject> getWorkspaceJavaProjects() {
    Collection<IJavaProject> result = HashSetFactory.make();
    IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();

    for (IProject p : workspaceRoot.getProjects()) {
      try {
        if (p.hasNature(JavaCore.NATURE_ID)) {
          IJavaProject jp = JavaCore.create(p);
          if (jp != null) {
            result.add(jp);
          }
        }
      } catch (CoreException e) {
        // do nothing
      }
    }
    return result;
  }

  /**
   * Find the {@link IType} in the workspace corresponding to a class name.
   * 
   * @return null if not found
   * @throws IllegalArgumentException if projects == null
   */
  public static IType findJavaClassInProjects(String fullyQualifiedName, Collection<IJavaProject> projects)
      throws IllegalArgumentException {
    if (projects == null) {
      throw new IllegalArgumentException("projects == null");
    }
    for (IJavaProject project : projects) {
      try {
        IType t = project.findType(fullyQualifiedName);
        if (t != null) {
          return t;
        }
      } catch (JavaModelException e) {
        e.printStackTrace();
      }
    }
    System.err.println("failed to find " + fullyQualifiedName);
    return null;
    // IJavaElement[] arr = new IJavaElement[projects.size()];
    // projects.toArray(arr);
    // IJavaSearchScope scope = SearchEngine.createJavaSearchScope(arr, false);
    //
    // return searchForJavaClass(className, scope);
  }

  public static IType findJavaClassInResources(String className, Collection<IResource> resources) {
    if (resources == null) {
      throw new IllegalArgumentException("null resources");
    }
    Collection<IJavaProject> projects = HashSetFactory.make();
    for (IResource r : resources) {
      projects.add(JavaCore.create(r).getJavaProject());
    }
    return findJavaClassInProjects(className, projects);
  }

  // private static IType searchForJavaClass(String className, IJavaSearchScope scope) {
  // SearchPattern p = SearchPattern.createPattern(className, IJavaSearchConstants.CLASS_AND_INTERFACE,
  // IJavaSearchConstants.DECLARATIONS, SearchPattern.R_EXACT_MATCH);
  // SearchEngine engine = new SearchEngine();
  // final Collection<IJavaElement> kludge = HashSetFactory.make();
  // SearchRequestor requestor = new SearchRequestor() {
  //
  // @Override
  // public void acceptSearchMatch(SearchMatch match) throws CoreException {
  // kludge.add((IJavaElement) match.getElement());
  // }
  //
  // };
  // try {
  // engine.search(p, new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() }, scope, requestor, null);
  // } catch (CoreException e) {
  // e.printStackTrace();
  // }
  // if (kludge.size() == 1) {
  // System.err.println("Found " + className);
  // return (IType) kludge.iterator().next();
  // } else {
  // System.err.println("Failed to find " + className + " " + kludge.size());
  // return null;
  // }
  // }

  /**
   * Find the IMethod in the workspace corresponding to a method selector.
   * 
   * TODO: this is way too slow. figure out something better.
   * 
   * @return null if not found
   */
  public static IMethod findJavaMethodInProjects(String klass, String selector, Collection<IJavaProject> projects) {

    if (klass == null) {
      throw new IllegalArgumentException("null klass");
    }
    if (projects == null) {
      throw new IllegalArgumentException("null projects");
    }
    IType type = null;
    try {
      type = findJavaClassInProjects(klass, projects);
    } catch (Throwable t) {
      return null;
    }
    if (type == null) {
      return null;
    }
    String name = parseForName(selector, type);
    String[] paramTypes = parseForParameterTypes(selector);
    IMethod m = type.getMethod(name, paramTypes);
    IMethod[] methods = type.findMethods(m);
    if (methods != null && methods.length == 1) {
      return methods[0];
    } else {
      // methods is null. probably got screwed by generics.
      // i spent 5 hours trying to figure out how to fix this correctly
      // and failed. implementing a miserable hack instead.
      // Need to consult a guru to figure out how to do this.
      try {
        List<IMethod> matches = new ArrayList<IMethod>();
        Collection<String> typeParameterNames = getTypeParameterNames(type);
        METHODS: for (IMethod x : type.getMethods()) {
          if (x.getElementName().equals(name)) {
            if (x.getParameterTypes().length == paramTypes.length) {
              for (int i = 0; i < x.getParameterTypes().length; i++) {
                String s1 = Signature.getTypeErasure(Signature.getSignatureSimpleName(x.getParameterTypes()[i]));
                String s2 = Signature.getTypeErasure(Signature.getSignatureSimpleName(paramTypes[i]));
                if (typeParameterNames.contains(s1)) {
                  // s1 is a type parameter to the class. optimistically assume
                  // the types match.
                } else {
                  if (!s1.equals(s2)) {
                    // no match
                    continue METHODS;
                  }
                }
              }
              matches.add(x);
            }
          }
        }
        if (matches.size() == 1) {
          return matches.get(0);
        } else {
          System.err.println("findJavaMethodInWorkspace FAILED TO MATCH " + m);
          return null;
        }
      } catch (JavaModelException e) {
        e.printStackTrace();
        return null;
      }
    }
  }

  public static Collection<String> getTypeParameterNames(IType type) throws IllegalArgumentException, JavaModelException {
    if (type == null) {
      throw new IllegalArgumentException("type == null");
    }
    ITypeParameter[] tp = type.getTypeParameters();
    Collection<String> typeParameterNames = HashSetFactory.make(tp.length);
    for (ITypeParameter p : tp) {
      typeParameterNames.add(p.getElementName());
    }
    return typeParameterNames;
  }

  public static String parseForName(String selector, IType type) {
    if (selector == null) {
      throw new IllegalArgumentException("selector is null");
    }
    try {
      String result = selector.substring(0, selector.indexOf('('));
      if (result.equals("<init>")) {
        return type.getElementName();
      } else {
        return result;
      }
    } catch (StringIndexOutOfBoundsException e) {
      throw new IllegalArgumentException("invalid selector: " + selector);
    }
  }

  public static final String[] parseForParameterTypes(String selector) throws IllegalArgumentException {

    try {
      if (selector == null) {
        throw new IllegalArgumentException("selector is null");
      }
      String d = selector.substring(selector.indexOf('('));
      if (d.length() <= 2) {
        throw new IllegalArgumentException("invalid descriptor: " + d);

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

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

      int i = 1;
      while (true) {
        switch (d.charAt(i++)) {
        case TypeReference.VoidTypeCode:
          sigs.add(TypeReference.VoidName.toString());
          continue;
        case TypeReference.BooleanTypeCode:
          sigs.add(TypeReference.BooleanName.toString());
          continue;
        case TypeReference.ByteTypeCode:
          sigs.add(TypeReference.ByteName.toString());
          continue;
        case TypeReference.ShortTypeCode:
          sigs.add(TypeReference.ShortName.toString());
          continue;
        case TypeReference.IntTypeCode:
          sigs.add(TypeReference.IntName.toString());
          continue;
        case TypeReference.LongTypeCode:
          sigs.add(TypeReference.LongName.toString());
          continue;
        case TypeReference.FloatTypeCode:
          sigs.add(TypeReference.FloatName.toString());
          continue;
        case TypeReference.DoubleTypeCode:
          sigs.add(TypeReference.DoubleName.toString());
          continue;
        case TypeReference.CharTypeCode:
          sigs.add(TypeReference.CharName.toString());
          continue;
        case TypeReference.ArrayTypeCode: {
          int off = i - 1;
          while (d.charAt(i) == TypeReference.ArrayTypeCode) {
            ++i;
          }
          if (d.charAt(i++) == TypeReference.ClassTypeCode) {
            while (d.charAt(i++) != ';')
              ;
            sigs.add(d.substring(off, i).replaceAll("/", "."));
          } else {
            sigs.add(d.substring(off, i));
          }
          continue;
        }
        case (byte) ')': // end of parameter list
          return toArray(sigs);
        default: {
          // a class
          int off = i - 1;
          char c;
          do {
            c = d.charAt(i++);
          } while (c != ',' && c != ')');
          sigs.add("L" + d.substring(off, i - 1) + ";");

          if (c == ')') {
            return toArray(sigs);
          }

          continue;
        }
        }
      }
    } catch (StringIndexOutOfBoundsException e) {
      throw new IllegalArgumentException("error parsing selector " + selector);
    }
  }

  private static String[] toArray(ArrayList<String> sigs) {
    int size = sigs.size();
    if (size == 0) {
      return new String[0];
    }
    Iterator<String> it = sigs.iterator();
    String[] result = new String[size];
    for (int j = 0; j < size; j++) {
      result[j] = it.next();
    }
    return result;
  }

  /**
   * Find the IMethod in the workspace corresponding to a method signature.
   * 
   * This doesn't work for elements declared in inner classes. It's possible this is a 3.2 bug fixed in 3.3
   * 
   * @return null if not found
   */
  @Deprecated
  public static IMethod findJavaMethodInWorkspaceBrokenForInnerClasses(String methodSig) {
    // dammit ... this doesn't work for inner classes.

    System.err.println("Search for " + methodSig);
    SearchPattern p = SearchPattern.createPattern(methodSig, IJavaSearchConstants.METHOD, IJavaSearchConstants.DECLARATIONS,
        SearchPattern.R_EXACT_MATCH);
    IJavaSearchScope scope = SearchEngine.createWorkspaceScope();
    SearchEngine engine = new SearchEngine();
    final Collection<IJavaElement> kludge = HashSetFactory.make();
    SearchRequestor requestor = new SearchRequestor() {

      @Override
      public void acceptSearchMatch(SearchMatch match) throws CoreException {
        kludge.add((IJavaElement) match.getElement());
      }

    };
    try {
      engine.search(p, new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() }, scope, requestor, null);
    } catch (CoreException e) {
      e.printStackTrace();
    }
    if (kludge.size() == 1) {
      return (IMethod) kludge.iterator().next();
    } else {
      System.err.println("RETURNED " + kludge.size() + " " + kludge);
      return null;
    }
  }

  /**
   * Use the search engine to find all methods in a java element
   */
  public static Collection<IMethod> findMethods(IJavaElement elt) {

    if (elt instanceof ICompilationUnit) {
      Collection<IMethod> result = HashSetFactory.make();
      for (IType type : getClasses((ICompilationUnit) elt)) {
        try {
          for (IMethod m : type.getMethods()) {
            result.add(m);
          }
        } catch (JavaModelException e) {
          e.printStackTrace();
        }
      }
      return result;
    } else {
      final Collection<IMethod> result = HashSetFactory.make();
      SearchPattern p = SearchPattern.createPattern("*", IJavaSearchConstants.METHOD, IJavaSearchConstants.DECLARATIONS,
          SearchPattern.R_PATTERN_MATCH);
      SearchPattern p2 = SearchPattern.createPattern("*", IJavaSearchConstants.CONSTRUCTOR, IJavaSearchConstants.DECLARATIONS,
          SearchPattern.R_PATTERN_MATCH);
      IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { elt }, IJavaSearchScope.SOURCES);
      SearchEngine engine = new SearchEngine();
      SearchRequestor requestor = new SearchRequestor() {
        @Override
        public void acceptSearchMatch(SearchMatch match) throws CoreException {
          if (match.getElement() instanceof IMethod) {
            result.add((IMethod) match.getElement());
          }
        }
      };
      try {
        engine.search(p, new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() }, scope, requestor, null);
        engine.search(p2, new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() }, scope, requestor, null);
      } catch (CoreException e) {
        e.printStackTrace();
      }

      return result;
    }
  }

  /**
   * get a {@link StructuredSelection} corresponding to the named projects
   */
  public static StructuredSelection getStructuredSelectionForProjectNames(Collection<String> projectNames) {
    if (projectNames == null) {
      throw new IllegalArgumentException("null projectNames");
    }
    Object[] projects = new Object[projectNames.size()];
    int i = 0;
    for (String projectName : projectNames) {
      projects[i++] = getJavaProject(projectName);
    }
    StructuredSelection selection = new StructuredSelection(projects);
    return selection;
  }

  public static IJavaProject getNamedProject(String projectName) {
    IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
    IJavaModel javaModel = JavaCore.create(workspaceRoot);
    IJavaProject helloWorldProject = javaModel.getJavaProject(projectName);
    return helloWorldProject;
  }

  public static ASTNode getAST(IFile javaSourceFile) {
	  ASTParser parser = ASTParser.newParser(AST.JLS3);
	  parser.setSource(JavaCore.createCompilationUnitFrom(javaSourceFile));
	  parser.setProject(JavaCore.create(javaSourceFile.getProject()));
	  parser.setResolveBindings(true);
	  return parser.createAST(new NullProgressMonitor());
  }
  
  public static ASTNode getOriginalNode(JdtPosition pos) {
	  ASTNode root = getAST(pos.getEclipseFile());
	  return getOriginalNode(root, pos);
  }

  public static ASTNode getOriginalNode(ASTNode root, JdtPosition pos) {
	  	return NodeFinder.perform(root, pos.getFirstOffset(), pos.getLastOffset()-pos.getFirstOffset());
  }
  
}
