/**
 * 企业级TransmittableThreadLocal管理器
 * 提供线程池场景下的上下文传递和TTL装饰器管理
 */
@Component
@Slf4j
public class TransmittableThreadLocalManager {

    private final Map<String, TransmittableThreadLocal<?>> ttlMap = new ConcurrentHashMap<>();
    private final TTLDecoratorManager ttlDecoratorManager;
    private final ThreadPoolTransmitter threadPoolTransmitter;
    private final AsyncTaskTransmitter asyncTaskTransmitter;
    private final PerformanceMonitor performanceMonitor;

    /**
     * 创建TransmittableThreadLocal实例
     */
    public <T> TransmittableThreadLocal<T> createTransmittableThreadLocal(String name, Class<T> type) {
        try {
            // 检查是否已存在
            if (ttlMap.containsKey(name)) {
                throw new TransmittableThreadLocalException("TransmittableThreadLocal已存在: " + name);
            }

            // 创建TransmittableThreadLocal实例
            TransmittableThreadLocal<T> ttl = new TransmittableThreadLocal<T>() {
                @Override
                protected T initialValue() {
                    try {
                        return type.newInstance();
                    } catch (Exception e) {
                        log.error("TransmittableThreadLocal初始值创建失败: {}", name, e);
                        return null;
                    }
                }

                @Override
                protected T copy(T parentValue) {
                    try {
                        // 记录复制操作
                        performanceMonitor.recordCopy(name, parentValue);

                        // 执行上下文复制逻辑
                        return ttlDecoratorManager.copyContext(name, parentValue);

                    } catch (Exception e) {
                        log.error("TransmittableThreadLocal复制失败: {}", name, e);
                        return parentValue; // 返回父线程的值
                    }
                }

                @Override
                protected void beforeExecute() {
                    try {
                        // 记录执行前操作
                        performanceMonitor.recordBeforeExecute(name);

                        // 执行上下文设置逻辑
                        ttlDecoratorManager.beforeExecute(name);

                    } catch (Exception e) {
                        log.error("TransmittableThreadLocal执行前操作失败: {}", name, e);
                    }
                }

                @Override
                protected void afterExecute() {
                    try {
                        // 记录执行后操作
                        performanceMonitor.recordAfterExecute(name);

                        // 执行上下文清理逻辑
                        ttlDecoratorManager.afterExecute(name);

                    } catch (Exception e) {
                        log.error("TransmittableThreadLocal执行后操作失败: {}", name, e);
                    }
                }

                @Override
                public void set(T value) {
                    super.set(value);
                    // 记录设置操作
                    performanceMonitor.recordOperation(name, "set");
                }

                @Override
                public T get() {
                    T value = super.get();
                    // 记录获取操作
                    performanceMonitor.recordOperation(name, "get");
                    return value;
                }

                @Override
                public void remove() {
                    T value = get();
                    super.remove();
                    // 记录移除操作
                    performanceMonitor.recordOperation(name, "remove");
                }
            };

            // 注册TransmittableThreadLocal
            ttlMap.put(name, ttl);

            // 注册到TTL装饰器管理器
            ttlDecoratorManager.registerTransmittableThreadLocal(name, ttl);

            log.info("TransmittableThreadLocal创建成功: {}", name);
            return ttl;

        } catch (Exception e) {
            log.error("TransmittableThreadLocal创建失败: {}", name, e);
            throw new TransmittableThreadLocalException("TransmittableThreadLocal创建失败: " + e.getMessage());
        }
    }

    /**
     * 获取TransmittableThreadLocal实例
     */
    @SuppressWarnings("unchecked")
    public <T> TransmittableThreadLocal<T> getTransmittableThreadLocal(String name) {
        TransmittableThreadLocal<?> ttl = ttlMap.get(name);
        if (ttl == null) {
            throw new TransmittableThreadLocalException("TransmittableThreadLocal不存在: " + name);
        }
        return (TransmittableThreadLocal<T>) ttl;
    }

    /**
     * 设置TransmittableThreadLocal值
     */
    public <T> void setValue(String name, T value) {
        try {
            TransmittableThreadLocal<T> ttl = getTransmittableThreadLocal(name);
            ttl.set(value);

            log.debug("TransmittableThreadLocal值设置成功: {} = {}", name, value);

        } catch (Exception e) {
            log.error("TransmittableThreadLocal值设置失败: {}", name, e);
            throw new TransmittableThreadLocalException("TransmittableThreadLocal值设置失败: " + e.getMessage());
        }
    }

    /**
     * 获取TransmittableThreadLocal值
     */
    public <T> T getValue(String name) {
        try {
            TransmittableThreadLocal<T> ttl = getTransmittableThreadLocal(name);
            T value = ttl.get();

            return value;

        } catch (Exception e) {
            log.error("TransmittableThreadLocal值获取失败: {}", name, e);
            throw new TransmittableThreadLocalException("TransmittableThreadLocal值获取失败: " + e.getMessage());
        }
    }

    /**
     * 移除TransmittableThreadLocal值
     */
    public <T> void removeValue(String name) {
        try {
            TransmittableThreadLocal<T> ttl = getTransmittableThreadLocal(name);
            ttl.remove();

            log.debug("TransmittableThreadLocal值移除成功: {}", name);

        } catch (Exception e) {
            log.error("TransmittableThreadLocal值移除失败: {}", name, e);
            throw new TransmittableThreadLocalException("TransmittableThreadLocal值移除失败: " + e.getMessage());
        }
    }

    /**
     * 装饰Runnable
     */
    public Runnable decorateRunnable(String taskName, Runnable runnable) {
        try {
            return ttlDecoratorManager.decorateRunnable(taskName, runnable);

        } catch (Exception e) {
            log.error("装饰Runnable失败: {}", taskName, e);
            throw new TransmittableThreadLocalException("装饰Runnable失败: " + e.getMessage());
        }
    }

    /**
     * 装饰Callable
     */
    public <T> Callable<T> decorateCallable(String taskName, Callable<T> callable) {
        try {
            return ttlDecoratorManager.decorateCallable(taskName, callable);

        } catch (Exception e) {
            log.error("装饰Callable失败: {}", taskName, e);
            throw new TransmittableThreadLocalException("装饰Callable失败: " + e.getMessage());
        }
    }

    /**
     * 装饰Executor
     */
    public Executor decorateExecutor(String executorName, Executor executor) {
        try {
            return ttlDecoratorManager.decorateExecutor(executorName, executor);

        } catch (Exception e) {
            log.error("装饰Executor失败: {}", executorName, e);
            throw new TransmittableThreadLocalException("装饰Executor失败: " + e.getMessage());
        }
    }

    /**
     * 装饰ExecutorService
     */
    public ExecutorService decorateExecutorService(String executorName, ExecutorService executorService) {
        try {
            return ttlDecoratorManager.decorateExecutorService(executorName, executorService);

        } catch (Exception e) {
            log.error("装饰ExecutorService失败: {}", executorName, e);
            throw new TransmittableThreadLocalException("装饰ExecutorService失败: " + e.getMessage());
        }
    }

    /**
     * 装饰ScheduledExecutorService
     */
    public ScheduledExecutorService decorateScheduledExecutorService(String executorName, ScheduledExecutorService scheduledExecutorService) {
        try {
            return ttlDecoratorManager.decorateScheduledExecutorService(executorName, scheduledExecutorService);

        } catch (Exception e) {
            log.error("装饰ScheduledExecutorService失败: {}", executorName, e);
            throw new TransmittableThreadLocalException("装饰ScheduledExecutorService失败: " + e.getMessage());
        }
    }

    /**
     * 执行异步任务
     */
    public <T> CompletableFuture<T> executeAsyncTask(String taskName, Callable<T> task) {
        try {
            return asyncTaskTransmitter.executeAsyncTask(taskName, task);

        } catch (Exception e) {
            log.error("执行异步任务失败: {}", taskName, e);
            throw new TransmittableThreadLocalException("执行异步任务失败: " + e.getMessage());
        }
    }

    /**
     * 执行异步任务（带超时）
     */
    public <T> CompletableFuture<T> executeAsyncTaskWithTimeout(String taskName, Callable<T> task, long timeout, TimeUnit timeUnit) {
        try {
            return asyncTaskTransmitter.executeAsyncTaskWithTimeout(taskName, task, timeout, timeUnit);

        } catch (Exception e) {
            log.error("执行异步任务失败: {}", taskName, e);
            throw new TransmittableThreadLocalException("执行异步任务失败: " + e.getMessage());
        }
    }

    /**
     * 批量执行异步任务
     */
    public <T> CompletableFuture<List<T>> executeBatchAsyncTasks(String taskName, List<Callable<T>> tasks) {
        try {
            return asyncTaskTransmitter.executeBatchAsyncTasks(taskName, tasks);

        } catch (Exception e) {
            log.error("批量执行异步任务失败: {}", taskName, e);
            throw new TransmittableThreadLocalException("批量执行异步任务失败: " + e.getMessage());
        }
    }

    /**
     * 清理所有TransmittableThreadLocal
     */
    public void clearAll() {
        try {
            for (Map.Entry<String, TransmittableThreadLocal<?>> entry : ttlMap.entrySet()) {
                String name = entry.getKey();
                TransmittableThreadLocal<?> ttl = entry.getValue();

                try {
                    ttl.remove();
                    log.debug("TransmittableThreadLocal清理成功: {}", name);
                } catch (Exception e) {
                    log.error("TransmittableThreadLocal清理失败: {}", name, e);
                }
            }

            log.info("所有TransmittableThreadLocal清理完成");

        } catch (Exception e) {
            log.error("TransmittableThreadLocal清理失败", e);
            throw new TransmittableThreadLocalException("TransmittableThreadLocal清理失败: " + e.getMessage());
        }
    }

    /**
     * 获取TransmittableThreadLocal统计信息
     */
    public TransmittableThreadLocalStatistics getStatistics() {
        try {
            Map<String, TransmittableThreadLocalInfo> ttlInfos = new HashMap<>();

            for (Map.Entry<String, TransmittableThreadLocal<?>> entry : ttlMap.entrySet()) {
                String name = entry.getKey();
                TransmittableThreadLocal<?> ttl = entry.getValue();

                TransmittableThreadLocalInfo info = TransmittableThreadLocalInfo.builder()
                        .name(name)
                        .type(ttl.getClass().getSimpleName())
                        .hasValue(ttl.get() != null)
                        .build();

                ttlInfos.put(name, info);
            }

            return TransmittableThreadLocalStatistics.builder()
                    .totalCount(ttlMap.size())
                    .transmittableThreadLocalInfos(ttlInfos)
                    .decoratorMetrics(ttlDecoratorManager.getDecoratorMetrics())
                    .transmissionMetrics(threadPoolTransmitter.getTransmissionMetrics())
                    .asyncTaskMetrics(asyncTaskTransmitter.getAsyncTaskMetrics())
                    .performanceMetrics(performanceMonitor.getMetrics())
                    .build();

        } catch (Exception e) {
            log.error("获取TransmittableThreadLocal统计信息失败", e);
            throw new TransmittableThreadLocalException("获取TransmittableThreadLocal统计信息失败: " + e.getMessage());
        }
    }

    /**
     * 销毁TransmittableThreadLocal管理器
     */
    @PreDestroy
    public void destroy() {
        try {
            // 清理所有TransmittableThreadLocal
            clearAll();

            // 清理资源
            ttlMap.clear();

            log.info("TransmittableThreadLocal管理器销毁完成");

        } catch (Exception e) {
            log.error("TransmittableThreadLocal管理器销毁失败", e);
        }
    }
}

/**
 * TTL装饰器管理器
 * 负责管理各种TTL装饰器
 */
@Component
@Slf4j
public class TTLDecoratorManager {

    private final Map<String, TransmittableThreadLocal<?>> registeredTTLs = new ConcurrentHashMap<>();
    private final AtomicLong totalDecorations = new AtomicLong(0);
    private final AtomicLong successfulDecorations = new AtomicLong(0);
    private final AtomicLong failedDecorations = new AtomicLong(0);

    /**
     * 注册TransmittableThreadLocal
     */
    public void registerTransmittableThreadLocal(String name, TransmittableThreadLocal<?> ttl) {
        try {
            registeredTTLs.put(name, ttl);

            log.info("TransmittableThreadLocal注册成功: {}", name);

        } catch (Exception e) {
            log.error("TransmittableThreadLocal注册失败: {}", name, e);
            throw new TTLDecoratorException("TransmittableThreadLocal注册失败: " + e.getMessage());
        }
    }

    /**
     * 复制上下文
     */
    public <T> T copyContext(String name, T parentValue) {
        try {
            if (parentValue == null) {
                return null;
            }

            // 根据上下文类型执行不同的复制策略
            switch (name) {
                case "userContext":
                    return copyUserContext(parentValue);
                case "requestContext":
                    return copyRequestContext(parentValue);
                case "businessContext":
                    return copyBusinessContext(parentValue);
                case "securityContext":
                    return copySecurityContext(parentValue);
                case "logContext":
                    return copyLogContext(parentValue);
                default:
                    return copyDefaultContext(parentValue);
            }

        } catch (Exception e) {
            log.error("复制上下文失败: {}", name, e);
            return parentValue;
        }
    }

    /**
     * 复制用户上下文
     */
    @SuppressWarnings("unchecked")
    private <T> T copyUserContext(T parentValue) {
        try {
            if (parentValue instanceof UserContext) {
                UserContext parentUserContext = (UserContext) parentValue;

                // 创建新的用户上下文，复制父线程的信息
                UserContext copiedUserContext = UserContext.builder()
                        .userId(parentUserContext.getUserId())
                        .username(parentUserContext.getUsername())
                        .email(parentUserContext.getEmail())
                        .roles(new ArrayList<>(parentUserContext.getRoles()))
                        .permissions(new ArrayList<>(parentUserContext.getPermissions()))
                        .loginTime(parentUserContext.getLoginTime())
                        .threadId(Thread.currentThread().getId())
                        .copiedFrom(Thread.currentThread().getName())
                        .build();

                return (T) copiedUserContext;
            }

            return parentValue;

        } catch (Exception e) {
            log.error("复制用户上下文失败", e);
            return parentValue;
        }
    }

    /**
     * 复制请求上下文
     */
    @SuppressWarnings("unchecked")
    private <T> T copyRequestContext(T parentValue) {
        try {
            if (parentValue instanceof RequestContext) {
                RequestContext parentRequestContext = (RequestContext) parentValue;

                // 创建新的请求上下文，复制父线程的信息
                RequestContext copiedRequestContext = RequestContext.builder()
                        .requestId(parentRequestContext.getRequestId())
                        .requestTime(parentRequestContext.getRequestTime())
                        .clientIp(parentRequestContext.getClientIp())
                        .userAgent(parentRequestContext.getUserAgent())
                        .threadId(Thread.currentThread().getId())
                        .copiedFrom(Thread.currentThread().getName())
                        .build();

                return (T) copiedRequestContext;
            }

            return parentValue;

        } catch (Exception e) {
            log.error("复制请求上下文失败", e);
            return parentValue;
        }
    }

    /**
     * 复制业务上下文
     */
    @SuppressWarnings("unchecked")
    private <T> T copyBusinessContext(T parentValue) {
        try {
            if (parentValue instanceof Map) {
                Map<String, Object> parentBusinessContext = (Map<String, Object>) parentValue;

                // 创建新的业务上下文，深度复制父线程的信息
                Map<String, Object> copiedBusinessContext = new HashMap<>();
                for (Map.Entry<String, Object> entry : parentBusinessContext.entrySet()) {
                    String key = entry.getKey();
                    Object value = entry.getValue();

                    // 深度复制值
                    Object copiedValue = deepCopyValue(value);
                    copiedBusinessContext.put(key, copiedValue);
                }

                // 添加复制信息
                copiedBusinessContext.put("threadId", Thread.currentThread().getId());
                copiedBusinessContext.put("copiedFrom", Thread.currentThread().getName());

                return (T) copiedBusinessContext;
            }

            return parentValue;

        } catch (Exception e) {
            log.error("复制业务上下文失败", e);
            return parentValue;
        }
    }

    /**
     * 复制安全上下文
     */
    @SuppressWarnings("unchecked")
    private <T> T copySecurityContext(T parentValue) {
        try {
            if (parentValue instanceof SecurityContext) {
                SecurityContext parentSecurityContext = (SecurityContext) parentValue;

                // 创建新的安全上下文，复制父线程的信息
                SecurityContext copiedSecurityContext = SecurityContext.builder()
                        .principal(parentSecurityContext.getPrincipal())
                        .authorities(new ArrayList<>(parentSecurityContext.getAuthorities()))
                        .authenticated(parentSecurityContext.isAuthenticated())
                        .threadId(Thread.currentThread().getId())
                        .copiedFrom(Thread.currentThread().getName())
                        .build();

                return (T) copiedSecurityContext;
            }

            return parentValue;

        } catch (Exception e) {
            log.error("复制安全上下文失败", e);
            return parentValue;
        }
    }

    /**
     * 复制日志上下文
     */
    @SuppressWarnings("unchecked")
    private <T> T copyLogContext(T parentValue) {
        try {
            if (parentValue instanceof LogContext) {
                LogContext parentLogContext = (LogContext) parentValue;

                // 创建新的日志上下文，复制父线程的信息
                LogContext copiedLogContext = LogContext.builder()
                        .traceId(parentLogContext.getTraceId())
                        .spanId(parentLogContext.getSpanId())
                        .parentSpanId(parentLogContext.getParentSpanId())
                        .threadId(Thread.currentThread().getId())
                        .copiedFrom(Thread.currentThread().getName())
                        .build();

                return (T) copiedLogContext;
            }

            return parentValue;

        } catch (Exception e) {
            log.error("复制日志上下文失败", e);
            return parentValue;
        }
    }

    /**
     * 复制默认上下文
     */
    private <T> T copyDefaultContext(T parentValue) {
        try {
            // 对于其他类型的上下文，执行浅度复制
            if (parentValue instanceof Cloneable) {
                // 如果对象实现了Cloneable接口，尝试克隆
                try {
                    Method cloneMethod = parentValue.getClass().getMethod("clone");
                    return (T) cloneMethod.invoke(parentValue);
                } catch (Exception e) {
                    log.debug("对象克隆失败，使用原始值: {}", e.getMessage());
                }
            }

            // 返回原始值
            return parentValue;

        } catch (Exception e) {
            log.error("复制默认上下文失败", e);
            return parentValue;
        }
    }

    /**
     * 深度复制值
     */
    private Object deepCopyValue(Object value) {
        try {
            if (value == null) {
                return null;
            }

            if (value instanceof String || value instanceof Number || value instanceof Boolean) {
                return value; // 基本类型直接返回
            }

            if (value instanceof List) {
                List<?> list = (List<?>) value;
                List<Object> copiedList = new ArrayList<>();
                for (Object item : list) {
                    copiedList.add(deepCopyValue(item));
                }
                return copiedList;
            }

            if (value instanceof Map) {
                Map<?, ?> map = (Map<?, ?>) value;
                Map<Object, Object> copiedMap = new HashMap<>();
                for (Map.Entry<?, ?> entry : map.entrySet()) {
                    Object key = deepCopyValue(entry.getKey());
                    Object val = deepCopyValue(entry.getValue());
                    copiedMap.put(key, val);
                }
                return copiedMap;
            }

            // 对于其他对象，尝试序列化反序列化
            try {
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(baos);
                oos.writeObject(value);
                oos.close();

                ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
                ObjectInputStream ois = new ObjectInputStream(bais);
                Object copiedValue = ois.readObject();
                ois.close();

                return copiedValue;

            } catch (Exception e) {
                log.debug("序列化复制失败，使用原始值: {}", e.getMessage());
                return value;
            }

        } catch (Exception e) {
            log.error("深度复制值失败", e);
            return value;
        }
    }

    /**
     * 执行前操作
     */
    public void beforeExecute(String name) {
        try {
            // 记录执行前操作
            log.debug("TransmittableThreadLocal执行前操作: {}", name);

        } catch (Exception e) {
            log.error("执行前操作失败: {}", name, e);
        }
    }

    /**
     * 执行后操作
     */
    public void afterExecute(String name) {
        try {
            // 记录执行后操作
            log.debug("TransmittableThreadLocal执行后操作: {}", name);

        } catch (Exception e) {
            log.error("执行后操作失败: {}", name, e);
        }
    }

    /**
     * 装饰Runnable
     */
    public Runnable decorateRunnable(String taskName, Runnable runnable) {
        try {
            totalDecorations.incrementAndGet();

            Runnable decoratedRunnable = TtlRunnable.get(runnable);

            successfulDecorations.incrementAndGet();
            log.debug("Runnable装饰成功: {}", taskName);

            return decoratedRunnable;

        } catch (Exception e) {
            failedDecorations.incrementAndGet();
            log.error("Runnable装饰失败: {}", taskName, e);
            throw new TTLDecoratorException("Runnable装饰失败: " + e.getMessage());
        }
    }

    /**
     * 装饰Callable
     */
    public <T> Callable<T> decorateCallable(String taskName, Callable<T> callable) {
        try {
            totalDecorations.incrementAndGet();

            Callable<T> decoratedCallable = TtlCallable.get(callable);

            successfulDecorations.incrementAndGet();
            log.debug("Callable装饰成功: {}", taskName);

            return decoratedCallable;

        } catch (Exception e) {
            failedDecorations.incrementAndGet();
            log.error("Callable装饰失败: {}", taskName, e);
            throw new TTLDecoratorException("Callable装饰失败: " + e.getMessage());
        }
    }

    /**
     * 装饰Executor
     */
    public Executor decorateExecutor(String executorName, Executor executor) {
        try {
            totalDecorations.incrementAndGet();

            Executor decoratedExecutor = TtlExecutors.getTtlExecutor(executor);

            successfulDecorations.incrementAndGet();
            log.debug("Executor装饰成功: {}", executorName);

            return decoratedExecutor;

        } catch (Exception e) {
            failedDecorations.incrementAndGet();
            log.error("Executor装饰失败: {}", executorName, e);
            throw new TTLDecoratorException("Executor装饰失败: " + e.getMessage());
        }
    }

    /**
     * 装饰ExecutorService
     */
    public ExecutorService decorateExecutorService(String executorName, ExecutorService executorService) {
        try {
            totalDecorations.incrementAndGet();

            ExecutorService decoratedExecutorService = TtlExecutors.getTtlExecutorService(executorService);

            successfulDecorations.incrementAndGet();
            log.debug("ExecutorService装饰成功: {}", executorName);

            return decoratedExecutorService;

        } catch (Exception e) {
            failedDecorations.incrementAndGet();
            log.error("ExecutorService装饰失败: {}", executorName, e);
            throw new TTLDecoratorException("ExecutorService装饰失败: " + e.getMessage());
        }
    }

    /**
     * 装饰ScheduledExecutorService
     */
    public ScheduledExecutorService decorateScheduledExecutorService(String executorName, ScheduledExecutorService scheduledExecutorService) {
        try {
            totalDecorations.incrementAndGet();

            ScheduledExecutorService decoratedScheduledExecutorService = TtlExecutors.getTtlScheduledExecutorService(scheduledExecutorService);

            successfulDecorations.incrementAndGet();
            log.debug("ScheduledExecutorService装饰成功: {}", executorName);

            return decoratedScheduledExecutorService;

        } catch (Exception e) {
            failedDecorations.incrementAndGet();
            log.error("ScheduledExecutorService装饰失败: {}", executorName, e);
            throw new TTLDecoratorException("ScheduledExecutorService装饰失败: " + e.getMessage());
        }
    }

    /**
     * 获取装饰器指标
     */
    public DecoratorMetrics getDecoratorMetrics() {
        try {
            long total = totalDecorations.get();
            long successful = successfulDecorations.get();
            long failed = failedDecorations.get();
            double successRate = total > 0 ? (double) successful / total : 0;

            return DecoratorMetrics.builder()
                    .totalDecorations(total)
                    .successfulDecorations(successful)
                    .failedDecorations(failed)
                    .successRate(successRate)
                    .registeredTTLCount(registeredTTLs.size())
                    .build();

        } catch (Exception e) {
            log.error("获取装饰器指标失败", e);
            throw new TTLDecoratorException("获取装饰器指标失败: " + e.getMessage());
        }
    }
}

/**
 * 线程池传递器
 * 负责管理线程池间的上下文传递
 */
@Component
@Slf4j
public class ThreadPoolTransmitter {

    private final Map<String, ExecutorService> decoratedExecutors = new ConcurrentHashMap<>();
    private final Map<String, ScheduledExecutorService> decoratedScheduledExecutors = new ConcurrentHashMap<>();

    private final AtomicLong totalTransmissions = new AtomicLong(0);
    private final AtomicLong successfulTransmissions = new AtomicLong(0);
    private final AtomicLong failedTransmissions = new AtomicLong(0);

    /**
     * 创建装饰的线程池
     */
    public ExecutorService createDecoratedThreadPool(String poolName, int corePoolSize, int maximumPoolSize) {
        try {
            // 检查是否已存在
            if (decoratedExecutors.containsKey(poolName)) {
                throw new ThreadPoolTransmitterException("装饰的线程池已存在: " + poolName);
            }

            // 创建原始线程池
            ThreadPoolExecutor originalExecutor = new ThreadPoolExecutor(
                    corePoolSize,
                    maximumPoolSize,
                    60L,
                    TimeUnit.SECONDS,
                    new LinkedBlockingQueue<>(1000),
                    new ThreadFactory() {
                        private final AtomicInteger threadNumber = new AtomicInteger(1);
                        private final String namePrefix = poolName + "-";

                        @Override
                        public Thread newThread(Runnable r) {
                            Thread thread = new Thread(r, namePrefix + threadNumber.getAndIncrement());
                            thread.setDaemon(false);
                            return thread;
                        }
                    },
                    new ThreadPoolExecutor.CallerRunsPolicy()
            );

            // 装饰线程池
            ExecutorService decoratedExecutor = TtlExecutors.getTtlExecutorService(originalExecutor);

            // 注册装饰的线程池
            decoratedExecutors.put(poolName, decoratedExecutor);

            log.info("装饰的线程池创建成功: {}", poolName);
            return decoratedExecutor;

        } catch (Exception e) {
            log.error("装饰的线程池创建失败: {}", poolName, e);
            throw new ThreadPoolTransmitterException("装饰的线程池创建失败: " + e.getMessage());
        }
    }

    /**
     * 创建装饰的定时线程池
     */
    public ScheduledExecutorService createDecoratedScheduledThreadPool(String poolName, int corePoolSize) {
        try {
            // 检查是否已存在
            if (decoratedScheduledExecutors.containsKey(poolName)) {
                throw new ThreadPoolTransmitterException("装饰的定时线程池已存在: " + poolName);
            }

            // 创建原始定时线程池
            ScheduledThreadPoolExecutor originalExecutor = new ScheduledThreadPoolExecutor(
                    corePoolSize,
                    new ThreadFactory() {
                        private final AtomicInteger threadNumber = new AtomicInteger(1);
                        private final String namePrefix = poolName + "-";

                        @Override
                        public Thread newThread(Runnable r) {
                            Thread thread = new Thread(r, namePrefix + threadNumber.getAndIncrement());
                            thread.setDaemon(false);
                            return thread;
                        }
                    },
                    new ThreadPoolExecutor.CallerRunsPolicy()
            );

            // 装饰定时线程池
            ScheduledExecutorService decoratedExecutor = TtlExecutors.getTtlScheduledExecutorService(originalExecutor);

            // 注册装饰的定时线程池
            decoratedScheduledExecutors.put(poolName, decoratedExecutor);

            log.info("装饰的定时线程池创建成功: {}", poolName);
            return decoratedExecutor;

        } catch (Exception e) {
            log.error("装饰的定时线程池创建失败: {}", poolName, e);
            throw new ThreadPoolTransmitterException("装饰的定时线程池创建失败: " + e.getMessage());
        }
    }

    /**
     * 获取装饰的线程池
     */
    public ExecutorService getDecoratedExecutor(String poolName) {
        ExecutorService executor = decoratedExecutors.get(poolName);
        if (executor == null) {
            throw new ThreadPoolTransmitterException("装饰的线程池不存在: " + poolName);
        }
        return executor;
    }

    /**
     * 获取装饰的定时线程池
     */
    public ScheduledExecutorService getDecoratedScheduledExecutor(String poolName) {
        ScheduledExecutorService executor = decoratedScheduledExecutors.get(poolName);
        if (executor == null) {
            throw new ThreadPoolTransmitterException("装饰的定时线程池不存在: " + poolName);
        }
        return executor;
    }

    /**
     * 执行任务
     */
    public <T> CompletableFuture<T> executeTask(String poolName, Callable<T> task) {
        try {
            ExecutorService executor = getDecoratedExecutor(poolName);

            totalTransmissions.incrementAndGet();

            CompletableFuture<T> future = CompletableFuture.supplyAsync(() -> {
                try {
                    T result = task.call();
                    successfulTransmissions.incrementAndGet();
                    return result;
                } catch (Exception e) {
                    failedTransmissions.incrementAndGet();
                    log.error("任务执行失败: {}", poolName, e);
                    throw new RuntimeException("任务执行失败: " + e.getMessage(), e);
                }
            }, executor);

            return future;

        } catch (Exception e) {
            log.error("执行任务失败: {}", poolName, e);
            throw new ThreadPoolTransmitterException("执行任务失败: " + e.getMessage());
        }
    }

    /**
     * 批量执行任务
     */
    public <T> CompletableFuture<List<T>> executeBatchTasks(String poolName, List<Callable<T>> tasks) {
        try {
            ExecutorService executor = getDecoratedExecutor(poolName);

            totalTransmissions.addAndGet(tasks.size());

            List<CompletableFuture<T>> futures = tasks.stream()
                    .map(task -> CompletableFuture.supplyAsync(() -> {
                        try {
                            T result = task.call();
                            successfulTransmissions.incrementAndGet();
                            return result;
                        } catch (Exception e) {
                            failedTransmissions.incrementAndGet();
                            log.error("批量任务中的单个任务执行失败: {}", poolName, e);
                            throw new RuntimeException("任务执行失败: " + e.getMessage(), e);
                        }
                    }, executor))
                    .collect(Collectors.toList());

            CompletableFuture<List<T>> future = CompletableFuture.allOf(
                    futures.toArray(new CompletableFuture[0]))
                    .thenApply(v -> futures.stream()
                            .map(CompletableFuture::join)
                            .collect(Collectors.toList()));

            return future;

        } catch (Exception e) {
            log.error("批量执行任务失败: {}", poolName, e);
            throw new ThreadPoolTransmitterException("批量执行任务失败: " + e.getMessage());
        }
    }

    /**
     * 执行定时任务
     */
    public ScheduledFuture<?> scheduleTask(String poolName, Runnable task, long delay, TimeUnit unit) {
        try {
            ScheduledExecutorService executor = getDecoratedScheduledExecutor(poolName);

            totalTransmissions.incrementAndGet();

            ScheduledFuture<?> future = executor.schedule(() -> {
                try {
                    task.run();
                    successfulTransmissions.incrementAndGet();
                } catch (Exception e) {
                    failedTransmissions.incrementAndGet();
                    log.error("定时任务执行失败: {}", poolName, e);
                }
            }, delay, unit);

            return future;

        } catch (Exception e) {
            log.error("执行定时任务失败: {}", poolName, e);
            throw new ThreadPoolTransmitterException("执行定时任务失败: " + e.getMessage());
        }
    }

    /**
     * 执行周期性任务
     */
    public ScheduledFuture<?> schedulePeriodicTask(String poolName, Runnable task, long initialDelay, long period, TimeUnit unit) {
        try {
            ScheduledExecutorService executor = getDecoratedScheduledExecutor(poolName);

            totalTransmissions.incrementAndGet();

            ScheduledFuture<?> future = executor.scheduleAtFixedRate(() -> {
                try {
                    task.run();
                    successfulTransmissions.incrementAndGet();
                } catch (Exception e) {
                    failedTransmissions.incrementAndGet();
                    log.error("周期性任务执行失败: {}", poolName, e);
                }
            }, initialDelay, period, unit);

            return future;

        } catch (Exception e) {
            log.error("执行周期性任务失败: {}", poolName, e);
            throw new ThreadPoolTransmitterException("执行周期性任务失败: " + e.getMessage());
        }
    }

    /**
     * 关闭线程池
     */
    public void shutdownExecutor(String poolName) {
        try {
            ExecutorService executor = decoratedExecutors.get(poolName);
            if (executor != null) {
                executor.shutdown();
                decoratedExecutors.remove(poolName);

                log.info("线程池关闭成功: {}", poolName);
            }

        } catch (Exception e) {
            log.error("关闭线程池失败: {}", poolName, e);
            throw new ThreadPoolTransmitterException("关闭线程池失败: " + e.getMessage());
        }
    }

    /**
     * 关闭定时线程池
     */
    public void shutdownScheduledExecutor(String poolName) {
        try {
            ScheduledExecutorService executor = decoratedScheduledExecutors.get(poolName);
            if (executor != null) {
                executor.shutdown();
                decoratedScheduledExecutors.remove(poolName);

                log.info("定时线程池关闭成功: {}", poolName);
            }

        } catch (Exception e) {
            log.error("关闭定时线程池失败: {}", poolName, e);
            throw new ThreadPoolTransmitterException("关闭定时线程池失败: " + e.getMessage());
        }
    }

    /**
     * 关闭所有线程池
     */
    public void shutdownAllExecutors() {
        try {
            // 关闭所有线程池
            for (String poolName : decoratedExecutors.keySet()) {
                shutdownExecutor(poolName);
            }

            // 关闭所有定时线程池
            for (String poolName : decoratedScheduledExecutors.keySet()) {
                shutdownScheduledExecutor(poolName);
            }

            log.info("所有线程池关闭完成");

        } catch (Exception e) {
            log.error("关闭所有线程池失败", e);
        }
    }

    /**
     * 获取传递指标
     */
    public TransmissionMetrics getTransmissionMetrics() {
        try {
            return TransmissionMetrics.builder()
                    .totalTransmissions(totalTransmissions.get())
                    .successfulTransmissions(successfulTransmissions.get())
                    .failedTransmissions(failedTransmissions.get())
                    .decoratedExecutorCount(decoratedExecutors.size())
                    .decoratedScheduledExecutorCount(decoratedScheduledExecutors.size())
                    .build();

        } catch (Exception e) {
            log.error("获取传递指标失败", e);
            throw new ThreadPoolTransmitterException("获取传递指标失败: " + e.getMessage());
        }
    }

    /**
     * 清理线程池传递器
     */
    @PreDestroy
    public void cleanup() {
        try {
            shutdownAllExecutors();
            log.info("线程池传递器清理完成");

        } catch (Exception e) {
            log.error("线程池传递器清理失败", e);
        }
    }
}

/**
 * 异步任务传递器
 * 负责管理异步任务的上下文传递
 */
@Component
@Slf4j
public class AsyncTaskTransmitter {

    private final ExecutorService defaultExecutor;
    private final Map<String, ExecutorService> customExecutors = new ConcurrentHashMap<>();

    private final AtomicLong totalTaskCount = new AtomicLong(0);
    private final AtomicLong completedTaskCount = new AtomicLong(0);
    private final AtomicLong failedTaskCount = new AtomicLong(0);

    /**
     * 执行异步任务
     */
    public <T> CompletableFuture<T> executeAsyncTask(String taskName, Callable<T> task) {
        try {
            totalTaskCount.incrementAndGet();

            // 装饰Callable
            Callable<T> decoratedTask = TtlCallable.get(task);

            // 创建异步任务
            CompletableFuture<T> future = CompletableFuture.supplyAsync(() -> {
                try {
                    T result = decoratedTask.call();
                    completedTaskCount.incrementAndGet();
                    log.debug("异步任务执行成功: {}", taskName);
                    return result;
                } catch (Exception e) {
                    failedTaskCount.incrementAndGet();
                    log.error("异步任务执行失败: {}", taskName, e);
                    throw new RuntimeException("异步任务执行失败: " + e.getMessage(), e);
                }
            }, defaultExecutor);

            return future;

        } catch (Exception e) {
            log.error("创建异步任务失败: {}", taskName, e);
            throw new AsyncTaskTransmitterException("创建异步任务失败: " + e.getMessage());
        }
    }

    /**
     * 执行异步任务（带超时）
     */
    public <T> CompletableFuture<T> executeAsyncTaskWithTimeout(String taskName, Callable<T> task, long timeout, TimeUnit timeUnit) {
        try {
            totalTaskCount.incrementAndGet();

            // 装饰Callable
            Callable<T> decoratedTask = TtlCallable.get(task);

            // 创建异步任务
            CompletableFuture<T> future = CompletableFuture.supplyAsync(() -> {
                try {
                    T result = decoratedTask.call();
                    completedTaskCount.incrementAndGet();
                    log.debug("异步任务执行成功: {}", taskName);
                    return result;
                } catch (Exception e) {
                    failedTaskCount.incrementAndGet();
                    log.error("异步任务执行失败: {}", taskName, e);
                    throw new RuntimeException("异步任务执行失败: " + e.getMessage(), e);
                }
            }, defaultExecutor);

            // 设置超时
            future.orTimeout(timeout, timeUnit);

            return future;

        } catch (Exception e) {
            log.error("创建异步任务失败: {}", taskName, e);
            throw new AsyncTaskTransmitterException("创建异步任务失败: " + e.getMessage());
        }
    }

    /**
     * 批量执行异步任务
     */
    public <T> CompletableFuture<List<T>> executeBatchAsyncTasks(String taskName, List<Callable<T>> tasks) {
        try {
            totalTaskCount.addAndGet(tasks.size());

            // 装饰所有Callable
            List<Callable<T>> decoratedTasks = tasks.stream()
                    .map(TtlCallable::get)
                    .collect(Collectors.toList());

            // 创建批量异步任务
            CompletableFuture<List<T>> future = CompletableFuture.supplyAsync(() -> {
                try {
                    List<T> results = new ArrayList<>();
                    for (Callable<T> task : decoratedTasks) {
                        try {
                            T result = task.call();
                            results.add(result);
                            completedTaskCount.incrementAndGet();
                        } catch (Exception e) {
                            log.error("批量任务中的单个任务执行失败: {}", taskName, e);
                            failedTaskCount.incrementAndGet();
                            throw e;
                        }
                    }

                    log.debug("批量异步任务执行成功: {}", taskName);
                    return results;

                } catch (Exception e) {
                    log.error("批量异步任务执行失败: {}", taskName, e);
                    throw new RuntimeException("批量异步任务执行失败: " + e.getMessage(), e);
                }
            }, defaultExecutor);

            return future;

        } catch (Exception e) {
            log.error("创建批量异步任务失败: {}", taskName, e);
            throw new AsyncTaskTransmitterException("创建批量异步任务失败: " + e.getMessage());
        }
    }

    /**
     * 执行异步任务（带重试）
     */
    public <T> CompletableFuture<T> executeAsyncTaskWithRetry(String taskName, Callable<T> task, int maxRetries) {
        try {
            totalTaskCount.incrementAndGet();

            // 装饰Callable
            Callable<T> decoratedTask = TtlCallable.get(task);

            // 创建异步任务
            CompletableFuture<T> future = CompletableFuture.supplyAsync(() -> {
                Exception lastException = null;

                for (int attempt = 0; attempt <= maxRetries; attempt++) {
                    try {
                        T result = decoratedTask.call();
                        completedTaskCount.incrementAndGet();
                        log.debug("异步任务执行成功: {} (尝试次数: {})", taskName, attempt + 1);
                        return result;

                    } catch (Exception e) {
                        lastException = e;
                        log.warn("异步任务执行失败: {} (尝试次数: {})", taskName, attempt + 1, e);

                        if (attempt < maxRetries) {
                            // 等待一段时间后重试
                            try {
                                Thread.sleep(1000 * (attempt + 1));
                            } catch (InterruptedException ie) {
                                Thread.currentThread().interrupt();
                                break;
                            }
                        }
                    }
                }

                failedTaskCount.incrementAndGet();
                log.error("异步任务执行失败: {} (最大重试次数: {})", taskName, maxRetries, lastException);
                throw new RuntimeException("异步任务执行失败: " + lastException.getMessage(), lastException);

            }, defaultExecutor);

            return future;

        } catch (Exception e) {
            log.error("创建异步任务失败: {}", taskName, e);
            throw new AsyncTaskTransmitterException("创建异步任务失败: " + e.getMessage());
        }
    }

    /**
     * 执行异步任务（带自定义执行器）
     */
    public <T> CompletableFuture<T> executeAsyncTaskWithExecutor(String taskName, Callable<T> task, String executorName) {
        try {
            totalTaskCount.incrementAndGet();

            // 获取自定义执行器
            ExecutorService executor = getCustomExecutor(executorName);

            // 装饰Callable
            Callable<T> decoratedTask = TtlCallable.get(task);

            // 创建异步任务
            CompletableFuture<T> future = CompletableFuture.supplyAsync(() -> {
                try {
                    T result = decoratedTask.call();
                    completedTaskCount.incrementAndGet();
                    log.debug("异步任务执行成功: {} (执行器: {})", taskName, executorName);
                    return result;
                } catch (Exception e) {
                    failedTaskCount.incrementAndGet();
                    log.error("异步任务执行失败: {} (执行器: {})", taskName, executorName, e);
                    throw new RuntimeException("异步任务执行失败: " + e.getMessage(), e);
                }
            }, executor);

            return future;

        } catch (Exception e) {
            log.error("创建异步任务失败: {}", taskName, e);
            throw new AsyncTaskTransmitterException("创建异步任务失败: " + e.getMessage());
        }
    }

    /**
     * 创建自定义执行器
     */
    public ExecutorService createCustomExecutor(String executorName, int corePoolSize, int maximumPoolSize) {
        try {
            // 检查是否已存在
            if (customExecutors.containsKey(executorName)) {
                throw new AsyncTaskTransmitterException("自定义执行器已存在: " + executorName);
            }

            // 创建原始执行器
            ThreadPoolExecutor originalExecutor = new ThreadPoolExecutor(
                    corePoolSize,
                    maximumPoolSize,
                    60L,
                    TimeUnit.SECONDS,
                    new LinkedBlockingQueue<>(1000),
                    new ThreadFactory() {
                        private final AtomicInteger threadNumber = new AtomicInteger(1);
                        private final String namePrefix = executorName + "-";

                        @Override
                        public Thread newThread(Runnable r) {
                            Thread thread = new Thread(r, namePrefix + threadNumber.getAndIncrement());
                            thread.setDaemon(false);
                            return thread;
                        }
                    },
                    new ThreadPoolExecutor.CallerRunsPolicy()
            );

            // 装饰执行器
            ExecutorService decoratedExecutor = TtlExecutors.getTtlExecutorService(originalExecutor);

            // 注册自定义执行器
            customExecutors.put(executorName, decoratedExecutor);

            log.info("自定义执行器创建成功: {}", executorName);
            return decoratedExecutor;

        } catch (Exception e) {
            log.error("自定义执行器创建失败: {}", executorName, e);
            throw new AsyncTaskTransmitterException("自定义执行器创建失败: " + e.getMessage());
        }
    }

    /**
     * 获取自定义执行器
     */
    public ExecutorService getCustomExecutor(String executorName) {
        ExecutorService executor = customExecutors.get(executorName);
        if (executor == null) {
            throw new AsyncTaskTransmitterException("自定义执行器不存在: " + executorName);
        }
        return executor;
    }

    /**
     * 关闭自定义执行器
     */
    public void shutdownCustomExecutor(String executorName) {
        try {
            ExecutorService executor = customExecutors.get(executorName);
            if (executor != null) {
                executor.shutdown();
                customExecutors.remove(executorName);

                log.info("自定义执行器关闭成功: {}", executorName);
            }

        } catch (Exception e) {
            log.error("关闭自定义执行器失败: {}", executorName, e);
            throw new AsyncTaskTransmitterException("关闭自定义执行器失败: " + e.getMessage());
        }
    }

    /**
     * 关闭所有自定义执行器
     */
    public void shutdownAllCustomExecutors() {
        try {
            for (String executorName : customExecutors.keySet()) {
                shutdownCustomExecutor(executorName);
            }

            log.info("所有自定义执行器关闭完成");

        } catch (Exception e) {
            log.error("关闭所有自定义执行器失败", e);
        }
    }

    /**
     * 获取异步任务指标
     */
    public AsyncTaskMetrics getAsyncTaskMetrics() {
        try {
            long total = totalTaskCount.get();
            long completed = completedTaskCount.get();
            long failed = failedTaskCount.get();
            double successRate = total > 0 ? (double) completed / total : 0;

            return AsyncTaskMetrics.builder()
                    .totalTaskCount(total)
                    .completedTaskCount(completed)
                    .failedTaskCount(failed)
                    .successRate(successRate)
                    .customExecutorCount(customExecutors.size())
                    .build();

        } catch (Exception e) {
            log.error("获取异步任务指标失败", e);
            throw new AsyncTaskTransmitterException("获取异步任务指标失败: " + e.getMessage());
        }
    }

    /**
     * 清理异步任务传递器
     */
    @PreDestroy
    public void cleanup() {
        try {
            // 关闭默认执行器
            defaultExecutor.shutdown();

            // 关闭所有自定义执行器
            shutdownAllCustomExecutors();

            log.info("异步任务传递器清理完成");

        } catch (Exception e) {
            log.error("异步任务传递器清理失败", e);
        }
    }
}