/**
 * 新生代大小优化策略
 */
@Component
public class YoungGenerationOptimizer {
    
    /**
     * 新生代大小优化原则
     * 
     * 1. 对象生命周期短 -> 增大新生代
     * 2. 对象生命周期长 -> 减小新生代
     * 3. Minor GC频繁 -> 增大新生代
     * 4. Minor GC停顿时间长 -> 减小新生代
     */
    
    /**
     * 高并发场景新生代优化
     * 特点: 对象生命周期短，Minor GC频繁
     */
    public String optimizeForHighConcurrency(int totalHeapMB) {
        // 新生代占堆的40-50%
        int youngGenMB = (int)(totalHeapMB * 0.45);
        
        return String.format(
            "-Xmn%dm " +
            "-XX:SurvivorRatio=8 " +
            "-XX:MaxTenuringThreshold=15",
            youngGenMB
        );
    }
    
    /**
     * 长生命周期对象场景新生代优化
     * 特点: 对象生命周期长，容易晋升到老年代
     */
    public String optimizeForLongLivedObjects(int totalHeapMB) {
        // 新生代占堆的25-30%
        int youngGenMB = (int)(totalHeapMB * 0.25);
        
        return String.format(
            "-Xmn%dm " +
            "-XX:SurvivorRatio=8 " +
            "-XX:MaxTenuringThreshold=10",
            youngGenMB
        );
    }
    
    /**
     * 低延迟场景新生代优化
     * 特点: 需要减少Minor GC停顿时间
     */
    public String optimizeForLowLatency(int totalHeapMB) {
        // 新生代适中，使用G1 GC
        int youngGenMB = (int)(totalHeapMB * 0.33);
        
        return String.format(
            "-Xmn%dm " +
            "-XX:+UseG1GC " +
            "-XX:MaxGCPauseMillis=50 " +
            "-XX:G1HeapRegionSize=8m",
            youngGenMB
        );
    }
    
    /**
     * 动态调整新生代大小
     */
    public String optimizeDynamically(int totalHeapMB, 
                                        double minorGCFrequency,
                                        double avgMinorGCTime) {
        // 根据Minor GC频率和停顿时间动态调整
        int youngGenMB;
        
        if (minorGCFrequency > 10 && avgMinorGCTime < 50) {
            // GC频繁但停顿时间短，可以增大新生代
            youngGenMB = (int)(totalHeapMB * 0.4);
        } else if (minorGCFrequency < 5 && avgMinorGCTime > 100) {
            // GC不频繁但停顿时间长，减小新生代
            youngGenMB = (int)(totalHeapMB * 0.25);
        } else {
            // 默认比例
            youngGenMB = totalHeapMB / 3;
        }
        
        return String.format("-Xmn%dm", youngGenMB);
    }
}

/**
 * Survivor区优化策略
 */
@Component
public class SurvivorOptimizer {
    
    /**
     * Survivor区优化原则
     * 
     * 1. 对象较大 -> 增大Survivor区
     * 2. 对象存活率高 -> 增大Survivor区
     * 3. 过早晋升 -> 增大Survivor区
     * 4. Survivor区利用率低 -> 减小Survivor区
     */
    
    /**
     * 大对象场景Survivor优化
     */
    public String optimizeForLargeObjects(int avgObjectSizeKB) {
        // 如果平均对象大小较大，增大Survivor区
        if (avgObjectSizeKB > 512) { // 512KB
            return "-XX:SurvivorRatio=4"; // Eden:Survivor = 4:1:1
        } else if (avgObjectSizeKB > 256) { // 256KB
            return "-XX:SurvivorRatio=6"; // Eden:Survivor = 6:1:1
        } else {
            return "-XX:SurvivorRatio=8"; // Eden:Survivor = 8:1:1 (默认)
        }
    }
    
    /**
     * 高存活率场景Survivor优化
     */
    public String optimizeForHighSurvivalRate(double survivalRate) {
        // 如果对象存活率高，增大Survivor区
        if (survivalRate > 0.5) {
            return "-XX:SurvivorRatio=4 -XX:TargetSurvivorRatio=60";
        } else if (survivalRate > 0.3) {
            return "-XX:SurvivorRatio=6 -XX:TargetSurvivorRatio=50";
        } else {
            return "-XX:SurvivorRatio=8 -XX:TargetSurvivorRatio=50"; // 默认
        }
    }
    
    /**
     * 过早晋升场景Survivor优化
     */
    public String optimizeForPrematurePromotion() {
        // 如果对象过早晋升，增大Survivor区和晋升年龄阈值
        return "-XX:SurvivorRatio=6 " +
               "-XX:MaxTenuringThreshold=15 " +
               "-XX:TargetSurvivorRatio=60";
    }
}

/**
 * 对象晋升策略优化
 */
@Component
public class PromotionStrategyOptimizer {
    
    /**
     * 对象晋升优化原则
     * 
     * 1. 过早晋升 -> 增大晋升年龄阈值
     * 2. 老年代压力大 -> 增大晋升年龄阈值
     * 3. Survivor区不足 -> 调整动态年龄判断
     */
    
    /**
     * 优化晋升年龄阈值
     */
    public String optimizeMaxTenuringThreshold(int avgObjectAge) {
        // 根据平均对象年龄调整晋升阈值
        if (avgObjectAge < 5) {
            // 对象年龄小，增大阈值，减少过早晋升
            return "-XX:MaxTenuringThreshold=15";
        } else if (avgObjectAge > 10) {
            // 对象年龄大，可以适当减小阈值
            return "-XX:MaxTenuringThreshold=10";
        } else {
            return "-XX:MaxTenuringThreshold=15"; // 默认
        }
    }
    
    /**
     * 优化动态年龄判断
     */
    public String optimizeDynamicAgeThreshold(double survivorUsageRate) {
        // 根据Survivor区使用率调整动态年龄判断
        if (survivorUsageRate > 0.8) {
            // Survivor区使用率高，降低目标使用率，提前晋升
            return "-XX:TargetSurvivorRatio=40";
        } else if (survivorUsageRate < 0.3) {
            // Survivor区使用率低，提高目标使用率，延迟晋升
            return "-XX:TargetSurvivorRatio=60";
        } else {
            return "-XX:TargetSurvivorRatio=50"; // 默认
        }
    }
    
    /**
     * 空间分配担保优化
     */
    public String optimizeHandlePromotionFailure() {
        // 允许Minor GC时老年代空间不足的情况
        // 减少Full GC频率，但可能增加Minor GC失败的风险
        return "-XX:HandlePromotionFailure=true";
    }
}

/**
 * 老年代大小优化策略
 */
@Component
public class OldGenerationOptimizer {
    
    /**
     * 老年代大小优化原则
     * 
     * 1. 长生命周期对象多 -> 增大老年代
     * 2. Full GC频繁 -> 增大老年代
     * 3. Full GC停顿时间长 -> 使用并发GC
     * 4. 内存充足 -> 增大老年代
     */
    
    /**
     * 长生命周期对象场景老年代优化
     */
    public String optimizeForLongLivedObjects(int totalHeapMB) {
        // 老年代占堆的70-75%
        int oldGenMB = (int)(totalHeapMB * 0.7);
        
        return String.format(
            "-XX:NewRatio=2 " + // 老年代:新生代 = 2:1
            "-XX:+UseG1GC " +
            "-XX:MaxGCPauseMillis=200 " +
            "-XX:InitiatingHeapOccupancyPercent=40"
        );
    }
    
    /**
     * Full GC频繁场景老年代优化
     */
    public String optimizeForFrequentFullGC(int totalHeapMB, 
                                            double fullGCFrequency) {
        // 如果Full GC频繁，增大老年代
        int oldGenMB;
        if (fullGCFrequency > 1) { // 每分钟超过1次
            oldGenMB = (int)(totalHeapMB * 0.75);
        } else {
            oldGenMB = (int)(totalHeapMB * 0.67);
        }
        
        return String.format(
            "-XX:NewRatio=2 " +
            "-XX:+UseG1GC " +
            "-XX:InitiatingHeapOccupancyPercent=35 " +
            "-XX:MaxGCPauseMillis=200"
        );
    }
    
    /**
     * 低延迟场景老年代优化
     */
    public String optimizeForLowLatency(int totalHeapMB) {
        // 使用G1 GC，严格控制停顿时间
        return String.format(
            "-XX:+UseG1GC " +
            "-XX:MaxGCPauseMillis=50 " +
            "-XX:G1HeapRegionSize=8m " +
            "-XX:InitiatingHeapOccupancyPercent=30 " +
            "-XX:ConcGCThreads=4"
        );
    }
}

/**
 * 老年代GC算法优化
 */
@Component
public class OldGenerationGCOptimizer {
    
    /**
     * 吞吐量优先场景GC优化
     */
    public String optimizeForThroughput(int heapSizeMB) {
        if (heapSizeMB < 512) {
            // 小堆内存，使用Serial GC
            return "-XX:+UseSerialGC";
        } else {
            // 大堆内存，使用Parallel GC
            return "-XX:+UseParallelGC " +
                   "-XX:ParallelGCThreads=8 " +
                   "-XX:MaxGCPauseMillis=200";
        }
    }
    
    /**
     * 低延迟场景GC优化
     */
    public String optimizeForLowLatency(int heapSizeMB) {
        if (heapSizeMB < 4096) {
            // 中小堆内存，使用CMS GC
            return "-XX:+UseConcMarkSweepGC " +
                   "-XX:CMSInitiatingOccupancyFraction=70 " +
                   "-XX:+UseCMSCompactAtFullCollection " +
                   "-XX:CMSFullGCsBeforeCompaction=0 " +
                   "-XX:+CMSParallelRemarkEnabled " +
                   "-XX:+CMSParallelInitialMarkEnabled";
        } else {
            // 大堆内存，使用G1 GC
            return "-XX:+UseG1GC " +
                   "-XX:MaxGCPauseMillis=100 " +
                   "-XX:G1HeapRegionSize=16m " +
                   "-XX:InitiatingHeapOccupancyPercent=45 " +
                   "-XX:ConcGCThreads=4";
        }
    }
    
    /**
     * 大堆内存场景GC优化
     */
    public String optimizeForLargeHeap(int heapSizeMB) {
        // 大堆内存必须使用G1 GC或ZGC
        int regionSizeMB = calculateOptimalRegionSize(heapSizeMB);
        
        return String.format(
            "-XX:+UseG1GC " +
            "-XX:MaxGCPauseMillis=300 " +
            "-XX:G1HeapRegionSize=%dm " +
            "-XX:InitiatingHeapOccupancyPercent=40 " +
            "-XX:ConcGCThreads=8 " +
            "-XX:ParallelGCThreads=8",
            regionSizeMB
        );
    }
    
    private int calculateOptimalRegionSize(int heapSizeMB) {
        // G1要求Region数量在2048-8192之间
        int[] regionSizes = {1, 2, 4, 8, 16, 32};
        for (int size : regionSizes) {
            int regionCount = heapSizeMB / size;
            if (regionCount >= 2048 && regionCount <= 8192) {
                return size;
            }
        }
        return 16; // 默认16M
    }
}

/**
 * 老年代GC参数调优
 */
@Component
public class OldGenerationGCParameterTuner {
    
    /**
     * CMS GC参数优化
     */
    public String optimizeCMSParameters(double oldGenUsageRate) {
        // 根据老年代使用率调整CMS触发阈值
        int initiatingOccupancy;
        if (oldGenUsageRate > 0.8) {
            // 使用率高，提前触发CMS
            initiatingOccupancy = 60;
        } else if (oldGenUsageRate < 0.5) {
            // 使用率低，延迟触发CMS
            initiatingOccupancy = 80;
        } else {
            initiatingOccupancy = 70; // 默认
        }
        
        return String.format(
            "-XX:+UseConcMarkSweepGC " +
            "-XX:CMSInitiatingOccupancyFraction=%d " +
            "-XX:+UseCMSCompactAtFullCollection " +
            "-XX:CMSFullGCsBeforeCompaction=0 " +
            "-XX:+CMSParallelRemarkEnabled " +
            "-XX:+CMSParallelInitialMarkEnabled " +
            "-XX:CMSWaitDuration=2000",
            initiatingOccupancy
        );
    }
    
    /**
     * G1 GC参数优化
     */
    public String optimizeG1Parameters(int heapSizeMB, 
                                        int maxPauseMillis,
                                        double oldGenUsageRate) {
        int regionSizeMB = calculateOptimalRegionSize(heapSizeMB);
        int initiatingOccupancy = (int)(oldGenUsageRate * 100) - 5;
        
        return String.format(
            "-XX:+UseG1GC " +
            "-XX:MaxGCPauseMillis=%d " +
            "-XX:G1HeapRegionSize=%dm " +
            "-XX:InitiatingHeapOccupancyPercent=%d " +
            "-XX:ConcGCThreads=4 " +
            "-XX:ParallelGCThreads=8 " +
            "-XX:G1ReservePercent=10 " +
            "-XX:G1HeapWastePercent=5",
            maxPauseMillis, regionSizeMB, initiatingOccupancy
        );
    }
    
    private int calculateOptimalRegionSize(int heapSizeMB) {
        int[] regionSizes = {1, 2, 4, 8, 16, 32};
        for (int size : regionSizes) {
            int regionCount = heapSizeMB / size;
            if (regionCount >= 2048 && regionCount <= 8192) {
                return size;
            }
        }
        return 16;
    }
}

/**
 * 大对象识别与分类
 */
@Component
public class LargeObjectIdentifier {
    
    /**
     * 大对象定义
     * 
     * 1. 超过PretenureSizeThreshold的对象
     * 2. 超过G1 Region一半大小的对象
     * 3. 占用大量连续内存的对象
     */
    
    /**
     * 识别大对象
     */
    public List<LargeObjectInfo> identifyLargeObjects(String heapDumpPath) {
        List<LargeObjectInfo> largeObjects = new ArrayList<>();
        
        // 分析堆转储文件，识别大对象
        // 1. 对象大小超过阈值
        // 2. 对象类型（数组、集合等）
        // 3. 对象引用关系
        
        return largeObjects;
    }
    
    /**
     * 分类大对象
     */
    public Map<String, List<LargeObjectInfo>> classifyLargeObjects(
            List<LargeObjectInfo> largeObjects) {
        Map<String, List<LargeObjectInfo>> classified = new HashMap<>();
        
        for (LargeObjectInfo obj : largeObjects) {
            String category = classifyObject(obj);
            classified.computeIfAbsent(category, k -> new ArrayList<>()).add(obj);
        }
        
        return classified;
    }
    
    private String classifyObject(LargeObjectInfo obj) {
        // 根据对象类型和大小分类
        if (obj.getType().contains("Array") || obj.getType().contains("[]")) {
            return "数组";
        } else if (obj.getType().contains("List") || obj.getType().contains("Map")) {
            return "集合";
        } else if (obj.getType().contains("String")) {
            return "字符串";
        } else {
            return "其他";
        }
    }
}

/**
 * 大对象信息
 */
@Data
class LargeObjectInfo {
    private String className;
    private String type;
    private long size;
    private int count;
    private List<String> references = new ArrayList<>();
}

/**
 * 大对象分配优化策略
 */
@Component
public class LargeObjectAllocationOptimizer {
    
    /**
     * 大对象分配优化原则
     * 
     * 1. 大对象直接进入老年代
     * 2. 避免大对象在新生代分配
     * 3. 使用对象池复用大对象
     * 4. 拆分大对象为小对象
     */
    
    /**
     * 配置大对象阈值
     */
    public String configurePretenureSizeThreshold(int thresholdKB) {
        // 大于阈值的对象直接进入老年代
        // 默认值为0，表示所有对象都在新生代分配
        return String.format("-XX:PretenureSizeThreshold=%d", thresholdKB * 1024);
    }
    
    /**
     * 根据应用特点优化大对象阈值
     */
    public String optimizePretenureSizeThreshold(int avgObjectSizeKB, 
                                                  int maxObjectSizeKB) {
        // 如果平均对象大小较大，设置较大的阈值
        int thresholdKB;
        if (maxObjectSizeKB > 1024) { // 1MB
            thresholdKB = 512; // 512KB
        } else if (maxObjectSizeKB > 512) { // 512KB
            thresholdKB = 256; // 256KB
        } else if (avgObjectSizeKB > 256) { // 256KB
            thresholdKB = 128; // 128KB
        } else {
            thresholdKB = 0; // 不设置，所有对象在新生代分配
        }
        
        if (thresholdKB > 0) {
            return String.format("-XX:PretenureSizeThreshold=%d", thresholdKB * 1024);
        } else {
            return "";
        }
    }
    
    /**
     * G1 GC大对象处理
     */
    public String configureG1LargeObjectHandling(int regionSizeMB) {
        // G1中，大于Region一半的对象会被分配在Humongous Region
        // Humongous对象直接进入老年代
        return String.format(
            "-XX:+UseG1GC " +
            "-XX:G1HeapRegionSize=%dm " +
            "-XX:G1ReservePercent=10",
            regionSizeMB
        );
    }
}

/**
 * 大对象优化实践
 */
@Component
public class LargeObjectOptimization {
    
    /**
     * 对象池优化
     * 复用大对象，减少分配和回收
     */
    public class LargeObjectPool<T> {
        private final Queue<T> pool = new ConcurrentLinkedQueue<>();
        private final Supplier<T> factory;
        private final int maxSize;
        
        public LargeObjectPool(Supplier<T> factory, int maxSize) {
            this.factory = factory;
            this.maxSize = maxSize;
        }
        
        public T borrow() {
            T obj = pool.poll();
            if (obj == null) {
                obj = factory.get();
            }
            return obj;
        }
        
        public void returnObject(T obj) {
            if (pool.size() < maxSize) {
                reset(obj);
                pool.offer(obj);
            }
        }
        
        private void reset(T obj) {
            // 重置对象状态
        }
    }
    
    /**
     * 大对象拆分
     * 将大对象拆分为多个小对象
     */
    public class LargeObjectSplitter {
        /**
         * 拆分大数组
         */
        public <T> List<T[]> splitArray(T[] largeArray, int chunkSize) {
            List<T[]> chunks = new ArrayList<>();
            for (int i = 0; i < largeArray.length; i += chunkSize) {
                int end = Math.min(i + chunkSize, largeArray.length);
                T[] chunk = Arrays.copyOfRange(largeArray, i, end);
                chunks.add(chunk);
            }
            return chunks;
        }
        
        /**
         * 拆分大集合
         */
        public <T> List<List<T>> splitList(List<T> largeList, int chunkSize) {
            List<List<T>> chunks = new ArrayList<>();
            for (int i = 0; i < largeList.size(); i += chunkSize) {
                int end = Math.min(i + chunkSize, largeList.size());
                chunks.add(new ArrayList<>(largeList.subList(i, end)));
            }
            return chunks;
        }
    }
    
    /**
     * 大对象缓存优化
     */
    public class LargeObjectCache<K, V> {
        private final Cache<K, V> cache;
        
        public LargeObjectCache(int maxSize, long expireAfterWrite) {
            this.cache = Caffeine.newBuilder()
                .maximumSize(maxSize)
                .expireAfterWrite(expireAfterWrite, TimeUnit.SECONDS)
                .recordStats()
                .build();
        }
        
        public V get(K key) {
            return cache.getIfPresent(key);
        }
        
        public void put(K key, V value) {
            cache.put(key, value);
        }
        
        public void invalidate(K key) {
            cache.invalidate(key);
        }
    }
}

/**
 * 内存优化诊断工具
 */
@Service
public class MemoryOptimizationDiagnostic {
    
    /**
     * 诊断新生代问题
     */
    public DiagnosticResult diagnoseYoungGeneration() {
        DiagnosticResult result = new DiagnosticResult();
        
        // 1. 检查Minor GC频率
        double minorGCFrequency = getMinorGCFrequency();
        if (minorGCFrequency > 10) {
            result.addIssue("Minor GC频率过高: " + minorGCFrequency + "次/分钟");
            result.addRecommendation("增大新生代大小: -Xmn<size>");
        }
        
        // 2. 检查Minor GC停顿时间
        double avgMinorGCTime = getAvgMinorGCTime();
        if (avgMinorGCTime > 100) {
            result.addIssue("Minor GC停顿时间过长: " + avgMinorGCTime + "ms");
            result.addRecommendation("减小新生代大小或使用G1 GC");
        }
        
        // 3. 检查对象晋升率
        double promotionRate = getPromotionRate();
        if (promotionRate > 0.3) {
            result.addIssue("对象晋升率过高: " + promotionRate * 100 + "%");
            result.addRecommendation("增大Survivor区或提高晋升年龄阈值");
        }
        
        return result;
    }
    
    /**
     * 诊断老年代问题
     */
    public DiagnosticResult diagnoseOldGeneration() {
        DiagnosticResult result = new DiagnosticResult();
        
        // 1. 检查Full GC频率
        double fullGCFrequency = getFullGCFrequency();
        if (fullGCFrequency > 0.5) {
            result.addIssue("Full GC频率过高: " + fullGCFrequency + "次/分钟");
            result.addRecommendation("增大老年代大小或优化对象晋升策略");
        }
        
        // 2. 检查Full GC停顿时间
        double avgFullGCTime = getAvgFullGCTime();
        if (avgFullGCTime > 1000) {
            result.addIssue("Full GC停顿时间过长: " + avgFullGCTime + "ms");
            result.addRecommendation("使用G1 GC或CMS GC");
        }
        
        // 3. 检查老年代使用率
        double oldGenUsageRate = getOldGenUsageRate();
        if (oldGenUsageRate > 0.9) {
            result.addIssue("老年代使用率过高: " + oldGenUsageRate * 100 + "%");
            result.addRecommendation("增大堆内存或优化对象生命周期");
        }
        
        return result;
    }
    
    /**
     * 诊断大对象问题
     */
    public DiagnosticResult diagnoseLargeObjects() {
        DiagnosticResult result = new DiagnosticResult();
        
        // 1. 检查大对象数量
        int largeObjectCount = getLargeObjectCount();
        if (largeObjectCount > 100) {
            result.addIssue("大对象数量过多: " + largeObjectCount);
            result.addRecommendation("优化大对象分配策略或使用对象池");
        }
        
        // 2. 检查大对象大小
        long totalLargeObjectSize = getTotalLargeObjectSize();
        long heapSize = getHeapSize();
        double largeObjectRatio = (double) totalLargeObjectSize / heapSize;
        if (largeObjectRatio > 0.3) {
            result.addIssue("大对象占用内存比例过高: " + largeObjectRatio * 100 + "%");
            result.addRecommendation("拆分大对象或使用对象池");
        }
        
        return result;
    }
    
    private double getMinorGCFrequency() {
        // 获取Minor GC频率
        return 0.0;
    }
    
    private double getAvgMinorGCTime() {
        // 获取平均Minor GC停顿时间
        return 0.0;
    }
    
    private double getPromotionRate() {
        // 获取对象晋升率
        return 0.0;
    }
    
    private double getFullGCFrequency() {
        // 获取Full GC频率
        return 0.0;
    }
    
    private double getAvgFullGCTime() {
        // 获取平均Full GC停顿时间
        return 0.0;
    }
    
    private double getOldGenUsageRate() {
        // 获取老年代使用率
        return 0.0;
    }
    
    private int getLargeObjectCount() {
        // 获取大对象数量
        return 0;
    }
    
    private long getTotalLargeObjectSize() {
        // 获取大对象总大小
        return 0L;
    }
    
    private long getHeapSize() {
        // 获取堆大小
        return 0L;
    }
}

/**
 * 诊断结果
 */
@Data
class DiagnosticResult {
    private List<String> issues = new ArrayList<>();
    private List<String> recommendations = new ArrayList<>();
    
    public void addIssue(String issue) {
        issues.add(issue);
    }
    
    public void addRecommendation(String recommendation) {
        recommendations.add(recommendation);
    }
}

/**
 * 综合优化方案生成器
 */
@Component
public class ComprehensiveOptimizationPlan {
    
    /**
     * 生成优化方案
     */
    public OptimizationPlan generatePlan(DiagnosticResult diagnostic) {
        OptimizationPlan plan = new OptimizationPlan();
        
        // 根据诊断结果生成优化方案
        for (String issue : diagnostic.getIssues()) {
            if (issue.contains("Minor GC频率过高")) {
                plan.addOptimization("增大新生代大小");
            } else if (issue.contains("Minor GC停顿时间过长")) {
                plan.addOptimization("减小新生代大小或使用G1 GC");
            } else if (issue.contains("对象晋升率过高")) {
                plan.addOptimization("增大Survivor区或提高晋升年龄阈值");
            } else if (issue.contains("Full GC频率过高")) {
                plan.addOptimization("增大老年代大小或优化对象晋升策略");
            } else if (issue.contains("Full GC停顿时间过长")) {
                plan.addOptimization("使用G1 GC或CMS GC");
            } else if (issue.contains("老年代使用率过高")) {
                plan.addOptimization("增大堆内存或优化对象生命周期");
            } else if (issue.contains("大对象数量过多")) {
                plan.addOptimization("优化大对象分配策略或使用对象池");
            } else if (issue.contains("大对象占用内存比例过高")) {
                plan.addOptimization("拆分大对象或使用对象池");
            }
        }
        
        return plan;
    }
    
    /**
     * 生成JVM参数配置
     */
    public String generateJVMConfig(OptimizationPlan plan, 
                                    int totalHeapMB,
                                    String useCase) {
        StringBuilder config = new StringBuilder();
        
        // 基础配置
        config.append(String.format("-Xms%dm -Xmx%dm ", totalHeapMB, totalHeapMB));
        
        // 根据优化方案生成配置
        if (plan.getOptimizations().contains("增大新生代大小")) {
            int youngGenMB = (int)(totalHeapMB * 0.4);
            config.append(String.format("-Xmn%dm ", youngGenMB));
        } else if (plan.getOptimizations().contains("减小新生代大小")) {
            int youngGenMB = (int)(totalHeapMB * 0.25);
            config.append(String.format("-Xmn%dm ", youngGenMB));
        } else {
            int youngGenMB = totalHeapMB / 3;
            config.append(String.format("-Xmn%dm ", youngGenMB));
        }
        
        if (plan.getOptimizations().contains("使用G1 GC")) {
            config.append("-XX:+UseG1GC ");
            config.append("-XX:MaxGCPauseMillis=200 ");
            config.append("-XX:G1HeapRegionSize=16m ");
            config.append("-XX:InitiatingHeapOccupancyPercent=45 ");
        } else if (plan.getOptimizations().contains("使用CMS GC")) {
            config.append("-XX:+UseConcMarkSweepGC ");
            config.append("-XX:CMSInitiatingOccupancyFraction=70 ");
        }
        
        if (plan.getOptimizations().contains("增大Survivor区")) {
            config.append("-XX:SurvivorRatio=6 ");
        }
        
        if (plan.getOptimizations().contains("提高晋升年龄阈值")) {
            config.append("-XX:MaxTenuringThreshold=15 ");
        }
        
        // GC日志配置
        config.append("-Xlog:gc*:file=/var/log/gc.log:time,uptime,level,tags:filecount=5,filesize=20M ");
        
        // OOM配置
        config.append("-XX:+HeapDumpOnOutOfMemoryError ");
        config.append("-XX:HeapDumpPath=/tmp/heapdump.hprof");
        
        return config.toString();
    }
}

/**
 * 优化方案
 */
@Data
class OptimizationPlan {
    private List<String> optimizations = new ArrayList<>();
    
    public void addOptimization(String optimization) {
        optimizations.add(optimization);
    }
}

/**
 * 高并发场景内存优化
 */
@Component
public class HighConcurrencyOptimization {
    
    /**
     * 高并发场景特点
     * - 对象生命周期短
     * - Minor GC频繁
     * - 需要高吞吐量
     */
    
    /**
     * 生成高并发场景优化配置
     */
    public String generateConfig(int totalHeapMB) {
        // 1. 增大新生代（对象生命周期短）
        int youngGenMB = (int)(totalHeapMB * 0.45);
        
        // 2. 使用Parallel GC（吞吐量优先）
        // 3. 优化Survivor区
        // 4. 提高晋升年龄阈值
        
        return String.format(
            "-Xms%dm -Xmx%dm " +
            "-Xmn%dm " +
            "-XX:SurvivorRatio=8 " +
            "-XX:MaxTenuringThreshold=15 " +
            "-XX:+UseParallelGC " +
            "-XX:ParallelGCThreads=8 " +
            "-XX:MaxGCPauseMillis=200 " +
            "-Xlog:gc*:file=/var/log/gc.log:time,uptime,level,tags:filecount=5,filesize=20M",
            totalHeapMB, totalHeapMB, youngGenMB
        );
    }
}

/**
 * 低延迟场景内存优化
 */
@Component
public class LowLatencyOptimization {
    
    /**
     * 低延迟场景特点
     * - 需要可预测的停顿时间
     * - GC停顿时间要求极低
     * - 可以使用更多内存
     */
    
    /**
     * 生成低延迟场景优化配置
     */
    public String generateConfig(int totalHeapMB) {
        // 1. 使用G1 GC（可预测停顿时间）
        // 2. 严格控制停顿时间
        // 3. 优化Region大小
        // 4. 提前触发并发标记
        
        int regionSizeMB = calculateOptimalRegionSize(totalHeapMB);
        
        return String.format(
            "-Xms%dm -Xmx%dm " +
            "-XX:+UseG1GC " +
            "-XX:MaxGCPauseMillis=50 " +
            "-XX:G1HeapRegionSize=%dm " +
            "-XX:InitiatingHeapOccupancyPercent=30 " +
            "-XX:ConcGCThreads=4 " +
            "-XX:ParallelGCThreads=8 " +
            "-Xlog:gc*:file=/var/log/gc.log:time,uptime,level,tags:filecount=5,filesize=20M",
            totalHeapMB, totalHeapMB, regionSizeMB
        );
    }
    
    private int calculateOptimalRegionSize(int heapSizeMB) {
        int[] regionSizes = {1, 2, 4, 8, 16, 32};
        for (int size : regionSizes) {
            int regionCount = heapSizeMB / size;
            if (regionCount >= 2048 && regionCount <= 8192) {
                return size;
            }
        }
        return 8; // 低延迟场景使用较小的Region
    }
}

/**
 * 大数据处理场景内存优化
 */
@Component
public class BigDataOptimization {
    
    /**
     * 大数据处理场景特点
     * - 大堆内存
     * - 大对象多
     * - 需要处理大量数据
     */
    
    /**
     * 生成大数据处理场景优化配置
     */
    public String generateConfig(int totalHeapMB) {
        // 1. 大堆内存
        // 2. 使用G1 GC（适合大堆）
        // 3. 增大Region大小
        // 4. 优化大对象处理
        
        int regionSizeMB = calculateOptimalRegionSize(totalHeapMB);
        int youngGenMB = totalHeapMB / 3;
        
        return String.format(
            "-Xms%dm -Xmx%dm " +
            "-Xmn%dm " +
            "-XX:+UseG1GC " +
            "-XX:MaxGCPauseMillis=300 " +
            "-XX:G1HeapRegionSize=%dm " +
            "-XX:InitiatingHeapOccupancyPercent=40 " +
            "-XX:ConcGCThreads=8 " +
            "-XX:ParallelGCThreads=8 " +
            "-XX:PretenureSizeThreshold=1048576 " + // 1MB大对象直接进入老年代
            "-Xlog:gc*:file=/var/log/gc.log:time,uptime,level,tags:filecount=5,filesize=20M",
            totalHeapMB, totalHeapMB, youngGenMB, regionSizeMB
        );
    }
    
    private int calculateOptimalRegionSize(int heapSizeMB) {
        int[] regionSizes = {1, 2, 4, 8, 16, 32};
        for (int size : regionSizes) {
            int regionCount = heapSizeMB / size;
            if (regionCount >= 2048 && regionCount <= 8192) {
                return size;
            }
        }
        return 32; // 大数据场景使用较大的Region
    }
}