// 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 static com.android.tools.r8.utils.FunctionUtils.ignoreArgument;
import static org.objectweb.asm.Opcodes.AASTORE;
import static org.objectweb.asm.Opcodes.ACONST_NULL;
import static org.objectweb.asm.Opcodes.ALOAD;
import static org.objectweb.asm.Opcodes.ANEWARRAY;
import static org.objectweb.asm.Opcodes.ARETURN;
import static org.objectweb.asm.Opcodes.DUP;
import static org.objectweb.asm.Opcodes.F_SAME1;
import static org.objectweb.asm.Opcodes.IFEQ;
import static org.objectweb.asm.Opcodes.INVOKEINTERFACE;
import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
import static org.objectweb.asm.Opcodes.INVOKESTATIC;
import static org.objectweb.asm.Opcodes.INVOKEVIRTUAL;
import static org.objectweb.asm.Opcodes.NEW;
import static org.objectweb.asm.Opcodes.POP;

import com.android.tools.r8.TestBase;
import com.android.tools.r8.apimodel.AndroidApiVersionsXmlParser.ParsedApiClass;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.Reference;
import com.android.tools.r8.references.TypeReference;
import com.android.tools.r8.transformers.ClassFileTransformer.MethodPredicate;
import com.android.tools.r8.transformers.MethodTransformer;
import com.android.tools.r8.utils.DescriptorUtils;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import org.objectweb.asm.Label;
import org.objectweb.asm.Opcodes;

public class AndroidApiDatabaseBuilderGenerator extends TestBase {

  public static String generatedMainDescriptor() {
    return descriptor(AndroidApiDatabaseBuilderTemplate.class).replace("Template", "");
  }

  public static ClassReference ANDROID_API_LEVEL =
      Reference.classFromBinaryName("com/android/tools/r8/utils/AndroidApiLevel");
  public static ClassReference ANDROID_API_CLASS =
      Reference.classFromBinaryName("com/android/tools/r8/androidapi/AndroidApiClass");
  public static ClassReference TRAVERSAL_CONTINUATION =
      Reference.classFromBinaryName("com/android/tools/r8/utils/TraversalContinuation");

  /**
   * Generate the classes needed for looking up api level of references in the android.jar.
   *
   * <p>For each api class we generate a from AndroidApiDatabaseClassTemplate, extending
   * AndroidApiClass, such that all members can be traversed. Looking up the class reference
   * directly in one method will generate to much code and would probably be inefficient so we first
   * do a case on the package and then do a check on the simple name.
   *
   * <p>We therefore create a class file for each package, based on
   * AndroidApiDatabasePackageTemplate, that will do the dispatch to create a new
   * AndroidApiDatabaseClass for class in the package.
   *
   * <p>We then have a single entry-point, AndroidApiDatabaseBuilder, based on
   * AndroidApiDatabaseBuilderTemplate, that will do the dispatch to AndroidApiDatabasePackage based
   * on the package name.
   */
  public static void generate(List<ParsedApiClass> apiClasses, BiConsumer<String, byte[]> consumer)
      throws Exception {
    Map<String, List<ParsedApiClass>> packageToClassesMap = new HashMap<>();
    List<String> packages =
        apiClasses.stream()
            .map(
                apiClass -> {
                  String packageName =
                      DescriptorUtils.getPackageNameFromDescriptor(
                          apiClass.getClassReference().getDescriptor());
                  packageToClassesMap
                      .computeIfAbsent(packageName, ignoreArgument(ArrayList::new))
                      .add(apiClass);
                  return packageName;
                })
            .sorted()
            .distinct()
            .collect(Collectors.toList());

    for (ParsedApiClass apiClass : apiClasses) {
      consumer.accept(
          getApiClassDescriptor(apiClass),
          transformer(AndroidApiDatabaseClassTemplate.class)
              .setClassDescriptor(getApiClassDescriptor(apiClass))
              .addMethodTransformer(getInitTransformer(apiClass))
              .addMethodTransformer(getApiLevelTransformer(apiClass))
              .addMethodTransformer(getVisitFieldsTransformer(apiClass))
              .addMethodTransformer(getVisitMethodsTransformer(apiClass))
              .removeMethods(MethodPredicate.onName("placeHolderForInit"))
              .removeMethods(MethodPredicate.onName("placeHolderForGetApiLevel"))
              .removeMethods(MethodPredicate.onName("placeHolderForVisitFields"))
              .removeMethods(MethodPredicate.onName("placeHolderForVisitMethods"))
              .transform());
    }

    for (String pkg : packages) {
      consumer.accept(
          getPackageBuilderDescriptor(pkg),
          transformer(AndroidApiDatabasePackageTemplate.class)
              .setClassDescriptor(getPackageBuilderDescriptor(pkg))
              .addMethodTransformer(getBuildClassTransformer(packageToClassesMap.get(pkg)))
              .removeMethods(MethodPredicate.onName("placeHolder"))
              .transform());
    }

    consumer.accept(
        generatedMainDescriptor(),
        transformer(AndroidApiDatabaseBuilderTemplate.class)
            .setClassDescriptor(generatedMainDescriptor())
            .addMethodTransformer(getVisitApiClassesTransformer(apiClasses))
            .addMethodTransformer(getBuildPackageTransformer(packages))
            .removeMethods(MethodPredicate.onName("placeHolderForVisitApiClasses"))
            .removeMethods(MethodPredicate.onName("placeHolderForBuildClass"))
            .transform());
  }

  private static String getPackageBuilderDescriptor(String pkg) {
    return DescriptorUtils.javaTypeToDescriptor(
        AndroidApiDatabasePackageTemplate.class
            .getTypeName()
            .replace("Template", "ForPackage_" + pkg.replace(".", "_")));
  }

  private static String getApiClassDescriptor(ParsedApiClass apiClass) {
    return DescriptorUtils.javaTypeToDescriptor(
        AndroidApiDatabaseClassTemplate.class
            .getTypeName()
            .replace(
                "Template",
                "ForClass_" + apiClass.getClassReference().getTypeName().replace(".", "_")));
  }

  // The transformer below changes AndroidApiDatabaseClassTemplate.<init> from:
  //     super(Reference.classFromDescriptor(placeHolderForInit()));
  // into
  //     super(Reference.classFromDescriptor("<class-descriptor>"));
  private static MethodTransformer getInitTransformer(ParsedApiClass apiClass) {
    return replaceCode(
        "placeHolderForInit",
        transformer -> {
          transformer.visitLdcInsn(apiClass.getClassReference().getDescriptor());
        });
  }

  // The transformer below changes AndroidApiDatabaseClassTemplate.getApiLevel from:
  //     return placeHolderForGetApiLevel();
  // into
  //    return AndroidApiLevel.getAndroidApiLevel(<apiLevel>);
  private static MethodTransformer getApiLevelTransformer(ParsedApiClass apiClass) {
    return replaceCode(
        "placeHolderForGetApiLevel",
        transformer -> {
          transformer.visitLdcInsn(apiClass.getApiLevel().getLevel());
          transformer.visitMethodInsn(
              INVOKESTATIC,
              ANDROID_API_LEVEL.getBinaryName(),
              "getAndroidApiLevel",
              "(I)" + ANDROID_API_LEVEL.getDescriptor(),
              false);
        });
  }

  // The transformer below changes AndroidApiDatabaseClassTemplate.visitFields from:
  //     placeHolder();
  //     return TraversalContinuation.CONTINUE;
  // into
  //    TraversalContinuation s1 = visitField("field1", "descriptor1", apiLevel1, visitor)
  //    if (s1.shouldBreak()) {
  //       return s1;
  //    }
  //    TraversalContinuation s2 = visitField("field2", "descriptor2", apiLevel2, visitor)
  //    if (s2.shouldBreak()) {
  //       return s2;
  //    }
  //    ...
  //    return TraversalContinuation.CONTINUE;
  private static MethodTransformer getVisitFieldsTransformer(ParsedApiClass apiClass) {
    return replaceCode(
        "placeHolderForVisitFields",
        transformer -> {
          apiClass.visitFieldReferences(
              (apiLevel, references) -> {
                references.forEach(
                    reference -> {
                      transformer.visitVarInsn(ALOAD, 0);
                      transformer.visitLdcInsn(reference.getFieldName());
                      transformer.visitLdcInsn(reference.getFieldType().getDescriptor());
                      transformer.visitLdcInsn(apiLevel.getLevel());
                      transformer.visitVarInsn(ALOAD, 1);
                      transformer.visitMethodInsn(
                          INVOKEVIRTUAL,
                          ANDROID_API_CLASS.getBinaryName(),
                          "visitField",
                          "(Ljava/lang/String;"
                              + "Ljava/lang/String;"
                              + "I"
                              + "Ljava/util/function/BiFunction;)"
                              + TRAVERSAL_CONTINUATION.getDescriptor(),
                          false);
                      // Note that instead of storing the result here, we dup it on the stack.
                      transformer.visitInsn(DUP);
                      transformer.visitMethodInsn(
                          INVOKEVIRTUAL,
                          TRAVERSAL_CONTINUATION.getBinaryName(),
                          "shouldBreak",
                          "()Z",
                          false);
                      Label label = new Label();
                      transformer.visitJumpInsn(IFEQ, label);
                      transformer.visitInsn(ARETURN);
                      transformer.visitLabel(label);
                      transformer.visitFrame(
                          F_SAME1,
                          0,
                          new Object[] {},
                          1,
                          new Object[] {TRAVERSAL_CONTINUATION.getBinaryName()});
                      // The pop here is needed to remove the dupped value in the case we do not
                      // return.
                      transformer.visitInsn(POP);
                    });
              });
        });
  }

  // The transformer below changes AndroidApiDatabaseClassTemplate.visitMethods from:
  //     placeHolderForVisitMethods();
  //     return TraversalContinuation.CONTINUE;
  // into
  //    TraversalContinuation s1 = visitMethod(
  //      "method1", new String[] { "param11", ... , "param1X" }, null/return1, apiLevel1, visitor)
  //    if (s1.shouldBreak()) {
  //       return s1;
  //    }
  //    TraversalContinuation s1 = visitMethod(
  //      "method2", new String[] { "param21", ... , "param2X" }, null/return2, apiLevel2, visitor)
  //    if (s2.shouldBreak()) {
  //       return s2;
  //    }
  //    ...
  //    return TraversalContinuation.CONTINUE;
  private static MethodTransformer getVisitMethodsTransformer(ParsedApiClass apiClass) {
    return replaceCode(
        "placeHolderForVisitMethods",
        transformer -> {
          apiClass.visitMethodReferences(
              (apiLevel, references) -> {
                references.forEach(
                    reference -> {
                      transformer.visitVarInsn(ALOAD, 0);
                      transformer.visitLdcInsn(reference.getMethodName());
                      List<TypeReference> formalTypes = reference.getFormalTypes();
                      transformer.visitLdcInsn(formalTypes.size());
                      transformer.visitTypeInsn(ANEWARRAY, binaryName(String.class));
                      for (int i = 0; i < formalTypes.size(); i++) {
                        transformer.visitInsn(DUP);
                        transformer.visitLdcInsn(i);
                        transformer.visitLdcInsn(formalTypes.get(i).getDescriptor());
                        transformer.visitInsn(AASTORE);
                      }
                      if (reference.getReturnType() != null) {
                        transformer.visitLdcInsn(reference.getReturnType().getDescriptor());
                      } else {
                        transformer.visitInsn(ACONST_NULL);
                      }
                      transformer.visitLdcInsn(apiLevel.getLevel());
                      transformer.visitVarInsn(ALOAD, 1);
                      transformer.visitMethodInsn(
                          INVOKEVIRTUAL,
                          ANDROID_API_CLASS.getBinaryName(),
                          "visitMethod",
                          "(Ljava/lang/String;"
                              + "[Ljava/lang/String;Ljava/lang/String;"
                              + "I"
                              + "Ljava/util/function/BiFunction;)"
                              + TRAVERSAL_CONTINUATION.getDescriptor(),
                          false);
                      // Note that instead of storing the result here, we dup it on the stack.
                      transformer.visitInsn(DUP);
                      transformer.visitMethodInsn(
                          INVOKEVIRTUAL,
                          TRAVERSAL_CONTINUATION.getBinaryName(),
                          "shouldBreak",
                          "()Z",
                          false);
                      Label label = new Label();
                      transformer.visitJumpInsn(IFEQ, label);
                      transformer.visitInsn(ARETURN);
                      transformer.visitLabel(label);
                      transformer.visitFrame(
                          F_SAME1,
                          0,
                          new Object[] {},
                          1,
                          new Object[] {TRAVERSAL_CONTINUATION.getBinaryName()});
                      // The pop here is needed to remove the dupped value in the case we do not
                      // return.
                      transformer.visitInsn(POP);
                    });
              });
        });
  }

  // The transformer below changes AndroidApiDatabasePackageTemplate.buildClass from:
  //    placeHolder();
  //    return null;
  // into
  //    if ("<simple_class1>".equals(className)) {
  //      return new AndroidApiClassForClass_class_name1();
  //    }
  //    if ("<simple_class2>".equals(className)) {
  //      return new AndroidApiClassForClass_class_name2();
  //    }
  //    ...
  //    return null;
  private static MethodTransformer getBuildClassTransformer(List<ParsedApiClass> classesForPackage)
      throws NoSuchMethodException {
    Method equals = Object.class.getMethod("equals", Object.class);
    return replaceCode(
        "placeHolder",
        transformer -> {
          classesForPackage.forEach(
              apiClass -> {
                transformer.visitLdcInsn(
                    DescriptorUtils.getSimpleClassNameFromDescriptor(
                        apiClass.getClassReference().getDescriptor()));
                transformer.visitVarInsn(ALOAD, 0);
                transformer.visitMethodInsn(
                    INVOKEVIRTUAL,
                    binaryName(String.class),
                    equals.getName(),
                    methodDescriptor(equals),
                    false);
                Label label = new Label();
                transformer.visitJumpInsn(IFEQ, label);
                String binaryName =
                    DescriptorUtils.getBinaryNameFromDescriptor(getApiClassDescriptor(apiClass));
                transformer.visitTypeInsn(NEW, binaryName);
                transformer.visitInsn(DUP);
                transformer.visitMethodInsn(INVOKESPECIAL, binaryName, "<init>", "()V", false);
                transformer.visitInsn(ARETURN);
                transformer.visitLabel(label);
                transformer.visitFrame(Opcodes.F_SAME, 0, new Object[] {}, 0, new Object[0]);
              });
        });
  }

  // The transformer below changes AndroidApiDatabaseBuilderTemplate.buildClass from:
  //    String descriptor = classReference.getDescriptor();
  //    String packageName = DescriptorUtils.getPackageNameFromDescriptor(descriptor);
  //    String simpleClassName = DescriptorUtils.getSimpleClassNameFromDescriptor(descriptor);
  //    placeHolderForBuildClass();
  //    return null;
  // into
  //    String descriptor = classReference.getDescriptor();
  //    String packageName = DescriptorUtils.getPackageNameFromDescriptor(descriptor);
  //    String simpleClassName = DescriptorUtils.getSimpleClassNameFromDescriptor(descriptor);
  //    if ("<package_name1>".equals(packageName)) {
  //      return AndroidApiClassForPackage_package_name1(simpleClassName);
  //    }
  //    if ("<package_name2>".equals(simpleClassName)) {
  //      return AndroidApiClassForPackage_package_name2(simpleClassName);
  //    }
  //    ...
  //    return null;
  private static MethodTransformer getBuildPackageTransformer(List<String> packages)
      throws NoSuchMethodException {
    Method equals = String.class.getMethod("equals", Object.class);
    Method buildClass =
        AndroidApiDatabasePackageTemplate.class.getMethod("buildClass", String.class);
    return replaceCode(
        "placeHolderForBuildClass",
        transformer -> {
          packages.forEach(
              pkg -> {
                transformer.visitLdcInsn(pkg);
                transformer.visitVarInsn(ALOAD, 2);
                transformer.visitMethodInsn(
                    INVOKEVIRTUAL,
                    binaryName(String.class),
                    equals.getName(),
                    methodDescriptor(equals),
                    false);
                Label label = new Label();
                transformer.visitJumpInsn(IFEQ, label);
                transformer.visitVarInsn(ALOAD, 3);
                transformer.visitMethodInsn(
                    INVOKESTATIC,
                    DescriptorUtils.getBinaryNameFromDescriptor(getPackageBuilderDescriptor(pkg)),
                    buildClass.getName(),
                    methodDescriptor(buildClass),
                    false);
                transformer.visitInsn(ARETURN);
                transformer.visitLabel(label);
                transformer.visitFrame(
                    Opcodes.F_FULL,
                    4,
                    new Object[] {
                      binaryName(ClassReference.class),
                      binaryName(String.class),
                      binaryName(String.class),
                      binaryName(String.class)
                    },
                    0,
                    new Object[0]);
              });
        });
  }

  // The transformer below changes AndroidApiDatabaseBuilderTemplate.buildClass from:
  //    placeHolderForVisitApiClasses();
  // into
  //    classDescriptorConsumer.accept("<descriptor_class_1>");
  //    classDescriptorConsumer.accept("<descriptor_class_2>");
  //    ...
  //    return null;
  private static MethodTransformer getVisitApiClassesTransformer(List<ParsedApiClass> apiClasses) {
    return replaceCode(
        "placeHolderForVisitApiClasses",
        transformer -> {
          apiClasses.forEach(
              apiClass -> {
                transformer.visitVarInsn(ALOAD, 0);
                transformer.visitLdcInsn(apiClass.getClassReference().getDescriptor());
                transformer.visitMethodInsn(
                    INVOKEINTERFACE,
                    binaryName(Consumer.class),
                    "accept",
                    "(Ljava/lang/Object;)V",
                    true);
              });
        });
  }

  private static MethodTransformer replaceCode(
      String placeholderName, Consumer<MethodTransformer> consumer) {
    return new MethodTransformer() {

      @Override
      public void visitMaxs(int maxStack, int maxLocals) {
        super.visitMaxs(-1, maxLocals);
      }

      @Override
      public void visitMethodInsn(
          int opcode, String owner, String name, String descriptor, boolean isInterface) {
        if (name.equals(placeholderName)) {
          consumer.accept(this);
        } else {
          super.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
        }
      }
    };
  }
}