/*
 * Copyright (C) 2014 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.internal.codegen;

import static com.google.testing.compile.CompilationSubject.assertThat;
import static dagger.internal.codegen.Compilers.daggerCompiler;
import static dagger.internal.codegen.TestUtils.message;

import androidx.room.compiler.processing.util.Source;
import com.google.common.collect.ImmutableMap;
import com.google.testing.compile.Compilation;
import com.google.testing.compile.JavaFileObjects;
import dagger.testing.compile.CompilerTests;
import javax.tools.JavaFileObject;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

@RunWith(JUnit4.class)
public final class ComponentValidationTest {
  @Test
  public void componentOnConcreteClass() {
    Source componentFile =
        CompilerTests.javaSource(
            "test.NotAComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component",
            "final class NotAComponent {}");
    CompilerTests.daggerCompiler(componentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining("interface");
            });
  }

  @Test
  public void componentOnOverridingBuilder_failsWhenMethodNameConflictsWithStaticCreatorName() {
    Source componentFile =
        CompilerTests.javaSource(
            "test.TestComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component(modules=TestModule.class)",
            "interface TestComponent {",
            "  String builder();",
            "}");
    Source moduleFile =
        CompilerTests.javaSource(
            "test.TestModule",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "",
            "@Module",
            "interface TestModule {",
            "  @Provides",
            "  static String provideString() { return \"test\"; }",
            "}");

    CompilerTests.daggerCompiler(componentFile, moduleFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                  "The method test.TestComponent.builder() conflicts with a method");
            });
  }

  @Test
  public void componentOnOverridingCreate_failsWhenGeneratedCreateMethod() {
    Source componentFile =
        CompilerTests.javaSource(
            "test.TestComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component(modules=TestModule.class)",
            "interface TestComponent {",
            "  String create();",
            "}");
    Source moduleFile =
        CompilerTests.javaSource(
            "test.TestModule",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "",
            "@Module",
            "interface TestModule {",
            "  @Provides",
            "  static String provideString() { return \"test\"; }",
            "}");

    CompilerTests.daggerCompiler(componentFile, moduleFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                  "The method test.TestComponent.create() conflicts with a method");
            });
  }

  @Test
  public void subcomponentMethodNameBuilder_succeeds() {
    Source componentFile =
        CompilerTests.javaSource(
            "test.TestComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component",
            "interface TestComponent {",
            "  TestSubcomponent.Builder subcomponent();",
            "}");
    Source subcomponentFile =
        CompilerTests.javaSource(
            "test.TestSubcomponent",
            "package test;",
            "",
            "import dagger.Subcomponent;",
            "",
            "@Subcomponent(modules=TestModule.class)",
            "interface TestSubcomponent {",
            "  String builder();",
            "  @Subcomponent.Builder",
            "  interface Builder {",
            "    TestSubcomponent build();",
            "  }",
            "}");
    Source moduleFile =
        CompilerTests.javaSource(
            "test.TestModule",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "",
            "@Module",
            "interface TestModule {",
            "  @Provides",
            "  static String provideString() { return \"test\"; }",
            "}");

    CompilerTests.daggerCompiler(componentFile, subcomponentFile, moduleFile)
        .compile(subject -> subject.hasErrorCount(0));
  }

  @Test public void componentOnEnum() {
    Source componentFile =
        CompilerTests.javaSource(
            "test.NotAComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component",
            "enum NotAComponent {",
            "  INSTANCE",
            "}");
    CompilerTests.daggerCompiler(componentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining("interface");
            });
  }

  @Test public void componentOnAnnotation() {
    Source componentFile =
        CompilerTests.javaSource(
            "test.NotAComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component",
            "@interface NotAComponent {}");
    CompilerTests.daggerCompiler(componentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining("interface");
            });
  }

  @Test public void nonModuleModule() {
    Source componentFile =
        CompilerTests.javaSource(
            "test.NotAComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component(modules = Object.class)",
            "interface NotAComponent {}");
    CompilerTests.daggerCompiler(componentFile)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining("is not annotated with @Module");
            });
  }

  @Test
  public void componentWithInvalidModule() {
    Source module =
        CompilerTests.javaSource(
            "test.BadModule",
            "package test;",
            "",
            "import dagger.Binds;",
            "import dagger.Module;",
            "",
            "@Module",
            "abstract class BadModule {",
            "  @Binds abstract Object noParameters();",
            "}");
    Source component =
        CompilerTests.javaSource(
            "test.BadComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component(modules = BadModule.class)",
            "interface BadComponent {",
            "  Object object();",
            "}");
    CompilerTests.daggerCompiler(module, component)
        .compile(
            subject -> {
              subject.hasErrorCount(2);
              subject.hasErrorContaining("test.BadModule has errors")
                  .onSource(component)
                  .onLine(5);
              subject.hasErrorContaining(
                      "@Binds methods must have exactly one parameter, whose type is assignable to "
                          + "the return type")
                  .onSource(module)
                  .onLine(8);
            });
  }

  @Test
  public void attemptToInjectWildcardGenerics() {
    Source testComponent =
        CompilerTests.javaSource(
            "test.TestComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "import dagger.Lazy;",
            "import javax.inject.Provider;",
            "",
            "@Component",
            "interface TestComponent {",
            "  Lazy<? extends Number> wildcardNumberLazy();",
            "  Provider<? super Number> wildcardNumberProvider();",
            "}");
    CompilerTests.daggerCompiler(testComponent)
        .compile(
            subject -> {
              subject.hasErrorCount(2);
              subject.hasErrorContaining("wildcard type").onSource(testComponent).onLine(9);
              subject.hasErrorContaining("wildcard type").onSource(testComponent).onLine(10);
            });
  }

  // TODO(b/245954367): Migrate test to XProcessing Testing after this bug has been fixed.
  @Test
  public void invalidComponentDependencies() {
    JavaFileObject testComponent =
        JavaFileObjects.forSourceLines(
            "test.TestComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component(dependencies = int.class)",
            "interface TestComponent {}");
    Compilation compilation = daggerCompiler().compile(testComponent);
    assertThat(compilation).failed();
    assertThat(compilation).hadErrorContaining("int is not a valid component dependency type");
  }

  // TODO(b/245954367): Migrate test to XProcessing Testing after this bug has been fixed.
  @Test
  public void invalidComponentModules() {
    JavaFileObject testComponent =
        JavaFileObjects.forSourceLines(
            "test.TestComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component(modules = int.class)",
            "interface TestComponent {}");
    Compilation compilation = daggerCompiler().compile(testComponent);
    assertThat(compilation).failed();
    assertThat(compilation).hadErrorContaining("int is not a valid module type");
  }

  @Test
  public void moduleInDependencies() {
    Source testModule =
        CompilerTests.javaSource(
            "test.TestModule",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "",
            "@Module",
            "final class TestModule {",
            "  @Provides String s() { return null; }",
            "}");
    Source testComponent =
        CompilerTests.javaSource(
            "test.TestComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component(dependencies = TestModule.class)",
            "interface TestComponent {}");
    CompilerTests.daggerCompiler(testModule, testComponent)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                  "test.TestModule is a module, which cannot be a component dependency");
            });
  }

  @Test
  public void componentDependencyMustNotCycle_Direct() {
    Source shortLifetime =
        CompilerTests.javaSource(
            "test.ComponentShort",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component(dependencies = ComponentShort.class)",
            "interface ComponentShort {",
            "}");

    String errorMessage =
        message(
            "test.ComponentShort contains a cycle in its component dependencies:",
            "    test.ComponentShort");
    CompilerTests.daggerCompiler(shortLifetime)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(errorMessage);
            });

    // Test that this also fails when transitive validation is disabled.
    CompilerTests.daggerCompiler(shortLifetime)
        .withProcessingOptions(
            ImmutableMap.of("dagger.validateTransitiveComponentDependencies", "DISABLED"))
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(errorMessage);
            });
  }

  @Test
  public void componentDependencyMustNotCycle_Indirect() {
    Source longLifetime =
        CompilerTests.javaSource(
            "test.ComponentLong",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component(dependencies = ComponentMedium.class)",
            "interface ComponentLong {",
            "}");
    Source mediumLifetime =
        CompilerTests.javaSource(
            "test.ComponentMedium",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component(dependencies = ComponentLong.class)",
            "interface ComponentMedium {",
            "}");
    Source shortLifetime =
        CompilerTests.javaSource(
            "test.ComponentShort",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component(dependencies = ComponentMedium.class)",
            "interface ComponentShort {",
            "}");

    CompilerTests.daggerCompiler(longLifetime, mediumLifetime, shortLifetime)
        .compile(
            subject -> {
              subject.hasErrorCount(3);
              subject.hasErrorContaining(
                      message(
                          "test.ComponentLong contains a cycle in its component dependencies:",
                          "    test.ComponentLong",
                          "    test.ComponentMedium",
                          "    test.ComponentLong"))
                  .onSource(longLifetime);
              subject.hasErrorContaining(
                      message(
                          "test.ComponentMedium contains a cycle in its component dependencies:",
                          "    test.ComponentMedium",
                          "    test.ComponentLong",
                          "    test.ComponentMedium"))
                  .onSource(mediumLifetime);
              subject.hasErrorContaining(
                      message(
                          "test.ComponentShort contains a cycle in its component dependencies:",
                          "    test.ComponentMedium",
                          "    test.ComponentLong",
                          "    test.ComponentMedium",
                          "    test.ComponentShort"))
                  .onSource(shortLifetime);
            });

    // Test that compilation succeeds when transitive validation is disabled because the cycle
    // cannot be detected.
    CompilerTests.daggerCompiler(longLifetime, mediumLifetime, shortLifetime)
        .withProcessingOptions(
            ImmutableMap.of("dagger.validateTransitiveComponentDependencies", "DISABLED"))
        .compile(subject -> subject.hasErrorCount(0));
  }

  @Test
  public void abstractModuleWithInstanceMethod() {
    Source module =
        CompilerTests.javaSource(
            "test.TestModule",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "",
            "@Module",
            "abstract class TestModule {",
            "  @Provides int i() { return 1; }",
            "}");
    Source component =
        CompilerTests.javaSource(
            "test.TestComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component(modules = TestModule.class)",
            "interface TestComponent {",
            "  int i();",
            "}");
    CompilerTests.daggerCompiler(module, component)
        .compile(
            subject -> {
              subject.hasErrorCount(1);
              subject.hasErrorContaining(
                      "TestModule is abstract and has instance @Provides methods")
                  .onSource(component)
                  .onLineContaining("interface TestComponent");
            });
  }

  @Test
  public void abstractModuleWithInstanceMethod_subclassedIsAllowed() {
    Source abstractModule =
        CompilerTests.javaSource(
            "test.AbstractModule",
            "package test;",
            "",
            "import dagger.Module;",
            "import dagger.Provides;",
            "",
            "@Module",
            "abstract class AbstractModule {",
            "  @Provides int i() { return 1; }",
            "}");
    Source subclassedModule =
        CompilerTests.javaSource(
            "test.SubclassedModule",
            "package test;",
            "",
            "import dagger.Module;",
            "",
            "@Module",
            "class SubclassedModule extends AbstractModule {}");
    Source component =
        CompilerTests.javaSource(
            "test.TestComponent",
            "package test;",
            "",
            "import dagger.Component;",
            "",
            "@Component(modules = SubclassedModule.class)",
            "interface TestComponent {",
            "  int i();",
            "}");
    CompilerTests.daggerCompiler(abstractModule, subclassedModule, component)
        .compile(subject -> subject.hasErrorCount(0));
  }
}