import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class CompletableFutureTaskChain {
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(3);
    
    public void start() {
        executeTask1()
            .thenRunAsync(() -> executeTask2(), scheduler)
            .thenRunAsync(() -> executeTask3(), scheduler)
            .thenRun(() -> {
                System.out.println("所有任务完成！");
                scheduler.shutdown();
            });
    }
    
    private CompletableFuture<Void> executeTask1() {
        CompletableFuture<Void> future = new CompletableFuture<>();
        final int intervalA = 10;
        final int totalTimes = 10;
        final AtomicInteger counter = new AtomicInteger(0);
        
        scheduler.scheduleAtFixedRate(() -> {
            int count = counter.incrementAndGet();
            System.out.println("任务1 第" + count + "次执行");
            doTask1();
            
            if (count >= totalTimes) {
                future.complete(null);
                throw new RuntimeException("停止任务1"); // 抛异常来停止定时任务
            }
        }, 0, intervalA, TimeUnit.SECONDS);
        
        return future;
    }
    
    private void executeTask2() {
        // 根据任务1的结果计算B的值
        int intervalB = calculateBFromTask1Result();
        System.out.println("任务1完成，确定 B = " + intervalB + " 秒");
        
        final int totalTimes = 100;
        final AtomicInteger counter = new AtomicInteger(0);
        
        scheduler.scheduleAtFixedRate(() -> {
            int count = counter.incrementAndGet();
            System.out.println("任务2 第" + count + "次执行");
            doTask2();
            
            if (count >= totalTimes) {
                throw new RuntimeException("停止任务2");
            }
        }, 0, intervalB, TimeUnit.SECONDS);
    }
    
    private void executeTask3() {
        // 根据任务2的结果计算C的值
        int intervalC = calculateCFromTask2Result();
        System.out.println("任务2完成，确定 C = " + intervalC + " 秒");
        
        final int totalTimes = 200;
        final AtomicInteger counter = new AtomicInteger(0);
        
        scheduler.scheduleAtFixedRate(() -> {
            int count = counter.incrementAndGet();
            System.out.println("任务3 第" + count + "次执行");
            doTask3();
            
            if (count >= totalTimes) {
                throw new RuntimeException("停止任务3");
            }
        }, 0, intervalC, TimeUnit.SECONDS);
    }
    
    private int calculateBFromTask1Result() {
        // 基于任务1的结果计算B
        // 这里可以访问任务1的执行结果
        return 20;
    }
    
    private int calculateCFromTask2Result() {
        // 基于任务2的结果计算C
        return 30;
    }
    
    private void doTask1() { /* 任务1业务逻辑 */ }
    private void doTask2() { /* 任务2业务逻辑 */ }
    private void doTask3() { /* 任务3业务逻辑 */ }
}