import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
 
public class CompletableFutureDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 1. Task Creation
        CompletableFuture<Void> runAsync = CompletableFuture.runAsync(() -> {
            System.out.println("runAsync: Asynchronous task with no return value");
        });
 
        CompletableFuture<String> supplyAsync = CompletableFuture.supplyAsync(() -> {
            System.out.println("supplyAsync: Asynchronous task with a return value");
            return "Hello";
        });
 
        // 2. Async Callbacks
        CompletableFuture<String> thenApply = supplyAsync.thenApply(s -> s + " World");
        CompletableFuture<String> thenCompose = supplyAsync.thenCompose(s -> CompletableFuture.supplyAsync(() -> s + " Composed"));
        CompletableFuture<Void> thenAccept = supplyAsync.thenAccept(s -> System.out.println("thenAccept: " + s));
        CompletableFuture<Void> thenRun = supplyAsync.thenRun(() -> System.out.println("thenRun: No input, just run"));
 
        // 3. Composition
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Future1");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "Future2");
 
        CompletableFuture<String> thenCombine = future1.thenCombine(future2, (s1, s2) -> s1 + " + " + s2);
        CompletableFuture<Void> thenAcceptBoth = future1.thenAcceptBoth(future2, (s1, s2) -> 
            System.out.println("thenAcceptBoth: " + s1 + " and " + s2));
        CompletableFuture<Void> runAfterBoth = future1.runAfterBoth(future2, () -> 
            System.out.println("runAfterBoth: Both done"));
 
        CompletableFuture<Object> anyOf = CompletableFuture.anyOf(
            CompletableFuture.supplyAsync(() -> "Result A"),
            CompletableFuture.supplyAsync(() -> "Result B")
        );
        CompletableFuture<String> anyOfResult = anyOf.thenApply(Object::toString);
 
        CompletableFuture<Void> allOf = CompletableFuture.allOf(future1, future2)
            .thenRun(() -> System.out.println("allOf: All futures completed"));
 
        // applyToEither / acceptEither / runAfterEither
        CompletableFuture<String> fastFuture = CompletableFuture.supplyAsync(() -> {
            try { Thread.sleep(100); } catch (InterruptedException e) { }
            return "Fast";
        });
        CompletableFuture<String> slowFuture = CompletableFuture.supplyAsync(() -> {
            try { Thread.sleep(500); } catch (InterruptedException e) { }
            return "Slow";
        });
 
        CompletableFuture<String> applyToEither = fastFuture.applyToEither(slowFuture, s -> "Winner: " + s);
        CompletableFuture<Void> acceptEither = fastFuture.acceptEither(slowFuture, s -> 
            System.out.println("acceptEither: " + s));
        CompletableFuture<Void> runAfterEither = fastFuture.runAfterEither(slowFuture, () -> 
            System.out.println("runAfterEither: One finished"));
 
        // 4. Result Handling
        CompletableFuture<String> handle = supplyAsync.handle((result, ex) -> {
            if (ex != null) {
                return "Handled exception: " + ex.getMessage();
            } else {
                return "Handled result: " + result;
            }
        });
 
        CompletableFuture<String> whenComplete = supplyAsync.whenComplete((result, ex) -> {
            if (ex != null) {
                System.out.println("whenComplete - Exception: " + ex.getMessage());
            } else {
                System.out.println("whenComplete - Result: " + result);
            }
        });
 
        CompletableFuture<String> exceptionally = supplyAsync.exceptionally(ex -> {
            System.out.println("exceptionally caught: " + ex.getMessage());
            return "Default value on error";
        });
 
        // 5. Result Retrieval
        try {
            String resultGet = supplyAsync.get(); // Throws checked exceptions
            System.out.println("Result via get(): " + resultGet);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
 
        String resultJoin = supplyAsync.join(); // Throws unchecked CompletionException
        System.out.println("Result via join(): " + resultJoin);
 
        // Wait briefly to allow async tasks to complete (for demo clarity)
        Thread.sleep(600);
    }
}