/**
 * 企业级ThreadLocal管理器
 * 提供线程安全的ThreadLocal管理和内存泄漏防护
 */
@Component
@Slf4j
public class ThreadLocalManager {

    private final Map<String, ThreadLocal<?>> threadLocalMap = new ConcurrentHashMap<>();
    private final MemoryManager memoryManager;
    private final PerformanceMonitor performanceMonitor;
    private final LeakDetector leakDetector;
    private final ContextManager contextManager;

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

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

                @Override
                public void set(T value) {
                    super.set(value);
                    // 记录设置操作
                    memoryManager.recordSet(name, 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();
                    // 记录移除操作
                    memoryManager.recordRemove(name, value);
                    performanceMonitor.recordOperation(name, "remove");
                }
            };

            // 注册ThreadLocal
            threadLocalMap.put(name, threadLocal);

            // 注册到内存管理器
            memoryManager.registerThreadLocal(name, threadLocal);

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

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

    /**
     * 获取ThreadLocal实例
     */
    @SuppressWarnings("unchecked")
    public <T> ThreadLocal<T> getThreadLocal(String name) {
        ThreadLocal<?> threadLocal = threadLocalMap.get(name);
        if (threadLocal == null) {
            throw new ThreadLocalException("ThreadLocal不存在: " + name);
        }
        return (ThreadLocal<T>) threadLocal;
    }

    /**
     * 设置ThreadLocal值
     */
    public <T> void setValue(String name, T value) {
        try {
            ThreadLocal<T> threadLocal = getThreadLocal(name);
            threadLocal.set(value);

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

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

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

    /**
     * 获取ThreadLocal值
     */
    public <T> T getValue(String name) {
        try {
            ThreadLocal<T> threadLocal = getThreadLocal(name);
            T value = threadLocal.get();

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

            return value;

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

    /**
     * 移除ThreadLocal值
     */
    public <T> void removeValue(String name) {
        try {
            ThreadLocal<T> threadLocal = getThreadLocal(name);
            threadLocal.remove();

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

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

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

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

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

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

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

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

    /**
     * 获取ThreadLocal统计信息
     */
    public ThreadLocalStatistics getStatistics() {
        try {
            Map<String, ThreadLocalInfo> threadLocalInfos = new HashMap<>();

            for (Map.Entry<String, ThreadLocal<?>> entry : threadLocalMap.entrySet()) {
                String name = entry.getKey();
                ThreadLocal<?> threadLocal = entry.getValue();

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

                threadLocalInfos.put(name, info);
            }

            return ThreadLocalStatistics.builder()
                    .totalCount(threadLocalMap.size())
                    .threadLocalInfos(threadLocalInfos)
                    .memoryUsage(memoryManager.getMemoryUsage())
                    .performanceMetrics(performanceMonitor.getMetrics())
                    .leakDetection(leakDetector.getLeakDetection())
                    .build();

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

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

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

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

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

/**
 * 上下文管理器
 * 负责管理各种上下文信息
 */
@Component
@Slf4j
public class ContextManager {

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

    /**
     * 设置用户上下文
     */
    public void setUserContext(UserContext userContext) {
        try {
            String key = "userContext";
            setContext(key, userContext);

            // 设置到ThreadLocal
            setThreadLocalContext(key, userContext);

            log.debug("用户上下文设置成功: {}", userContext.getUserId());

        } catch (Exception e) {
            log.error("用户上下文设置失败", e);
            throw new ContextException("用户上下文设置失败: " + e.getMessage());
        }
    }

    /**
     * 获取用户上下文
     */
    public UserContext getUserContext() {
        try {
            String key = "userContext";
            UserContext userContext = getContext(key, UserContext.class);

            if (userContext == null) {
                // 从ThreadLocal获取
                userContext = getThreadLocalContext(key, UserContext.class);
            }

            return userContext;

        } catch (Exception e) {
            log.error("用户上下文获取失败", e);
            throw new ContextException("用户上下文获取失败: " + e.getMessage());
        }
    }

    /**
     * 设置请求上下文
     */
    public void setRequestContext(RequestContext requestContext) {
        try {
            String key = "requestContext";
            setContext(key, requestContext);

            // 设置到ThreadLocal
            setThreadLocalContext(key, requestContext);

            log.debug("请求上下文设置成功: {}", requestContext.getRequestId());

        } catch (Exception e) {
            log.error("请求上下文设置失败", e);
            throw new ContextException("请求上下文设置失败: " + e.getMessage());
        }
    }

    /**
     * 获取请求上下文
     */
    public RequestContext getRequestContext() {
        try {
            String key = "requestContext";
            RequestContext requestContext = getContext(key, RequestContext.class);

            if (requestContext == null) {
                // 从ThreadLocal获取
                requestContext = getThreadLocalContext(key, RequestContext.class);
            }

            return requestContext;

        } catch (Exception e) {
            log.error("请求上下文获取失败", e);
            throw new ContextException("请求上下文获取失败: " + e.getMessage());
        }
    }

    /**
     * 设置业务上下文
     */
    public void setBusinessContext(String businessKey, Object businessValue) {
        try {
            String key = "businessContext_" + businessKey;
            setContext(key, businessValue);

            // 设置到ThreadLocal
            setThreadLocalContext(key, businessValue);

            log.debug("业务上下文设置成功: {} = {}", businessKey, businessValue);

        } catch (Exception e) {
            log.error("业务上下文设置失败: {}", businessKey, e);
            throw new ContextException("业务上下文设置失败: " + e.getMessage());
        }
    }

    /**
     * 获取业务上下文
     */
    public <T> T getBusinessContext(String businessKey, Class<T> type) {
        try {
            String key = "businessContext_" + businessKey;
            T businessValue = getContext(key, type);

            if (businessValue == null) {
                // 从ThreadLocal获取
                businessValue = getThreadLocalContext(key, type);
            }

            return businessValue;

        } catch (Exception e) {
            log.error("业务上下文获取失败: {}", businessKey, e);
            throw new ContextException("业务上下文获取失败: " + e.getMessage());
        }
    }

    /**
     * 设置安全上下文
     */
    public void setSecurityContext(SecurityContext securityContext) {
        try {
            String key = "securityContext";
            setContext(key, securityContext);

            // 设置到ThreadLocal
            setThreadLocalContext(key, securityContext);

            log.debug("安全上下文设置成功: {}", securityContext.getPrincipal());

        } catch (Exception e) {
            log.error("安全上下文设置失败", e);
            throw new ContextException("安全上下文设置失败: " + e.getMessage());
        }
    }

    /**
     * 获取安全上下文
     */
    public SecurityContext getSecurityContext() {
        try {
            String key = "securityContext";
            SecurityContext securityContext = getContext(key, SecurityContext.class);

            if (securityContext == null) {
                // 从ThreadLocal获取
                securityContext = getThreadLocalContext(key, SecurityContext.class);
            }

            return securityContext;

        } catch (Exception e) {
            log.error("安全上下文获取失败", e);
            throw new ContextException("安全上下文获取失败: " + e.getMessage());
        }
    }

    /**
     * 设置日志上下文
     */
    public void setLogContext(LogContext logContext) {
        try {
            String key = "logContext";
            setContext(key, logContext);

            // 设置到ThreadLocal
            setThreadLocalContext(key, logContext);

            log.debug("日志上下文设置成功: {}", logContext.getTraceId());

        } catch (Exception e) {
            log.error("日志上下文设置失败", e);
            throw new ContextException("日志上下文设置失败: " + e.getMessage());
        }
    }

    /**
     * 获取日志上下文
     */
    public LogContext getLogContext() {
        try {
            String key = "logContext";
            LogContext logContext = getContext(key, LogContext.class);

            if (logContext == null) {
                // 从ThreadLocal获取
                logContext = getThreadLocalContext(key, LogContext.class);
            }

            return logContext;

        } catch (Exception e) {
            log.error("日志上下文获取失败", e);
            throw new ContextException("日志上下文获取失败: " + e.getMessage());
        }
    }

    /**
     * 设置上下文
     */
    private void setContext(String key, Object value) {
        contextMap.put(key, value);
    }

    /**
     * 获取上下文
     */
    private <T> T getContext(String key, Class<T> type) {
        Object value = contextMap.get(key);
        if (value != null && type.isAssignableFrom(value.getClass())) {
            return type.cast(value);
        }
        return null;
    }

    /**
     * 设置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);
    }

    /**
     * 获取ThreadLocal上下文
     */
    private <T> T getThreadLocalContext(String key, Class<T> type) {
        Map<String, Object> threadContext = threadLocalContext.get();
        if (threadContext != null) {
            Object value = threadContext.get(key);
            if (value != null && type.isAssignableFrom(value.getClass())) {
                return type.cast(value);
            }
        }
        return null;
    }

    /**
     * 记录上下文信息
     */
    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 ContextStatistics getContextStatistics() {
        try {
            Map<String, Object> threadContext = threadLocalContext.get();
            int threadLocalContextSize = threadContext != null ? threadContext.size() : 0;

            return ContextStatistics.builder()
                    .totalContextCount(contextMap.size())
                    .threadLocalContextCount(threadLocalContextSize)
                    .contextKeys(new ArrayList<>(contextMap.keySet()))
                    .build();

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

/**
 * 内存管理器
 * 负责ThreadLocal的内存管理和泄漏检测
 */
@Component
@Slf4j
public class MemoryManager {

    private final Map<String, ThreadLocal<?>> registeredThreadLocals = new ConcurrentHashMap<>();
    private final Map<String, Object> valueHistory = new ConcurrentHashMap<>();
    private final AtomicLong totalSetCount = new AtomicLong(0);
    private final AtomicLong totalGetCount = new AtomicLong(0);
    private final AtomicLong totalRemoveCount = new AtomicLong(0);

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

    /**
     * 注册ThreadLocal
     */
    public void registerThreadLocal(String name, ThreadLocal<?> threadLocal) {
        try {
            registeredThreadLocals.put(name, threadLocal);

            // 启动内存监控
            startMemoryMonitoring(name);

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

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

    /**
     * 记录设置操作
     */
    public void recordSet(String name, Object value) {
        try {
            totalSetCount.incrementAndGet();
            valueHistory.put(name + "_lastSet", value);
            valueHistory.put(name + "_setTime", System.currentTimeMillis());

            // 检查内存使用情况
            checkMemoryUsage(name, value);

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

    /**
     * 记录获取操作
     */
    public void recordGet(String name) {
        try {
            totalGetCount.incrementAndGet();
            valueHistory.put(name + "_getTime", System.currentTimeMillis());

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

    /**
     * 记录移除操作
     */
    public void recordRemove(String name, Object value) {
        try {
            totalRemoveCount.incrementAndGet();
            valueHistory.put(name + "_lastRemove", value);
            valueHistory.put(name + "_removeTime", System.currentTimeMillis());

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

    /**
     * 启动内存监控
     */
    private void startMemoryMonitoring(String name) {
        scheduler.scheduleAtFixedRate(() -> {
            try {
                monitorThreadLocalMemory(name);
            } catch (Exception e) {
                log.error("ThreadLocal内存监控失败: {}", name, e);
            }
        }, 0, 30, TimeUnit.SECONDS);
    }

    /**
     * 监控ThreadLocal内存
     */
    private void monitorThreadLocalMemory(String name) {
        try {
            ThreadLocal<?> threadLocal = registeredThreadLocals.get(name);
            if (threadLocal == null) {
                return;
            }

            // 检查内存使用情况
            long memoryUsage = getThreadLocalMemoryUsage(name);

            // 检查是否超过阈值
            if (memoryUsage > getMemoryThreshold()) {
                log.warn("ThreadLocal内存使用超过阈值: {} = {}", name, memoryUsage);

                // 触发垃圾回收
                triggerGarbageCollection(name);
            }

            // 检查泄漏
            checkMemoryLeak(name);

        } catch (Exception e) {
            log.error("ThreadLocal内存监控失败: {}", name, e);
        }
    }

    /**
     * 检查内存使用情况
     */
    private void checkMemoryUsage(String name, Object value) {
        try {
            if (value == null) {
                return;
            }

            // 估算对象大小
            long objectSize = estimateObjectSize(value);

            // 检查是否超过单个对象阈值
            if (objectSize > getSingleObjectThreshold()) {
                log.warn("ThreadLocal对象大小超过阈值: {} = {}", name, objectSize);
            }

        } catch (Exception e) {
            log.error("检查内存使用情况失败: {}", name, e);
        }
    }

    /**
     * 检查内存泄漏
     */
    private void checkMemoryLeak(String name) {
        try {
            ThreadLocal<?> threadLocal = registeredThreadLocals.get(name);
            if (threadLocal == null) {
                return;
            }

            // 检查ThreadLocal是否还有值
            Object value = threadLocal.get();
            if (value != null) {
                // 检查值是否长时间未更新
                Long lastSetTime = (Long) valueHistory.get(name + "_setTime");
                if (lastSetTime != null) {
                    long timeSinceLastSet = System.currentTimeMillis() - lastSetTime;
                    if (timeSinceLastSet > getLeakDetectionThreshold()) {
                        log.warn("检测到ThreadLocal可能泄漏: {} = {}", name, timeSinceLastSet);

                        // 触发清理
                        triggerCleanup(name);
                    }
                }
            }

        } catch (Exception e) {
            log.error("检查内存泄漏失败: {}", name, e);
        }
    }

    /**
     * 触发垃圾回收
     */
    private void triggerGarbageCollection(String name) {
        try {
            // 建议JVM进行垃圾回收
            System.gc();

            log.info("触发垃圾回收: {}", name);

        } catch (Exception e) {
            log.error("触发垃圾回收失败: {}", name, e);
        }
    }

    /**
     * 触发清理
     */
    private void triggerCleanup(String name) {
        try {
            ThreadLocal<?> threadLocal = registeredThreadLocals.get(name);
            if (threadLocal != null) {
                threadLocal.remove();
                log.info("触发ThreadLocal清理: {}", name);
            }

        } catch (Exception e) {
            log.error("触发清理失败: {}", name, e);
        }
    }

    /**
     * 获取ThreadLocal内存使用情况
     */
    private long getThreadLocalMemoryUsage(String name) {
        try {
            // 这里可以使用JVM内存分析工具
            // 简化实现，返回估算值
            return memoryAnalyzer.analyzeMemoryUsage(name);

        } catch (Exception e) {
            log.error("获取ThreadLocal内存使用情况失败: {}", name, e);
            return 0;
        }
    }

    /**
     * 估算对象大小
     */
    private long estimateObjectSize(Object value) {
        try {
            // 简化实现，返回估算值
            if (value instanceof String) {
                return ((String) value).length() * 2; // 每个字符2字节
            } else if (value instanceof Collection) {
                return ((Collection<?>) value).size() * 16; // 每个元素16字节
            } else if (value instanceof Map) {
                return ((Map<?, ?>) value).size() * 32; // 每个键值对32字节
            } else {
                return 64; // 默认64字节
            }

        } catch (Exception e) {
            log.error("估算对象大小失败", e);
            return 0;
        }
    }

    /**
     * 获取内存阈值
     */
    private long getMemoryThreshold() {
        // 默认1MB
        return 1024 * 1024;
    }

    /**
     * 获取单个对象阈值
     */
    private long getSingleObjectThreshold() {
        // 默认100KB
        return 100 * 1024;
    }

    /**
     * 获取泄漏检测阈值
     */
    private long getLeakDetectionThreshold() {
        // 默认5分钟
        return 5 * 60 * 1000;
    }

    /**
     * 获取内存使用情况
     */
    public MemoryUsage getMemoryUsage() {
        try {
            return MemoryUsage.builder()
                    .totalSetCount(totalSetCount.get())
                    .totalGetCount(totalGetCount.get())
                    .totalRemoveCount(totalRemoveCount.get())
                    .registeredThreadLocalCount(registeredThreadLocals.size())
                    .valueHistorySize(valueHistory.size())
                    .build();

        } catch (Exception e) {
            log.error("获取内存使用情况失败", e);
            throw new MemoryException("获取内存使用情况失败: " + e.getMessage());
        }
    }

    /**
     * 清理内存管理器
     */
    @PreDestroy
    public void cleanup() {
        try {
            scheduler.shutdown();
            registeredThreadLocals.clear();
            valueHistory.clear();

            log.info("内存管理器清理完成");

        } catch (Exception e) {
            log.error("内存管理器清理失败", e);
        }
    }
}

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

    private final Map<String, PerformanceMetrics> metricsMap = new ConcurrentHashMap<>();
    private final AtomicLong totalOperations = 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)
                        .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);
        }
    }

    /**
     * 更新指标
     */
    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();
    }

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

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

            return OverallPerformanceMetrics.builder()
                    .totalOperations(totalOps)
                    .totalLatency(totalLat)
                    .averageLatency(averageLatency)
                    .threadLocalCount(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("ThreadLocal性能指标 - 总操作数: {}, 平均延迟: {}ns, ThreadLocal数量: {}", 
                    overallMetrics.getTotalOperations(),
                    overallMetrics.getAverageLatency(),
                    overallMetrics.getThreadLocalCount());

            // 记录每个ThreadLocal的性能指标
            for (PerformanceMetrics metrics : metricsMap.values()) {
                log.debug("ThreadLocal性能指标 - {}: 设置={}, 获取={}, 移除={}, 平均延迟={}ns", 
                        metrics.getName(),
                        metrics.getSetCount(),
                        metrics.getGetCount(),
                        metrics.getRemoveCount(),
                        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);
        }
    }
}

/**
 * 泄漏检测器
 * 负责检测ThreadLocal内存泄漏
 */
@Component
@Slf4j
public class LeakDetector {

    private final Map<String, LeakDetectionInfo> leakDetectionMap = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    private final AtomicLong totalLeakCount = new AtomicLong(0);
    private final AtomicLong totalDetectionCount = new AtomicLong(0);

    /**
     * 检测ThreadLocal泄漏
     */
    public LeakDetectionResult detectLeak(String name, ThreadLocal<?> threadLocal) {
        try {
            totalDetectionCount.incrementAndGet();

            LeakDetectionInfo info = leakDetectionMap.computeIfAbsent(name, k -> 
                LeakDetectionInfo.builder()
                        .name(k)
                        .threadLocal(threadLocal)
                        .firstDetectionTime(System.currentTimeMillis())
                        .lastDetectionTime(System.currentTimeMillis())
                        .detectionCount(0)
                        .leakCount(0)
                        .build()
            );

            // 更新检测信息
            info.setLastDetectionTime(System.currentTimeMillis());
            info.setDetectionCount(info.getDetectionCount() + 1);

            // 检测泄漏
            boolean isLeaked = performLeakDetection(info);

            if (isLeaked) {
                info.setLeakCount(info.getLeakCount() + 1);
                totalLeakCount.incrementAndGet();

                log.warn("检测到ThreadLocal泄漏: {}", name);
            }

            return LeakDetectionResult.builder()
                    .name(name)
                    .isLeaked(isLeaked)
                    .leakCount(info.getLeakCount())
                    .detectionCount(info.getDetectionCount())
                    .lastDetectionTime(info.getLastDetectionTime())
                    .build();

        } catch (Exception e) {
            log.error("检测ThreadLocal泄漏失败: {}", name, e);
            throw new LeakDetectionException("检测ThreadLocal泄漏失败: " + e.getMessage());
        }
    }

    /**
     * 执行泄漏检测
     */
    private boolean performLeakDetection(LeakDetectionInfo info) {
        try {
            ThreadLocal<?> threadLocal = info.getThreadLocal();

            // 检查ThreadLocal是否有值
            Object value = threadLocal.get();
            if (value == null) {
                return false; // 没有值，不是泄漏
            }

            // 检查值是否长时间未更新
            long timeSinceLastDetection = System.currentTimeMillis() - info.getLastDetectionTime();
            if (timeSinceLastDetection > getLeakThreshold()) {
                return true; // 长时间未更新，可能是泄漏
            }

            // 检查值的大小
            long valueSize = estimateValueSize(value);
            if (valueSize > getSizeThreshold()) {
                return true; // 值过大，可能是泄漏
            }

            // 检查值的类型
            if (isLeakProneType(value)) {
                return true; // 容易泄漏的类型
            }

            return false;

        } catch (Exception e) {
            log.error("执行泄漏检测失败: {}", info.getName(), e);
            return false;
        }
    }

    /**
     * 估算值的大小
     */
    private long estimateValueSize(Object value) {
        try {
            if (value instanceof String) {
                return ((String) value).length() * 2;
            } else if (value instanceof Collection) {
                return ((Collection<?>) value).size() * 16;
            } else if (value instanceof Map) {
                return ((Map<?, ?>) value).size() * 32;
            } else if (value instanceof byte[]) {
                return ((byte[]) value).length;
            } else {
                return 64; // 默认大小
            }

        } catch (Exception e) {
            log.error("估算值大小失败", e);
            return 0;
        }
    }

    /**
     * 检查是否是容易泄漏的类型
     */
    private boolean isLeakProneType(Object value) {
        try {
            // 检查是否是容易泄漏的类型
            if (value instanceof Collection) {
                Collection<?> collection = (Collection<?>) value;
                return collection.size() > 1000; // 集合过大
            } else if (value instanceof Map) {
                Map<?, ?> map = (Map<?, ?>) value;
                return map.size() > 1000; // Map过大
            } else if (value instanceof byte[]) {
                byte[] bytes = (byte[]) value;
                return bytes.length > 1024 * 1024; // 字节数组过大
            }

            return false;

        } catch (Exception e) {
            log.error("检查泄漏类型失败", e);
            return false;
        }
    }

    /**
     * 获取泄漏阈值
     */
    private long getLeakThreshold() {
        // 默认10分钟
        return 10 * 60 * 1000;
    }

    /**
     * 获取大小阈值
     */
    private long getSizeThreshold() {
        // 默认1MB
        return 1024 * 1024;
    }

    /**
     * 获取泄漏检测信息
     */
    public LeakDetectionInfo getLeakDetectionInfo(String name) {
        return leakDetectionMap.get(name);
    }

    /**
     * 获取所有泄漏检测信息
     */
    public Map<String, LeakDetectionInfo> getAllLeakDetectionInfo() {
        return new HashMap<>(leakDetectionMap);
    }

    /**
     * 获取泄漏检测统计
     */
    public LeakDetectionStatistics getLeakDetectionStatistics() {
        try {
            long totalLeaks = totalLeakCount.get();
            long totalDetections = totalDetectionCount.get();
            double leakRate = totalDetections > 0 ? (double) totalLeaks / totalDetections : 0;

            return LeakDetectionStatistics.builder()
                    .totalLeakCount(totalLeaks)
                    .totalDetectionCount(totalDetections)
                    .leakRate(leakRate)
                    .detectionInfoCount(leakDetectionMap.size())
                    .build();

        } catch (Exception e) {
            log.error("获取泄漏检测统计失败", e);
            throw new LeakDetectionException("获取泄漏检测统计失败: " + e.getMessage());
        }
    }

    /**
     * 启动泄漏检测
     */
    @PostConstruct
    public void startLeakDetection() {
        scheduler.scheduleAtFixedRate(() -> {
            try {
                performPeriodicLeakDetection();
            } catch (Exception e) {
                log.error("定期泄漏检测失败", e);
            }
        }, 0, 5, TimeUnit.MINUTES);
    }

    /**
     * 执行定期泄漏检测
     */
    private void performPeriodicLeakDetection() {
        try {
            for (LeakDetectionInfo info : leakDetectionMap.values()) {
                LeakDetectionResult result = detectLeak(info.getName(), info.getThreadLocal());

                if (result.isLeaked()) {
                    log.warn("定期检测发现ThreadLocal泄漏: {} - 泄漏次数: {}", 
                            result.getName(), result.getLeakCount());
                }
            }

        } catch (Exception e) {
            log.error("执行定期泄漏检测失败", e);
        }
    }

    /**
     * 清理泄漏检测器
     */
    @PreDestroy
    public void cleanup() {
        try {
            scheduler.shutdown();
            leakDetectionMap.clear();

            log.info("泄漏检测器清理完成");

        } catch (Exception e) {
            log.error("泄漏检测器清理失败", e);
        }
    }
}

/**
 * ThreadLocal配置
 */
@Configuration
@EnableConfigurationProperties(ThreadLocalProperties.class)
@Slf4j
public class ThreadLocalConfiguration {

    private final ThreadLocalProperties properties;

    /**
     * ThreadLocal管理器
     */
    @Bean
    @ConditionalOnMissingBean
    public ThreadLocalManager threadLocalManager(
            MemoryManager memoryManager,
            PerformanceMonitor performanceMonitor,
            LeakDetector leakDetector,
            ContextManager contextManager) {

        return new ThreadLocalManager(
                memoryManager,
                performanceMonitor,
                leakDetector,
                contextManager
        );
    }

    /**
     * 上下文管理器
     */
    @Bean
    @ConditionalOnMissingBean
    public ContextManager contextManager() {
        return new ContextManager();
    }

    /**
     * 内存管理器
     */
    @Bean
    @ConditionalOnMissingBean
    public MemoryManager memoryManager() {
        return new MemoryManager();
    }

    /**
     * 性能监控器
     */
    @Bean
    @ConditionalOnMissingBean
    public PerformanceMonitor performanceMonitor() {
        return new PerformanceMonitor();
    }

    /**
     * 泄漏检测器
     */
    @Bean
    @ConditionalOnMissingBean
    public LeakDetector leakDetector() {
        return new LeakDetector();
    }

    /**
     * 内存分析器
     */
    @Bean
    @ConditionalOnMissingBean
    public MemoryAnalyzer memoryAnalyzer() {
        return new MemoryAnalyzer();
    }

    /**
     * ThreadLocal管理端点
     */
    @Bean
    @ConditionalOnProperty(name = "thread-local.management.endpoints.enabled", havingValue = "true", matchIfMissing = true)
    public ThreadLocalManagementEndpoint threadLocalManagementEndpoint(
            ThreadLocalManager threadLocalManager) {

        return new ThreadLocalManagementEndpoint(threadLocalManager);
    }
}

/**
 * ThreadLocal属性配置
 */
@ConfigurationProperties(prefix = "thread-local")
@Data
@Slf4j
public class ThreadLocalProperties {

    /**
     * 是否启用ThreadLocal管理
     */
    private boolean enabled = true;

    /**
     * 是否启用内存管理
     */
    private boolean enableMemoryManagement = true;

    /**
     * 是否启用性能监控
     */
    private boolean enablePerformanceMonitoring = true;

    /**
     * 是否启用泄漏检测
     */
    private boolean enableLeakDetection = true;

    /**
     * 是否启用上下文管理
     */
    private boolean enableContextManagement = true;

    /**
     * 内存管理配置
     */
    private MemoryManagementConfig memoryManagement = new MemoryManagementConfig();

    /**
     * 性能监控配置
     */
    private PerformanceMonitoringConfig performanceMonitoring = new PerformanceMonitoringConfig();

    /**
     * 泄漏检测配置
     */
    private LeakDetectionConfig leakDetection = new LeakDetectionConfig();

    /**
     * 上下文管理配置
     */
    private ContextManagementConfig contextManagement = new ContextManagementConfig();

    /**
     * 内存管理配置
     */
    @Data
    public static class MemoryManagementConfig {
        /**
         * 内存阈值（字节）
         */
        private long memoryThreshold = 1024 * 1024; // 1MB

        /**
         * 单个对象阈值（字节）
         */
        private long singleObjectThreshold = 100 * 1024; // 100KB

        /**
         * 泄漏检测阈值（毫秒）
         */
        private long leakDetectionThreshold = 5 * 60 * 1000; // 5分钟

        /**
         * 监控间隔（秒）
         */
        private int monitoringInterval = 30;

        /**
         * 是否启用自动清理
         */
        private boolean enableAutoCleanup = true;

        /**
         * 清理间隔（分钟）
         */
        private int cleanupInterval = 10;
    }

    /**
     * 性能监控配置
     */
    @Data
    public static class PerformanceMonitoringConfig {
        /**
         * 是否启用性能监控
         */
        private boolean enabled = true;

        /**
         * 监控间隔（秒）
         */
        private int monitoringInterval = 60;

        /**
         * 是否启用延迟监控
         */
        private boolean enableLatencyMonitoring = true;

        /**
         * 是否启用吞吐量监控
         */
        private boolean enableThroughputMonitoring = true;

        /**
         * 延迟阈值（纳秒）
         */
        private long latencyThreshold = 1000000; // 1ms
    }

    /**
     * 泄漏检测配置
     */
    @Data
    public static class LeakDetectionConfig {
        /**
         * 是否启用泄漏检测
         */
        private boolean enabled = true;

        /**
         * 检测间隔（分钟）
         */
        private int detectionInterval = 5;

        /**
         * 泄漏阈值（毫秒）
         */
        private long leakThreshold = 10 * 60 * 1000; // 10分钟

        /**
         * 大小阈值（字节）
         */
        private long sizeThreshold = 1024 * 1024; // 1MB

        /**
         * 是否启用自动清理
         */
        private boolean enableAutoCleanup = true;
    }

    /**
     * 上下文管理配置
     */
    @Data
    public static class ContextManagementConfig {
        /**
         * 是否启用上下文管理
         */
        private boolean enabled = true;

        /**
         * 是否启用用户上下文
         */
        private boolean enableUserContext = true;

        /**
         * 是否启用请求上下文
         */
        private boolean enableRequestContext = true;

        /**
         * 是否启用业务上下文
         */
        private boolean enableBusinessContext = true;

        /**
         * 是否启用安全上下文
         */
        private boolean enableSecurityContext = true;

        /**
         * 是否启用日志上下文
         */
        private boolean enableLogContext = true;

        /**
         * 上下文超时时间（分钟）
         */
        private int contextTimeout = 30;
    }
}