package com.atlassian.vcache;
   
   import java.util.concurrent.CompletableFuture;
   
   public abstract class AsyncTesting {
       public static void main(String[] args) {
           /*
           System.out.println("And away");
   
          System.out.println("retrieved: " + retrieve().unsafeJoin());
  
          System.out.println("retrieved: " + retrieve().thenApply(s -> ">>" + s + "<<").unsafeJoin());
  
          System.out.println("isDone: " + willFail().isDone());
          System.out.println("isCancelled: " + willFail().isCancelled());
          System.out.println("isCompletedExceptionally: " + willFail().isCompletedExceptionally());
          CompletableFuture<String> outer = willFail().thenApply(s -> ">>" + s + "<<");
          System.out.println("isDone: " + outer.isDone());
          System.out.println("isCancelled: " + outer.isCancelled());
          System.out.println("isCompletedExceptionally: " + outer.isCompletedExceptionally());
  
          System.out.println("--> " + retrieve().handle((s, throwable) -> {
              if (throwable != null && throwable instanceof RuntimeException)
              {
                  throw (RuntimeException) throwable;
              }
              return s;
          }).unsafeJoin());
          System.out.println("--> " + willFail().handle((s, ex) -> (ex != null) ? "failed!!" : s).unsafeJoin());
  */
  //        final CompletableFuture<String> get1 = willFail("first stage");
          final CompletableFuture<String> get1 = retrieve("get1");
  //        final CompletableFuture<String> get2 = willFail(); //retrieve();
  //        final CompletableFuture<String> combined = get1.thenCombine(get2, (s1, s2) -> s1 + " <--> " + s2);
  //        get1.runAfterEither(get2, () -> System.out.println("Finished"));
  
  //        final CompletableFuture<String> combined = get1.thenCompose(s -> retrieve("get2--" + s));
          final CompletableFuture<String> combined = get1.thenCompose(s -> willFail("second stage"));
  
          final String combinedStr = combined.handle((val, err) -> {
              System.out.println("\n================");
              System.out.println("\tval = " + val);
              System.out.println("\terr = " + err);
              System.out.println("================");
              return val;
          }).join();
  
          System.out.println("combinedStr = " + combinedStr);
      }
  
      private static CompletableFuture<String> retrieve(String arg) {
          return CompletableFuture.completedFuture(arg);
      }
  
      private static CompletableFuture<String> willFail(String stage) {
          final CompletableFuture<String> result = new CompletableFuture<>();
          result.completeExceptionally(new RuntimeException(stage));
  //        result.completeExceptionally(new ExternalCacheException(
  //                new ExternalCacheResult.Failure(ExternalCacheResult.Failure.Reason.UNCLASSIFIED_FAILURE)));
          return result;
      }
  }