#容量评估与规划

// 大促容量评估
@Service
public class CapacityAssessmentService {

    /**
     * 大促容量评估
     */
    public CapacityReport assessForPromotion(PromotionPlan plan) {
        CapacityReport report = new CapacityReport();

        // 1. 预估DAU
        long estimatedDAU = plan.getBaseDAU() * plan.getGrowthRate();
        report.setEstimatedDAU(estimatedDAU);

        // 2. 预估峰值QPS
        long peakQPS = estimatePeakQPS(estimatedDAU, plan.getPeakHours());
        report.setPeakQPS(peakQPS);

        // 3. 评估各服务
        for (ServiceConfig service : plan.getServices()) {
            ServiceCapacity serviceCapacity = assessService(service, peakQPS);
            report.addServiceCapacity(service.getName(), serviceCapacity);
        }

        // 4. 评估数据库
        DBCapacity dbCapacity = assessDatabase(peakQPS);
        report.setDbCapacity(dbCapacity);

        // 5. 评估缓存
        CacheCapacity cacheCapacity = assessCache(estimatedDAU);
        report.setCacheCapacity(cacheCapacity);

        // 6. 评估网络带宽
        BandwidthCapacity bandwidthCapacity = assessBandwidth(peakQPS);
        report.setBandwidthCapacity(bandwidthCapacity);

        // 7. 输出扩容建议
        List<String> suggestions = generateSuggestions(report);
        report.setSuggestions(suggestions);

        return report;
    }

    /**
     * 预估峰值QPS
     */
    private long estimatePeakQPS(long dau, int peakHours) {
        // 峰值时段：2小时
        int peakDurationSeconds = peakHours * 3600;

        // 峰值QPS = DAU × 人均访问次数 × 峰值集中度 / 峰值时长
        long avgDailyQPS = dau * 10 / 86400;

        // 峰值因子：大促通常是平均的10-20倍
        int peakFactor = 15;

        return avgDailyQPS * peakFactor;
    }

    /**
     * 评估服务容量
     */
    private ServiceCapacity assessService(ServiceConfig service, long peakQPS) {
        ServiceCapacity capacity = new ServiceCapacity();

        // 单机QPS
        int singleMachineQPS = service.getSingleMachineQPS();

        // 需要的机器数
        int requiredMachines = (int) Math.ceil(
            (double) peakQPS / singleMachineQPS * 1.5  // 冗余1.5倍
        );

        // 当前机器数
        int currentMachines = service.getCurrentMachines();

        // 扩容建议
        if (requiredMachines > currentMachines) {
            capacity.setNeedExpand(true);
            capacity.setExpandCount(requiredMachines - currentMachines);
        }

        return capacity;
    }
}

// 应用层自动扩容
@Service
public class AutoScaleService {

    @Autowired
    private MonitorService monitorService;

    @Autowired
    private DeployService deployService;

    private static final double CPU_THRESHOLD = 70.0;
    private static final double MEMORY_THRESHOLD = 80.0;
    private static final int MIN_REPLICAS = 10;
    private static final int MAX_REPLICAS = 100;

    @Scheduled(fixedRate = 30000)  // 每30秒检查一次
    public void checkAndScale() {
        Metrics metrics = monitorService.getCurrentMetrics();

        double cpuUsage = metrics.getCpuUsage();
        double memoryUsage = metrics.getMemoryUsage();
        int currentReplicas = metrics.getReplicas();

        // 计算目标副本数
        int targetReplicas = calculateTargetReplicas(
            metrics, cpuUsage, memoryUsage, currentReplicas);

        // 限制范围
        targetReplicas = Math.max(MIN_REPLICAS,
            Math.min(MAX_REPLICAS, targetReplicas));

        if (targetReplicas != currentReplicas) {
            if (targetReplicas > currentReplicas) {
                log.info("扩容：{} -> {}", currentReplicas, targetReplicas);
                deployService.scaleUp(targetReplicas);
            } else {
                log.info("缩容：{} -> {}", currentReplicas, targetReplicas);
                deployService.scaleDown(targetReplicas);
            }
        }
    }

    private int calculateTargetReplicas(Metrics metrics,
                                        double cpuUsage,
                                        double memoryUsage,
                                        int currentReplicas) {
        // 基于CPU计算
        double cpuRatio = cpuUsage / CPU_THRESHOLD;

        // 基于内存计算
        double memoryRatio = memoryUsage / MEMORY_THRESHOLD;

        // 取较大值，额外加10%缓冲
        double ratio = Math.max(cpuRatio, memoryRatio);
        int target = (int) Math.ceil(currentReplicas * ratio * 1.1);

        return target;
    }
}