/**
 * Calculates the weights of cache entries.
 *
 * @author Charles Fry
 * @since 11.0
 */
@GwtCompatible
public interface Weigher<K, V> {

  /**
   * Returns the weight of a cache entry. There is no unit for entry weights; rather they are simply
   * relative to each other.
   *
   * @return the weight of the entry; must be non-negative
   */
  int weigh(K key, V value);

  /** Returns a {@link Weigher} that returns the given {@code constant} for every request. */
  static Weigher<Object, Object> constantWeigher(int constant) {
    return new ConstantWeigher(constant);
  }

  /** Returns a {@link Weigher} that uses the integer key as the weight. */
  static Weigher<Integer, Object> intKeyWeigher() {
    return new IntKeyWeigher();
  }

  @CanIgnoreReturnValue // TODO(b/27479612): consider removing this
  public <K1 extends K, V1 extends V> CacheBuilder<K1, V1> weigher(
      Weigher<? super K1, ? super V1> weigher) {
    checkState(this.weigher == null);
    if (strictParsing) {
      checkState(
          this.maximumSize == UNSET_INT,
          "weigher can not be combined with maximum size (%s provided)",
          this.maximumSize);
    }

    IdentityLoader<Integer> loader = identityLoader();

    // Even numbers are free, odd are too expensive
    Weigher<Integer, Integer> evensOnly =
        new Weigher<Integer, Integer>() {
          @Override
          public int weigh(Integer k, Integer v) {
            return k % 2;
          }
        };

    assertWithMessage("removalListener")
        .that(actual.removalListener)
        .isEqualTo(expected.removalListener);
    assertWithMessage("weigher").that(actual.weigher).isEqualTo(expected.weigher);
    assertWithMessage("valueEquivalence")
        .that(actual.valueEquivalence)
        .isEqualTo(expected.valueEquivalence);

  public void testSetWeigher() {
    Weigher<Object, Object> testWeigher =
        new Weigher<Object, Object>() {
          @Override
          public int weigh(Object key, Object value) {
            return 42;
          }
        };
    LocalCache<Object, Object> map =
        makeLocalCache(createCacheBuilder().maximumWeight(1).weigher(testWeigher));
    assertThat(map.weigher).isSameInstanceAs(testWeigher);
  }

  public void testSetWeigher() {
    Weigher<Object, Object> testWeigher =
        new Weigher<Object, Object>() {
          @Override
          public int weigh(Object key, Object value) {
            return 42;
          }
        };
    LocalCache<Object, Object> map =
        makeLocalCache(createCacheBuilder().maximumWeight(1).weigher(testWeigher));
    assertThat(map.weigher).isSameInstanceAs(testWeigher);
  }

  @CanIgnoreReturnValue // TODO(b/27479612): consider removing this
  public <K1 extends K, V1 extends V> CacheBuilder<K1, V1> weigher(
      Weigher<? super K1, ? super V1> weigher) {
    checkState(this.weigher == null);
    if (strictParsing) {
      checkState(
          this.maximumSize == UNSET_INT,
          "weigher can not be combined with maximum size (%s provided)",
          this.maximumSize);
    }

  }

  @GwtIncompatible // weigher
  public void testWeigher_withoutMaximumWeight() {
    CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder().weigher(constantWeigher(42));
    assertThrows(IllegalStateException.class, () -> builder.build(identityLoader()));
  }

  @GwtIncompatible // weigher
  public void testWeigher_withMaximumSize() {
    assertThrows(

  /** Strategy for referencing values. */
  final Strength valueStrength;

  /** The maximum weight of this map. UNSET_INT if there is no maximum. */
  final long maxWeight;

  /** Weigher to weigh cache entries. */
  final Weigher<K, V> weigher;

  /** How long after the last access to an entry the map will retain that entry. */
  final long expireAfterAccessNanos;