package com.yfd.platform.component.utils;

import org.jetbrains.annotations.NotNull;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 优化后的线程池管理类
 * 说明：使用可控的自定义线程池替代无界的CachedThreadPool
 */
public final class OptimizedThreadPool {

    // 使用静态内部类实现线程安全的单例模式
    private static class InstanceHolder {

        private static final OptimizedThreadPool INSTANCE = new OptimizedThreadPool();
    }

    private final ThreadPoolExecutor executorService;

    // 私有构造函数防止外部实例化
    private OptimizedThreadPool() {
        // 获取处理器核心数（动态适配不同机器）
        int corePoolSize = Runtime.getRuntime().availableProcessors();

        // 配置线程池参数（生产环境建议参数可配置化）
        this.executorService = new ThreadPoolExecutor(
                // 核心线程数（建议等于CPU核心数）
                corePoolSize,
                // 最大线程数（建议2-4倍核心数）
                corePoolSize * 2,
                // 空闲线程存活时间（秒）
                60L,
                // 时间单位
                TimeUnit.SECONDS,
                // 有界任务队列（防止OOM）
                new LinkedBlockingQueue<>(1000),
                // 自定义线程工厂（便于问题排查）
                new CustomThreadFactory(),
                // 拒绝策略（主线程执行）
                new ThreadPoolExecutor.CallerRunsPolicy()
        );
    }

    /**
     * 获取线程池单例实例（线程安全）
     */
    public static OptimizedThreadPool getInstance() {
        return InstanceHolder.INSTANCE;
    }

    /**
     * 执行异步任务（增强版）
     */
    public void execute(Runnable task) {
        // 添加基础校验（生产环境可扩展）
        if (task == null) {
            throw new IllegalArgumentException("任务不能为空");
        }

        // 添加异常处理包装
        executorService.execute(wrapTask(task));
    }

    /**
     * 任务包装器（统一异常处理）
     */
    private Runnable wrapTask(Runnable task) {
        return () -> {
            try {
                task.run();
            } catch (Exception e) {
                // 统一的异常处理（建议接入日志系统）
                System.err.println("任务执行失败: " + e.getMessage());
                e.printStackTrace();
            }
        };
    }

    /**
     * 优雅关闭线程池（重要！必须调用）
     */
    public void shutdown() {
        executorService.shutdown();
        try {
            // 等待任务完成（可配置超时时间）
            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
                executorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            executorService.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }

    /**
     * 获取线程池状态（监控用）
     */
    public String getPoolStatus() {
        return String.format(
                "Pool Status: [Active: %d, Core: %d, Max: %d, Queue: %d/%d]",
                executorService.getActiveCount(),
                executorService.getCorePoolSize(),
                executorService.getMaximumPoolSize(),
                executorService.getQueue().size(),
                executorService.getQueue().remainingCapacity()
        );
    }

    /**
     * 自定义线程工厂（命名规范化）
     */
    private static class CustomThreadFactory implements ThreadFactory {

        private final AtomicInteger threadCounter = new AtomicInteger(1);
        private static final String THREAD_NAME_PREFIX = "optimized-pool-thread-";

        @Override
        public Thread newThread(@NotNull Runnable r) {
            Thread thread = new Thread(r, THREAD_NAME_PREFIX + threadCounter.getAndIncrement());
            thread.setDaemon(false);  // 非守护线程
            thread.setPriority(Thread.NORM_PRIORITY);
            return thread;
        }
    }
}
