#阿里架构

// 淘宝早期数据分片策略（示意）
public class OrderShardingStrategy {

    // 按用户 ID 哈希分片：userId % 分片数
    public int getShardIndex(Long userId, int shardCount) {
        return (int) (userId % shardCount);
    }

    // 路由到具体的数据库连接
    public DataSource getDataSource(Long userId) {
        int shardIndex = getShardIndex(userId, shardCount);
        return dataSources[shardIndex];
    }

    // 查询订单
    public List<Order> findOrdersByUser(Long userId, int offset, int limit) {
        DataSource ds = getDataSource(userId);
        try (Connection conn = ds.getConnection()) {
            // 分片内分页查询
            String sql = "SELECT * FROM orders WHERE user_id = ? LIMIT ? OFFSET ?";
            return query(conn, sql, userId, limit, offset);
        }
    }
}

// 支付宝担保交易核心流程
public class EscrowPaymentService {

    // 1. 买家付款：资金进入支付宝托管账户
    public PaymentResult buyerPay(Long orderId, BigDecimal amount) {
        Order order = orderService.findById(orderId);

        // 创建托管交易
        EscrowTransaction tx = new EscrowTransaction();
        tx.setOrderId(orderId);
        tx.setBuyerId(order.getBuyerId());
        tx.setSellerId(order.getSellerId());
        tx.setAmount(amount);
        tx.setStatus(TransactionStatus.IN_ESCROW); // 资金在托管中
        tx.setCreatedAt(now());
        escrowRepo.save(tx);

        // 冻结买家账户相应金额
        accountService.freeze(order.getBuyerId(), amount);

        return PaymentResult.success(tx.getId());
    }

    // 2. 买家确认收货：资金解冻给卖家
    public SettlementResult confirmReceipt(Long orderId) {
        Order order = orderService.findById(orderId);

        // 验证：只有买家才能确认收货
        if (!currentUserId().equals(order.getBuyerId())) {
            throw new UnauthorizedException();
        }

        EscrowTransaction tx = escrowRepo.findByOrderId(orderId);

        // 解冻买家资金，并转入卖家账户
        accountService.unfreeze(tx.getBuyerId(), tx.getAmount());
        accountService.credit(tx.getSellerId(), tx.getAmount());

        tx.setStatus(TransactionStatus.RELEASED);
        escrowRepo.save(tx);

        // 更新订单状态
        orderService.updateStatus(orderId, OrderStatus.COMPLETED);

        return SettlementResult.success();
    }

    // 3. 退款：资金退回买家
    public RefundResult refund(Long orderId, BigDecimal amount, String reason) {
        EscrowTransaction tx = escrowRepo.findByOrderId(orderId);

        // 从卖家账户扣款，退回买家
        accountService.debit(tx.getSellerId(), amount);
        accountService.unfreezeAndCredit(tx.getBuyerId(), amount);

        tx.setStatus(TransactionStatus.REFUNDED);
        tx.setRefundAmount(amount);
        tx.setRefundReason(reason);
        escrowRepo.save(tx);

        return RefundResult.success();
    }
}

// Dubbo 服务提供者
@Service(version = "1.0.0")
public class OrderServiceImpl implements OrderService {

    @Autowired private OrderRepository orderRepository;

    @Override
    public Order createOrder(Long userId, List<Long> productIds) {
        Order order = new Order();
        order.setUserId(userId);
        order.setStatus(OrderStatus.CREATED);
        order.setCreatedAt(new Date());
        order = orderRepository.save(order);

        // 扣减库存（同步调用库存服务）
        inventoryService.deductStock(productIds);

        // 发送订单创建事件（异步）
        orderEventPublisher.publishCreated(order.getId());

        return order;
    }
}

// Dubbo 服务消费者
@RestController
@RequestMapping("/api/orders")
public class OrderController {

    @Reference(version = "1.0.0", loadbalance = "roundrobin")
    private OrderService orderService;

    @Reference(version = "1.0.0", timeout = 3000, retries = 2)
    private StockService stockService;

    @PostMapping
    public Response createOrder(@RequestBody OrderRequest request) {
        // Dubbo 会自动从注册中心获取可用实例，负载均衡分发
        Order order = orderService.createOrder(
            request.getUserId(),
            request.getProductIds()
        );
        return Response.success(order);
    }
}

// RocketMQ 事务消息：保证订单服务和库存服务的一致性
@Service
public class OrderService {

    @Autowired private RocketMQTemplate rocketMQTemplate;
    @Autowired private OrderRepository orderRepository;

    public void createOrder(Long userId, List<Long> productIds) {
        // 1. 发送半消息（此时消费者看不到这条消息）
        // TransactionProducer 负责管理事务状态
        rocketMQTemplate.sendMessageInTransaction(
            "order-topic:create",
            MessageBuilder.withPayload(
                new OrderMessage(userId, productIds))
                .setHeader("orderId", UUID.randomUUID().toString())
                .build(),
            // TransactionListener：本地事务 + 事务状态回查
            (msg, arg) -> {
                try {
                    // 执行本地事务：创建订单记录
                    Order order = new Order();
                    order.setUserId(userId);
                    order.setStatus(OrderStatus.PENDING);
                    orderRepository.save(order);

                    // 扣减库存（同步调用）
                    boolean deducted = stockService.deduct(productIds);
                    if (!deducted) {
                        throw new StockException("库存不足");
                    }

                    // 本地事务成功，提交半消息，消费者可以消费
                    return LocalTransactionState.COMMIT_MESSAGE;

                } catch (Exception e) {
                    // 本地事务失败，回滚半消息
                    return LocalTransactionState.ROLLBACK_MESSAGE;
                }
            },
            null
        );
    }
}

// 延迟消息：订单超时未支付自动取消
@Service
public class OrderCancelScheduler {

    @Autowired private OrderRepository orderRepository;
    @Autowired private RocketMQTemplate rocketMQTemplate;

    public void scheduleOrderTimeoutCheck(Long orderId) {
        // 订单创建后 15 分钟，检查是否已支付
        // 延迟消息：15 分钟后才投递到消费者
        rocketMQTemplate.asyncSend("order-topic:timeout-check",
            new OrderTimeoutMessage(orderId),
            new SendCallback() {
                @Override
                public void onSuccess(SendResult result) {
                    // 发送成功，定时器会在 15 分钟后触发
                }

                @Override
                public void onException(Throwable e) {
                    // 发送失败，记录日志，人工介入
                    log.error("Failed to schedule timeout check for order {}",
                        orderId, e);
                }
            });
    }
}

// Sentinel 限流规则配置
@Configuration
public class SentinelConfig {

    @PostConstruct
    public void initRules() {
        // 流量控制规则
        List<FlowRule> flowRules = new ArrayList<>();

        FlowRule orderRule = new FlowRule();
        orderRule.setResource("order/create");
        orderRule.setGrade(RuleConstant.FLOW_GRADE_QPS); // 按 QPS 限流
        orderRule.setCount(10000); // 10000 QPS
        orderRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        flowRules.add(orderRule);

        FlowRuleManager.loadRules(flowRules);

        // 熔断规则
        List<DegradeRule> degradeRules = new ArrayList<>();

        DegradeRule degradeRule = new DegradeRule();
        degradeRule.setResource("payment/charge");
        degradeRule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT);
        degradeRule.setCount(5);    // 5 次异常触发熔断
        degradeRule.setTimeWindow(10); // 熔断持续 10 秒
        degradeRule.setMinRequestAmount(10); // 至少 10 次请求才计算异常率
        degradeRules.add(degradeRule);

        DegradeRuleManager.loadRules(degradeRules);
    }
}

// 使用注解声明资源
@RestController
@RequestMapping("/order")
public class OrderController {

    @SentinelResource(value = "order/create",
        blockHandler = "createBlockHandler",
        fallback = "createFallback")
    public Response createOrder(@RequestBody OrderRequest request) {
        return orderService.create(request);
    }

    // 限流处理：超过 QPS 上限时执行
    public Response createBlockHandler(OrderRequest request,
                                       BlockException ex) {
        log.warn("Order create rate limited: {}", ex.getClass().getSimpleName());
        return Response.error("系统繁忙，请稍后再试");
    }

    // 降级处理：服务异常时执行
    public Response createFallback(OrderRequest request, Throwable ex) {
        log.error("Order create failed", ex);
        return Response.error("服务暂时不可用");
    }
}