// Copyright (c) 2019, 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 nesthostexample;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import com.android.tools.r8.D8TestCompileResult;
import com.android.tools.r8.JdkClassFileProvider;
import com.android.tools.r8.JvmTestBuilder;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.TestRuntime.CfVm;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.ir.desugar.nest.NestBasedAccessDesugaring;
import com.android.tools.r8.references.Reference;
import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

@RunWith(Parameterized.class)
public class FullNestOnProgramPathTest extends TestBase {

  public static final ImmutableMap<Class<?>, String> NEST_MAIN_RESULT =
      ImmutableMap.<Class<?>, String>builder()
          .put(
              BasicNestHostWithInnerClassFields.class,
              StringUtils.lines(BasicNestHostWithInnerClassFields.getExpectedResult()))
          .put(
              BasicNestHostWithInnerClassMethods.class,
              StringUtils.lines(BasicNestHostWithInnerClassMethods.getExpectedResult()))
          .put(
              BasicNestHostWithInnerClassConstructors.class,
              StringUtils.lines(BasicNestHostWithInnerClassConstructors.getExpectedResult()))
          .put(
              BasicNestHostWithAnonymousInnerClass.class,
              StringUtils.lines(BasicNestHostWithAnonymousInnerClass.getExpectedResult()))
          .put(NestHostExample.class, StringUtils.lines(NestHostExample.getExpectedResult()))
          .build();

  public FullNestOnProgramPathTest(TestParameters parameters) {
    this.parameters = parameters;
  }

  private final TestParameters parameters;

  @Parameters(name = "{0}")
  public static TestParametersCollection data() {
    return getTestParameters()
        .withCfRuntimesStartingFromIncluding(CfVm.JDK11)
        .withDexRuntimes()
        .withApiLevelsStartingAtIncluding(apiLevelWithInvokeCustomSupport())
        .enableApiLevelsForCf()
        .build();
  }

  @Test
  public void testAllNestsReference() throws Exception {
    parameters.assumeJvmTestParameters();
    JvmTestBuilder jvmTestBuilder =
        testForJvm(parameters).addProgramClassesAndInnerClasses(NEST_MAIN_RESULT.keySet());
    for (Class<?> clazz : NEST_MAIN_RESULT.keySet()) {
      jvmTestBuilder
          .run(parameters.getRuntime(), clazz)
          .assertSuccessWithOutput(NEST_MAIN_RESULT.get(clazz));
    }
  }

  @Test
  public void testAllNestsD8() throws Exception {
    D8TestCompileResult compileResult =
        testForD8(parameters.getBackend())
            .addProgramClassesAndInnerClasses(NEST_MAIN_RESULT.keySet())
            .setMinApi(parameters)
            .compile()
            .applyIf(parameters.isDexRuntime(), b -> b.inspect(this::assertOnlyRequiredBridges));
    for (Class<?> clazz : NEST_MAIN_RESULT.keySet()) {
      compileResult
          .run(parameters.getRuntime(), clazz)
          .assertSuccessWithOutput(NEST_MAIN_RESULT.get(clazz));
    }
  }

  @Test
  public void testAllNestsR8() throws Exception {
    parameters.assumeR8TestParameters();
    R8TestCompileResult compileResult =
        testForR8(parameters.getBackend())
            .addDontShrink()
            .addDontObfuscate()
            .addKeepAllAttributes()
            .addOptionsModification(options -> options.enableNestReduction = false)
            .addProgramClassesAndInnerClasses(NEST_MAIN_RESULT.keySet())
            .applyIf(
                parameters.isCfRuntime(),
                b -> b.addLibraryProvider(JdkClassFileProvider.fromSystemJdk()))
            .setMinApi(parameters)
            .compile()
            .inspect(this::assertOnlyRequiredBridges)
            .applyIf(
                parameters.isCfRuntime(),
                b -> b.inspect(FullNestOnProgramPathTest::checkNestMateAttributes));
    for (Class<?> clazz : NEST_MAIN_RESULT.keySet()) {
      compileResult
          .run(parameters.getRuntime(), clazz)
          .assertSuccessWithOutput(NEST_MAIN_RESULT.get(clazz));
    }
  }

  // Single Nest test compile only the nest into dex,
  // then run the main class from this dex.
  @Test
  public void testSingleNestR8() throws Exception {
    parameters.assumeR8TestParameters();
    for (Class<?> clazz : NEST_MAIN_RESULT.keySet()) {
      testForR8(parameters.getBackend())
          .addDontShrink()
          .addDontObfuscate()
          .addKeepAllAttributes()
          .setMinApi(parameters)
          .addProgramClassesAndInnerClasses(clazz)
          .addOptionsModification(options -> options.enableNestReduction = false)
          .applyIf(
              parameters.isCfRuntime(),
              b -> b.addLibraryProvider(JdkClassFileProvider.fromSystemJdk()))
          .compile()
          .run(parameters.getRuntime(), clazz)
          .assertSuccessWithOutput(NEST_MAIN_RESULT.get(clazz));
    }
  }

  @Test
  public void testSingleNestD8() throws Exception {
    for (Class<?> clazz : NEST_MAIN_RESULT.keySet()) {
      testForD8(parameters.getBackend())
          .setMinApi(parameters)
          .addProgramClassesAndInnerClasses(clazz)
          .compile()
          .run(parameters.getRuntime(), clazz)
          .assertSuccessWithOutput(NEST_MAIN_RESULT.get(clazz));
    }
  }

  private static int minNumberOfTestClasses() {
    return NEST_MAIN_RESULT.keySet().stream()
        .mapToInt(
            c -> {
              try {
                return ToolHelper.getClassFilesForInnerClasses(c).size() + 1;
              } catch (IOException e) {
                throw new RuntimeException(e);
              }
            })
        .sum();
  }

  private static void checkNestMateAttributes(CodeInspector inspector) {
    // Interface method desugaring may add extra classes
    assertTrue(minNumberOfTestClasses() <= inspector.allClasses().size());
    List<String> outerClassNames =
        NEST_MAIN_RESULT.keySet().stream().map(Class::getSimpleName).collect(Collectors.toList());
    ImmutableList<String> nonNestClasses =
        ImmutableList.of("NeverInline", "OutsideInliningNoAccess", "OutsideInliningWithAccess");
    inspector.forAllClasses(
        classSubject -> {
          DexClass dexClass = classSubject.getDexProgramClass();
          if (!nonNestClasses.contains(dexClass.type.getName())) {
            assertTrue(dexClass.isInANest());
            if (outerClassNames.contains(dexClass.type.getName())) {
              assertNull(dexClass.getNestHostClassAttribute());
              assertFalse(dexClass.getNestMembersClassAttributes().isEmpty());
            } else {
              assertTrue(dexClass.getNestMembersClassAttributes().isEmpty());
              assertTrue(
                  outerClassNames.contains(
                      dexClass.getNestHostClassAttribute().getNestHost().getName()));
            }
          }
        });
  }

  private void assertOnlyRequiredBridges(CodeInspector inspector) {
    // The following 2 classes have an extra private member which does not require a bridge.

    // Two bridges for method and staticMethod.
    int methodNumBridges = parameters.isCfRuntime() ? 0 : 2;
    ClassSubject methodMainClass = inspector.clazz(BasicNestHostWithInnerClassMethods.class);
    assertEquals(methodNumBridges, methodMainClass.allMethods(this::isNestBridge).size());

    // Two bridges for method and staticMethod.
    int constructorNumBridges = parameters.isCfRuntime() ? 0 : 1;
    ClassSubject constructorMainClass =
        inspector.clazz(BasicNestHostWithInnerClassConstructors.class);
    assertEquals(constructorNumBridges, constructorMainClass.allMethods(this::isNestBridge).size());

    // Four bridges for field and staticField, both get & set.
    int fieldNumBridges = parameters.isCfRuntime() ? 0 : 4;
    ClassSubject fieldMainClass = inspector.clazz(BasicNestHostWithInnerClassFields.class);
    assertEquals(fieldNumBridges, fieldMainClass.allMethods(this::isNestBridge).size());
  }

  private boolean isNestBridge(FoundMethodSubject methodSubject) {
    DexEncodedMethod method = methodSubject.getMethod();
    if (method.isInstanceInitializer()) {
      if (method.getReference().proto.parameters.isEmpty()) {
        return false;
      }
      DexType[] formals = method.getReference().proto.parameters.values;
      DexType lastFormal = formals[formals.length - 1];
      return lastFormal.isClassType()
          && SyntheticItemsTestUtils.isInitializerTypeArgument(
              Reference.classFromDescriptor(lastFormal.toDescriptorString()));
    }
    return method
        .getReference()
        .name
        .toString()
        .startsWith(NestBasedAccessDesugaring.NEST_ACCESS_NAME_PREFIX);
  }
}