/**
 * 企业级InheritableThreadLocal管理器
 * 提供父子线程间的上下文传递和继承管理
 */
@Component
@Slf4j
public class InheritableThreadLocalManager {

    private final Map<String, InheritableThreadLocal<?>> inheritableThreadLocalMap = new ConcurrentHashMap<>();
    private final ContextInheritanceManager contextInheritanceManager;
    private final AsyncTaskManager asyncTaskManager;
    private final ThreadPoolManager threadPoolManager;
    private final PerformanceMonitor performanceMonitor;

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

            // 创建InheritableThreadLocal实例
            InheritableThreadLocal<T> inheritableThreadLocal = new InheritableThreadLocal<T>() {
                @Override
                protected T childValue(T parentValue) {
                    try {
                        // 记录子线程继承操作
                        performanceMonitor.recordInheritance(name, parentValue);

                        // 执行上下文继承逻辑
                        return contextInheritanceManager.inheritContext(name, parentValue);

                    } catch (Exception e) {
                        log.error("子线程继承上下文失败: {}", name, e);
                        return parentValue; // 返回父线程的值
                    }
                }

                @Override
                protected T initialValue() {
                    try {
                        return type.newInstance();
                    } catch (Exception e) {
                        log.error("InheritableThreadLocal初始值创建失败: {}", name, e);
                        return null;
                    }
                }

                @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");
                }
            };

            // 注册InheritableThreadLocal
            inheritableThreadLocalMap.put(name, inheritableThreadLocal);

            // 注册到上下文继承管理器
            contextInheritanceManager.registerInheritableThreadLocal(name, inheritableThreadLocal);

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

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

    /**
     * 获取InheritableThreadLocal实例
     */
    @SuppressWarnings("unchecked")
    public <T> InheritableThreadLocal<T> getInheritableThreadLocal(String name) {
        InheritableThreadLocal<?> inheritableThreadLocal = inheritableThreadLocalMap.get(name);
        if (inheritableThreadLocal == null) {
            throw new InheritableThreadLocalException("InheritableThreadLocal不存在: " + name);
        }
        return (InheritableThreadLocal<T>) inheritableThreadLocal;
    }

    /**
     * 设置InheritableThreadLocal值
     */
    public <T> void setValue(String name, T value) {
        try {
            InheritableThreadLocal<T> inheritableThreadLocal = getInheritableThreadLocal(name);
            inheritableThreadLocal.set(value);

            // 记录上下文信息
            contextInheritanceManager.recordContext(name, value);

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

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

    /**
     * 获取InheritableThreadLocal值
     */
    public <T> T getValue(String name) {
        try {
            InheritableThreadLocal<T> inheritableThreadLocal = getInheritableThreadLocal(name);
            T value = inheritableThreadLocal.get();

            // 记录上下文信息
            contextInheritanceManager.recordContext(name, value);

            return value;

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

    /**
     * 移除InheritableThreadLocal值
     */
    public <T> void removeValue(String name) {
        try {
            InheritableThreadLocal<T> inheritableThreadLocal = getInheritableThreadLocal(name);
            inheritableThreadLocal.remove();

            // 清理上下文信息
            contextInheritanceManager.clearContext(name);

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

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

    /**
     * 执行异步任务
     */
    public <T> CompletableFuture<T> executeAsyncTask(String taskName, Callable<T> task) {
        try {
            // 获取当前线程的上下文
            Map<String, Object> currentContext = contextInheritanceManager.getCurrentContext();

            // 创建异步任务
            CompletableFuture<T> future = asyncTaskManager.executeAsyncTask(taskName, task, currentContext);

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

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

    /**
     * 执行异步任务（带返回值处理）
     */
    public <T, R> CompletableFuture<R> executeAsyncTaskWithResult(String taskName, Callable<T> task, Function<T, R> resultProcessor) {
        try {
            // 获取当前线程的上下文
            Map<String, Object> currentContext = contextInheritanceManager.getCurrentContext();

            // 创建异步任务
            CompletableFuture<R> future = asyncTaskManager.executeAsyncTaskWithResult(taskName, task, resultProcessor, currentContext);

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

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

    /**
     * 批量执行异步任务
     */
    public <T> CompletableFuture<List<T>> executeBatchAsyncTasks(String taskName, List<Callable<T>> tasks) {
        try {
            // 获取当前线程的上下文
            Map<String, Object> currentContext = contextInheritanceManager.getCurrentContext();

            // 创建批量异步任务
            CompletableFuture<List<T>> future = asyncTaskManager.executeBatchAsyncTasks(taskName, tasks, currentContext);

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

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

    /**
     * 创建自定义线程池
     */
    public ExecutorService createCustomThreadPool(String poolName, int corePoolSize, int maximumPoolSize) {
        try {
            ExecutorService threadPool = threadPoolManager.createCustomThreadPool(poolName, corePoolSize, maximumPoolSize);

            log.info("自定义线程池创建成功: {}", poolName);
            return threadPool;

        } catch (Exception e) {
            log.error("自定义线程池创建失败: {}", poolName, e);
            throw new InheritableThreadLocalException("自定义线程池创建失败: " + e.getMessage());
        }
    }

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

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

            // 清理上下文信息
            contextInheritanceManager.clearAllContext();

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

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

    /**
     * 获取InheritableThreadLocal统计信息
     */
    public InheritableThreadLocalStatistics getStatistics() {
        try {
            Map<String, InheritableThreadLocalInfo> inheritableThreadLocalInfos = new HashMap<>();

            for (Map.Entry<String, InheritableThreadLocal<?>> entry : inheritableThreadLocalMap.entrySet()) {
                String name = entry.getKey();
                InheritableThreadLocal<?> inheritableThreadLocal = entry.getValue();

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

                inheritableThreadLocalInfos.put(name, info);
            }

            return InheritableThreadLocalStatistics.builder()
                    .totalCount(inheritableThreadLocalMap.size())
                    .inheritableThreadLocalInfos(inheritableThreadLocalInfos)
                    .inheritanceMetrics(contextInheritanceManager.getInheritanceMetrics())
                    .asyncTaskMetrics(asyncTaskManager.getAsyncTaskMetrics())
                    .threadPoolMetrics(threadPoolManager.getThreadPoolMetrics())
                    .performanceMetrics(performanceMonitor.getMetrics())
                    .build();

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

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

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

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

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

/**
 * 上下文继承管理器
 * 负责管理父子线程间的上下文继承
 */
@Component
@Slf4j
public class ContextInheritanceManager {

    private final Map<String, InheritableThreadLocal<?>> registeredInheritableThreadLocals = new ConcurrentHashMap<>();
    private final Map<String, Object> contextMap = new ConcurrentHashMap<>();
    private final ThreadLocal<Map<String, Object>> threadLocalContext = new ThreadLocal<>();

    private final AtomicLong totalInheritanceCount = new AtomicLong(0);
    private final AtomicLong successfulInheritanceCount = new AtomicLong(0);
    private final AtomicLong failedInheritanceCount = new AtomicLong(0);

    /**
     * 注册InheritableThreadLocal
     */
    public void registerInheritableThreadLocal(String name, InheritableThreadLocal<?> inheritableThreadLocal) {
        try {
            registeredInheritableThreadLocals.put(name, inheritableThreadLocal);

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

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

    /**
     * 继承上下文
     */
    public <T> T inheritContext(String name, T parentValue) {
        try {
            totalInheritanceCount.incrementAndGet();

            // 执行上下文继承逻辑
            T inheritedValue = performContextInheritance(name, parentValue);

            if (inheritedValue != null) {
                successfulInheritanceCount.incrementAndGet();
                log.debug("上下文继承成功: {} = {}", name, inheritedValue);
            } else {
                failedInheritanceCount.incrementAndGet();
                log.warn("上下文继承失败: {}", name);
            }

            return inheritedValue;

        } catch (Exception e) {
            failedInheritanceCount.incrementAndGet();
            log.error("上下文继承失败: {}", name, e);
            return parentValue; // 返回父线程的值
        }
    }

    /**
     * 执行上下文继承
     */
    private <T> T performContextInheritance(String name, T parentValue) {
        try {
            if (parentValue == null) {
                return null;
            }

            // 根据上下文类型执行不同的继承策略
            switch (name) {
                case "userContext":
                    return inheritUserContext(parentValue);
                case "requestContext":
                    return inheritRequestContext(parentValue);
                case "businessContext":
                    return inheritBusinessContext(parentValue);
                case "securityContext":
                    return inheritSecurityContext(parentValue);
                case "logContext":
                    return inheritLogContext(parentValue);
                default:
                    return inheritDefaultContext(parentValue);
            }

        } catch (Exception e) {
            log.error("执行上下文继承失败: {}", name, e);
            return parentValue;
        }
    }

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

                // 创建新的用户上下文，继承父线程的信息
                UserContext inheritedUserContext = 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())
                        .inheritedFrom(Thread.currentThread().getName())
                        .build();

                return (T) inheritedUserContext;
            }

            return parentValue;

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

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

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

                return (T) inheritedRequestContext;
            }

            return parentValue;

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

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

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

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

                // 添加继承信息
                inheritedBusinessContext.put("threadId", Thread.currentThread().getId());
                inheritedBusinessContext.put("inheritedFrom", Thread.currentThread().getName());

                return (T) inheritedBusinessContext;
            }

            return parentValue;

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

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

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

                return (T) inheritedSecurityContext;
            }

            return parentValue;

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

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

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

                return (T) inheritedLogContext;
            }

            return parentValue;

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

    /**
     * 继承默认上下文
     */
    private <T> T inheritDefaultContext(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 recordContext(String name, Object value) {
        try {
            String key = "record_" + name;
            setThreadLocalContext(key, value);

        } catch (Exception e) {
            log.error("记录上下文信息失败: {}", name, e);
        }
    }

    /**
     * 清理上下文信息
     */
    public void clearContext(String name) {
        try {
            String key = "record_" + name;
            Map<String, Object> threadContext = threadLocalContext.get();
            if (threadContext != null) {
                threadContext.remove(key);
            }

        } catch (Exception e) {
            log.error("清理上下文信息失败: {}", name, e);
        }
    }

    /**
     * 清理所有上下文
     */
    public void clearAllContext() {
        try {
            contextMap.clear();
            threadLocalContext.remove();

            log.info("所有上下文清理完成");

        } catch (Exception e) {
            log.error("清理所有上下文失败", e);
        }
    }

    /**
     * 获取当前上下文
     */
    public Map<String, Object> getCurrentContext() {
        try {
            Map<String, Object> currentContext = new HashMap<>();

            // 获取ThreadLocal上下文
            Map<String, Object> threadContext = threadLocalContext.get();
            if (threadContext != null) {
                currentContext.putAll(threadContext);
            }

            // 获取全局上下文
            currentContext.putAll(contextMap);

            return currentContext;

        } catch (Exception e) {
            log.error("获取当前上下文失败", e);
            return new HashMap<>();
        }
    }

    /**
     * 设置ThreadLocal上下文
     */
    private void setThreadLocalContext(String key, Object value) {
        Map<String, Object> threadContext = threadLocalContext.get();
        if (threadContext == null) {
            threadContext = new HashMap<>();
            threadLocalContext.set(threadContext);
        }
        threadContext.put(key, value);
    }

    /**
     * 获取继承指标
     */
    public InheritanceMetrics getInheritanceMetrics() {
        try {
            long total = totalInheritanceCount.get();
            long successful = successfulInheritanceCount.get();
            long failed = failedInheritanceCount.get();
            double successRate = total > 0 ? (double) successful / total : 0;

            return InheritanceMetrics.builder()
                    .totalInheritanceCount(total)
                    .successfulInheritanceCount(successful)
                    .failedInheritanceCount(failed)
                    .successRate(successRate)
                    .registeredInheritableThreadLocalCount(registeredInheritableThreadLocals.size())
                    .build();

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

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

    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);

    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);

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

            // 创建异步任务
            CompletableFuture<T> future = CompletableFuture.supplyAsync(() -> {
                try {
                    // 设置上下文
                    setTaskContext(context);

                    // 执行任务
                    T result = task.call();

                    completedTaskCount.incrementAndGet();
                    log.debug("异步任务执行成功: {}", taskName);

                    return result;

                } catch (Exception e) {
                    failedTaskCount.incrementAndGet();
                    log.error("异步任务执行失败: {}", taskName, e);
                    throw new RuntimeException("异步任务执行失败: " + e.getMessage(), e);
                } finally {
                    // 清理上下文
                    clearTaskContext();
                }
            }, defaultExecutor);

            return future;

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

    /**
     * 执行异步任务（带返回值处理）
     */
    public <T, R> CompletableFuture<R> executeAsyncTaskWithResult(String taskName, Callable<T> task, 
            Function<T, R> resultProcessor, Map<String, Object> context) {
        try {
            totalTaskCount.incrementAndGet();

            // 创建异步任务
            CompletableFuture<R> future = CompletableFuture.supplyAsync(() -> {
                try {
                    // 设置上下文
                    setTaskContext(context);

                    // 执行任务
                    T taskResult = task.call();

                    // 处理结果
                    R processedResult = resultProcessor.apply(taskResult);

                    completedTaskCount.incrementAndGet();
                    log.debug("异步任务执行成功: {}", taskName);

                    return processedResult;

                } catch (Exception e) {
                    failedTaskCount.incrementAndGet();
                    log.error("异步任务执行失败: {}", taskName, e);
                    throw new RuntimeException("异步任务执行失败: " + e.getMessage(), e);
                } finally {
                    // 清理上下文
                    clearTaskContext();
                }
            }, defaultExecutor);

            return future;

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

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

            // 创建批量异步任务
            CompletableFuture<List<T>> future = CompletableFuture.supplyAsync(() -> {
                try {
                    // 设置上下文
                    setTaskContext(context);

                    // 执行批量任务
                    List<T> results = new ArrayList<>();
                    for (Callable<T> task : tasks) {
                        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);
                } finally {
                    // 清理上下文
                    clearTaskContext();
                }
            }, defaultExecutor);

            return future;

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

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

            // 创建异步任务
            CompletableFuture<T> future = CompletableFuture.supplyAsync(() -> {
                try {
                    // 设置上下文
                    setTaskContext(context);

                    // 执行任务
                    T result = task.call();

                    completedTaskCount.incrementAndGet();
                    log.debug("异步任务执行成功: {}", taskName);

                    return result;

                } catch (Exception e) {
                    failedTaskCount.incrementAndGet();
                    log.error("异步任务执行失败: {}", taskName, e);
                    throw new RuntimeException("异步任务执行失败: " + e.getMessage(), e);
                } finally {
                    // 清理上下文
                    clearTaskContext();
                }
            }, defaultExecutor);

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

            return future;

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

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

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

                for (int attempt = 0; attempt <= maxRetries; attempt++) {
                    try {
                        // 设置上下文
                        setTaskContext(context);

                        // 执行任务
                        T result = task.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;
                            }
                        }
                    } finally {
                        // 清理上下文
                        clearTaskContext();
                    }
                }

                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 AsyncTaskException("创建异步任务失败: " + e.getMessage());
        }
    }

    /**
     * 设置任务上下文
     */
    private void setTaskContext(Map<String, Object> context) {
        try {
            if (context != null && !context.isEmpty()) {
                // 设置到ThreadLocal
                for (Map.Entry<String, Object> entry : context.entrySet()) {
                    String key = entry.getKey();
                    Object value = entry.getValue();

                    // 这里可以根据需要设置到具体的InheritableThreadLocal
                    // 简化实现，记录到日志
                    log.debug("设置任务上下文: {} = {}", key, value);
                }
            }

        } catch (Exception e) {
            log.error("设置任务上下文失败", e);
        }
    }

    /**
     * 清理任务上下文
     */
    private void clearTaskContext() {
        try {
            // 清理ThreadLocal
            // 简化实现，记录到日志
            log.debug("清理任务上下文");

        } 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 AsyncTaskException("获取异步任务指标失败: " + e.getMessage());
        }
    }

    /**
     * 创建自定义执行器
     */
    public ExecutorService createCustomExecutor(String executorName, int corePoolSize, int maximumPoolSize) {
        try {
            ExecutorService executor = Executors.newFixedThreadPool(maximumPoolSize, r -> {
                Thread thread = new Thread(r);
                thread.setName(executorName + "-" + thread.getId());
                thread.setDaemon(true);
                return thread;
            });

            customExecutors.put(executorName, executor);

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

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

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

            // 关闭自定义执行器
            for (ExecutorService executor : customExecutors.values()) {
                executor.shutdown();
            }

            // 关闭调度器
            scheduler.shutdown();

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

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

/**
 * 线程池管理器
 * 负责管理自定义线程池和InheritableThreadLocal支持
 */
@Component
@Slf4j
public class ThreadPoolManager {

    private final Map<String, ExecutorService> threadPools = new ConcurrentHashMap<>();
    private final Map<String, ThreadPoolInfo> threadPoolInfos = new ConcurrentHashMap<>();

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

    /**
     * 创建自定义线程池
     */
    public ExecutorService createCustomThreadPool(String poolName, int corePoolSize, int maximumPoolSize) {
        try {
            // 检查是否已存在
            if (threadPools.containsKey(poolName)) {
                throw new ThreadPoolException("线程池已存在: " + poolName);
            }

            // 创建线程工厂
            ThreadFactory threadFactory = new InheritableThreadFactory(poolName);

            // 创建拒绝策略
            RejectedExecutionHandler rejectedHandler = new InheritableRejectedExecutionHandler(poolName);

            // 创建线程池
            ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                    corePoolSize,
                    maximumPoolSize,
                    60L,
                    TimeUnit.SECONDS,
                    new LinkedBlockingQueue<>(1000),
                    threadFactory,
                    rejectedHandler
            );

            // 注册线程池
            threadPools.put(poolName, threadPool);

            // 创建线程池信息
            ThreadPoolInfo info = ThreadPoolInfo.builder()
                    .name(poolName)
                    .corePoolSize(corePoolSize)
                    .maximumPoolSize(maximumPoolSize)
                    .currentPoolSize(threadPool.getPoolSize())
                    .activeCount(threadPool.getActiveCount())
                    .taskCount(threadPool.getTaskCount())
                    .completedTaskCount(threadPool.getCompletedTaskCount())
                    .build();

            threadPoolInfos.put(poolName, info);

            log.info("自定义线程池创建成功: {}", poolName);
            return threadPool;

        } catch (Exception e) {
            log.error("自定义线程池创建失败: {}", poolName, e);
            throw new ThreadPoolException("自定义线程池创建失败: " + e.getMessage());
        }
    }

    /**
     * 获取线程池
     */
    public ExecutorService getThreadPool(String poolName) {
        ExecutorService threadPool = threadPools.get(poolName);
        if (threadPool == null) {
            throw new ThreadPoolException("线程池不存在: " + poolName);
        }
        return threadPool;
    }

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

            totalTaskCount.incrementAndGet();

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

            return future;

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

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

            totalTaskCount.addAndGet(tasks.size());

            List<CompletableFuture<T>> futures = tasks.stream()
                    .map(task -> CompletableFuture.supplyAsync(() -> {
                        try {
                            T result = task.call();
                            completedTaskCount.incrementAndGet();
                            return result;
                        } catch (Exception e) {
                            log.error("批量任务中的单个任务执行失败: {}", poolName, e);
                            throw new RuntimeException("任务执行失败: " + e.getMessage(), e);
                        }
                    }, threadPool))
                    .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 ThreadPoolException("批量执行任务失败: " + e.getMessage());
        }
    }

    /**
     * 获取线程池信息
     */
    public ThreadPoolInfo getThreadPoolInfo(String poolName) {
        ThreadPoolInfo info = threadPoolInfos.get(poolName);
        if (info == null) {
            throw new ThreadPoolException("线程池信息不存在: " + poolName);
        }

        // 更新实时信息
        ExecutorService threadPool = threadPools.get(poolName);
        if (threadPool instanceof ThreadPoolExecutor) {
            ThreadPoolExecutor tpe = (ThreadPoolExecutor) threadPool;
            info.setCurrentPoolSize(tpe.getPoolSize());
            info.setActiveCount(tpe.getActiveCount());
            info.setTaskCount(tpe.getTaskCount());
            info.setCompletedTaskCount(tpe.getCompletedTaskCount());
        }

        return info;
    }

    /**
     * 获取所有线程池信息
     */
    public Map<String, ThreadPoolInfo> getAllThreadPoolInfos() {
        Map<String, ThreadPoolInfo> allInfos = new HashMap<>();

        for (String poolName : threadPools.keySet()) {
            try {
                ThreadPoolInfo info = getThreadPoolInfo(poolName);
                allInfos.put(poolName, info);
            } catch (Exception e) {
                log.error("获取线程池信息失败: {}", poolName, e);
            }
        }

        return allInfos;
    }

    /**
     * 关闭线程池
     */
    public void shutdownThreadPool(String poolName) {
        try {
            ExecutorService threadPool = threadPools.get(poolName);
            if (threadPool != null) {
                threadPool.shutdown();
                threadPools.remove(poolName);
                threadPoolInfos.remove(poolName);

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

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

    /**
     * 关闭所有线程池
     */
    public void shutdownAllThreadPools() {
        try {
            for (String poolName : threadPools.keySet()) {
                shutdownThreadPool(poolName);
            }

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

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

    /**
     * 获取线程池指标
     */
    public ThreadPoolMetrics getThreadPoolMetrics() {
        try {
            return ThreadPoolMetrics.builder()
                    .totalThreadPoolCount(threadPools.size())
                    .totalTaskCount(totalTaskCount.get())
                    .completedTaskCount(completedTaskCount.get())
                    .rejectedTaskCount(rejectedTaskCount.get())
                    .build();

        } catch (Exception e) {
            log.error("获取线程池指标失败", e);
            throw new ThreadPoolException("获取线程池指标失败: " + e.getMessage());
        }
    }

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

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

/**
 * 可继承线程工厂
 * 支持InheritableThreadLocal的线程工厂
 */
public class InheritableThreadFactory implements ThreadFactory {

    private final String poolName;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final ThreadGroup group;

    public InheritableThreadFactory(String poolName) {
        this.poolName = poolName;
        SecurityManager s = System.getSecurityManager();
        this.group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new InheritableThread(group, r, poolName + "-" + threadNumber.getAndIncrement(), 0);

        if (thread.isDaemon()) {
            thread.setDaemon(false);
        }

        if (thread.getPriority() != Thread.NORM_PRIORITY) {
            thread.setPriority(Thread.NORM_PRIORITY);
        }

        return thread;
    }
}

/**
 * 可继承拒绝策略
 * 支持InheritableThreadLocal的拒绝策略
 */
public class InheritableRejectedExecutionHandler implements RejectedExecutionHandler {

    private final String poolName;
    private final AtomicLong rejectedCount = new AtomicLong(0);

    public InheritableRejectedExecutionHandler(String poolName) {
        this.poolName = poolName;
    }

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        rejectedCount.incrementAndGet();

        log.warn("任务被拒绝执行: {} - 线程池: {}, 活跃线程: {}, 队列大小: {}", 
                r.getClass().getSimpleName(), 
                poolName, 
                executor.getActiveCount(), 
                executor.getQueue().size());

        // 尝试在调用线程中执行
        if (!executor.isShutdown()) {
            try {
                r.run();
            } catch (Exception e) {
                log.error("在调用线程中执行任务失败", e);
            }
        }
    }

    public long getRejectedCount() {
        return rejectedCount.get();
    }
}

/**
 * 性能监控器
 * 负责监控InheritableThreadLocal的性能指标
 */
@Component
@Slf4j
public class PerformanceMonitor {

    private final Map<String, PerformanceMetrics> metricsMap = new ConcurrentHashMap<>();
    private final AtomicLong totalOperations = new AtomicLong(0);
    private final AtomicLong totalInheritanceOperations = new AtomicLong(0);
    private final AtomicLong totalLatency = new AtomicLong(0);

    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    /**
     * 记录操作
     */
    public void recordOperation(String name, String operation) {
        try {
            totalOperations.incrementAndGet();

            PerformanceMetrics metrics = metricsMap.computeIfAbsent(name, k -> 
                PerformanceMetrics.builder()
                        .name(k)
                        .setCount(0)
                        .getCount(0)
                        .removeCount(0)
                        .inheritanceCount(0)
                        .totalLatency(0)
                        .averageLatency(0)
                        .maxLatency(0)
                        .minLatency(Long.MAX_VALUE)
                        .lastOperationTime(System.currentTimeMillis())
                        .build()
            );

            long startTime = System.nanoTime();

            // 更新指标
            updateMetrics(metrics, operation);

            long endTime = System.nanoTime();
            long latency = endTime - startTime;

            totalLatency.addAndGet(latency);
            metrics.setTotalLatency(metrics.getTotalLatency() + latency);
            metrics.setAverageLatency(metrics.getTotalLatency() / getTotalOperationCount(metrics));
            metrics.setMaxLatency(Math.max(metrics.getMaxLatency(), latency));
            metrics.setMinLatency(Math.min(metrics.getMinLatency(), latency));
            metrics.setLastOperationTime(System.currentTimeMillis());

        } catch (Exception e) {
            log.error("记录操作失败: {} - {}", name, operation, e);
        }
    }

    /**
     * 记录继承操作
     */
    public void recordInheritance(String name, Object value) {
        try {
            totalInheritanceOperations.incrementAndGet();

            PerformanceMetrics metrics = metricsMap.computeIfAbsent(name, k -> 
                PerformanceMetrics.builder()
                        .name(k)
                        .setCount(0)
                        .getCount(0)
                        .removeCount(0)
                        .inheritanceCount(0)
                        .totalLatency(0)
                        .averageLatency(0)
                        .maxLatency(0)
                        .minLatency(Long.MAX_VALUE)
                        .lastOperationTime(System.currentTimeMillis())
                        .build()
            );

            metrics.setInheritanceCount(metrics.getInheritanceCount() + 1);
            metrics.setLastOperationTime(System.currentTimeMillis());

        } catch (Exception e) {
            log.error("记录继承操作失败: {}", name, e);
        }
    }

    /**
     * 更新指标
     */
    private void updateMetrics(PerformanceMetrics metrics, String operation) {
        switch (operation) {
            case "set":
                metrics.setSetCount(metrics.getSetCount() + 1);
                break;
            case "get":
                metrics.setGetCount(metrics.getGetCount() + 1);
                break;
            case "remove":
                metrics.setRemoveCount(metrics.getRemoveCount() + 1);
                break;
        }
    }

    /**
     * 获取总操作次数
     */
    private long getTotalOperationCount(PerformanceMetrics metrics) {
        return metrics.getSetCount() + metrics.getGetCount() + metrics.getRemoveCount() + metrics.getInheritanceCount();
    }

    /**
     * 获取性能指标
     */
    public Map<String, PerformanceMetrics> getMetrics() {
        return new HashMap<>(metricsMap);
    }

    /**
     * 获取总体性能指标
     */
    public OverallPerformanceMetrics getOverallMetrics() {
        try {
            long totalOps = totalOperations.get();
            long totalInheritanceOps = totalInheritanceOperations.get();
            long totalLat = totalLatency.get();
            double averageLatency = totalOps > 0 ? (double) totalLat / totalOps : 0;

            return OverallPerformanceMetrics.builder()
                    .totalOperations(totalOps)
                    .totalInheritanceOperations(totalInheritanceOps)
                    .totalLatency(totalLat)
                    .averageLatency(averageLatency)
                    .inheritableThreadLocalCount(metricsMap.size())
                    .build();

        } catch (Exception e) {
            log.error("获取总体性能指标失败", e);
            throw new PerformanceException("获取总体性能指标失败: " + e.getMessage());
        }
    }

    /**
     * 启动性能监控
     */
    @PostConstruct
    public void startMonitoring() {
        scheduler.scheduleAtFixedRate(() -> {
            try {
                logPerformanceMetrics();
            } catch (Exception e) {
                log.error("性能监控失败", e);
            }
        }, 0, 60, TimeUnit.SECONDS);
    }

    /**
     * 记录性能指标
     */
    private void logPerformanceMetrics() {
        try {
            OverallPerformanceMetrics overallMetrics = getOverallMetrics();

            log.info("InheritableThreadLocal性能指标 - 总操作数: {}, 继承操作数: {}, 平均延迟: {}ns, InheritableThreadLocal数量: {}", 
                    overallMetrics.getTotalOperations(),
                    overallMetrics.getTotalInheritanceOperations(),
                    overallMetrics.getAverageLatency(),
                    overallMetrics.getInheritableThreadLocalCount());

            // 记录每个InheritableThreadLocal的性能指标
            for (PerformanceMetrics metrics : metricsMap.values()) {
                log.debug("InheritableThreadLocal性能指标 - {}: 设置={}, 获取={}, 移除={}, 继承={}, 平均延迟={}ns", 
                        metrics.getName(),
                        metrics.getSetCount(),
                        metrics.getGetCount(),
                        metrics.getRemoveCount(),
                        metrics.getInheritanceCount(),
                        metrics.getAverageLatency());
            }

        } catch (Exception e) {
            log.error("记录性能指标失败", e);
        }
    }

    /**
     * 清理性能监控器
     */
    @PreDestroy
    public void cleanup() {
        try {
            scheduler.shutdown();
            metricsMap.clear();

            log.info("性能监控器清理完成");

        } catch (Exception e) {
            log.error("性能监控器清理失败", e);
        }
    }
}