/*
 * Copyright (C) 2020 The Dagger Authors.
 *
 * 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 dagger.hilt.android;

import static com.google.common.truth.Truth.assertThat;

import android.os.Build;
import androidx.activity.ComponentActivity;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import dagger.hilt.android.other.pkg.AndroidEntryPointBaseClassOtherPkg;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;

/**
 * Regression test for https://github.com/google/dagger/issues/1910
 *
 * <p>There are 8 different tests to cover 3 levels of inheritance where each level uses either the
 * long-form (L) or short-form (S) of @AndroidEntryPoint:
 *
 * <ol>
 *   <li> L -> L -> L
 *   <li> L -> L -> S
 *   <li> L -> S -> L
 *   <li> L -> S -> S
 *   <li> S -> L -> L
 *   <li> S -> L -> S
 *   <li> S -> S -> L
 *   <li> S -> S -> S
 * </ol>
 *
 * Note: We don't actually test injection in this class because Bazel doesn't do bytecode injection.
 * We're only testing that the classes build, and verifying their inheritance matches what we
 * expect.
 */
@RunWith(AndroidJUnit4.class)
// Robolectric requires Java9 to run API 29 and above, so use API 28 instead
@Config(sdk = Build.VERSION_CODES.P)
public final class AndroidEntryPointBaseClassTest {

  @AndroidEntryPoint
  public static final class SSActivity extends AndroidEntryPointBaseClassOtherPkg.SBaseActivity {}

  @AndroidEntryPoint
  public static final class SLActivity extends AndroidEntryPointBaseClassOtherPkg.LBaseActivity {}

  @AndroidEntryPoint(AndroidEntryPointBaseClassOtherPkg.SBaseActivity.class)
  public static final class LSActivity extends Hilt_AndroidEntryPointBaseClassTest_LSActivity {}

  @AndroidEntryPoint(AndroidEntryPointBaseClassOtherPkg.LBaseActivity.class)
  public static final class LLActivity extends Hilt_AndroidEntryPointBaseClassTest_LLActivity {}

  @AndroidEntryPoint(LL.class)
  public static final class LLL extends Hilt_AndroidEntryPointBaseClassTest_LLL {}

  @AndroidEntryPoint(LS.class)
  public static final class LLS extends Hilt_AndroidEntryPointBaseClassTest_LLS {}

  @AndroidEntryPoint(SL.class)
  public static final class LSL extends Hilt_AndroidEntryPointBaseClassTest_LSL {}

  @AndroidEntryPoint(SS.class)
  public static final class LSS extends Hilt_AndroidEntryPointBaseClassTest_LSS {}

  @AndroidEntryPoint
  public static final class SLL extends LL {}

  @AndroidEntryPoint
  public static final class SLS extends LS {}

  @AndroidEntryPoint
  public static final class SSL extends SL {}

  @AndroidEntryPoint
  public static final class SSS extends SS {}

  @AndroidEntryPoint(L.class)
  public static class LL extends Hilt_AndroidEntryPointBaseClassTest_LL {}

  @AndroidEntryPoint(S.class)
  public static class LS extends Hilt_AndroidEntryPointBaseClassTest_LS {}

  @AndroidEntryPoint
  public static class SL extends L {}

  @AndroidEntryPoint
  public static class SS extends S {}

  @AndroidEntryPoint(ComponentActivity.class)
  public static class L extends Hilt_AndroidEntryPointBaseClassTest_L {}

  @AndroidEntryPoint
  public static class S extends ComponentActivity {}

  @Test
  public void checkGeneratedClassHierarchy_shortForm() throws Exception {
    // When using the short form notation, the generated top level class is not actually assignable
    // to the generated base classes at compile time
    assertIsNotAssignableTo(
        Hilt_AndroidEntryPointBaseClassTest_SSS.class,
        Hilt_AndroidEntryPointBaseClassTest_S.class);
    assertIsNotAssignableTo(
        Hilt_AndroidEntryPointBaseClassTest_SS.class,
        Hilt_AndroidEntryPointBaseClassTest_S.class);
  }

  @Test
  public void checkGeneratedClassHierarchy_longForm() throws Exception {
    // When using the long form notation, they are assignable at compile time
    assertIsAssignableTo(
        Hilt_AndroidEntryPointBaseClassTest_LLL.class,
        Hilt_AndroidEntryPointBaseClassTest_LL.class);
    assertIsAssignableTo(
        Hilt_AndroidEntryPointBaseClassTest_LL.class,
        Hilt_AndroidEntryPointBaseClassTest_L.class);
  }

  @Test
  public void checkGeneratedClassHierarchy_shortFormRoot() throws Exception {
    // If the root is short-form, then the child class cannot be assigned to it.
    assertIsNotAssignableTo(
        Hilt_AndroidEntryPointBaseClassTest_LLS.class,
        Hilt_AndroidEntryPointBaseClassTest_S.class);
    assertIsNotAssignableTo(
        Hilt_AndroidEntryPointBaseClassTest_LS.class,
        Hilt_AndroidEntryPointBaseClassTest_S.class);
  }

  @Test
  public void checkGeneratedClassHierarchy_longFormRoot() throws Exception {
    // If the root is long-form, then the child class can be assigned to it.
    assertIsAssignableTo(
        Hilt_AndroidEntryPointBaseClassTest_SSL.class,
        Hilt_AndroidEntryPointBaseClassTest_L.class);
    assertIsAssignableTo(
        Hilt_AndroidEntryPointBaseClassTest_SL.class,
        Hilt_AndroidEntryPointBaseClassTest_L.class);
  }

  /** Asserts that the {@code class1} is not assignable to the {@code class2}. */
  private static void assertIsNotAssignableTo(Class<?> class1, Class<?> class2) {
    assertThat(class2.isAssignableFrom(class1)).isFalse();
  }

  /** Asserts that the {@code class1} is assignable to the {@code class2}. */
  private static void assertIsAssignableTo(Class<?> class1, Class<?> class2) {
    assertThat(class1).isAssignableTo(class2);
  }
}