// CAP理论在多机房场景
// 1. 强一致性（CP）：保证数据一致性，可能牺牲可用性
// 2. 最终一致性（AP）：保证可用性，最终达到一致性
// 3. 分区容错性（P）：必须保证，因为网络分区不可避免

public class CAPTheory {
    
    // CP模式：强一致性
    public class StrongConsistency {
        // 写入时同步到所有机房
        // 读取时从主机房读取
        // 网络分区时可能拒绝服务
    }
    
    // AP模式：最终一致性
    public class EventualConsistency {
        // 写入时异步同步到其他机房
        // 读取时可以从任意机房读取
        // 网络分区时仍可提供服务
    }
}

import java.util.concurrent.CompletableFuture;
import java.util.List;

// 强一致性写入
public class StrongConsistencyWriter {
    
    private List<DataCenter> dataCenters;
    
    public boolean write(String key, String value) {
        // 1. 同步写入所有机房
        List<CompletableFuture<Boolean>> futures = new ArrayList<>();
        
        for (DataCenter dc : dataCenters) {
            CompletableFuture<Boolean> future = CompletableFuture.supplyAsync(() -> {
                return dc.write(key, value);
            });
            futures.add(future);
        }
        
        // 2. 等待所有机房写入成功
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
        
        // 3. 检查所有写入是否成功
        for (CompletableFuture<Boolean> future : futures) {
            if (!future.join()) {
                // 写入失败，需要回滚
                rollback(key);
                return false;
            }
        }
        
        return true;
    }
    
    private void rollback(String key) {
        // 回滚所有已写入的数据
        for (DataCenter dc : dataCenters) {
            dc.delete(key);
        }
    }
}

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

// 最终一致性写入
public class EventualConsistencyWriter {
    
    private DataCenter primaryDC;
    private List<DataCenter> replicaDCs;
    private BlockingQueue<WriteTask> writeQueue;
    
    public EventualConsistencyWriter() {
        this.writeQueue = new LinkedBlockingQueue<>();
        // 启动异步同步线程
        startSyncThread();
    }
    
    public boolean write(String key, String value) {
        // 1. 立即写入主机房
        boolean success = primaryDC.write(key, value);
        
        if (success) {
            // 2. 异步同步到其他机房
            WriteTask task = new WriteTask(key, value);
            writeQueue.offer(task);
        }
        
        return success;
    }
    
    private void startSyncThread() {
        new Thread(() -> {
            while (true) {
                try {
                    WriteTask task = writeQueue.take();
                    // 异步同步到所有副本机房
                    for (DataCenter dc : replicaDCs) {
                        syncToDataCenter(dc, task);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }).start();
    }
    
    private void syncToDataCenter(DataCenter dc, WriteTask task) {
        // 重试机制
        int maxRetries = 3;
        for (int i = 0; i < maxRetries; i++) {
            try {
                dc.write(task.getKey(), task.getValue());
                break;
            } catch (Exception e) {
                if (i == maxRetries - 1) {
                    // 记录失败，后续补偿
                    recordFailedSync(dc, task);
                }
            }
        }
    }
}

// 跨机房延迟影响
// 1. 同步调用延迟：每次调用增加10-100ms
// 2. 数据同步延迟：数据同步需要时间
// 3. 事务处理延迟：分布式事务需要多次网络往返

public class NetworkLatencyAnalysis {
    
    // 同步调用延迟
    public class SyncCallLatency {
        // 本地调用：< 1ms
        // 同机房调用：1-5ms
        // 跨机房调用：10-100ms
        
        public void localCall() {
            // 本地调用，延迟 < 1ms
        }
        
        public void sameDCCall() {
            // 同机房调用，延迟 1-5ms
        }
        
        public void crossDCCall() {
            // 跨机房调用，延迟 10-100ms
            // 对性能影响显著
        }
    }
    
    // 异步调用优化
    public class AsyncCallOptimization {
        public CompletableFuture<String> asyncCall(String data) {
            // 异步调用，不阻塞主流程
            return CompletableFuture.supplyAsync(() -> {
                return remoteService.process(data);
            });
        }
    }
}

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

// 网络分区检测和处理
public class NetworkPartitionHandler {
    
    private AtomicBoolean partitionDetected = new AtomicBoolean(false);
    private long lastHeartbeatTime;
    private long partitionTimeout = 5000; // 5秒超时
    
    public void detectPartition() {
        // 定期检测网络分区
        new Thread(() -> {
            while (true) {
                try {
                    long currentTime = System.currentTimeMillis();
                    if (currentTime - lastHeartbeatTime > partitionTimeout) {
                        partitionDetected.set(true);
                        handlePartition();
                    } else {
                        partitionDetected.set(false);
                    }
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }).start();
    }
    
    private void handlePartition() {
        // 网络分区处理策略
        // 1. 切换到本地模式
        // 2. 停止跨机房同步
        // 3. 记录分区日志
        // 4. 等待网络恢复
        
        System.out.println("Network partition detected, switching to local mode");
        // 实现分区处理逻辑
    }
    
    public void updateHeartbeat() {
        this.lastHeartbeatTime = System.currentTimeMillis();
    }
    
    public boolean isPartitioned() {
        return partitionDetected.get();
    }
}

// 数据同步方式
// 1. 主从同步：主机房写入，从机房同步
// 2. 多主同步：多个机房都可以写入
// 3. 异步同步：异步同步数据，提高性能

public class DataSyncStrategy {
    
    // 主从同步
    public class MasterSlaveSync {
        private DataCenter master;
        private List<DataCenter> slaves;
        
        public boolean write(String key, String value) {
            // 1. 写入主机房
            boolean success = master.write(key, value);
            
            if (success) {
                // 2. 异步同步到从机房
                syncToSlaves(key, value);
            }
            
            return success;
        }
        
        private void syncToSlaves(String key, String value) {
            for (DataCenter slave : slaves) {
                slave.asyncWrite(key, value);
            }
        }
    }
    
    // 多主同步
    public class MultiMasterSync {
        private List<DataCenter> masters;
        private ConflictResolver conflictResolver;
        
        public boolean write(String key, String value, String dcId) {
            // 1. 写入本地机房
            DataCenter localDC = getDataCenter(dcId);
            boolean success = localDC.write(key, value);
            
            if (success) {
                // 2. 同步到其他主机房
                syncToOtherMasters(key, value, dcId);
            }
            
            return success;
        }
        
        private void syncToOtherMasters(String key, String value, String sourceDCId) {
            for (DataCenter dc : masters) {
                if (!dc.getId().equals(sourceDCId)) {
                    // 检查冲突
                    String existingValue = dc.read(key);
                    if (existingValue != null && !existingValue.equals(value)) {
                        // 解决冲突
                        String resolvedValue = conflictResolver.resolve(
                            key, existingValue, value, sourceDCId, dc.getId()
                        );
                        dc.write(key, resolvedValue);
                    } else {
                        dc.write(key, value);
                    }
                }
            }
        }
    }
}

import java.util.Comparator;

// 冲突解决策略
public class ConflictResolver {
    
    // 时间戳优先
    public String resolveByTimestamp(String key, String value1, long timestamp1,
                                     String value2, long timestamp2) {
        return timestamp1 > timestamp2 ? value1 : value2;
    }
    
    // 最后写入优先（LWW - Last Write Wins）
    public String resolveByLastWrite(String key, String value1, String dcId1,
                                     String value2, String dcId2) {
        // 比较机房优先级
        int priority1 = getDataCenterPriority(dcId1);
        int priority2 = getDataCenterPriority(dcId2);
        
        return priority1 > priority2 ? value1 : value2;
    }
    
    // 业务规则解决
    public String resolveByBusinessRule(String key, String value1, String value2) {
        // 根据业务规则解决冲突
        // 例如：订单状态冲突，选择更高级的状态
        return businessRule.resolve(key, value1, value2);
    }
    
    // 合并策略
    public String resolveByMerge(String key, String value1, String value2) {
        // 合并两个值
        // 例如：集合类型数据可以合并
        return mergeStrategy.merge(key, value1, value2);
    }
    
    private int getDataCenterPriority(String dcId) {
        // 返回机房优先级
        return 0;
    }
}

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

// 故障检测
public class FailureDetector {
    
    private ScheduledExecutorService scheduler;
    private long heartbeatInterval = 1000; // 1秒
    private long failureTimeout = 5000; // 5秒超时
    private Map<String, Long> lastHeartbeatTimes;
    private Map<String, Boolean> failureStatus;
    
    public FailureDetector() {
        this.scheduler = Executors.newScheduledThreadPool(1);
        this.lastHeartbeatTimes = new ConcurrentHashMap<>();
        this.failureStatus = new ConcurrentHashMap<>();
        startDetection();
    }
    
    private void startDetection() {
        scheduler.scheduleAtFixedRate(() -> {
            long currentTime = System.currentTimeMillis();
            
            for (Map.Entry<String, Long> entry : lastHeartbeatTimes.entrySet()) {
                String dcId = entry.getKey();
                long lastTime = entry.getValue();
                
                if (currentTime - lastTime > failureTimeout) {
                    // 检测到故障
                    if (!failureStatus.getOrDefault(dcId, false)) {
                        handleFailure(dcId);
                        failureStatus.put(dcId, true);
                    }
                } else {
                    // 恢复
                    if (failureStatus.getOrDefault(dcId, false)) {
                        handleRecovery(dcId);
                        failureStatus.put(dcId, false);
                    }
                }
            }
        }, 0, heartbeatInterval, TimeUnit.MILLISECONDS);
    }
    
    public void updateHeartbeat(String dcId) {
        lastHeartbeatTimes.put(dcId, System.currentTimeMillis());
    }
    
    private void handleFailure(String dcId) {
        System.out.println("DataCenter failure detected: " + dcId);
        // 1. 触发故障切换
        // 2. 停止向故障机房写入
        // 3. 切换到备用机房
        triggerFailover(dcId);
    }
    
    private void handleRecovery(String dcId) {
        System.out.println("DataCenter recovered: " + dcId);
        // 1. 数据同步
        // 2. 逐步恢复流量
        // 3. 恢复正常服务
        triggerRecovery(dcId);
    }
    
    private void triggerFailover(String dcId) {
        // 实现故障切换逻辑
    }
    
    private void triggerRecovery(String dcId) {
        // 实现恢复逻辑
    }
}

// 故障切换
public class FailoverManager {
    
    private DataCenter primaryDC;
    private List<DataCenter> standbyDCs;
    private DataCenter currentActiveDC;
    
    public FailoverManager(DataCenter primaryDC, List<DataCenter> standbyDCs) {
        this.primaryDC = primaryDC;
        this.standbyDCs = standbyDCs;
        this.currentActiveDC = primaryDC;
    }
    
    public void failover(String failedDCId) {
        // 1. 选择新的主机房
        DataCenter newPrimary = selectNewPrimary(failedDCId);
        
        // 2. 切换流量
        switchTraffic(newPrimary);
        
        // 3. 数据同步
        syncData(newPrimary);
        
        // 4. 更新配置
        updateConfiguration(newPrimary);
        
        this.currentActiveDC = newPrimary;
    }
    
    private DataCenter selectNewPrimary(String failedDCId) {
        // 选择策略：
        // 1. 优先级最高
        // 2. 延迟最低
        // 3. 负载最低
        
        return standbyDCs.stream()
            .filter(dc -> !dc.getId().equals(failedDCId))
            .min(Comparator.comparing(this::calculatePriority))
            .orElseThrow(() -> new RuntimeException("No available datacenter"));
    }
    
    private double calculatePriority(DataCenter dc) {
        // 计算优先级
        // 考虑：延迟、负载、健康状态
        return dc.getLatency() * 0.4 + dc.getLoad() * 0.3 + (dc.isHealthy() ? 0 : 100) * 0.3;
    }
    
    private void switchTraffic(DataCenter newPrimary) {
        // 切换流量到新主机房
        // 1. 更新DNS
        // 2. 更新负载均衡配置
        // 3. 通知所有服务
    }
    
    private void syncData(DataCenter newPrimary) {
        // 同步数据到新主机房
        // 1. 检查数据一致性
        // 2. 同步缺失数据
        // 3. 验证数据完整性
    }
}

import java.util.List;
import java.util.Random;

// 跨机房负载均衡
public class CrossDCLoadBalancer {
    
    private List<DataCenter> dataCenters;
    private LoadBalanceStrategy strategy;
    
    public DataCenter selectDataCenter(String clientLocation) {
        switch (strategy) {
            case GEOGRAPHIC:
                return selectByGeographic(clientLocation);
            case LATENCY:
                return selectByLatency(clientLocation);
            case LOAD:
                return selectByLoad();
            case ROUND_ROBIN:
                return selectByRoundRobin();
            default:
                return selectByGeographic(clientLocation);
        }
    }
    
    // 地理位置优先
    private DataCenter selectByGeographic(String clientLocation) {
        return dataCenters.stream()
            .min(Comparator.comparing(dc -> 
                calculateDistance(clientLocation, dc.getLocation())))
            .orElse(dataCenters.get(0));
    }
    
    // 延迟优先
    private DataCenter selectByLatency(String clientLocation) {
        return dataCenters.stream()
            .min(Comparator.comparing(dc -> 
                measureLatency(clientLocation, dc.getId())))
            .orElse(dataCenters.get(0));
    }
    
    // 负载优先
    private DataCenter selectByLoad() {
        return dataCenters.stream()
            .min(Comparator.comparing(DataCenter::getLoad))
            .orElse(dataCenters.get(0));
    }
    
    // 轮询
    private int roundRobinIndex = 0;
    private DataCenter selectByRoundRobin() {
        DataCenter dc = dataCenters.get(roundRobinIndex);
        roundRobinIndex = (roundRobinIndex + 1) % dataCenters.size();
        return dc;
    }
    
    private double calculateDistance(String location1, String location2) {
        // 计算地理位置距离
        return 0;
    }
    
    private long measureLatency(String clientLocation, String dcId) {
        // 测量延迟
        return 0;
    }
}

enum LoadBalanceStrategy {
    GEOGRAPHIC,  // 地理位置
    LATENCY,     // 延迟
    LOAD,        // 负载
    ROUND_ROBIN  // 轮询
}

// 智能流量分配
public class IntelligentTrafficDistribution {
    
    private Map<String, Double> trafficWeights;
    private List<DataCenter> dataCenters;
    
    public DataCenter selectDataCenter() {
        // 根据权重分配流量
        double random = Math.random();
        double cumulativeWeight = 0.0;
        
        for (DataCenter dc : dataCenters) {
            cumulativeWeight += trafficWeights.get(dc.getId());
            if (random <= cumulativeWeight) {
                return dc;
            }
        }
        
        return dataCenters.get(0);
    }
    
    public void adjustWeights() {
        // 动态调整权重
        // 1. 根据机房负载
        // 2. 根据机房健康状态
        // 3. 根据业务需求
        
        for (DataCenter dc : dataCenters) {
            double load = dc.getLoad();
            boolean healthy = dc.isHealthy();
            
            double weight = trafficWeights.get(dc.getId());
            
            if (!healthy) {
                weight = 0; // 故障机房权重为0
            } else if (load > 0.8) {
                weight *= 0.5; // 高负载降低权重
            } else if (load < 0.5) {
                weight *= 1.2; // 低负载增加权重
            }
            
            trafficWeights.put(dc.getId(), Math.max(0, Math.min(1, weight)));
        }
        
        // 归一化权重
        normalizeWeights();
    }
    
    private void normalizeWeights() {
        double sum = trafficWeights.values().stream().mapToDouble(Double::doubleValue).sum();
        if (sum > 0) {
            trafficWeights.replaceAll((k, v) -> v / sum);
        }
    }
}

import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

// 多机房监控
public class MultiDCMonitor {
    
    private ScheduledExecutorService scheduler;
    private List<DataCenter> dataCenters;
    private MetricsCollector metricsCollector;
    private AlertManager alertManager;
    
    public MultiDCMonitor(List<DataCenter> dataCenters) {
        this.scheduler = Executors.newScheduledThreadPool(1);
        this.dataCenters = dataCenters;
        this.metricsCollector = new MetricsCollector();
        this.alertManager = new AlertManager();
        startMonitoring();
    }
    
    private void startMonitoring() {
        scheduler.scheduleAtFixedRate(() -> {
            for (DataCenter dc : dataCenters) {
                // 1. 收集指标
                Metrics metrics = metricsCollector.collect(dc);
                
                // 2. 检查告警
                checkAlerts(dc, metrics);
                
                // 3. 记录日志
                logMetrics(dc, metrics);
            }
        }, 0, 10, TimeUnit.SECONDS);
    }
    
    private void checkAlerts(DataCenter dc, Metrics metrics) {
        // CPU使用率告警
        if (metrics.getCpuUsage() > 80) {
            alertManager.sendAlert(dc.getId(), "CPU_USAGE_HIGH", 
                "CPU usage: " + metrics.getCpuUsage() + "%");
        }
        
        // 内存使用率告警
        if (metrics.getMemoryUsage() > 85) {
            alertManager.sendAlert(dc.getId(), "MEMORY_USAGE_HIGH", 
                "Memory usage: " + metrics.getMemoryUsage() + "%");
        }
        
        // 延迟告警
        if (metrics.getLatency() > 100) {
            alertManager.sendAlert(dc.getId(), "LATENCY_HIGH", 
                "Latency: " + metrics.getLatency() + "ms");
        }
        
        // 错误率告警
        if (metrics.getErrorRate() > 0.01) {
            alertManager.sendAlert(dc.getId(), "ERROR_RATE_HIGH", 
                "Error rate: " + metrics.getErrorRate());
        }
    }
    
    private void logMetrics(DataCenter dc, Metrics metrics) {
        // 记录监控指标
        System.out.println(String.format(
            "DC: %s, CPU: %.2f%%, Memory: %.2f%%, Latency: %dms, ErrorRate: %.4f",
            dc.getId(), metrics.getCpuUsage(), metrics.getMemoryUsage(),
            metrics.getLatency(), metrics.getErrorRate()
        ));
    }
}

// 监控指标
class Metrics {
    private double cpuUsage;
    private double memoryUsage;
    private long latency;
    private double errorRate;
    
    // Getters and setters
    public double getCpuUsage() { return cpuUsage; }
    public void setCpuUsage(double cpuUsage) { this.cpuUsage = cpuUsage; }
    public double getMemoryUsage() { return memoryUsage; }
    public void setMemoryUsage(double memoryUsage) { this.memoryUsage = memoryUsage; }
    public long getLatency() { return latency; }
    public void setLatency(long latency) { this.latency = latency; }
    public double getErrorRate() { return errorRate; }
    public void setErrorRate(double errorRate) { this.errorRate = errorRate; }
}

// 统一运维管理
public class UnifiedOpsManager {
    
    private List<DataCenter> dataCenters;
    private ConfigManager configManager;
    private DeploymentManager deploymentManager;
    
    public void deployToAllDCs(String version) {
        // 1. 灰度发布
        DataCenter canaryDC = selectCanaryDC();
        deployToDC(canaryDC, version);
        
        // 2. 验证
        if (validateDeployment(canaryDC, version)) {
            // 3. 全量发布
            for (DataCenter dc : dataCenters) {
                if (!dc.getId().equals(canaryDC.getId())) {
                    deployToDC(dc, version);
                }
            }
        } else {
            // 回滚
            rollback(canaryDC);
        }
    }
    
    public void updateConfig(String configKey, String configValue) {
        // 1. 更新配置
        configManager.update(configKey, configValue);
        
        // 2. 推送到所有机房
        for (DataCenter dc : dataCenters) {
            pushConfig(dc, configKey, configValue);
        }
        
        // 3. 验证配置生效
        validateConfig();
    }
    
    public void rollback(String dcId, String version) {
        // 回滚到指定版本
        DataCenter dc = getDataCenter(dcId);
        deploymentManager.rollback(dc, version);
    }
    
    private DataCenter selectCanaryDC() {
        // 选择灰度机房
        return dataCenters.get(0);
    }
    
    private boolean validateDeployment(DataCenter dc, String version) {
        // 验证部署是否成功
        return true;
    }
    
    private void deployToDC(DataCenter dc, String version) {
        // 部署到指定机房
        deploymentManager.deploy(dc, version);
    }
}

// 多机房架构设计
public class MultiDCArchitecture {
    
    // 1. 数据层：主从复制
    public class DataLayer {
        private DataCenter masterDC;
        private List<DataCenter> slaveDCs;
        
        public void write(String key, String value) {
            // 写入主机房
            masterDC.write(key, value);
            // 异步同步到从机房
            syncToSlaves(key, value);
        }
        
        public String read(String key) {
            // 优先从本地机房读取
            DataCenter localDC = getLocalDC();
            return localDC.read(key);
        }
    }
    
    // 2. 服务层：多活部署
    public class ServiceLayer {
        private List<DataCenter> activeDCs;
        private LoadBalancer loadBalancer;
        
        public Response processRequest(Request request) {
            // 选择机房
            DataCenter dc = loadBalancer.select(request);
            // 处理请求
            return dc.process(request);
        }
    }
    
    // 3. 接入层：智能路由
    public class AccessLayer {
        private DNSManager dnsManager;
        private TrafficRouter trafficRouter;
        
        public DataCenter route(String clientIP) {
            // 根据客户端IP选择最优机房
            return trafficRouter.route(clientIP);
        }
    }
}

// 多机房/多活关键难点总结
public class KeyChallenges {
    
    // 1. 数据一致性难点
    // 难点：多机房数据一致性问题
    // 解决方案：
    // - 强一致性：同步写入所有机房（性能低）
    // - 最终一致性：异步同步（性能高，有延迟）
    // - 根据业务场景选择合适的一致性级别
    
    // 2. 网络延迟难点
    // 难点：跨机房网络延迟10-100ms
    // 解决方案：
    // - 异步调用减少延迟影响
    // - 本地优先策略
    // - 缓存减少跨机房调用
    
    // 3. 数据同步难点
    // 难点：数据实时同步和冲突解决
    // 解决方案：
    // - 主从同步：简单但单点故障
    // - 多主同步：复杂但高可用
    // - 冲突解决：时间戳、业务规则、合并策略
    
    // 4. 故障切换难点
    // 难点：自动故障检测和切换
    // 解决方案：
    // - 心跳检测机制
    // - 自动故障切换
    // - 数据同步和验证
    
    // 5. 负载均衡难点
    // 难点：跨机房流量调度
    // 解决方案：
    // - 地理位置优先
    // - 延迟优先
    // - 负载优先
    // - 智能权重分配
    
    // 6. 监控运维难点
    // 难点：多机房监控和运维管理
    // 解决方案：
    // - 统一监控平台
    // - 自动化运维
    // - 灰度发布
    // - 快速回滚
}