/**
 * CAP不可能性的逻辑证明
 * 假设：网络分区P必然发生（分布式系统的基本假设）
 * 推导：当P发生时，我们必须在C和A之间做出选择
 */
public class CAPImpossibilityProof {
    
    public void capTradeoff(boolean networkPartition) {
        if (networkPartition) {
            // 场景：网络分区发生，节点A和节点B无法通信
            
            // 选择1：保持一致性(C)
            // 节点A需要写入数据，但必须同步到节点B
            // 由于网络分区，同步失败 → 节点A拒绝写入 → 牺牲可用性(A)
            
            // 选择2：保持可用性(A)  
            // 节点A接受写入，但无法同步到节点B
            // 节点B可能提供旧数据 → 牺牲一致性(C)
            
            // 结论：P发生时，C和A不可兼得
        }
    }
}

public class ConsistencyLevels {
    // 1. 强一致性（线性一致性）
    public void strongConsistency() {
        // 任何读取都返回最新写入的值
        // 实现代价：性能低，延迟高
        // 应用场景：银行转账、库存扣减
    }
    
    // 2. 顺序一致性
    public void sequentialConsistency() {
        // 所有操作都有全局顺序，但读取可能不是最新
        // 实现代价：中等
        // 应用场景：消息队列、事件溯源
    }
    
    // 3. 最终一致性
    public void eventualConsistency() {
        // 给定足够时间，所有副本最终一致
        // 实现代价：低，高性能
        // 应用场景：社交网络、内容分发
    }
    
    // 4. 读写一致性
    public void readYourWritesConsistency() {
        // 用户总能读到自己的写入
        // 但可能读不到其他人的最新写入
        // 应用场景：用户会话、个人配置
    }
}

public class AvailabilityMetrics {
    // 可用性计算公式：可用时间 / (可用时间 + 不可用时间)
    
    public void calculateAvailability() {
        // 业界标准：
        double twoNines = 0.99;     // 年停机时间：87.6小时
        double threeNines = 0.999;  // 年停机时间：8.76小时  
        double fourNines = 0.9999;  // 年停机时间：52.6分钟
        double fiveNines = 0.99999; // 年停机时间：5.26分钟
        
        // 分布式系统通常追求：三个9到四个9
    }
    
    // 影响可用性的因素
    public enum DowntimeCauses {
        NETWORK_PARTITION,    // 网络分区
        NODE_FAILURE,         // 节点故障
        SOFTWARE_UPGRADE,     // 软件升级
        DATABASE_MAINTENANCE, // 数据库维护
        LOAD_SPIKES           // 流量峰值
    }
}

public class NetworkPartitionReality {
    
    public void realWorldPartitions() {
        // 云环境中的网络分区统计（基于AWS/Azure实际数据）
        Map<String, Double> partitionProbability = new HashMap<>();
        partitionProbability.put("同一可用区", 0.001);    // 0.1%概率
        partitionProbability.put("同一区域不同可用区", 0.01); // 1%概率  
        partitionProbability.put("跨区域", 0.05);        // 5%概率
        
        // 结论：必须设计为分区容错，因为分区必然发生
    }
    
    // 分区检测机制
    public boolean detectPartition(Node currentNode, List<Node> clusterNodes) {
        int responsiveNodes = 0;
        for (Node node : clusterNodes) {
            if (currentNode.ping(node, 1000)) { // 1秒超时
                responsiveNodes++;
            }
        }
        
        // 如果无法与多数节点通信，则认为发生分区
        return responsiveNodes < clusterNodes.size() / 2;
    }
}

// ZooKeeper客户端使用示例
public class ZooKeeperCPExample {
    private ZooKeeper zk;
    
    public void demonstrateCP() throws Exception {
        // 1. 创建临时顺序节点（用于分布式锁）
        String lockPath = zk.create("/locks/resource-", 
                                   null,
                                   ZooDefs.Ids.OPEN_ACL_UNSAFE,
                                   CreateMode.EPHEMERAL_SEQUENTIAL);
        
        // 2. 网络分区发生时的行为
        simulateNetworkPartition(() -> {
            try {
                // CP特性：分区期间可能拒绝服务，但保证数据一致
                String data = new String(zk.getData("/config/key", false, null));
                System.out.println("读取数据: " + data);
            } catch (KeeperException.ConnectionLossException e) {
                // 网络分区时抛出异常，牺牲可用性
                System.out.println("网络分区，服务暂时不可用");
            }
        });
    }
    
    // ZooKeeper的写一致性保证
    public void writeWithConsistency(String path, String data) throws Exception {
        // Zab协议保证：写操作需要多数派确认
        Stat stat = zk.setData(path, data.getBytes(), -1);
        
        // 只有超过半数的ZooKeeper节点确认，写操作才成功
        // 这保证了强一致性，但在网络分区时可能失败
    }
}

// Eureka服务注册发现示例
@Configuration
@EnableEurekaServer
public class EurekaAPExample {
    
    // Eureka服务器配置
    @Bean
    public EurekaServerConfig eurekaServerConfig() {
        return new DefaultEurekaServerConfig() {
            @Override
            public boolean shouldEnableSelfPreservation() {
                // AP特性：开启自我保护模式
                // 网络分区时，即使节点失联也不立即注销
                return true;
            }
        };
    }
    
    // Eureka客户端配置
    @Bean
    @Profile("client")
    public EurekaClientConfig eurekaClientConfig() {
        return new DefaultEurekaClientConfig() {
            @Override
            public boolean shouldRegisterWithEureka() {
                return true;
            }
            
            @Override
            public boolean shouldDisableDelta() {
                // AP特性：允许使用增量信息，可能数据不一致但可用
                return false;
            }
        };
    }
}
// 服务消费者示例
@Service
public class ServiceConsumer {
    @Autowired
    private DiscoveryClient discoveryClient;
    
    @HystrixCommand(fallbackMethod = "fallbackService")
    public String callService(String serviceName) {
        // AP特性：可能获得不是最新的服务实例列表
        List<ServiceInstance> instances = discoveryClient.getInstances(serviceName);
        
        if (instances.isEmpty()) {
            // 但服务始终可用，可能返回缓存数据或降级结果
            throw new RuntimeException("无可用实例，但系统仍可响应");
        }
        
        // 负载均衡调用
        ServiceInstance instance = instances.get(0);
        return restTemplate.getForObject(instance.getUri() + "/api", String.class);
    }
    
    public String fallbackService(String serviceName) {
        // 可用性保证：即使目标服务不可用，也有降级方案
        return "降级数据：服务暂时不可用";
    }
}

// MySQL主从集群示例（追求CA特性）
public class MySQLCACluster {
    
    // 主库写操作
    public void writeToMaster(String data) {
        try (Connection conn = masterDataSource.getConnection()) {
            // 强一致性写操作
            PreparedStatement stmt = conn.prepareStatement("INSERT INTO table VALUES (?)");
            stmt.setString(1, data);
            stmt.executeUpdate();
            
            // 同步复制到从库（牺牲部分性能保证一致性）
            waitForSlaveSync();
        }
    }
    
    // 从库读操作
    public String readFromSlave(String key) {
        try (Connection conn = getSlaveConnection()) {
            // 可能读取到旧数据（取决于复制延迟）
            PreparedStatement stmt = conn.prepareStatement("SELECT data FROM table WHERE key = ?");
            stmt.setString(1, key);
            ResultSet rs = stmt.executeQuery();
            
            return rs.next() ? rs.getString("data") : null;
        }
    }
    
    private void waitForSlaveSync() {
        // 等待所有从库同步完成
        // 如果某个从库网络分区，写操作可能阻塞或失败
        // 这体现了CA系统对分区容错性的牺牲
    }
}

public class CAPDecisionFramework {
    
    public CAPChoice recommendCAP(BusinessContext context) {
        // 决策矩阵：根据业务特性选择CAP组合
        if (context.isFinancialTransaction()) {
            return CAPChoice.CP; // 金融交易：一致性优先
        } else if (context.isSocialMedia()) {
            return CAPChoice.AP; // 社交媒体：可用性优先  
        } else if (context.isInternalManagement()) {
            return CAPChoice.CA; // 内部管理：网络稳定环境
        }
        
        return CAPChoice.AP; // 默认选择AP，保证可用性
    }
    
    public enum CAPChoice {
        CP("一致性+分区容错", "ZooKeeper, etcd, HBase"),
        AP("可用性+分区容错", "Cassandra, DynamoDB, Eureka"), 
        CA("一致性+可用性", "MySQL集群, Oracle RAC");
        
        private final String description;
        private final String examples;
        
        CAPChoice(String description, String examples) {
            this.description = description;
            this.examples = examples;
        }
    }
}

// 微服务系统中混合使用CAP策略
@SpringBootApplication
public class MicroservicesCAPApplication {
    
    // 不同服务采用不同的CAP策略
    @Service
    public class OrderService {
        // CP策略：订单服务需要强一致性
        @Autowired
        private DistributedLock lock; // 使用ZooKeeper实现
        
        @Transactional 
        public void createOrder(Order order) {
            lock.lock();
            try {
                // 保证订单创建的原子性和一致性
                orderRepository.save(order);
                inventoryService.deductStock(order.getItems());
            } finally {
                lock.unlock();
            }
        }
    }
    
    @Service 
    public class ProductService {
        // AP策略：商品服务优先保证可用性
        @Cacheable(value = "products", unless = "#result == null")
        public Product getProduct(String productId) {
            // 即使数据库暂时不可用，也能返回缓存数据
            return productRepository.findById(productId)
                    .orElseGet(() -> getProductFromCache(productId));
        }
    }
    
    @Service
    public class RecommendationService {
        // 最终一致性：推荐服务可以接受数据延迟
        @Async
        public void updateUserPreferences(String userId, UserAction action) {
            // 异步处理，不阻塞主流程
            preferenceEngine.processAction(userId, action);
        }
    }
}

// 新一代系统对CAP的灵活处理
public class ModernCAPApproach {
    
    // 1. 动态CAP调整
    public void dynamicCAPAdjustment() {
        // 根据运行时条件动态调整CAP策略
        if (systemLoad < 0.7) {
            enableStrongConsistency(); // 低负载时用CP
        } else {
            enableEventualConsistency(); // 高负载时用AP
        }
    }
    
    // 2. 细粒度CAP控制
    public void granularCAPControl() {
        // 不同数据不同的一致性要求
        Map<DataType, ConsistencyLevel> consistencyMap = Map.of(
            DataType.USER_PROFILE, ConsistencyLevel.STRONG,      // 用户资料：强一致
            DataType.SOCIAL_FEED, ConsistencyLevel.EVENTUAL,     // 社交动态：最终一致
            DataType.CACHE_DATA, ConsistencyLevel.WEAK          // 缓存数据：弱一致
        );
    }
    
    // 3. CAP与BASE结合
    public void capWithBASE() {
        // 基本可用：核心功能保证可用，非核心功能可降级
        // 软状态：允许中间状态存在
        // 最终一致：通过异步机制达到最终一致
        
        // 这种结合在现代系统中越来越常见
    }
}