// Copyright 2017 The Nomulus 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 google.registry.monitoring.metrics.contrib;

import static com.google.common.base.Preconditions.checkNotNull;

import com.google.common.base.Function;
import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.common.collect.Ordering;
import com.google.common.truth.FailureStrategy;
import com.google.common.truth.Subject;
import google.registry.monitoring.metrics.Metric;
import google.registry.monitoring.metrics.MetricPoint;
import java.util.HashSet;
import java.util.Set;
import javax.annotation.Nullable;

/**
 * Base truth subject for asserting things about {@link Metric} instances.
 *
 * <p>For use with the Google <a href="https://google.github.io/truth/">Truth</a> framework.
 */
abstract class AbstractMetricSubject<
        T, M extends Metric<T>, S extends AbstractMetricSubject<T, M, S>>
    extends Subject<S, M> {

  /** And chainer to allow fluent assertions. */
  public static class And<S extends AbstractMetricSubject<?, ?, S>> {

    private final S subject;

    And(S subject) {
      this.subject = subject;
    }

    public S and() {
      return subject;
    }
  }

  @SuppressWarnings("unchecked")
  And<S> andChainer() {
    return new And<>((S) this);
  }

  /** List of label value tuples about which an assertion has been made so far.
   *
   * <p>Used to track what tuples have been seen, in order to support hasNoOtherValues() assertions.
   */
  protected final Set<ImmutableList<String>> expectedNondefaultLabelTuples = new HashSet<>();

  /**
   * Function to convert a metric point to a nice string representation for use in error messages.
   */
  protected final Function<MetricPoint<T>, String> metricPointConverter =
      new Function<MetricPoint<T>, String>() {
        @Override
        public String apply(MetricPoint<T> metricPoint) {
          return String.format(
              "%s => %s",
              Joiner.on(':').join(metricPoint.labelValues()),
              getMessageRepresentation(metricPoint.value()));
        }
      };

  protected AbstractMetricSubject(FailureStrategy strategy, M actual) {
    super(strategy, checkNotNull(actual));
  }

  /**
   * Returns the string representation of the subject.
   *
   * <p>For metrics, it makes sense to use the metric name, as given in the schema.
   */
  @Override
  public String actualCustomStringRepresentation() {
    return actual().getMetricSchema().name();
  }

  /**
   * Asserts that the metric has a given value for the specified label values.
   *
   * @param value the value which the metric should have
   * @param labels the labels for which the value is being asserted; the number and order of labels
   *     should match the definition of the metric
   */
  public And<S> hasValueForLabels(T value, String... labels) {
    MetricPoint<T> metricPoint = findMetricPointForLabels(ImmutableList.copyOf(labels));
    if (metricPoint == null) {
      failWithBadResults(
          "has a value for labels",
          Joiner.on(':').join(labels),
          "has labeled values",
          Lists.transform(
              Ordering.<MetricPoint<T>>natural().sortedCopy(actual().getTimestampedValues()),
              metricPointConverter));
    }
    if (!metricPoint.value().equals(value)) {
      failWithBadResults(
          String.format("has a value of %s for labels", value),
          Joiner.on(':').join(labels),
          "has a value of",
          getMessageRepresentation(metricPoint.value()));
    }
    expectedNondefaultLabelTuples.add(ImmutableList.copyOf(labels));
    return andChainer();
  }

  /**
   * Asserts that the metric has any (non-default) value for the specified label values.
   *
   * @param labels the labels for which the value is being asserted; the number and order of labels
   *     should match the definition of the metric
   */
  public And<S> hasAnyValueForLabels(String... labels) {
    MetricPoint<T> metricPoint = findMetricPointForLabels(ImmutableList.copyOf(labels));
    if (metricPoint == null) {
      failWithBadResults(
          "has a value for labels",
          Joiner.on(':').join(labels),
          "has labeled values",
          Lists.transform(
              Ordering.<MetricPoint<T>>natural().sortedCopy(actual().getTimestampedValues()),
              metricPointConverter));
    }
    if (hasDefaultValue(metricPoint)) {
      failWithBadResults(
          "has a non-default value for labels",
          Joiner.on(':').join(labels),
          "has a value of",
          getMessageRepresentation(metricPoint.value()));
    }
    expectedNondefaultLabelTuples.add(ImmutableList.copyOf(labels));
    return andChainer();
  }

  /**
   * Asserts that the metric does not have a (non-default) value for the specified label values.
   */
  protected And<S> doesNotHaveAnyValueForLabels(String... labels) {
    MetricPoint<T> metricPoint = findMetricPointForLabels(ImmutableList.copyOf(labels));
    if (metricPoint != null) {
      failWithBadResults(
          "has no value for labels",
          Joiner.on(':').join(labels),
          "has a value of",
          getMessageRepresentation(metricPoint.value()));
    }
    return andChainer();
  }

  /**
   * Asserts that the metric has no (non-default) values other than those about which an assertion
   * has already been made.
   */
  public And<S> hasNoOtherValues() {
    for (MetricPoint<T> metricPoint : actual().getTimestampedValues()) {
      if (!expectedNondefaultLabelTuples.contains(metricPoint.labelValues())) {
        if (!hasDefaultValue(metricPoint)) {
          failWithBadResults(
              "has",
              "no other nondefault values",
              "has labeled values",
              Lists.transform(
                  Ordering.<MetricPoint<T>>natural().sortedCopy(actual().getTimestampedValues()),
                  metricPointConverter));
        }
        return andChainer();
      }
    }
    return andChainer();
  }

  private @Nullable MetricPoint<T> findMetricPointForLabels(ImmutableList<String> labels) {
    if (actual().getMetricSchema().labels().size() != labels.size()) {
      return null;
    }
    for (MetricPoint<T> metricPoint : actual().getTimestampedValues()) {
      if (metricPoint.labelValues().equals(labels)) {
        return metricPoint;
      }
    }
    return null;
  }

  /**
   * Returns true if the metric point has a non-default value.
   *
   * <p>This should be overridden by subclasses. E.g. for incrementable metrics, the method should
   * return true if the value is not zero, and so on.
   */
  protected abstract boolean hasDefaultValue(MetricPoint<T> metricPoint);

  /** Returns a string representation of a metric point value, for use in error messages. */
  protected abstract String getMessageRepresentation(T value);
}