// Tomcat连接器配置管理器
@Component
public class TomcatConnectorConfigManager {
    
    private final Map<String, ConnectorConfig> connectorConfigs = new HashMap<>();
    
    /**
     * 创建HTTP连接器配置
     */
    public ConnectorConfig createHttpConnectorConfig() {
        ConnectorConfig config = new ConnectorConfig();
        
        // 基本配置
        config.setPort(8080);
        config.setProtocol("HTTP/1.1");
        config.setConnectionTimeout(20000);
        config.setRedirectPort(8443);
        
        // 线程池配置
        config.setMaxThreads(200);
        config.setMinSpareThreads(10);
        config.setMaxSpareThreads(50);
        config.setAcceptCount(100);
        
        // 连接配置
        config.setMaxConnections(8192);
        config.setMaxKeepAliveRequests(100);
        config.setKeepAliveTimeout(15000);
        
        // 性能优化配置
        config.setCompression("on");
        config.setCompressionMinSize(2048);
        config.setCompressableMimeType("text/html,text/xml,text/plain,text/css,text/javascript");
        
        return config;
    }
    
    /**
     * 创建AJP连接器配置
     */
    public ConnectorConfig createAjpConnectorConfig() {
        ConnectorConfig config = new ConnectorConfig();
        
        // 基本配置
        config.setPort(8009);
        config.setProtocol("AJP/1.3");
        config.setConnectionTimeout(20000);
        
        // 线程池配置
        config.setMaxThreads(200);
        config.setMinSpareThreads(10);
        config.setMaxSpareThreads(50);
        config.setAcceptCount(100);
        
        // AJP特定配置
        config.setMaxConnections(8192);
        config.setPacketSize(8192);
        config.setMaxPacketSize(65536);
        
        return config;
    }
    
    /**
     * 创建NIO连接器配置
     */
    public ConnectorConfig createNioConnectorConfig() {
        ConnectorConfig config = new ConnectorConfig();
        
        // 基本配置
        config.setPort(8080);
        config.setProtocol("org.apache.coyote.http11.Http11NioProtocol");
        config.setConnectionTimeout(20000);
        
        // 线程池配置
        config.setMaxThreads(200);
        config.setMinSpareThreads(10);
        config.setMaxSpareThreads(50);
        config.setAcceptCount(100);
        
        // NIO特定配置
        config.setMaxConnections(8192);
        config.setPollerThreadCount(2);
        config.setPollerThreadPriority(5);
        config.setSelectorTimeout(1000);
        
        return config;
    }
    
    /**
     * 根据系统资源计算最优配置
     */
    public ConnectorConfig calculateOptimalConfig(SystemResources resources) {
        ConnectorConfig config = new ConnectorConfig();
        
        // 根据CPU核心数计算最大线程数
        int maxThreads = calculateMaxThreads(resources.getCpuCores());
        config.setMaxThreads(maxThreads);
        
        // 根据内存大小计算最小空闲线程数
        int minSpareThreads = calculateMinSpareThreads(resources.getMemoryGB());
        config.setMinSpareThreads(minSpareThreads);
        
        // 根据系统负载计算接受队列大小
        int acceptCount = calculateAcceptCount(resources.getLoadAverage());
        config.setAcceptCount(acceptCount);
        
        // 根据网络带宽计算最大连接数
        int maxConnections = calculateMaxConnections(resources.getNetworkBandwidth());
        config.setMaxConnections(maxConnections);
        
        return config;
    }
    
    /**
     * 计算最大线程数
     */
    private int calculateMaxThreads(int cpuCores) {
        // 经验公式：CPU核心数 * 2 + 1
        int baseThreads = cpuCores * 2 + 1;
        
        // 根据应用类型调整
        if (isIOIntensive()) {
            return baseThreads * 2; // IO密集型应用
        } else if (isCPUIntensive()) {
            return baseThreads; // CPU密集型应用
        } else {
            return (int) (baseThreads * 1.5); // 混合型应用
        }
    }
    
    /**
     * 计算最小空闲线程数
     */
    private int calculateMinSpareThreads(int memoryGB) {
        // 根据内存大小计算，每GB内存约10个线程
        int baseThreads = memoryGB * 10;
        
        // 确保最小值为5，最大值为50
        return Math.max(5, Math.min(50, baseThreads));
    }
    
    /**
     * 计算接受队列大小
     */
    private int calculateAcceptCount(double loadAverage) {
        if (loadAverage < 1.0) {
            return 100; // 低负载
        } else if (loadAverage < 2.0) {
            return 200; // 中等负载
        } else {
            return 500; // 高负载
        }
    }
    
    /**
     * 计算最大连接数
     */
    private int calculateMaxConnections(int bandwidthMbps) {
        // 根据网络带宽计算，每Mbps约100个连接
        int baseConnections = bandwidthMbps * 100;
        
        // 确保最小值为1000，最大值为10000
        return Math.max(1000, Math.min(10000, baseConnections));
    }
    
    /**
     * 检查是否为IO密集型应用
     */
    private boolean isIOIntensive() {
        // 根据应用特征判断
        return true; // 默认按IO密集型处理
    }
    
    /**
     * 检查是否为CPU密集型应用
     */
    private boolean isCPUIntensive() {
        // 根据应用特征判断
        return false;
    }
}

// 连接器配置类
public class ConnectorConfig {
    private int port;
    private String protocol;
    private int connectionTimeout;
    private int redirectPort;
    private int maxThreads;
    private int minSpareThreads;
    private int maxSpareThreads;
    private int acceptCount;
    private int maxConnections;
    private int maxKeepAliveRequests;
    private int keepAliveTimeout;
    private String compression;
    private int compressionMinSize;
    private String compressableMimeType;
    private int pollerThreadCount;
    private int pollerThreadPriority;
    private int selectorTimeout;
    private int packetSize;
    private int maxPacketSize;
    
    // 构造函数和getter/setter方法
}

// 系统资源类
public class SystemResources {
    private int cpuCores;
    private int memoryGB;
    private double loadAverage;
    private int networkBandwidth;
    
    // 构造函数和getter/setter方法
}

// Tomcat连接器性能优化器
@Component
public class TomcatConnectorOptimizer {
    
    @Autowired
    private TomcatConnectorConfigManager configManager;
    
    @Autowired
    private SystemMonitor systemMonitor;
    
    /**
     * 优化连接器配置
     */
    public OptimizationResult optimizeConnector(String connectorName) {
        try {
            // 获取当前系统资源
            SystemResources resources = getCurrentSystemResources();
            
            // 计算最优配置
            ConnectorConfig optimalConfig = configManager.calculateOptimalConfig(resources);
            
            // 应用配置
            applyConnectorConfig(connectorName, optimalConfig);
            
            // 验证配置效果
            boolean isValid = validateConnectorConfig(connectorName);
            
            if (isValid) {
                return new OptimizationResult(true, "连接器配置优化成功");
            } else {
                return new OptimizationResult(false, "连接器配置验证失败");
            }
            
        } catch (Exception e) {
            logger.error("连接器优化失败: {}", e.getMessage());
            return new OptimizationResult(false, "连接器优化失败: " + e.getMessage());
        }
    }
    
    /**
     * 获取当前系统资源
     */
    private SystemResources getCurrentSystemResources() {
        SystemResources resources = new SystemResources();
        
        // 获取CPU核心数
        resources.setCpuCores(Runtime.getRuntime().availableProcessors());
        
        // 获取内存大小
        long totalMemory = Runtime.getRuntime().totalMemory();
        resources.setMemoryGB((int) (totalMemory / (1024 * 1024 * 1024)));
        
        // 获取系统负载
        double loadAverage = systemMonitor.getLoadAverage();
        resources.setLoadAverage(loadAverage);
        
        // 获取网络带宽（估算）
        int networkBandwidth = estimateNetworkBandwidth();
        resources.setNetworkBandwidth(networkBandwidth);
        
        return resources;
    }
    
    /**
     * 应用连接器配置
     */
    private void applyConnectorConfig(String connectorName, ConnectorConfig config) {
        // 这里需要根据具体的Tomcat版本和部署方式来实现
        // 可能涉及修改server.xml或通过JMX动态配置
        
        logger.info("应用连接器配置: {}", connectorName);
        logger.info("最大线程数: {}", config.getMaxThreads());
        logger.info("最小空闲线程数: {}", config.getMinSpareThreads());
        logger.info("接受队列大小: {}", config.getAcceptCount());
        logger.info("最大连接数: {}", config.getMaxConnections());
    }
    
    /**
     * 验证连接器配置
     */
    private boolean validateConnectorConfig(String connectorName) {
        // 检查配置是否生效
        // 可以通过JMX或监控接口验证
        
        try {
            // 模拟配置验证
            Thread.sleep(1000);
            return true;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }
    
    /**
     * 估算网络带宽
     */
    private int estimateNetworkBandwidth() {
        // 根据系统配置估算网络带宽
        // 这里使用默认值，实际应用中可以通过网络测试获取
        return 100; // 100Mbps
    }
}

// 优化结果类
public class OptimizationResult {
    private boolean success;
    private String message;
    
    // 构造函数和getter/setter方法
}

// Tomcat线程池配置优化器
@Component
public class TomcatThreadPoolOptimizer {
    
    @Autowired
    private ThreadPoolMonitor threadPoolMonitor;
    
    @Autowired
    private PerformanceAnalyzer performanceAnalyzer;
    
    /**
     * 优化线程池配置
     */
    public ThreadPoolOptimizationResult optimizeThreadPool() {
        try {
            // 分析当前线程池性能
            ThreadPoolPerformanceAnalysis analysis = analyzeThreadPoolPerformance();
            
            // 识别性能瓶颈
            List<ThreadPoolBottleneck> bottlenecks = identifyBottlenecks(analysis);
            
            // 生成优化建议
            List<OptimizationSuggestion> suggestions = generateOptimizationSuggestions(bottlenecks);
            
            // 应用优化配置
            OptimizationResult result = applyOptimizations(suggestions);
            
            return new ThreadPoolOptimizationResult(result.isSuccess(), result.getMessage(), suggestions);
            
        } catch (Exception e) {
            logger.error("线程池优化失败: {}", e.getMessage());
            return new ThreadPoolOptimizationResult(false, "线程池优化失败: " + e.getMessage(), null);
        }
    }
    
    /**
     * 分析线程池性能
     */
    private ThreadPoolPerformanceAnalysis analyzeThreadPoolPerformance() {
        ThreadPoolPerformanceAnalysis analysis = new ThreadPoolPerformanceAnalysis();
        
        // 获取线程池指标
        ThreadPoolMetrics metrics = threadPoolMonitor.getCurrentMetrics();
        analysis.setMetrics(metrics);
        
        // 分析线程使用率
        double threadUtilization = calculateThreadUtilization(metrics);
        analysis.setThreadUtilization(threadUtilization);
        
        // 分析请求处理时间
        long averageResponseTime = calculateAverageResponseTime(metrics);
        analysis.setAverageResponseTime(averageResponseTime);
        
        // 分析队列使用情况
        double queueUtilization = calculateQueueUtilization(metrics);
        analysis.setQueueUtilization(queueUtilization);
        
        // 分析错误率
        double errorRate = calculateErrorRate(metrics);
        analysis.setErrorRate(errorRate);
        
        return analysis;
    }
    
    /**
     * 计算线程使用率
     */
    private double calculateThreadUtilization(ThreadPoolMetrics metrics) {
        int activeThreads = metrics.getActiveThreads();
        int maxThreads = metrics.getMaxThreads();
        
        if (maxThreads == 0) {
            return 0.0;
        }
        
        return (double) activeThreads / maxThreads;
    }
    
    /**
     * 计算平均响应时间
     */
    private long calculateAverageResponseTime(ThreadPoolMetrics metrics) {
        // 这里需要根据实际的监控数据计算
        // 可以通过JMX或自定义监控获取
        return metrics.getAverageResponseTime();
    }
    
    /**
     * 计算队列使用率
     */
    private double calculateQueueUtilization(ThreadPoolMetrics metrics) {
        int queueSize = metrics.getQueueSize();
        int maxQueueSize = metrics.getMaxQueueSize();
        
        if (maxQueueSize == 0) {
            return 0.0;
        }
        
        return (double) queueSize / maxQueueSize;
    }
    
    /**
     * 计算错误率
     */
    private double calculateErrorRate(ThreadPoolMetrics metrics) {
        long totalRequests = metrics.getTotalRequests();
        long errorRequests = metrics.getErrorRequests();
        
        if (totalRequests == 0) {
            return 0.0;
        }
        
        return (double) errorRequests / totalRequests;
    }
    
    /**
     * 识别性能瓶颈
     */
    private List<ThreadPoolBottleneck> identifyBottlenecks(ThreadPoolPerformanceAnalysis analysis) {
        List<ThreadPoolBottleneck> bottlenecks = new ArrayList<>();
        
        // 线程使用率过高
        if (analysis.getThreadUtilization() > 0.8) {
            bottlenecks.add(new ThreadPoolBottleneck(
                BottleneckType.HIGH_THREAD_UTILIZATION,
                "线程使用率过高: " + analysis.getThreadUtilization(),
                analysis.getThreadUtilization()));
        }
        
        // 响应时间过长
        if (analysis.getAverageResponseTime() > 5000) {
            bottlenecks.add(new ThreadPoolBottleneck(
                BottleneckType.LONG_RESPONSE_TIME,
                "响应时间过长: " + analysis.getAverageResponseTime() + "ms",
                analysis.getAverageResponseTime()));
        }
        
        // 队列使用率过高
        if (analysis.getQueueUtilization() > 0.8) {
            bottlenecks.add(new ThreadPoolBottleneck(
                BottleneckType.HIGH_QUEUE_UTILIZATION,
                "队列使用率过高: " + analysis.getQueueUtilization(),
                analysis.getQueueUtilization()));
        }
        
        // 错误率过高
        if (analysis.getErrorRate() > 0.05) {
            bottlenecks.add(new ThreadPoolBottleneck(
                BottleneckType.HIGH_ERROR_RATE,
                "错误率过高: " + analysis.getErrorRate(),
                analysis.getErrorRate()));
        }
        
        return bottlenecks;
    }
    
    /**
     * 生成优化建议
     */
    private List<OptimizationSuggestion> generateOptimizationSuggestions(List<ThreadPoolBottleneck> bottlenecks) {
        List<OptimizationSuggestion> suggestions = new ArrayList<>();
        
        for (ThreadPoolBottleneck bottleneck : bottlenecks) {
            switch (bottleneck.getType()) {
                case HIGH_THREAD_UTILIZATION:
                    suggestions.add(createThreadIncreaseSuggestion(bottleneck));
                    break;
                case LONG_RESPONSE_TIME:
                    suggestions.add(createResponseTimeOptimizationSuggestion(bottleneck));
                    break;
                case HIGH_QUEUE_UTILIZATION:
                    suggestions.add(createQueueOptimizationSuggestion(bottleneck));
                    break;
                case HIGH_ERROR_RATE:
                    suggestions.add(createErrorRateOptimizationSuggestion(bottleneck));
                    break;
            }
        }
        
        return suggestions;
    }
    
    /**
     * 创建线程增加建议
     */
    private OptimizationSuggestion createThreadIncreaseSuggestion(ThreadPoolBottleneck bottleneck) {
        OptimizationSuggestion suggestion = new OptimizationSuggestion();
        suggestion.setType(OptimizationType.INCREASE_THREADS);
        suggestion.setTitle("增加最大线程数");
        suggestion.setDescription("当前线程使用率过高，建议增加最大线程数");
        suggestion.setPriority(OptimizationPriority.HIGH);
        
        // 计算建议的线程数
        int currentMaxThreads = getCurrentMaxThreads();
        int suggestedMaxThreads = (int) (currentMaxThreads * 1.5);
        suggestion.addParameter("maxThreads", String.valueOf(suggestedMaxThreads));
        
        return suggestion;
    }
    
    /**
     * 创建响应时间优化建议
     */
    private OptimizationSuggestion createResponseTimeOptimizationSuggestion(ThreadPoolBottleneck bottleneck) {
        OptimizationSuggestion suggestion = new OptimizationSuggestion();
        suggestion.setType(OptimizationType.OPTIMIZE_RESPONSE_TIME);
        suggestion.setTitle("优化响应时间");
        suggestion.setDescription("当前响应时间过长，建议优化业务逻辑或增加线程数");
        suggestion.setPriority(OptimizationPriority.HIGH);
        
        suggestion.addParameter("maxThreads", String.valueOf(getCurrentMaxThreads() * 2));
        suggestion.addParameter("minSpareThreads", String.valueOf(getCurrentMinSpareThreads() * 2));
        
        return suggestion;
    }
    
    /**
     * 创建队列优化建议
     */
    private OptimizationSuggestion createQueueOptimizationSuggestion(ThreadPoolBottleneck bottleneck) {
        OptimizationSuggestion suggestion = new OptimizationSuggestion();
        suggestion.setType(OptimizationType.OPTIMIZE_QUEUE);
        suggestion.setTitle("优化队列配置");
        suggestion.setDescription("当前队列使用率过高，建议增加队列大小或优化处理逻辑");
        suggestion.setPriority(OptimizationPriority.MEDIUM);
        
        suggestion.addParameter("acceptCount", String.valueOf(getCurrentAcceptCount() * 2));
        suggestion.addParameter("maxConnections", String.valueOf(getCurrentMaxConnections() * 2));
        
        return suggestion;
    }
    
    /**
     * 创建错误率优化建议
     */
    private OptimizationSuggestion createErrorRateOptimizationSuggestion(ThreadPoolBottleneck bottleneck) {
        OptimizationSuggestion suggestion = new OptimizationSuggestion();
        suggestion.setType(OptimizationType.OPTIMIZE_ERROR_RATE);
        suggestion.setTitle("优化错误率");
        suggestion.setDescription("当前错误率过高，建议检查业务逻辑或增加超时时间");
        suggestion.setPriority(OptimizationPriority.HIGH);
        
        suggestion.addParameter("connectionTimeout", "30000");
        suggestion.addParameter("keepAliveTimeout", "30000");
        
        return suggestion;
    }
    
    /**
     * 应用优化配置
     */
    private OptimizationResult applyOptimizations(List<OptimizationSuggestion> suggestions) {
        try {
            for (OptimizationSuggestion suggestion : suggestions) {
                applyOptimizationSuggestion(suggestion);
            }
            
            return new OptimizationResult(true, "优化配置应用成功");
            
        } catch (Exception e) {
            logger.error("应用优化配置失败: {}", e.getMessage());
            return new OptimizationResult(false, "应用优化配置失败: " + e.getMessage());
        }
    }
    
    /**
     * 应用单个优化建议
     */
    private void applyOptimizationSuggestion(OptimizationSuggestion suggestion) {
        switch (suggestion.getType()) {
            case INCREASE_THREADS:
                applyThreadIncrease(suggestion);
                break;
            case OPTIMIZE_RESPONSE_TIME:
                applyResponseTimeOptimization(suggestion);
                break;
            case OPTIMIZE_QUEUE:
                applyQueueOptimization(suggestion);
                break;
            case OPTIMIZE_ERROR_RATE:
                applyErrorRateOptimization(suggestion);
                break;
        }
    }
    
    /**
     * 应用线程增加优化
     */
    private void applyThreadIncrease(OptimizationSuggestion suggestion) {
        String maxThreadsStr = suggestion.getParameter("maxThreads");
        if (maxThreadsStr != null) {
            int maxThreads = Integer.parseInt(maxThreadsStr);
            updateMaxThreads(maxThreads);
            logger.info("最大线程数已更新为: {}", maxThreads);
        }
    }
    
    /**
     * 应用响应时间优化
     */
    private void applyResponseTimeOptimization(OptimizationSuggestion suggestion) {
        String maxThreadsStr = suggestion.getParameter("maxThreads");
        String minSpareThreadsStr = suggestion.getParameter("minSpareThreads");
        
        if (maxThreadsStr != null) {
            updateMaxThreads(Integer.parseInt(maxThreadsStr));
        }
        
        if (minSpareThreadsStr != null) {
            updateMinSpareThreads(Integer.parseInt(minSpareThreadsStr));
        }
        
        logger.info("响应时间优化配置已应用");
    }
    
    /**
     * 应用队列优化
     */
    private void applyQueueOptimization(OptimizationSuggestion suggestion) {
        String acceptCountStr = suggestion.getParameter("acceptCount");
        String maxConnectionsStr = suggestion.getParameter("maxConnections");
        
        if (acceptCountStr != null) {
            updateAcceptCount(Integer.parseInt(acceptCountStr));
        }
        
        if (maxConnectionsStr != null) {
            updateMaxConnections(Integer.parseInt(maxConnectionsStr));
        }
        
        logger.info("队列优化配置已应用");
    }
    
    /**
     * 应用错误率优化
     */
    private void applyErrorRateOptimization(OptimizationSuggestion suggestion) {
        String connectionTimeoutStr = suggestion.getParameter("connectionTimeout");
        String keepAliveTimeoutStr = suggestion.getParameter("keepAliveTimeout");
        
        if (connectionTimeoutStr != null) {
            updateConnectionTimeout(Integer.parseInt(connectionTimeoutStr));
        }
        
        if (keepAliveTimeoutStr != null) {
            updateKeepAliveTimeout(Integer.parseInt(keepAliveTimeoutStr));
        }
        
        logger.info("错误率优化配置已应用");
    }
    
    // 获取当前配置的方法
    private int getCurrentMaxThreads() {
        // 通过JMX或监控接口获取当前配置
        return 200; // 默认值
    }
    
    private int getCurrentMinSpareThreads() {
        return 10; // 默认值
    }
    
    private int getCurrentAcceptCount() {
        return 100; // 默认值
    }
    
    private int getCurrentMaxConnections() {
        return 8192; // 默认值
    }
    
    // 更新配置的方法
    private void updateMaxThreads(int maxThreads) {
        // 通过JMX或配置文件更新
        logger.info("更新最大线程数为: {}", maxThreads);
    }
    
    private void updateMinSpareThreads(int minSpareThreads) {
        logger.info("更新最小空闲线程数为: {}", minSpareThreads);
    }
    
    private void updateAcceptCount(int acceptCount) {
        logger.info("更新接受队列大小为: {}", acceptCount);
    }
    
    private void updateMaxConnections(int maxConnections) {
        logger.info("更新最大连接数为: {}", maxConnections);
    }
    
    private void updateConnectionTimeout(int connectionTimeout) {
        logger.info("更新连接超时时间为: {}", connectionTimeout);
    }
    
    private void updateKeepAliveTimeout(int keepAliveTimeout) {
        logger.info("更新Keep-Alive超时时间为: {}", keepAliveTimeout);
    }
}

// 线程池性能分析类
public class ThreadPoolPerformanceAnalysis {
    private ThreadPoolMetrics metrics;
    private double threadUtilization;
    private long averageResponseTime;
    private double queueUtilization;
    private double errorRate;
    
    // getter/setter方法
}

// 线程池瓶颈类
public class ThreadPoolBottleneck {
    private BottleneckType type;
    private String description;
    private double severity;
    
    // 构造函数和getter/setter方法
}

public enum BottleneckType {
    HIGH_THREAD_UTILIZATION,
    LONG_RESPONSE_TIME,
    HIGH_QUEUE_UTILIZATION,
    HIGH_ERROR_RATE
}

// 优化建议类
public class OptimizationSuggestion {
    private OptimizationType type;
    private String title;
    private String description;
    private OptimizationPriority priority;
    private Map<String, String> parameters = new HashMap<>();
    
    public void addParameter(String key, String value) {
        parameters.put(key, value);
    }
    
    public String getParameter(String key) {
        return parameters.get(key);
    }
    
    // getter/setter方法
}

public enum OptimizationType {
    INCREASE_THREADS,
    OPTIMIZE_RESPONSE_TIME,
    OPTIMIZE_QUEUE,
    OPTIMIZE_ERROR_RATE
}

public enum OptimizationPriority {
    LOW,    // 低优先级
    MEDIUM, // 中优先级
    HIGH    // 高优先级
}

// 线程池优化结果类
public class ThreadPoolOptimizationResult {
    private boolean success;
    private String message;
    private List<OptimizationSuggestion> suggestions;
    
    // 构造函数和getter/setter方法
}

// Tomcat线程池监控器
@Component
public class TomcatThreadPoolMonitor {
    
    private final Map<String, ThreadPoolMetrics> metricsHistory = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
    
    @PostConstruct
    public void init() {
        // 启动定期监控
        scheduler.scheduleAtFixedRate(this::collectMetrics, 0, 30, TimeUnit.SECONDS);
    }
    
    /**
     * 收集线程池指标
     */
    public void collectMetrics() {
        try {
            ThreadPoolMetrics metrics = getCurrentThreadPoolMetrics();
            String timestamp = String.valueOf(System.currentTimeMillis());
            metricsHistory.put(timestamp, metrics);
            
            // 清理历史数据（保留最近1小时）
            cleanupHistoryData();
            
        } catch (Exception e) {
            logger.error("收集线程池指标失败: {}", e.getMessage());
        }
    }
    
    /**
     * 获取当前线程池指标
     */
    public ThreadPoolMetrics getCurrentThreadPoolMetrics() {
        ThreadPoolMetrics metrics = new ThreadPoolMetrics();
        
        try {
            // 通过JMX获取线程池指标
            MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
            
            // 获取线程池MBean
            ObjectName threadPoolName = new ObjectName("Catalina:type=ThreadPool,name=*");
            Set<ObjectName> threadPoolNames = mBeanServer.queryNames(threadPoolName, null);
            
            for (ObjectName name : threadPoolNames) {
                // 获取线程池属性
                int maxThreads = (Integer) mBeanServer.getAttribute(name, "maxThreads");
                int currentThreadCount = (Integer) mBeanServer.getAttribute(name, "currentThreadCount");
                int currentThreadsBusy = (Integer) mBeanServer.getAttribute(name, "currentThreadsBusy");
                int maxConnections = (Integer) mBeanServer.getAttribute(name, "maxConnections");
                int currentThreadCount = (Integer) mBeanServer.getAttribute(name, "currentThreadCount");
                
                metrics.setMaxThreads(maxThreads);
                metrics.setCurrentThreadCount(currentThreadCount);
                metrics.setActiveThreads(currentThreadsBusy);
                metrics.setMaxConnections(maxConnections);
                
                // 计算其他指标
                metrics.setIdleThreads(currentThreadCount - currentThreadsBusy);
                metrics.setThreadUtilization((double) currentThreadsBusy / maxThreads);
            }
            
        } catch (Exception e) {
            logger.error("获取线程池指标失败: {}", e.getMessage());
            // 返回默认值
            metrics.setMaxThreads(200);
            metrics.setCurrentThreadCount(10);
            metrics.setActiveThreads(5);
            metrics.setIdleThreads(5);
            metrics.setThreadUtilization(0.25);
        }
        
        return metrics;
    }
    
    /**
     * 获取线程池指标历史
     */
    public Map<String, ThreadPoolMetrics> getMetricsHistory() {
        return new HashMap<>(metricsHistory);
    }
    
    /**
     * 获取线程池趋势分析
     */
    public ThreadPoolTrendAnalysis getTrendAnalysis() {
        ThreadPoolTrendAnalysis analysis = new ThreadPoolTrendAnalysis();
        
        // 分析线程使用率趋势
        List<Double> threadUtilizationTrend = calculateThreadUtilizationTrend();
        analysis.setThreadUtilizationTrend(threadUtilizationTrend);
        
        // 分析响应时间趋势
        List<Long> responseTimeTrend = calculateResponseTimeTrend();
        analysis.setResponseTimeTrend(responseTimeTrend);
        
        // 分析队列使用率趋势
        List<Double> queueUtilizationTrend = calculateQueueUtilizationTrend();
        analysis.setQueueUtilizationTrend(queueUtilizationTrend);
        
        return analysis;
    }
    
    /**
     * 计算线程使用率趋势
     */
    private List<Double> calculateThreadUtilizationTrend() {
        return metricsHistory.values().stream()
            .map(ThreadPoolMetrics::getThreadUtilization)
            .collect(Collectors.toList());
    }
    
    /**
     * 计算响应时间趋势
     */
    private List<Long> calculateResponseTimeTrend() {
        return metricsHistory.values().stream()
            .map(ThreadPoolMetrics::getAverageResponseTime)
            .collect(Collectors.toList());
    }
    
    /**
     * 计算队列使用率趋势
     */
    private List<Double> calculateQueueUtilizationTrend() {
        return metricsHistory.values().stream()
            .map(ThreadPoolMetrics::getQueueUtilization)
            .collect(Collectors.toList());
    }
    
    /**
     * 清理历史数据
     */
    private void cleanupHistoryData() {
        long cutoffTime = System.currentTimeMillis() - 3600000; // 1小时前
        
        metricsHistory.entrySet().removeIf(entry -> {
            long timestamp = Long.parseLong(entry.getKey());
            return timestamp < cutoffTime;
        });
    }
    
    @PreDestroy
    public void destroy() {
        scheduler.shutdown();
    }
}

// 线程池指标类
public class ThreadPoolMetrics {
    private int maxThreads;              // 最大线程数
    private int currentThreadCount;      // 当前线程数
    private int activeThreads;           // 活跃线程数
    private int idleThreads;             // 空闲线程数
    private int maxConnections;          // 最大连接数
    private int queueSize;               // 队列大小
    private int maxQueueSize;            // 最大队列大小
    private double threadUtilization;    // 线程使用率
    private double queueUtilization;     // 队列使用率
    private long averageResponseTime;    // 平均响应时间
    private long totalRequests;          // 总请求数
    private long errorRequests;          // 错误请求数
    private long timestamp;              // 时间戳
    
    // 构造函数和getter/setter方法
}

// 线程池趋势分析类
public class ThreadPoolTrendAnalysis {
    private List<Double> threadUtilizationTrend;
    private List<Long> responseTimeTrend;
    private List<Double> queueUtilizationTrend;
    
    // getter/setter方法
}

// Tomcat性能监控器
@Component
public class TomcatPerformanceMonitor {
    
    @Autowired
    private TomcatThreadPoolMonitor threadPoolMonitor;
    
    @Autowired
    private AlertManager alertManager;
    
    @Autowired
    private MetricsCollector metricsCollector;
    
    /**
     * 监控Tomcat性能
     */
    public TomcatPerformanceReport monitorPerformance() {
        try {
            // 收集性能指标
            TomcatPerformanceMetrics metrics = collectPerformanceMetrics();
            
            // 分析性能瓶颈
            List<PerformanceBottleneck> bottlenecks = analyzePerformanceBottlenecks(metrics);
            
            // 生成性能报告
            TomcatPerformanceReport report = generatePerformanceReport(metrics, bottlenecks);
            
            // 发送告警
            sendAlerts(bottlenecks);
            
            return report;
            
        } catch (Exception e) {
            logger.error("Tomcat性能监控失败: {}", e.getMessage());
            return new TomcatPerformanceReport(false, "监控失败: " + e.getMessage());
        }
    }
    
    /**
     * 收集性能指标
     */
    private TomcatPerformanceMetrics collectPerformanceMetrics() {
        TomcatPerformanceMetrics metrics = new TomcatPerformanceMetrics();
        
        // 收集线程池指标
        ThreadPoolMetrics threadPoolMetrics = threadPoolMonitor.getCurrentThreadPoolMetrics();
        metrics.setThreadPoolMetrics(threadPoolMetrics);
        
        // 收集系统指标
        SystemMetrics systemMetrics = collectSystemMetrics();
        metrics.setSystemMetrics(systemMetrics);
        
        // 收集应用指标
        ApplicationMetrics applicationMetrics = collectApplicationMetrics();
        metrics.setApplicationMetrics(applicationMetrics);
        
        return metrics;
    }
    
    /**
     * 收集系统指标
     */
    private SystemMetrics collectSystemMetrics() {
        SystemMetrics metrics = new SystemMetrics();
        
        // CPU使用率
        double cpuUsage = getCpuUsage();
        metrics.setCpuUsage(cpuUsage);
        
        // 内存使用率
        double memoryUsage = getMemoryUsage();
        metrics.setMemoryUsage(memoryUsage);
        
        // 磁盘使用率
        double diskUsage = getDiskUsage();
        metrics.setDiskUsage(diskUsage);
        
        // 网络使用率
        double networkUsage = getNetworkUsage();
        metrics.setNetworkUsage(networkUsage);
        
        return metrics;
    }
    
    /**
     * 收集应用指标
     */
    private ApplicationMetrics collectApplicationMetrics() {
        ApplicationMetrics metrics = new ApplicationMetrics();
        
        // 请求处理时间
        long averageResponseTime = getAverageResponseTime();
        metrics.setAverageResponseTime(averageResponseTime);
        
        // 请求吞吐量
        double throughput = getThroughput();
        metrics.setThroughput(throughput);
        
        // 错误率
        double errorRate = getErrorRate();
        metrics.setErrorRate(errorRate);
        
        // 活跃会话数
        int activeSessions = getActiveSessions();
        metrics.setActiveSessions(activeSessions);
        
        return metrics;
    }
    
    /**
     * 分析性能瓶颈
     */
    private List<PerformanceBottleneck> analyzePerformanceBottlenecks(TomcatPerformanceMetrics metrics) {
        List<PerformanceBottleneck> bottlenecks = new ArrayList<>();
        
        // 线程池瓶颈
        ThreadPoolMetrics threadPoolMetrics = metrics.getThreadPoolMetrics();
        if (threadPoolMetrics.getThreadUtilization() > 0.8) {
            bottlenecks.add(new PerformanceBottleneck(
                BottleneckType.HIGH_THREAD_UTILIZATION,
                "线程使用率过高: " + threadPoolMetrics.getThreadUtilization(),
                threadPoolMetrics.getThreadUtilization()));
        }
        
        // 系统瓶颈
        SystemMetrics systemMetrics = metrics.getSystemMetrics();
        if (systemMetrics.getCpuUsage() > 80) {
            bottlenecks.add(new PerformanceBottleneck(
                BottleneckType.HIGH_CPU_USAGE,
                "CPU使用率过高: " + systemMetrics.getCpuUsage() + "%",
                systemMetrics.getCpuUsage()));
        }
        
        if (systemMetrics.getMemoryUsage() > 85) {
            bottlenecks.add(new PerformanceBottleneck(
                BottleneckType.HIGH_MEMORY_USAGE,
                "内存使用率过高: " + systemMetrics.getMemoryUsage() + "%",
                systemMetrics.getMemoryUsage()));
        }
        
        // 应用瓶颈
        ApplicationMetrics applicationMetrics = metrics.getApplicationMetrics();
        if (applicationMetrics.getAverageResponseTime() > 5000) {
            bottlenecks.add(new PerformanceBottleneck(
                BottleneckType.LONG_RESPONSE_TIME,
                "响应时间过长: " + applicationMetrics.getAverageResponseTime() + "ms",
                applicationMetrics.getAverageResponseTime()));
        }
        
        if (applicationMetrics.getErrorRate() > 0.05) {
            bottlenecks.add(new PerformanceBottleneck(
                BottleneckType.HIGH_ERROR_RATE,
                "错误率过高: " + applicationMetrics.getErrorRate(),
                applicationMetrics.getErrorRate()));
        }
        
        return bottlenecks;
    }
    
    /**
     * 生成性能报告
     */
    private TomcatPerformanceReport generatePerformanceReport(TomcatPerformanceMetrics metrics, 
                                                            List<PerformanceBottleneck> bottlenecks) {
        TomcatPerformanceReport report = new TomcatPerformanceReport();
        
        // 设置基本信息
        report.setGeneratedAt(System.currentTimeMillis());
        report.setMetrics(metrics);
        report.setBottlenecks(bottlenecks);
        
        // 计算性能评分
        double performanceScore = calculatePerformanceScore(metrics, bottlenecks);
        report.setPerformanceScore(performanceScore);
        
        // 设置性能等级
        PerformanceLevel level = determinePerformanceLevel(performanceScore);
        report.setPerformanceLevel(level);
        
        // 生成总结
        String summary = generatePerformanceSummary(metrics, bottlenecks);
        report.setSummary(summary);
        
        return report;
    }
    
    /**
     * 计算性能评分
     */
    private double calculatePerformanceScore(TomcatPerformanceMetrics metrics, 
                                          List<PerformanceBottleneck> bottlenecks) {
        double score = 100.0;
        
        // 线程池评分
        ThreadPoolMetrics threadPoolMetrics = metrics.getThreadPoolMetrics();
        if (threadPoolMetrics.getThreadUtilization() > 0.8) {
            score -= 20;
        } else if (threadPoolMetrics.getThreadUtilization() > 0.6) {
            score -= 10;
        }
        
        // 系统评分
        SystemMetrics systemMetrics = metrics.getSystemMetrics();
        if (systemMetrics.getCpuUsage() > 80) {
            score -= 25;
        } else if (systemMetrics.getCpuUsage() > 60) {
            score -= 15;
        }
        
        if (systemMetrics.getMemoryUsage() > 85) {
            score -= 25;
        } else if (systemMetrics.getMemoryUsage() > 70) {
            score -= 15;
        }
        
        // 应用评分
        ApplicationMetrics applicationMetrics = metrics.getApplicationMetrics();
        if (applicationMetrics.getAverageResponseTime() > 5000) {
            score -= 20;
        } else if (applicationMetrics.getAverageResponseTime() > 2000) {
            score -= 10;
        }
        
        if (applicationMetrics.getErrorRate() > 0.05) {
            score -= 30;
        } else if (applicationMetrics.getErrorRate() > 0.01) {
            score -= 15;
        }
        
        // 瓶颈数量评分
        score -= bottlenecks.size() * 5;
        
        return Math.max(0, score);
    }
    
    /**
     * 发送告警
     */
    private void sendAlerts(List<PerformanceBottleneck> bottlenecks) {
        for (PerformanceBottleneck bottleneck : bottlenecks) {
            switch (bottleneck.getType()) {
                case HIGH_THREAD_UTILIZATION:
                    alertManager.sendAlert(AlertType.HIGH_THREAD_UTILIZATION, 
                        "线程使用率过高: " + bottleneck.getSeverity());
                    break;
                case HIGH_CPU_USAGE:
                    alertManager.sendAlert(AlertType.HIGH_CPU_USAGE, 
                        "CPU使用率过高: " + bottleneck.getSeverity() + "%");
                    break;
                case HIGH_MEMORY_USAGE:
                    alertManager.sendAlert(AlertType.HIGH_MEMORY_USAGE, 
                        "内存使用率过高: " + bottleneck.getSeverity() + "%");
                    break;
                case LONG_RESPONSE_TIME:
                    alertManager.sendAlert(AlertType.LONG_RESPONSE_TIME, 
                        "响应时间过长: " + bottleneck.getSeverity() + "ms");
                    break;
                case HIGH_ERROR_RATE:
                    alertManager.sendAlert(AlertType.HIGH_ERROR_RATE, 
                        "错误率过高: " + bottleneck.getSeverity());
                    break;
            }
        }
    }
    
    // 获取各种指标的方法
    private double getCpuUsage() {
        // 通过系统监控获取CPU使用率
        return SystemMonitor.getCpuUsage();
    }
    
    private double getMemoryUsage() {
        // 通过系统监控获取内存使用率
        return SystemMonitor.getMemoryUsage();
    }
    
    private double getDiskUsage() {
        // 通过系统监控获取磁盘使用率
        return SystemMonitor.getDiskUsage();
    }
    
    private double getNetworkUsage() {
        // 通过系统监控获取网络使用率
        return SystemMonitor.getNetworkUsage();
    }
    
    private long getAverageResponseTime() {
        // 通过应用监控获取平均响应时间
        return ApplicationMonitor.getAverageResponseTime();
    }
    
    private double getThroughput() {
        // 通过应用监控获取吞吐量
        return ApplicationMonitor.getThroughput();
    }
    
    private double getErrorRate() {
        // 通过应用监控获取错误率
        return ApplicationMonitor.getErrorRate();
    }
    
    private int getActiveSessions() {
        // 通过应用监控获取活跃会话数
        return ApplicationMonitor.getActiveSessions();
    }
}

// Tomcat性能指标类
public class TomcatPerformanceMetrics {
    private ThreadPoolMetrics threadPoolMetrics;
    private SystemMetrics systemMetrics;
    private ApplicationMetrics applicationMetrics;
    
    // getter/setter方法
}

// 系统指标类
public class SystemMetrics {
    private double cpuUsage;
    private double memoryUsage;
    private double diskUsage;
    private double networkUsage;
    
    // getter/setter方法
}

// 应用指标类
public class ApplicationMetrics {
    private long averageResponseTime;
    private double throughput;
    private double errorRate;
    private int activeSessions;
    
    // getter/setter方法
}

// Tomcat性能报告类
public class TomcatPerformanceReport {
    private boolean success;
    private String message;
    private long generatedAt;
    private TomcatPerformanceMetrics metrics;
    private List<PerformanceBottleneck> bottlenecks;
    private double performanceScore;
    private PerformanceLevel performanceLevel;
    private String summary;
    
    // getter/setter方法
}

// 性能等级枚举
public enum PerformanceLevel {
    EXCELLENT,  // 优秀 (90-100)
    GOOD,       // 良好 (80-89)
    FAIR,       // 一般 (70-79)
    POOR,       // 较差 (60-69)
    BAD         // 很差 (0-59)
}