package com.atlassian.vcache;
   
   import java.time.Duration;
   import java.util.Collection;
   import java.util.Map;
   import java.util.Optional;
   import java.util.concurrent.CompletableFuture;
   import java.util.concurrent.CompletionStage;
   import java.util.function.Function;
  import java.util.stream.Collectors;
  import javax.annotation.PostConstruct;
  
  import com.atlassian.vcache.marshallers.MarshallerFactory;
  
  /**
   * Sample usage of a ExternalCache.
   */
  public class ExternalSample
  {
      private static final Function<String, Long> VALUE_MAPPER = key -> {
          switch (key)
          {
              case "currentCount":
                  return 42L;
              case "licensedCount":
                  return 666L;
              default:
                  throw new IllegalArgumentException("Unknown key: " + key);
          }
      };
  
      private static final Function<Collection<String>, Map<String, Long>> VALUE_FACTORY = keys ->
              keys.stream().collect(Collectors.toMap(key -> key, VALUE_MAPPER));
  
      private final DirectExternalCache<Long> cache;
  
      public ExternalSample(VCacheFactory factory)
      {
          ExternalCacheSettings settings = new ExternalCacheSettingsBuilder().
                  defaultTtl(Duration.ofSeconds(666)).
                  dataChangeRateHint(ChangeRate.HIGH_CHANGE).
                  entryCountHint(42).
                  entryGrowthRateHint(ChangeRate.LOW_CHANGE).
                  build();
  
          cache = factory.getDirectExternalCache(
                  "mycache",
                  MarshallerFactory.serializableMarshaller(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()
      {
          CompletableFuture<Map<String, Optional<IdentifiedValue<Long>>>> getOp = cache.getBulkIdentified("currentCount", "licensedCount");
  
          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;
  
              CompletableFuture<Boolean> replaceOp =
                      cache.replaceIf("currentCount", currentValues.get("currentCount").get().identifier(), newCount);
 
             return replaceOp.handle((replaced, replaceEx) -> {
                 if (replaceEx != null)
                 {
                     // Deal with it
                     return false;
                 }
 
                 // Really should loop of the replaceIf fails.....
                 return replaced;
             }).join();
         });
 
         return outcome.toCompletableFuture().join();
     }
 
     public long spareLicenses()
     {
         CompletableFuture<Map<String, Long>> cached = cache.getBulk(VALUE_FACTORY, "currentCount", "licensedCount");
 
         return fold(cached,
                 (m) -> m.get("licensedCount") - m.get("currentCount"),
                 (err) -> -1L);
     }
 
     private <T, R> R fold(CompletableFuture<T> on, Function<T, R> success, Function<Throwable, R> failure)
     {
         return on.handle((val, err) ->
                 (val != null) ? success.apply(val) : failure.apply(err)).join();
     }
 }