// Copyright 2017 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.rules.config;

import static com.google.devtools.build.lib.collect.nestedset.Order.STABLE_ORDER;
import static com.google.devtools.build.lib.packages.Type.STRING;
import static com.google.devtools.build.lib.packages.Types.STRING_LIST;

import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMultiset;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Multiset;
import com.google.devtools.build.lib.actions.ActionConflictException;
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.analysis.Allowlist;
import com.google.devtools.build.lib.analysis.ConfiguredTarget;
import com.google.devtools.build.lib.analysis.RuleConfiguredTargetBuilder;
import com.google.devtools.build.lib.analysis.RuleConfiguredTargetFactory;
import com.google.devtools.build.lib.analysis.RuleContext;
import com.google.devtools.build.lib.analysis.RuleDefinitionEnvironment;
import com.google.devtools.build.lib.analysis.RunfilesProvider;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
import com.google.devtools.build.lib.packages.Attribute;
import com.google.devtools.build.lib.packages.Attribute.ComputedDefault;
import com.google.devtools.build.lib.packages.AttributeMap;
import java.util.List;
import java.util.Optional;
import javax.annotation.Nullable;
import net.starlark.java.eval.Starlark;
import net.starlark.java.eval.StarlarkSemantics;

/**
 * The implementation of the config_feature_flag rule for defining custom flags for Android rules.
 */
public class ConfigFeatureFlag implements RuleConfiguredTargetFactory {
  /**
   * The name of the policy that is used to restrict access to the config_feature_flag rule and
   * attribute-triggered access to the feature flags setter transition.
   */
  public static final String ALLOWLIST_NAME = "config_feature_flag";

  /** The label of the policy for ALLOWLIST_NAME. */
  private static final String ALLOWLIST_LABEL =
      "//tools/allowlists/config_feature_flag:config_feature_flag";

  /** Constructs a definition for the attribute used to restrict access to config_feature_flag. */
  public static Attribute.Builder<Label> getAllowlistAttribute(RuleDefinitionEnvironment env) {
    return Allowlist.getAttributeFromAllowlistName(ALLOWLIST_NAME)
        .value(env.getToolsLabel(ALLOWLIST_LABEL));
  }

  /**
   * Constructs a definition for the attribute used to restrict access to config_feature_flag. The
   * allowlist will only be reached if the given {@code attributeToInspect} has a value explicitly
   * specified.
   */
  public static Attribute.Builder<Label> getAllowlistAttribute(
      RuleDefinitionEnvironment env, String attributeToInspect) {
    final Label label = env.getToolsLabel(ALLOWLIST_LABEL);
    return Allowlist.getAttributeFromAllowlistName(ALLOWLIST_NAME)
        .value(
            /**
             * Critically, get is never actually called on attributeToInspect and thus it is not
             * necessary to declare whether it is configurable, for this context.
             */
            new ComputedDefault() {
              @Nullable
              @Override
              public Label getDefault(AttributeMap rule) {
                return rule.isAttributeValueExplicitlySpecified(attributeToInspect) ? label : null;
              }
            });
  }

  /**
   * The name of the policy that is used to restrict access to rule definitions attaching the
   * feature flag setting transition.
   *
   * <p>Defined here for consistency with ALLOWLIST_NAME policy.
   */
  public static final String SETTER_ALLOWLIST_NAME = "config_feature_flag_setter";

  /** The label of the policy for SETTER_ALLOWLIST_NAME. */
  private static final String SETTER_ALLOWLIST_LABEL =
      "//tools/allowlists/config_feature_flag:config_feature_flag_setter";

  /** Constructs a definition for the attribute used to restrict access to config_feature_flag. */
  public static Attribute.Builder<Label> getSetterAllowlistAttribute(
      RuleDefinitionEnvironment env) {
    return Allowlist.getAttributeFromAllowlistName(SETTER_ALLOWLIST_NAME)
        .value(env.getToolsLabel(SETTER_ALLOWLIST_LABEL));
  }

  @Override
  @Nullable
  public ConfiguredTarget create(RuleContext ruleContext)
      throws InterruptedException, RuleErrorException, ActionConflictException {
    List<String> specifiedValues = ruleContext.attributes().get("allowed_values", STRING_LIST);
    ImmutableSet<String> values = ImmutableSet.copyOf(specifiedValues);
    if (values.size() != specifiedValues.size()) {
      ImmutableMultiset<String> groupedValues = ImmutableMultiset.copyOf(specifiedValues);
      ImmutableList.Builder<String> duplicates = new ImmutableList.Builder<>();
      for (Multiset.Entry<String> value : groupedValues.entrySet()) {
        if (value.getCount() > 1) {
          duplicates.add(value.getElement());
        }
      }
      // This is a problem with attributes of config_feature_flag itself so throw error here.
      ruleContext.attributeError(
          "allowed_values",
          "cannot contain duplicates, but contained multiple of "
              + Starlark.repr(duplicates.build(), StarlarkSemantics.DEFAULT));
    }

    Optional<String> defaultValue =
        ruleContext.attributes().isAttributeValueExplicitlySpecified("default_value")
            ? Optional.of(ruleContext.attributes().get("default_value", STRING))
            : Optional.empty();
    if (defaultValue.isPresent() && !values.contains(defaultValue.get())) {
      // This is a problem with attributes of config_feature_flag itself so throw error here.
      ruleContext.attributeError(
          "default_value",
          "must be one of "
              + Starlark.repr(values.asList(), StarlarkSemantics.DEFAULT)
              + ", but was "
              + Starlark.repr(defaultValue.get(), StarlarkSemantics.DEFAULT));
    }

    if (ruleContext.hasErrors()) {
      // Don't bother validating the value if the flag was already incorrectly specified without
      // looking at the value.
      return null;
    }

    Object rawStarlarkValue =
        ruleContext
            .getConfiguration()
            .getOptions()
            .getStarlarkOptions()
            .get(ruleContext.getLabel());
    if (!(rawStarlarkValue instanceof FeatureFlagValue)) {
      // Retain legacy behavior of treating feature flags that somehow are not FeatureFlagValue
      // as set to default
      rawStarlarkValue = FeatureFlagValue.DefaultValue.INSTANCE;
    }

    @Nullable
    ConfigFeatureFlagProvider provider =
        constructProvider((FeatureFlagValue) rawStarlarkValue, defaultValue, values, ruleContext);
    if (provider == null) {
      return null;
    }

    return new RuleConfiguredTargetBuilder(ruleContext)
        .setFilesToBuild(NestedSetBuilder.<Artifact>emptySet(STABLE_ORDER))
        .addProvider(RunfilesProvider.class, RunfilesProvider.EMPTY)
        .addNativeDeclaredProvider(provider)
        .build();
  }

  /**
   * Calculate and return a ConfigFeatureFlagProvider.
   *
   * <p>At this point any errors here are due to something being 'wrong' with the configuration. In
   * particular, this provider may be constructed BEFORE a rule transition sets the expected
   * configuration and thus want to defer errors until later in analysis when this value is actually
   * consumed as the errors would otherwise be unfixable.
   *
   * <p>An exception is made for if the value is explicitly set to value not in the allowed values
   * list (either on the commandline or as part of a previous transition). In that case, that is an
   * immediate error as can be fixed by ensuring those places set to allowed values. This is
   * consistent with the behavior of build_setting.
   */
  @Nullable
  private static ConfigFeatureFlagProvider constructProvider(
      FeatureFlagValue featureFlagValue,
      Optional<String> defaultValue,
      ImmutableSet<String> values,
      RuleContext ruleContext) {
    Predicate<String> isValidValue = Predicates.in(values);
    if (featureFlagValue instanceof FeatureFlagValue.SetValue) {
      String setValue = ((FeatureFlagValue.SetValue) featureFlagValue).value();
      if (!isValidValue.apply(setValue)) {
        // This is consistent with build_setting, which also immediate checks that
        // explicitly set values are valid values.
        ruleContext.ruleError(
            "value must be one of "
                + Starlark.repr(values.asList(), StarlarkSemantics.DEFAULT)
                + ", but was "
                + Starlark.repr(setValue, StarlarkSemantics.DEFAULT));
        return null;
      }
      return ConfigFeatureFlagProvider.create(setValue, null, isValidValue);
    } else if (featureFlagValue.equals(FeatureFlagValue.DefaultValue.INSTANCE)) {
      if (!defaultValue.isPresent()) {
        // Should defer error in case value is set by upcoming rule transition.
        // (Although, rule authors could just add a default.)
        // build_setting always has a default so this can't happen for them.
        return ConfigFeatureFlagProvider.create(
            null,
            String.format(
                "Feature flag %s has no default but no value was explicitly specified.",
                ruleContext.getLabel()),
            isValidValue);
      }
      return ConfigFeatureFlagProvider.create(defaultValue.get(), null, isValidValue);
    } else if (featureFlagValue.equals(FeatureFlagValue.UnknownValue.INSTANCE)) {
      // Must defer error in case value is set by upcoming rule transition.
      // build_setting doesn't have trimming logic so this can't happen for them.
      return ConfigFeatureFlagProvider.create(
          null,
          String.format(
              "Feature flag %1$s was accessed in a configuration it is not present in. All "
                  + "targets which depend on %1$s directly or indirectly must name it in their "
                  + "transitive_configs attribute.",
              ruleContext.getLabel()),
          isValidValue);
    } else {
      throw new IllegalStateException("Impossible state for FeatureFlagValue: " + featureFlagValue);
    }
  }
}
