// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

package com.android.tools.r8.apimodel;

import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.androidapi.AndroidApiLevelHashingDatabaseImpl;
import com.android.tools.r8.apimodel.AndroidApiVersionsXmlParser.ParsedApiClass;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexMember;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexReference;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.LibraryClass;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.Pair;
import com.android.tools.r8.utils.structural.DefaultHashingVisitor;
import com.android.tools.r8.utils.structural.HasherWrapper;
import com.android.tools.r8.utils.structural.StructuralItem;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.function.BiConsumer;

public class AndroidApiHashingDatabaseBuilderGenerator extends TestBase {

  /**
   * Generate the information needed for looking up api level of references in the android.jar. This
   * method will generate three different files and store them in the passed paths. pathToIndices
   * will be an int array with hashcode entries for each DexReference. The pathToApiLevels is a byte
   * array with a byte describing the api level that the index in pathToIndices has. To ensure that
   * this lookup work the generate algorithm tracks all colliding hash codes such and stores them in
   * another format. The indices map is populated with all colliding entries and a -1 is inserted
   * for the api level.
   */
  public static void generate(
      List<ParsedApiClass> apiClasses,
      Path pathToIndices,
      Path pathToApiLevels,
      Path ambiguousDefinitions,
      AndroidApiLevel androidJarApiLevel)
      throws Exception {
    Map<ClassReference, Map<DexMethod, AndroidApiLevel>> methodMap = new HashMap<>();
    Map<ClassReference, Map<DexField, AndroidApiLevel>> fieldMap = new HashMap<>();
    Map<ClassReference, ParsedApiClass> lookupMap = new HashMap<>();
    Path androidJar = ToolHelper.getAndroidJar(androidJarApiLevel);
    AppView<AppInfoWithLiveness> appView =
        computeAppViewWithLiveness(AndroidApp.builder().addLibraryFile(androidJar).build());
    DexItemFactory factory = appView.dexItemFactory();

    Map<Integer, AndroidApiLevel> apiLevelMap = new HashMap<>();
    Map<Integer, Pair<DexReference, AndroidApiLevel>> reverseMap = new HashMap<>();
    Map<AndroidApiLevel, Set<DexReference>> ambiguousMap = new HashMap<>();
    // Populate maps for faster lookup.
    for (ParsedApiClass apiClass : apiClasses) {
      DexType type = factory.createType(apiClass.getClassReference().getDescriptor());
      AndroidApiLevel existing = apiLevelMap.put(type.hashCode(), apiClass.getApiLevel());
      assert existing == null;
      reverseMap.put(type.hashCode(), Pair.create(type, apiClass.getApiLevel()));
    }

    for (ParsedApiClass apiClass : apiClasses) {
      Map<DexMethod, AndroidApiLevel> methodsForApiClass = new HashMap<>();
      apiClass.visitMethodReferences(
          (apiLevel, methods) -> {
            methods.forEach(
                method -> methodsForApiClass.put(factory.createMethod(method), apiLevel));
          });
      Map<DexField, AndroidApiLevel> fieldsForApiClass = new HashMap<>();
      apiClass.visitFieldReferences(
          (apiLevel, fields) -> {
            fields.forEach(field -> fieldsForApiClass.put(factory.createField(field), apiLevel));
          });
      methodMap.put(apiClass.getClassReference(), methodsForApiClass);
      fieldMap.put(apiClass.getClassReference(), fieldsForApiClass);
      lookupMap.put(apiClass.getClassReference(), apiClass);
    }

    BiConsumer<DexReference, AndroidApiLevel> addConsumer =
        addReferenceToMaps(apiLevelMap, reverseMap, ambiguousMap);

    for (ParsedApiClass apiClass : apiClasses) {
      computeAllReferencesInHierarchy(
              lookupMap,
              factory,
              factory.createType(apiClass.getClassReference().getDescriptor()),
              apiClass,
              AndroidApiLevel.B,
              new IdentityHashMap<>())
          .forEach(addConsumer);
    }

    Map<DexType, String> missingMemberInformation = new IdentityHashMap<>();
    for (LibraryClass clazz : appView.app().asDirect().libraryClasses()) {
      ParsedApiClass parsedApiClass = lookupMap.get(clazz.getClassReference());
      if (parsedApiClass == null) {
        missingMemberInformation.put(clazz.getType(), "Could not be found in " + androidJar);
        continue;
      }
      StringBuilder classBuilder = new StringBuilder();
      Map<DexField, AndroidApiLevel> fieldMapForClass = fieldMap.get(clazz.getClassReference());
      assert fieldMapForClass != null;
      clazz.forEachClassField(
          field -> {
            if (field.getAccessFlags().isPublic()
                && getApiLevelFromReference(field.getReference(), apiLevelMap, ambiguousMap) == null
                && field.toSourceString().contains("this$0")) {
              classBuilder.append("  ").append(field).append(" is missing\n");
            }
          });
      Map<DexMethod, AndroidApiLevel> methodMapForClass = methodMap.get(clazz.getClassReference());
      assert methodMapForClass != null;
      clazz.forEachClassMethod(
          method -> {
            if (method.getAccessFlags().isPublic()
                && getApiLevelFromReference(method.getReference(), apiLevelMap, ambiguousMap)
                    == null
                && !factory.objectMembers.isObjectMember(method.getReference())) {
              classBuilder.append("  ").append(method).append(" is missing\n");
            }
          });
      if (classBuilder.length() > 0) {
        missingMemberInformation.put(clazz.getType(), classBuilder.toString());
      }
    }

    // api-versions.xml do not encode all members of StringBuffers and StringBuilders, check that we
    // only have missing definitions for those two classes.
    assert missingMemberInformation.size() == 2;
    assert missingMemberInformation.containsKey(factory.stringBufferType);
    assert missingMemberInformation.containsKey(factory.stringBuilderType);

    int[] indices = new int[apiLevelMap.size()];
    byte[] apiLevel = new byte[apiLevelMap.size()];
    ArrayList<Integer> integers = new ArrayList<>(apiLevelMap.keySet());
    for (int i = 0; i < integers.size(); i++) {
      indices[i] = integers.get(i);
      AndroidApiLevel androidApiLevel = apiLevelMap.get(integers.get(i));
      assert androidApiLevel != null;
      apiLevel[i] =
          (byte)
              (androidApiLevel == AndroidApiLevel.ANDROID_PLATFORM
                  ? -1
                  : androidApiLevel.getLevel());
    }

    try (FileOutputStream fileOutputStream = new FileOutputStream(pathToIndices.toFile());
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream)) {
      objectOutputStream.writeObject(indices);
    }

    try (FileOutputStream fileOutputStream = new FileOutputStream(pathToApiLevels.toFile());
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream)) {
      objectOutputStream.writeObject(apiLevel);
    }

    String ambiguousMapSerialized = serializeAmbiguousMap(ambiguousMap);
    Files.write(ambiguousDefinitions, ambiguousMapSerialized.getBytes(StandardCharsets.UTF_8));
  }

  /** This will serialize a collection of DexReferences with the api level they correspond to. */
  private static String serializeAmbiguousMap(
      Map<AndroidApiLevel, Set<DexReference>> ambiguousMap) {
    Set<String> seen = new HashSet<>();
    StringBuilder sb = new StringBuilder();
    ambiguousMap.forEach(
        (apiLevel, references) -> {
          references.forEach(
              reference -> {
                HasherWrapper defaultHasher = AndroidApiLevelHashingDatabaseImpl.getDefaultHasher();
                reference.accept(
                    type -> DefaultHashingVisitor.run(type, defaultHasher, DexType::acceptHashing),
                    field ->
                        DefaultHashingVisitor.run(
                            field, defaultHasher, StructuralItem::acceptHashing),
                    method ->
                        DefaultHashingVisitor.run(
                            method, defaultHasher, StructuralItem::acceptHashing));
                String referenceHash = defaultHasher.hash().toString();
                if (!seen.add(referenceHash)) {
                  throw new RuntimeException(
                      "More than one item with key: <"
                          + referenceHash
                          + ">. The choice of key encoding will need to change to generate a valid"
                          + " api database");
                }
                sb.append(referenceHash).append(":").append(apiLevel.getLevel()).append("\n");
              });
        });
    return sb.toString();
  }

  private static AndroidApiLevel getApiLevelFromReference(
      DexReference reference,
      Map<Integer, AndroidApiLevel> apiLevelMap,
      Map<AndroidApiLevel, Set<DexReference>> ambiguousMap) {
    int hashCode = reference.hashCode();
    AndroidApiLevel androidApiLevel = apiLevelMap.get(hashCode);
    if (androidApiLevel == null) {
      return null;
    }
    if (androidApiLevel == AndroidApiLevel.ANDROID_PLATFORM) {
      for (Entry<AndroidApiLevel, Set<DexReference>> apiAmbiguousSet : ambiguousMap.entrySet()) {
        if (apiAmbiguousSet.getValue().contains(reference)) {
          return apiAmbiguousSet.getKey();
        }
      }
      return null;
    } else {
      return androidApiLevel;
    }
  }

  private static BiConsumer<DexReference, AndroidApiLevel> addReferenceToMaps(
      Map<Integer, AndroidApiLevel> apiLevelMap,
      Map<Integer, Pair<DexReference, AndroidApiLevel>> reverseMap,
      Map<AndroidApiLevel, Set<DexReference>> ambiguousMap) {
    return ((reference, apiLevel) -> {
      AndroidApiLevel existingMethod = apiLevelMap.put(reference.hashCode(), apiLevel);
      if (existingMethod == AndroidApiLevel.ANDROID_PLATFORM) {
        addAmbiguousEntry(apiLevel, reference, ambiguousMap);
      } else if (existingMethod != null) {
        apiLevelMap.put(reference.hashCode(), AndroidApiLevel.ANDROID_PLATFORM);
        Pair<DexReference, AndroidApiLevel> existingPair = reverseMap.get(reference.hashCode());
        addAmbiguousEntry(existingPair.getSecond(), existingPair.getFirst(), ambiguousMap);
        addAmbiguousEntry(apiLevel, reference, ambiguousMap);
      } else {
        reverseMap.put(reference.hashCode(), Pair.create(reference, apiLevel));
      }
    });
  }

  private static void addAmbiguousEntry(
      AndroidApiLevel apiLevel,
      DexReference reference,
      Map<AndroidApiLevel, Set<DexReference>> ambiguousMap) {
    ambiguousMap.computeIfAbsent(apiLevel, ignored -> new HashSet<>()).add(reference);
  }

  @SuppressWarnings("unchecked")
  private static <T extends DexMember<?, ?>>
      Map<T, AndroidApiLevel> computeAllReferencesInHierarchy(
          Map<ClassReference, ParsedApiClass> lookupMap,
          DexItemFactory factory,
          DexType holder,
          ParsedApiClass apiClass,
          AndroidApiLevel linkLevel,
          Map<T, AndroidApiLevel> additionMap) {
    if (!apiClass.getClassReference().getDescriptor().equals(factory.objectDescriptor.toString())) {
      apiClass.visitMethodReferences(
          (apiLevel, methodReferences) -> {
            methodReferences.forEach(
                methodReference -> {
                  T member = (T) factory.createMethod(methodReference).withHolder(holder, factory);
                  addIfNewOrApiLevelIsLower(linkLevel, additionMap, apiLevel, member);
                });
          });
      apiClass.visitFieldReferences(
          (apiLevel, fieldReferences) -> {
            fieldReferences.forEach(
                fieldReference -> {
                  T member = (T) factory.createField(fieldReference).withHolder(holder, factory);
                  addIfNewOrApiLevelIsLower(linkLevel, additionMap, apiLevel, member);
                });
          });
      apiClass.visitSuperType(
          (superType, apiLevel) -> {
            computeAllReferencesInHierarchy(
                lookupMap,
                factory,
                holder,
                lookupMap.get(superType),
                linkLevel.max(apiLevel),
                additionMap);
          });
      apiClass.visitInterface(
          (iFace, apiLevel) -> {
            computeAllReferencesInHierarchy(
                lookupMap,
                factory,
                holder,
                lookupMap.get(iFace),
                linkLevel.max(apiLevel),
                additionMap);
          });
    }
    return additionMap;
  }

  private static <T extends DexMember<?, ?>> void addIfNewOrApiLevelIsLower(
      AndroidApiLevel linkLevel,
      Map<T, AndroidApiLevel> additionMap,
      AndroidApiLevel apiLevel,
      T member) {
    AndroidApiLevel currentApiLevel = apiLevel.max(linkLevel);
    AndroidApiLevel existingApiLevel = additionMap.get(member);
    if (existingApiLevel == null || currentApiLevel.isLessThanOrEqualTo(existingApiLevel)) {
      additionMap.put(member, currentApiLevel);
    }
  }
}