// Copyright 2014 The Bazel Authors. All rights reserved.
//
// 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 com.google.devtools.build.lib.analysis;

import com.google.devtools.build.lib.analysis.AliasProvider.TargetMode;
import com.google.devtools.build.lib.analysis.ConfiguredRuleClassProvider.PrerequisiteValidator;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.cmdline.PackageIdentifier;
import com.google.devtools.build.lib.packages.Attribute;
import com.google.devtools.build.lib.packages.FunctionSplitTransitionWhitelist;
import com.google.devtools.build.lib.packages.NonconfigurableAttributeMapper;
import com.google.devtools.build.lib.packages.OutputFile;
import com.google.devtools.build.lib.packages.PackageGroup;
import com.google.devtools.build.lib.packages.RawAttributeMapper;
import com.google.devtools.build.lib.packages.Rule;
import com.google.devtools.build.lib.packages.RuleErrorConsumer;
import com.google.devtools.build.lib.packages.Target;
import com.google.devtools.build.lib.packages.Type;
import com.google.devtools.build.lib.skyframe.ConfiguredTargetAndData;

/**
 * A base implementation of {@link PrerequisiteValidator} that performs common checks based on
 * definitions of what is considered the same logical package and what is considered "experimental"
 * code, which has may have relaxed checks for visibility and deprecation.
 */
public abstract class CommonPrerequisiteValidator implements PrerequisiteValidator {
  @Override
  public void validate(
      RuleContext.Builder contextBuilder,
      ConfiguredTargetAndData prerequisite,
      Attribute attribute) {
    validateDirectPrerequisiteLocation(contextBuilder, prerequisite);
    validateDirectPrerequisiteVisibility(contextBuilder, prerequisite, attribute);
    validateDirectPrerequisiteForTestOnly(contextBuilder, prerequisite);
    validateDirectPrerequisiteForDeprecation(
        contextBuilder, contextBuilder.getRule(), prerequisite, contextBuilder.forAspect());
  }

  /**
   * Returns whether two packages are considered the same for purposes of deprecation warnings.
   * Dependencies within the same package do not print deprecation warnings; a package in the
   * javatests directory may also depend on its corresponding java package without a warning.
   */
  public abstract boolean isSameLogicalPackage(
      PackageIdentifier thisPackage, PackageIdentifier prerequisitePackage);

  /**
   * Returns whether a package is considered experimental. Packages outside of experimental may not
   * depend on packages that are experimental.
   */
  protected abstract boolean packageUnderExperimental(PackageIdentifier packageIdentifier);

  protected abstract boolean checkVisibilityForExperimental(RuleContext.Builder context);

  protected abstract boolean allowExperimentalDeps(RuleContext.Builder context);

  private void validateDirectPrerequisiteVisibility(
      RuleContext.Builder context, ConfiguredTargetAndData prerequisite, Attribute attribute) {
    String attrName = attribute.getName();
    Rule rule = context.getRule();
    Target prerequisiteTarget = prerequisite.getTarget();

    // We don't check the visibility of late-bound attributes, because it would break some
    // features.
    if (!isSameLogicalPackage(
            rule.getLabel().getPackageIdentifier(),
            AliasProvider.getDependencyLabel(prerequisite.getConfiguredTarget())
                .getPackageIdentifier())
        && !Attribute.isLateBound(attrName)) {

      // Determine if we should use the new visibility rules for tools.
      boolean toolCheckAtDefinition = false;
      try {
        toolCheckAtDefinition =
            context.getStarlarkSemantics().incompatibleVisibilityPrivateAttributesAtDefinition();
      } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
      }

      if (!toolCheckAtDefinition
          || !attribute.isImplicit()
          || rule.getRuleClassObject().getRuleDefinitionEnvironmentLabel() == null) {
        // Default check: The attribute must be visible from the target.
        if (!context.isVisible(prerequisite.getConfiguredTarget())) {
          handleVisibilityConflict(context, prerequisite, rule.getLabel());
        }
      } else {
        // For implicit attributes, check if the prerequisite is visible from the location of the
        // rule definition
        Label implicitDefinition = rule.getRuleClassObject().getRuleDefinitionEnvironmentLabel();
        if (!RuleContext.isVisible(implicitDefinition, prerequisite.getConfiguredTarget())) {
          handleVisibilityConflict(context, prerequisite, implicitDefinition);
        }
      }
    }

    if (prerequisiteTarget instanceof PackageGroup) {
      boolean containsPackageSpecificationProvider =
          RawAttributeMapper.of(rule)
              .getAttributeDefinition(attrName)
              .getRequiredProviders()
              .getDescription()
              .contains("PackageSpecificationProvider");
      // TODO(plf): Add the PackageSpecificationProvider to the 'visibility' attribute.
      if (!attrName.equals("visibility")
          && !attrName.equals(FunctionSplitTransitionWhitelist.WHITELIST_ATTRIBUTE_NAME)
          && !containsPackageSpecificationProvider) {
        context.attributeError(
            attrName,
            "in "
                + attrName
                + " attribute of "
                + rule.getRuleClass()
                + " rule "
                + rule.getLabel()
                + ": "
                + AliasProvider.describeTargetWithAliases(prerequisite, TargetMode.WITH_KIND)
                + " is misplaced here (they are only allowed in the visibility attribute)");
      }
    }
  }

  private void handleVisibilityConflict(
      RuleContext.Builder context, ConfiguredTargetAndData prerequisite, Label rule) {
    if (packageUnderExperimental(rule.getPackageIdentifier())
        && !checkVisibilityForExperimental(context)) {
      return;
    }

    if (!context.getConfiguration().checkVisibility()) {
      String errorMessage =
          String.format(
              "Target '%s' violates visibility of "
                  + "%s. Continuing because --nocheck_visibility is active",
              rule, AliasProvider.describeTargetWithAliases(prerequisite, TargetMode.WITHOUT_KIND));
      context.ruleWarning(errorMessage);
    } else {
      String errorMessage =
          String.format(
              "%s is not visible from target '%s'. Check "
                  + "the visibility declaration of the former target if you think "
                  + "the dependency is legitimate",
              AliasProvider.describeTargetWithAliases(prerequisite, TargetMode.WITHOUT_KIND), rule);
      context.ruleError(errorMessage);
    }
  }

  private void validateDirectPrerequisiteLocation(
      RuleContext.Builder context, ConfiguredTargetAndData prerequisite) {
    Rule rule = context.getRule();
    Target prerequisiteTarget = prerequisite.getTarget();
    Label prerequisiteLabel = prerequisiteTarget.getLabel();

    if (packageUnderExperimental(prerequisiteLabel.getPackageIdentifier())
        && !packageUnderExperimental(rule.getLabel().getPackageIdentifier())) {
      String message =
          "non-experimental target '"
              + rule.getLabel()
              + "' depends on experimental target '"
              + prerequisiteLabel
              + "'";
      if (allowExperimentalDeps(context)) {
        context.ruleWarning(
            message + " (ignored due to --experimental_deps_ok;" + " do not submit)");
      } else {
        context.ruleError(
            message
                + " (you may not check in such a dependency,"
                + " though you can test "
                + "against it by passing --experimental_deps_ok)");
      }
    }
  }

  /** Returns whether a deprecation warning should be printed for the prerequisite described. */
  private boolean shouldEmitDeprecationWarningFor(
      String thisDeprecation,
      PackageIdentifier thisPackage,
      String prerequisiteDeprecation,
      PackageIdentifier prerequisitePackage,
      boolean forAspect) {
    // Don't report deprecation edges from javatests to java or within a package;
    // otherwise tests of deprecated code generate nuisance warnings.
    // Don't report deprecation if the current target is also deprecated,
    // or if the current context is evaluating an aspect,
    // as the base target would have already printed the deprecation warnings.
    return (!forAspect
        && prerequisiteDeprecation != null
        && !isSameLogicalPackage(thisPackage, prerequisitePackage)
        && thisDeprecation == null);
  }

  /** Checks if the given prerequisite is deprecated and prints a warning if so. */
  private void validateDirectPrerequisiteForDeprecation(
      RuleErrorConsumer errors,
      Rule rule,
      ConfiguredTargetAndData prerequisite,
      boolean forAspect) {
    Target prerequisiteTarget = prerequisite.getTarget();
    Label prerequisiteLabel = prerequisiteTarget.getLabel();
    PackageIdentifier thatPackage = prerequisiteLabel.getPackageIdentifier();
    PackageIdentifier thisPackage = rule.getLabel().getPackageIdentifier();

    if (prerequisiteTarget instanceof Rule) {
      Rule prerequisiteRule = (Rule) prerequisiteTarget;
      String thisDeprecation =
          NonconfigurableAttributeMapper.of(rule).has("deprecation", Type.STRING)
              ? NonconfigurableAttributeMapper.of(rule).get("deprecation", Type.STRING)
              : null;
      String thatDeprecation =
          NonconfigurableAttributeMapper.of(prerequisiteRule).has("deprecation", Type.STRING)
              ? NonconfigurableAttributeMapper.of(prerequisiteRule).get("deprecation", Type.STRING)
              : null;
      if (shouldEmitDeprecationWarningFor(
          thisDeprecation, thisPackage, thatDeprecation, thatPackage, forAspect)) {
        errors.ruleWarning(
            "target '"
                + rule.getLabel()
                + "' depends on deprecated target '"
                + prerequisiteLabel
                + "': "
                + thatDeprecation);
      }
    }

    if (prerequisiteTarget instanceof OutputFile) {
      Rule generatingRule = ((OutputFile) prerequisiteTarget).getGeneratingRule();
      String thisDeprecation =
          NonconfigurableAttributeMapper.of(rule).get("deprecation", Type.STRING);
      String thatDeprecation =
          NonconfigurableAttributeMapper.of(generatingRule).get("deprecation", Type.STRING);
      if (shouldEmitDeprecationWarningFor(
          thisDeprecation, thisPackage, thatDeprecation, thatPackage, forAspect)) {
        errors.ruleWarning(
            "target '"
                + rule.getLabel()
                + "' depends on the output file "
                + prerequisiteLabel
                + " of a deprecated rule "
                + generatingRule.getLabel()
                + "': "
                + thatDeprecation);
      }
    }
  }

  /** Check that the dependency is not test-only, or the current rule is test-only. */
  private void validateDirectPrerequisiteForTestOnly(
      RuleContext.Builder context, ConfiguredTargetAndData prerequisite) {
    Rule rule = context.getRule();

    if (rule.getRuleClassObject().getAdvertisedProviders().canHaveAnyProvider()) {
      // testonly-ness will be checked directly between the depender and the target of the alias;
      // getTarget() called by the depender will not return the alias rule, but its actual target
      return;
    }

    Target prerequisiteTarget = prerequisite.getTarget();
    PackageIdentifier thisPackage = rule.getLabel().getPackageIdentifier();

    if (isTestOnlyRule(prerequisiteTarget) && !isTestOnlyRule(rule)) {
      String message =
          "non-test target '"
              + rule.getLabel()
              + "' depends on testonly "
              + AliasProvider.describeTargetWithAliases(prerequisite, TargetMode.WITHOUT_KIND)
              + " and doesn't have testonly attribute set";
      if (packageUnderExperimental(thisPackage)) {
        context.ruleWarning(message);
      } else {
        context.ruleError(message);
      }
    }
  }

  private static boolean isTestOnlyRule(Target target) {
    return (target instanceof Rule)
        && NonconfigurableAttributeMapper.of((Rule) target).has("testonly", Type.BOOLEAN)
        && NonconfigurableAttributeMapper.of((Rule) target).get("testonly", Type.BOOLEAN);
  }
}