/*
 * 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.validation;

import static com.google.common.collect.Iterables.getOnlyElement;
import static dagger.internal.codegen.base.Util.reentrantComputeIfAbsent;
import static dagger.internal.codegen.binding.AssistedInjectionAnnotations.assistedInjectedConstructors;
import static dagger.internal.codegen.binding.InjectionAnnotations.injectedConstructors;
import static dagger.internal.codegen.binding.SourceFiles.factoryNameForElement;
import static dagger.internal.codegen.binding.SourceFiles.membersInjectorNameForType;
import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
import static dagger.internal.codegen.xprocessing.XElements.closestEnclosingTypeElement;
import static dagger.internal.codegen.xprocessing.XElements.getAnyAnnotation;
import static dagger.internal.codegen.xprocessing.XMethodElements.hasTypeParameters;
import static dagger.internal.codegen.xprocessing.XTypes.isSubtype;

import androidx.room.compiler.processing.XAnnotation;
import androidx.room.compiler.processing.XConstructorElement;
import androidx.room.compiler.processing.XElement;
import androidx.room.compiler.processing.XExecutableParameterElement;
import androidx.room.compiler.processing.XFieldElement;
import androidx.room.compiler.processing.XMethodElement;
import androidx.room.compiler.processing.XProcessingEnv;
import androidx.room.compiler.processing.XType;
import androidx.room.compiler.processing.XTypeElement;
import androidx.room.compiler.processing.XVariableElement;
import com.google.common.collect.ImmutableSet;
import com.squareup.javapoet.ClassName;
import com.squareup.javapoet.TypeName;
import dagger.internal.codegen.base.ClearableCache;
import dagger.internal.codegen.base.DaggerSuperficialValidation;
import dagger.internal.codegen.binding.InjectionAnnotations;
import dagger.internal.codegen.binding.MethodSignatureFormatter;
import dagger.internal.codegen.compileroption.CompilerOptions;
import dagger.internal.codegen.javapoet.TypeNames;
import dagger.internal.codegen.langmodel.Accessibility;
import dagger.internal.codegen.model.Scope;
import dagger.internal.codegen.xprocessing.XAnnotations;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
import javax.tools.Diagnostic;

/**
 * A {@linkplain ValidationReport validator} for {@link Inject}-annotated elements and the types
 * that contain them.
 */
@Singleton
public final class InjectValidator implements ClearableCache {

  private final XProcessingEnv processingEnv;
  private final DependencyRequestValidator dependencyRequestValidator;
  private final InjectionAnnotations injectionAnnotations;
  private final DaggerSuperficialValidation superficialValidation;
  private final MethodSignatureFormatter methodSignatureFormatter;
  private final InternalValidator validator;
  private final InternalValidator validatorWhenGeneratingCode;

  @Inject
  InjectValidator(
      XProcessingEnv processingEnv,
      DependencyRequestValidator dependencyRequestValidator,
      CompilerOptions compilerOptions,
      InjectionAnnotations injectionAnnotations,
      DaggerSuperficialValidation superficialValidation,
      MethodSignatureFormatter methodSignatureFormatter) {
    this.processingEnv = processingEnv;
    this.dependencyRequestValidator = dependencyRequestValidator;
    this.injectionAnnotations = injectionAnnotations;
    this.superficialValidation = superficialValidation;
    this.methodSignatureFormatter = methodSignatureFormatter;

    // When validating types that require a generated factory class we need to error on private and
    // static inject members even if the compiler options are set to not error.
    this.validatorWhenGeneratingCode =
        new InternalValidator(Diagnostic.Kind.ERROR, Diagnostic.Kind.ERROR);

    // When validating types that might not require a generated factory we can take the user flags
    // for private and static inject members into account, but try to reuse the existing one if the
    // diagnostic kinds are the same.
    this.validator =
        (compilerOptions.privateMemberValidationKind() == Diagnostic.Kind.ERROR
                && compilerOptions.staticMemberValidationKind() == Diagnostic.Kind.ERROR)
            ? validatorWhenGeneratingCode
            : new InternalValidator(
                compilerOptions.privateMemberValidationKind(),
                compilerOptions.staticMemberValidationKind());
  }

  @Override
  public void clearCache() {
    validator.clearCache();
    validatorWhenGeneratingCode.clearCache();
  }

  public ValidationReport validate(XTypeElement typeElement) {
    return validator.validate(typeElement);
  }

  public ValidationReport validateForMembersInjection(XTypeElement typeElement) {
    return validator.validateForMembersInjection(typeElement);
  }

  /**
   * Validates {@code typeElement} that requires a factory to be generated.
   *
   * <p>In this case, the validator will have stricter validation for private and static injection
   * since the generated factory doesn't support those types.
   */
  public ValidationReport validateWhenGeneratingCode(XTypeElement typeElement) {
    if (typeElement.getPackageName().startsWith("org.atinject.tck")) {
      // The Technology Compatibility Kit (TCK) package is a special package for testing the JSR330
      // spec, which includes optional features like supporting static/private inject members. Even
      // though Dagger doesn't support this, we allow it for this one case for the test coverage
      // purposes. Use the normal validator which takes the user's compiler flags into account.
      return validator.validate(typeElement);
    }
    return validatorWhenGeneratingCode.validate(typeElement);
  }

  private final class InternalValidator {
    private final Diagnostic.Kind privateMemberDiagnosticKind;
    private final Diagnostic.Kind staticMemberDiagnosticKind;
    private final Map<XTypeElement, ValidationReport> provisionReports = new HashMap<>();
    private final Map<XTypeElement, ValidationReport> membersInjectionReports = new HashMap<>();

    InternalValidator(
        Diagnostic.Kind privateMemberDiagnosticKind, Diagnostic.Kind staticMemberDiagnosticKind) {
      this.privateMemberDiagnosticKind = privateMemberDiagnosticKind;
      this.staticMemberDiagnosticKind = staticMemberDiagnosticKind;
    }

    void clearCache() {
      provisionReports.clear();
      membersInjectionReports.clear();
    }

    ValidationReport validate(XTypeElement typeElement) {
      return reentrantComputeIfAbsent(provisionReports, typeElement, this::validateUncached);
    }

    private ValidationReport validateUncached(XTypeElement typeElement) {
      ValidationReport.Builder builder = ValidationReport.about(typeElement);
      builder.addSubreport(validateForMembersInjectionInternal(typeElement));

      ImmutableSet<XConstructorElement> injectConstructors =
          ImmutableSet.<XConstructorElement>builder()
              .addAll(injectedConstructors(typeElement))
              .addAll(assistedInjectedConstructors(typeElement))
              .build();

      switch (injectConstructors.size()) {
        case 0:
          break; // Nothing to validate.
        case 1:
          builder.addSubreport(validateConstructor(getOnlyElement(injectConstructors)));
          break;
        default:
          builder.addError(
              String.format(
                  "Type %s may only contain one injected constructor. Found: %s",
                  typeElement.getQualifiedName(),
                  injectConstructors.stream()
                      .map(methodSignatureFormatter::format)
                      .collect(toImmutableList())),
              typeElement);
      }

      return builder.build();
    }

    private ValidationReport validateConstructor(XConstructorElement constructorElement) {
      superficialValidation.validateTypeOf(constructorElement);
      ValidationReport.Builder builder =
          ValidationReport.about(constructorElement.getEnclosingElement());

      if (InjectionAnnotations.hasInjectAnnotation(constructorElement)
          && constructorElement.hasAnnotation(TypeNames.ASSISTED_INJECT)) {
        builder.addError("Constructors cannot be annotated with both @Inject and @AssistedInject");
      }

      ClassName injectAnnotation =
          getAnyAnnotation(
                  constructorElement,
                  TypeNames.INJECT,
                  TypeNames.INJECT_JAVAX,
                  TypeNames.ASSISTED_INJECT)
              .map(XAnnotations::getClassName)
              .get();

      if (constructorElement.isPrivate()) {
        builder.addError(
            "Dagger does not support injection into private constructors", constructorElement);
      }

      // If this type has already been processed in a previous round or compilation unit then there
      // is no reason to recheck for invalid scope annotations since it's already been checked.
      // This allows us to skip superficial validation of constructor annotations in subsequent
      // compilations where the annotation types may no longer be on the classpath.
      if (!processedInPreviousRoundOrCompilationUnit(constructorElement)) {
        superficialValidation.validateAnnotationsOf(constructorElement);
        for (XAnnotation qualifier : injectionAnnotations.getQualifiers(constructorElement)) {
          builder.addError(
              String.format(
                  "@Qualifier annotations are not allowed on @%s constructors",
                  injectAnnotation.simpleName()),
              constructorElement,
              qualifier);
        }

        String scopeErrorMsg =
            String.format(
                "@Scope annotations are not allowed on @%s constructors",
                injectAnnotation.simpleName());

        if (injectAnnotation.equals(TypeNames.INJECT)
            || injectAnnotation.equals(TypeNames.INJECT_JAVAX)) {
          scopeErrorMsg += "; annotate the class instead";
        }

        for (Scope scope : injectionAnnotations.getScopes(constructorElement)) {
          builder.addError(
              scopeErrorMsg, constructorElement, scope.scopeAnnotation().xprocessing());
        }
      }

      for (XExecutableParameterElement parameter : constructorElement.getParameters()) {
        superficialValidation.validateTypeOf(parameter);
        validateDependencyRequest(builder, parameter);
      }

      if (throwsCheckedExceptions(constructorElement)) {
        builder.addItem(
            String.format(
                "Dagger does not support checked exceptions on @%s constructors",
                injectAnnotation.simpleName()),
            privateMemberDiagnosticKind,
            constructorElement);
      }

      checkInjectIntoPrivateClass(constructorElement, builder);

      XTypeElement enclosingElement = constructorElement.getEnclosingElement();
      if (enclosingElement.isAbstract()) {
        builder.addError(
            String.format(
                "@%s is nonsense on the constructor of an abstract class",
                injectAnnotation.simpleName()),
            constructorElement);
      }

      if (enclosingElement.isNested() && !enclosingElement.isStatic()) {
        builder.addError(
            String.format(
                "@%s constructors are invalid on inner classes. "
                    + "Did you mean to make the class static?",
                injectAnnotation.simpleName()),
            constructorElement);
      }

      // Note: superficial validation of the annotations is done as part of getting the scopes.
      ImmutableSet<Scope> scopes =
          injectionAnnotations.getScopes(constructorElement.getEnclosingElement());
      if (injectAnnotation.equals(TypeNames.ASSISTED_INJECT)) {
        for (Scope scope : scopes) {
          builder.addError(
              "A type with an @AssistedInject-annotated constructor cannot be scoped",
              enclosingElement,
              scope.scopeAnnotation().xprocessing());
        }
      } else if (scopes.size() > 1) {
        for (Scope scope : scopes) {
          builder.addError(
              "A single binding may not declare more than one @Scope",
              enclosingElement,
              scope.scopeAnnotation().xprocessing());
        }
      }

      return builder.build();
    }

    private ValidationReport validateField(XFieldElement fieldElement) {
      superficialValidation.validateTypeOf(fieldElement);
      ValidationReport.Builder builder = ValidationReport.about(fieldElement);
      if (fieldElement.isFinal()) {
        builder.addError("@Inject fields may not be final", fieldElement);
      }

      if (fieldElement.isPrivate()) {
        builder.addItem(
            "Dagger does not support injection into private fields",
            privateMemberDiagnosticKind,
            fieldElement);
      }

      if (fieldElement.isStatic()) {
        builder.addItem(
            "Dagger does not support injection into static fields",
            staticMemberDiagnosticKind,
            fieldElement);
      }

      if (fieldElement.isProtected()
          && fieldElement.getEnclosingElement().isFromKotlin()
          ) {
        builder.addError(
            "Dagger injector does not have access to kotlin protected fields", fieldElement);
      }

      validateDependencyRequest(builder, fieldElement);

      return builder.build();
    }

    private ValidationReport validateMethod(XMethodElement methodElement) {
      superficialValidation.validateTypeOf(methodElement);
      ValidationReport.Builder builder = ValidationReport.about(methodElement);
      if (methodElement.isAbstract()) {
        builder.addError("Methods with @Inject may not be abstract", methodElement);
      }

      if (methodElement.isPrivate()) {
        builder.addItem(
            "Dagger does not support injection into private methods",
            privateMemberDiagnosticKind,
            methodElement);
      }

      if (methodElement.isStatic()) {
        builder.addItem(
            "Dagger does not support injection into static methods",
            staticMemberDiagnosticKind,
            methodElement);
      }

      // No need to resolve type parameters since we're only checking existence.
      if (hasTypeParameters(methodElement)) {
        builder.addError("Methods with @Inject may not declare type parameters", methodElement);
      }

      // No need to resolve thrown types since we're only checking existence.
      if (!methodElement.getThrownTypes().isEmpty()) {
        builder.addError(
            "Methods with @Inject may not throw checked exceptions. "
                + "Please wrap your exceptions in a RuntimeException instead.",
            methodElement);
      }

      for (XExecutableParameterElement parameter : methodElement.getParameters()) {
        superficialValidation.validateTypeOf(parameter);
        validateDependencyRequest(builder, parameter);
      }

      return builder.build();
    }

    private void validateDependencyRequest(
        ValidationReport.Builder builder, XVariableElement parameter) {
      dependencyRequestValidator.validateDependencyRequest(builder, parameter, parameter.getType());
      dependencyRequestValidator.checkNotProducer(builder, parameter);
    }

    public ValidationReport validateForMembersInjection(XTypeElement typeElement) {
      return !processedInPreviousRoundOrCompilationUnit(typeElement)
          ? validate(typeElement) // validate everything
          : validateForMembersInjectionInternal(typeElement); // validate only inject members
    }

    private ValidationReport validateForMembersInjectionInternal(XTypeElement typeElement) {
      return reentrantComputeIfAbsent(
          membersInjectionReports, typeElement, this::validateForMembersInjectionInternalUncached);
    }

    private ValidationReport validateForMembersInjectionInternalUncached(XTypeElement typeElement) {
      superficialValidation.validateTypeOf(typeElement);
      // TODO(beder): This element might not be currently compiled, so this error message could be
      // left in limbo. Find an appropriate way to display the error message in that case.
      ValidationReport.Builder builder = ValidationReport.about(typeElement);
      boolean hasInjectedMembers = false;
      for (XFieldElement field : typeElement.getDeclaredFields()) {
        if (InjectionAnnotations.hasInjectAnnotation(field)) {
          hasInjectedMembers = true;
          ValidationReport report = validateField(field);
          if (!report.isClean()) {
            builder.addSubreport(report);
          }
        }
      }
      for (XMethodElement method : typeElement.getDeclaredMethods()) {
        if (InjectionAnnotations.hasInjectAnnotation(method)) {
          hasInjectedMembers = true;
          ValidationReport report = validateMethod(method);
          if (!report.isClean()) {
            builder.addSubreport(report);
          }
        }
      }

      if (hasInjectedMembers) {
        checkInjectIntoPrivateClass(typeElement, builder);
        checkInjectIntoKotlinObject(typeElement, builder);
      }

      Optional.ofNullable(typeElement.getSuperType())
          .filter(supertype -> !supertype.getTypeName().equals(TypeName.OBJECT))
          .ifPresent(
              supertype -> {
                superficialValidation.validateSuperTypeOf(typeElement);
                ValidationReport report = validateForMembersInjection(supertype.getTypeElement());
                if (!report.isClean()) {
                  builder.addSubreport(report);
                }
              });

      return builder.build();
    }

    /** Returns true if the given method element declares a checked exception. */
    private boolean throwsCheckedExceptions(XConstructorElement constructorElement) {
      XType runtimeException = processingEnv.findType(TypeNames.RUNTIME_EXCEPTION);
      XType error = processingEnv.findType(TypeNames.ERROR);
      superficialValidation.validateThrownTypesOf(constructorElement);
      return !constructorElement.getThrownTypes().stream()
          .allMatch(type -> isSubtype(type, runtimeException) || isSubtype(type, error));
    }

    private void checkInjectIntoPrivateClass(XElement element, ValidationReport.Builder builder) {
      if (!Accessibility.isElementAccessibleFromOwnPackage(closestEnclosingTypeElement(element))) {
        builder.addItem(
            "Dagger does not support injection into private classes",
            privateMemberDiagnosticKind,
            element);
      }
    }

    private void checkInjectIntoKotlinObject(
        XTypeElement element, ValidationReport.Builder builder) {
      if (element.isKotlinObject() || element.isCompanionObject()) {
        builder.addError("Dagger does not support injection into Kotlin objects", element);
      }
    }

    private boolean processedInPreviousRoundOrCompilationUnit(
        XConstructorElement injectConstructor) {
      return processingEnv.findTypeElement(factoryNameForElement(injectConstructor)) != null;
    }

    private boolean processedInPreviousRoundOrCompilationUnit(XTypeElement membersInjectedType) {
      return processingEnv.findTypeElement(membersInjectorNameForType(membersInjectedType)) != null;
    }
  }
}