/*
 * Copyright 2008 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.gwt.tools.apichecker;

import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.NotFoundException;
import com.google.gwt.core.ext.typeinfo.TypeOracle;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * {@link ApiDiffGenerator} encapsulates a class that produces the diff between
 * two api's.
 */
public final class ApiDiffGenerator {

  private static enum Relation {
    NONE, SUBCLASS, SUPERCLASS;
  }

  public static final String DELIMITER = " ";

  /* variable just for debugging -- find why an apiChange is being removed */
  static final String HAY_API_CHANGE = "";

  /**
   * The two types might belong to different typeOracles.
   */
  static boolean isFirstTypeAssignableToSecond(JType firstType, JType secondType) {

    // getJNISignature() does TypeErasure
    if (firstType.getJNISignature().equals(secondType.getJNISignature())) {
      return true;
    }
    JClassType classType1 = firstType.isClassOrInterface();
    JClassType classType2 = secondType.isClassOrInterface();
    if (classType1 == null || classType2 == null) {
      return false;
    }
    TypeOracle newApiTypeOracle = classType2.getOracle();
    // get the appropriate classObject in the newApi
    JClassType firstClassType = newApiTypeOracle.findType(classType1.getQualifiedSourceName());
    JClassType secondClassType = newApiTypeOracle.findType(classType2.getQualifiedSourceName());
    // The types might not necessarily exist in the newApi
    if (firstClassType == null || secondClassType == null) {
      return false;
    }
    return firstClassType.isAssignableTo(secondClassType);
  }

  static Set<String> removeIntersection(Set<String> s1, Set<String> s2) {
    Set<String> intersection = new HashSet<String>(s1);
    intersection.retainAll(s2);
    s1.removeAll(intersection);
    s2.removeAll(intersection);
    return intersection;
  }

  Map<String, ApiPackageDiffGenerator> intersectingPackages = new HashMap<String, ApiPackageDiffGenerator>();
  Set<String> missingPackageNames;

  final ApiContainer newApi;

  final ApiContainer oldApi;

  ApiDiffGenerator(ApiContainer newApi, ApiContainer oldApi) {
    this.newApi = newApi;
    this.oldApi = oldApi;
  }

  ApiClassDiffGenerator findApiClassDiffGenerator(String className) {
    int i = className.length() - 1;
    while (i >= 0) {
      int dot = className.lastIndexOf('.', i);
      String pkgName = "";
      String typeName = className;
      if (dot != -1) {
        pkgName = className.substring(0, dot);
        typeName = className.substring(dot + 1);
        i = dot - 1;
      } else {
        i = -1;
      }
      ApiClassDiffGenerator result = findApiClassDiffGenerator(pkgName,
          typeName);
      if (result != null) {
        return result;
      }
    }
    return null;
  }

  // TODO(amitmanjhi): cache the results
  /**
   * Finds a type given its package-relative name. For nested classes, use its
   * source name rather than its binary name (that is, use a "." rather than a
   * "$").
   * 
   * @return <code>null</code> if the type is not found
   */
  ApiClassDiffGenerator findApiClassDiffGenerator(String pkgName,
      String typeName) {
    ApiPackageDiffGenerator pkg = findApiPackageDiffGenerator(pkgName);
    if (pkg != null) {
      ApiClassDiffGenerator type = pkg.findApiClassDiffGenerator(pkgName + "."
          + typeName);
      if (type != null) {
        return type;
      }
    }
    return null;
  }

  ApiPackageDiffGenerator findApiPackageDiffGenerator(String key) {
    return intersectingPackages.get(key);
  }

  Collection<ApiChange> getApiDiff() throws NotFoundException {

    computeApiDiff();

    Collection<ApiChange> collection = new ArrayList<ApiChange>();
    Set<ApiPackage> missingPackages = oldApi.getApiPackagesBySet(missingPackageNames);
    for (ApiPackage missingPackage : missingPackages) {
      collection.add(new ApiChange(missingPackage, ApiChange.Status.MISSING));
    }
    for (ApiPackageDiffGenerator intersectingPackage : intersectingPackages.values()) {
      collection.addAll(intersectingPackage.getApiDiff());
    }
    return collection;
  }

  ApiContainer getNewApiContainer() {
    return newApi;
  }

  ApiContainer getOldApiContainer() {
    return oldApi;
  }

  /**
   * Remove any apiChange x if there is another apiChange y such that the
   * apiElement and status for both x and y are the same and the apiClass for x
   * is a subclass of the apiClass for y.
   * 
   * @param originalCollection collection with duplicates.
   * @return collection minus duplicates.
   */
  Collection<ApiChange> removeDuplicates(
      Collection<ApiChange> originalCollection) {
    /*
     * Map from the hashCode of an apiChange to the list of ApiChanges. There
     * can be multiple ApiChanges that have the same hashCode, but neither is a
     * subset of another. Example: if B and C both extend A, and there is an
     * ApiChange in B and C due to an api element of A.
     */
    Map<Integer, Collection<ApiChange>> apiChangeMap = new HashMap<Integer, Collection<ApiChange>>();
    for (ApiChange apiChange : originalCollection) {
      String apiChangeStr = apiChange.getApiElement().getRelativeSignature();
      Collection<ApiChange> apiChangesSameHashCode = apiChangeMap.get(apiChange.hashCodeForDuplication());
      if (apiChangesSameHashCode == null) {
        apiChangesSameHashCode = new HashSet<ApiChange>();
        apiChangeMap.put(apiChange.hashCodeForDuplication(),
            apiChangesSameHashCode);
      }
      Collection<ApiChange> apiChangesToRemove = new HashSet<ApiChange>();
      boolean addNewElement = true;

      for (ApiChange oldApiChange : apiChangesSameHashCode) {
        String oldApiChangeStr = oldApiChange.getApiElement().getRelativeSignature();
        Relation relation = getRelationOfApiClassOfFirstArgToThatOfSecond(
            apiChange.getApiElement(), oldApiChange.getApiElement());
        if (relation == Relation.SUPERCLASS) {
          apiChangesToRemove.add(oldApiChange);
          if (ApiCompatibilityChecker.DEBUG_DUPLICATE_REMOVAL
              && oldApiChangeStr.indexOf(HAY_API_CHANGE) != -1) {
            System.out.println(oldApiChangeStr + " replaced by " + apiChangeStr
                + ", status = " + oldApiChange.getStatus());
          }
        } else if (relation == Relation.SUBCLASS) {
          addNewElement = false;
          if (ApiCompatibilityChecker.DEBUG_DUPLICATE_REMOVAL
              && apiChangeStr.indexOf(HAY_API_CHANGE) != -1) {
            System.out.println(apiChangeStr + " replaced by " + oldApiChangeStr);
          }
        }
      }
      apiChangesSameHashCode.removeAll(apiChangesToRemove);
      if (addNewElement) {
        apiChangesSameHashCode.add(apiChange);
      }
    }
    Collection<ApiChange> prunedCollection = new HashSet<ApiChange>();
    for (Collection<ApiChange> changes : apiChangeMap.values()) {
      prunedCollection.addAll(changes);
    }
    return prunedCollection;
  }

  /**
   * Compares 2 APIs for source compatibility. Algorithm: First find packages
   * that are in one but not in another. Then, look at at classes in the common
   * packages. Look at public classes.
   * 
   */
  private void computeApiDiff() throws NotFoundException {
    Set<String> newApiPackageNames = newApi.getApiPackageNames();
    missingPackageNames = oldApi.getApiPackageNames();
    Set<String> intersection = removeIntersection(newApiPackageNames,
        missingPackageNames);
    // Inspect each of the classes in each of the packages in the intersection
    for (String packageName : intersection) {
      ApiPackageDiffGenerator tempPackageDiffGenerator = new ApiPackageDiffGenerator(
          packageName, this);
      intersectingPackages.put(packageName, tempPackageDiffGenerator);
      tempPackageDiffGenerator.computeApiDiff();
    }
  }

  /**
   * Returns how ApiClass for first element is "related" to the ApiClass for
   * secondElement.
   */
  private Relation getRelationOfApiClassOfFirstArgToThatOfSecond(
      ApiElement firstApiElement, ApiElement secondApiElement) {
    JClassType firstClassType = null;
    JClassType secondClassType = null;
    if (firstApiElement instanceof ApiField) {
      firstClassType = ((ApiField) firstApiElement).getApiClass().getClassObject();
      secondClassType = ((ApiField) secondApiElement).getApiClass().getClassObject();
    }
    if (firstApiElement instanceof ApiAbstractMethod) {
      firstClassType = ((ApiAbstractMethod) firstApiElement).getApiClass().getClassObject();
      secondClassType = ((ApiAbstractMethod) secondApiElement).getApiClass().getClassObject();
    }
    if (firstClassType != null && secondClassType != null) {
      if (secondClassType.isAssignableTo(firstClassType)) {
        return Relation.SUPERCLASS;
      }
      if (firstClassType.isAssignableTo(secondClassType)) {
        return Relation.SUBCLASS;
      }
      return Relation.NONE;
    }
    throw new RuntimeException(
        "Inconsistent types for ApiElements: newApiElement " + firstApiElement
            + ", oldApiElement : " + secondApiElement);
  }

}