package com.atlassian.vcache;
   
   import com.atlassian.marshalling.jdk.JavaSerializationMarshalling;
   
   import javax.annotation.PostConstruct;
   import java.time.Duration;
   import java.util.Map;
   import java.util.Optional;
   import java.util.Set;
  import java.util.concurrent.CompletionStage;
  import java.util.function.Function;
  import java.util.stream.Collectors;
  
  import static com.atlassian.vcache.VCacheUtils.fold;
  
  /**
   * Sample usage of a ExternalCache.
   */
  public class ExternalSample {
      private static Long valueMapper(String key) {
          switch (key) {
              case "currentCount":
                  return 42L;
              case "licensedCount":
                  return 666L;
              default:
                  throw new IllegalArgumentException("Unknown key: " + key);
          }
      }
  
      private static final Function<Set<String>, Map<String, Long>> VALUE_FACTORY = keys ->
              keys.stream().collect(Collectors.toMap(key -> key, ExternalSample::valueMapper));
  
      private final DirectExternalCache<Long> cache;
  
      public ExternalSample(VCacheFactory factory) {
          final ExternalCacheSettings settings = new ExternalCacheSettingsBuilder().
                  defaultTtl(Duration.ofSeconds(666)).
                  dataChangeRateHint(ChangeRate.HIGH_CHANGE).
                  entryCountHint(42).
                  entryGrowthRateHint(ChangeRate.LOW_CHANGE).
                  build();
  
          cache = factory.getDirectExternalCache(
                  "mycache",
                  JavaSerializationMarshalling.pair(Long.TYPE),
                  settings);
      }
  
      @PostConstruct
      void init() {
          // Would not normally do this
          cache.put("licensedCount", 88L, PutPolicy.ADD_ONLY);
          cache.put("currentCount", 12L, PutPolicy.ADD_ONLY).whenComplete((b, ex) -> {
              if (ex != null) {
                  // log warning
              } else {
                  // log whether added
              }
          });
      }
  
      public boolean addUser() {
          final CompletionStage<Map<String, Optional<IdentifiedValue<Long>>>> getOp =
                  cache.getBulkIdentified("currentCount", "licensedCount");
  
          final CompletionStage<Boolean> outcome = getOp.handle((currentValues, t) -> {
  
              if (t != null) {
                  // Deal with it
                  return false;
              }
  
              // Check have values
              if (!currentValues.get("currentCount").isPresent() || !currentValues.get("licensedCount").isPresent()) {
                  // Deal with it
                  return false;
              }
  
              // Check have spare room
              if (currentValues.get("currentCount").get().value() < currentValues.get("licensedCount").get().value()) {
                  // Deal with it
                  return false;
              }
  
              // Increment and update
              final Long newCount = currentValues.get("currentCount").get().value() + 1;
  
              CompletionStage<Boolean> replaceOp =
                      cache.replaceIf("currentCount", currentValues.get("currentCount").get().identifier(), newCount);
  
              return fold(replaceOp,
                      success -> false,
                      failure -> false
              );
          });
  
          return outcome.toCompletableFuture().join();
      }
 
     public Long spareLicenses() {
         final CompletionStage<Map<String, Long>> cached = cache.getBulk(VALUE_FACTORY, "currentCount", "licensedCount");
 
         return fold(cached,
                 m -> m.get("licensedCount") - m.get("currentCount"),
                 err -> -1L);
     }
 }