package org.dromara.demo.controller;

import cn.hutool.core.thread.ThreadUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dromara.common.core.domain.R;
import org.dromara.common.doc.annotation.SaIgnore;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.TimeUnit;

/**
 * 线程池实战
 */
@SaIgnore // 忽略权限认证，方便测试
@Slf4j
@RequiredArgsConstructor
@RestController
@RequestMapping("/pool")
public class ThreadPoolController {

    /**
     * 模拟一个耗时 3 秒的方法
     */
    private void method1() {
        log.info("开始执行 method1 ...");
        // ThreadUtil 是 Hutool 提供的工具，可以安全地休眠
        ThreadUtil.sleep(3, TimeUnit.SECONDS); 
    }

}

// 位于 ThreadPoolController.java

    @GetMapping("/pool1")
    public R<Void> pool1() {
        long startTime = System.currentTimeMillis();
        
        // 在主线程中循环 5 次
        for (int i = 0; i < 5; i++) {
            method1();
        }
        
        long endTime = System.currentTimeMillis();
        log.info("pool1 总耗时: {} ms", (endTime - startTime));
        
        return R.ok("操作成功");
    }

// 位于 ThreadPoolController.java

// ... import ...
import java.util.concurrent.ScheduledExecutorService;

@SaIgnore
@Slf4j
@RequiredArgsConstructor // Lombok: 自动生成包含 final 字段的构造函数
@RestController
@RequestMapping("/pool")
public class ThreadPoolController {
    
    // 【核心】通过构造函数注入 RVP 5.x 默认配置的定时任务线程池
    // 它同样可以当做普通线程池使用
    private final ScheduledExecutorService scheduledExecutorService;

    // ... method1() ...
    // ... pool1() ...
}

// 位于 ThreadPoolController.java

    @GetMapping("/pool2")
    public R<Void> pool2() {
        long startTime = System.currentTimeMillis();
        
        // 循环 5 次
        for (int i = 0; i < 5; i++) {
            // 【核心】将 method1 作为一个“任务”
            // 提交 (execute) 给线程池，主线程“不等待”
            // this::method1 是 "方法引用"，等同于 () -> this.method1()
            scheduledExecutorService.execute(this::method1);
        }
        
        long endTime = System.currentTimeMillis();
        log.info("pool2 总耗时: {} ms", (endTime - startTime));
        
        return R.ok("操作成功");
    }

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    3,                      // corePoolSize - 核心线程数
    5,                      // maximumPoolSize - 最大线程数  
    60L,                    // keepAliveTime - 空闲线程存活时间
    TimeUnit.SECONDS,       // unit - 时间单位
    new ArrayBlockingQueue<>(20),  // workQueue - 任务队列
    new CustomThreadFactory(),     // threadFactory - 线程工厂
    new ThreadPoolExecutor.CallerRunsPolicy()  // handler - 拒绝策略
);

// 创建一个可观察的线程池
AtomicInteger counter = new AtomicInteger(0);
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    2, 4, 30L, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(2),
    r -> new Thread(r, "demo-" + counter.getAndIncrement())
);

// 监控线程池状态
ScheduledExecutorService monitor = Executors.newSingleThreadScheduledExecutor();
monitor.scheduleAtFixedRate(() -> {
    System.out.printf("活跃线程: %d, 队列任务: %d, 总完成: %d%n",
        executor.getActiveCount(),
        executor.getQueue().size(),
        executor.getCompletedTaskCount()
    );
}, 0, 1, TimeUnit.SECONDS);

// 模拟任务提交
for (int i = 1; i <= 6; i++) {
    final int taskId = i;
    executor.execute(() -> {
        System.out.println("Task-" + taskId + " 开始执行");
        ThreadUtil.sleep(2, TimeUnit.SECONDS);
    });
    System.out.println("提交了 Task-" + taskId);
    ThreadUtil.sleep(2, TimeUnit.SECONDS);
}

// 1. AbortPolicy（默认）：直接抛出异常
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());

// 2. CallerRunsPolicy：调用者线程执行
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

// 3. DiscardPolicy：静默丢弃
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());

// 4. DiscardOldestPolicy：丢弃最老的任务
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());

public class ThreadPoolShutdownDemo {
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2, 2, 0L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>()
        );
        
        // 提交一些任务
        for (int i = 1; i <= 5; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("开始执行 Task-" + taskId);
                try {
                    Thread.sleep(2000); // 每个任务需要2秒
                } catch (InterruptedException e) {
                    System.out.println("Task-" + taskId + " 被中断!");
                    return;
                }
                System.out.println("完成执行 Task-" + taskId);
            });
        }
        
        System.out.println("所有任务已提交，队列中有 " + 
            executor.getQueue().size() + " 个任务等待");
        
        // 演示 shutdown() - 优雅关闭
        demonstrateShutdown(executor);
        
        // 如果要演示 shutdownNow()，请注释上面一行，取消注释下面一行
        // demonstrateShutdownNow(executor);
    }
    
    private static void demonstrateShutdown(ThreadPoolExecutor executor) 
            throws InterruptedException {
        System.out.println("\n=== 执行 shutdown() ===");
        executor.shutdown();
        
        System.out.println("shutdown后，isShutdown=" + executor.isShutdown());
        System.out.println("shutdown后，isTerminated=" + executor.isTerminated());
        
        // 尝试提交新任务
        try {
            executor.execute(() -> System.out.println("新任务"));
        } catch (RejectedExecutionException e) {
            System.out.println("新任务被拒绝：" + e.getMessage());
        }
        
        // 等待所有任务完成
        boolean terminated = executor.awaitTermination(30, TimeUnit.SECONDS);
        System.out.println("所有任务完成：" + terminated);
    }
    
    private static void demonstrateShutdownNow(ThreadPoolExecutor executor) {
        System.out.println("\n=== 执行 shutdownNow() ===");
        List<Runnable> pendingTasks = executor.shutdownNow();
        
        System.out.println("被取消的任务数：" + pendingTasks.size());
        System.out.println("注意观察哪些任务被中断了");
    }
}

@PreDestroy
public void destroy() {
    log.info("开始关闭线程池...");
    
    // 第一步：停止接收新任务，等待现有任务完成
    scheduledPool.shutdown();
    asyncPool.shutdown();
    
    try {
        // 第二步：等待一段时间（给任务完成的机会）
        if (!scheduledPool.awaitTermination(120, TimeUnit.SECONDS)) {
            // 第三步：超时后强制关闭
            log.warn("等待超时，强制关闭定时任务线程池");
            scheduledPool.shutdownNow();
        }
        
        if (!asyncPool.awaitTermination(120, TimeUnit.SECONDS)) {
            log.warn("等待超时，强制关闭异步任务线程池");
            asyncPool.shutdownNow();
        }
    } catch (InterruptedException e) {
        // 第四步：处理中断异常
        log.error("关闭线程池被中断");
        scheduledPool.shutdownNow();
        asyncPool.shutdownNow();
        Thread.currentThread().interrupt();
    }
    
    log.info("线程池关闭完成");
}

@Slf4j
@AutoConfiguration
@EnableConfigurationProperties(ThreadPoolProperties.class)
public class ThreadPoolConfig {

    /**
     * 核心线程数 = cpu 核心数 + 1
     */
    private final int core = Runtime.getRuntime().availableProcessors() + 1;

    private ScheduledExecutorService scheduledExecutorService;

    // ... (Bean 和 destroy 方法)
}

/**
 * 执行周期性或定时任务
 */
@Bean(name = "scheduledExecutorService")
protected ScheduledExecutorService scheduledExecutorService() {
    // 1. 构建线程工厂
    BasicThreadFactory.Builder builder = new BasicThreadFactory.Builder()
        .daemon(true); // 设置为守护线程
    
    if (SpringUtils.isVirtual()) {
        // 2. (JDK 21+) 支持虚拟线程
        builder.namingPattern("virtual-schedule-pool-%d")
               .wrappedFactory(new VirtualThreadTaskExecutor().getVirtualThreadFactory());
    } else {
        // 3. 传统平台线程
        builder.namingPattern("schedule-pool-%d");
    }
    
    // 4. 创建 ScheduledThreadPoolExecutor 实例
    ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(
        core, // 核心线程数 (CPU+1)
        builder.build(), // 线程工厂 (带命名)
        new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
    ) {
        @Override
        protected void afterExecute(Runnable r, Throwable t) {
            // 5. 异常处理钩子
            super.afterExecute(r, t);
            printException(r, t);
        }
    };
    this.scheduledExecutorService = scheduledThreadPoolExecutor;
    return scheduledThreadPoolExecutor;
}

/**
 * 销毁事件
 */
@PreDestroy
public void destroy() {
    try {
        log.info("====关闭后台任务任务线程池====");
        ScheduledExecutorService pool = scheduledExecutorService;
        if (pool != null && !pool.isShutdown()) {
            // 1. (优雅关闭) 先停止接收新任务，等待已提交任务执行
            pool.shutdown();
            try {
                // 2. 等待 120 秒
                if (!pool.awaitTermination(120, TimeUnit.SECONDS)) {
                    // 3. (强制关闭) 超时，强制中断所有任务
                    pool.shutdownNow();
                    if (!pool.awaitTermination(120, TimeUnit.SECONDS)) {
                        log.info("Pool did not terminate");
                    }
                }
            } catch (InterruptedException ie) {
                // 4. (处理中断)
                pool.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
    } catch (Exception e) {
        log.error(e.getMessage(), e);
    }
}

// 位于 ThreadPoolController.java
// ...
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.CompletableFuture;

@RequiredArgsConstructor
@RestController
@RequestMapping("/pool")
public class ThreadPoolController {

    private final ScheduledExecutorService scheduledExecutorService;
    // ...
}

// 位于 ThreadPoolController.java
    
    @GetMapping("/pool3")
    public R<Void> pool3() {
        // 使用 Lambda 表达式定义一个 Runnable 任务
        Runnable task = () -> {
            log.info("我执行了 (execute)，线程名: {}", Thread.currentThread().getName());
        };
        
        // 提交任务
        scheduledExecutorService.execute(task);
        
        return R.ok("操作成功");
    }

// 位于 ThreadPoolController.java
    
    @GetMapping("/pool4")
    public R<String> pool4() {
        
        // 1. 创建一个异步任务
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            log.info("我执行了 (CompletableFuture)，正在计算...");
            ThreadUtil.sleep(3, TimeUnit.SECONDS);
            return "计算结果：123";
        }, scheduledExecutorService); // 使用我们的线程池

        // 2. 【推荐】注册异步回调，不阻塞主线程
        future.thenAccept(result -> {
            log.info("异步获得结果: {}", result);
        });
        
        // 3. 接口立即返回，不等待计算完成
        return R.ok("任务已提交，正在后台处理");
    }

// 位于 ThreadPoolController.java
    
    // 模拟耗时 1 秒的任务，返回 int
    private CompletableFuture<Integer> createAsyncTask(int i) {
        return CompletableFuture.supplyAsync(() -> {
            log.info("我执行了 (task {})", i);
            ThreadUtil.sleep(1, TimeUnit.SECONDS);
            return i;
        }, scheduledExecutorService);
    }

    /**
     * 【正确实践】：使用 CompletableFuture 并发执行
     */
    @GetMapping("/pool6")
    public R<List<Integer>> pool6() {
        long startTime = System.currentTimeMillis();
        
        // 创建 10 个异步任务
        List<CompletableFuture<Integer>> futures = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            futures.add(createAsyncTask(i));
        }
        
        // 等待所有任务完成并收集结果
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(
            futures.toArray(new CompletableFuture[0])
        );
        
        // 当所有任务完成后，收集结果
        CompletableFuture<List<Integer>> resultFuture = allFutures.thenApply(v ->
            futures.stream()
                .map(CompletableFuture::join)  // 此时不会阻塞，因为任务都已完成
                .collect(Collectors.toList())
        );
        
        // 获取最终结果（这里会阻塞，但仅等待最慢的任务）
        List<Integer> results = resultFuture.join();
        
        log.info("pool6 总耗时: {} ms", (System.currentTimeMillis() - startTime)); // 约 1 秒
        return R.ok(results);
    }

@GetMapping("/pool7")
public R<String> pool7() {
    CompletableFuture<String> future = CompletableFuture
        .supplyAsync(() -> {
            log.info("第一步：获取用户ID");
            return "user123";
        }, scheduledExecutorService)
        .thenApplyAsync(userId -> {
            log.info("第二步：根据用户ID {} 查询订单", userId);
            ThreadUtil.sleep(1, TimeUnit.SECONDS);
            return "订单号：ORDER-" + userId;
        }, scheduledExecutorService)
        .thenApplyAsync(orderId -> {
            log.info("第三步：根据 {} 查询物流信息", orderId);
            return orderId + " -> 已发货";
        }, scheduledExecutorService)
        .exceptionally(ex -> {
            log.error("处理出错", ex);
            return "处理失败";
        });
    
    // 注册完成后的回调
    future.thenAccept(result -> log.info("最终结果: {}", result));
    
    return R.ok("异步链式调用已启动");
}

@GetMapping("/pool8")
public R<Void> pool8() {
    log.info("pool8 接口被调用 (主线程)");

    // 延迟 3 秒后执行，并返回 CompletableFuture
    ScheduledFuture<String> scheduledFuture = scheduledExecutorService.schedule(() -> {
        log.info("延迟任务执行了");
        return "延迟任务的结果";
    }, 3, TimeUnit.SECONDS);
    
    // 将 ScheduledFuture 转换为 CompletableFuture 以便链式调用
    CompletableFuture<String> completableFuture = new CompletableFuture<>();
    scheduledExecutorService.execute(() -> {
        try {
            completableFuture.complete(scheduledFuture.get());
        } catch (Exception e) {
            completableFuture.completeExceptionally(e);
        }
    });
    
    // 注册回调
    completableFuture.thenAccept(result -> 
        log.info("延迟任务完成，结果: {}", result)
    );
    
    return R.ok("操作成功 (立即返回)");
}