#唯一索引与乐观锁

// 捕获唯一键冲突 = 幂等
try {
    orderRepository.save(order);
    return "订单创建成功";
} catch (DuplicateKeyException e) {
    // 唯一键冲突，说明订单已存在，返回幂等成功
    return "订单已存在";
}

@Service
@Slf4j
public class IdempotenceService {

    @Autowired
    private IdempotenceRecordRepository repository;

    @Autowired
    private ObjectMapper objectMapper;

    /**
     * 尝试获取幂等锁
     * @return 如果返回空，说明已存在或获取失败；如果返回记录，说明可以处理
     */
    @Transactional
    public Optional<IdempotenceRecord> tryAcquireLock(String idempotenceKey, String businessType) {
        // 1. 查找是否已存在
        Optional<IdempotenceRecord> existing =
            repository.findByIdempotenceKeyAndBusinessType(idempotenceKey, businessType);

        if (existing.isPresent()) {
            IdempotenceRecord record = existing.get();
            // 正在处理中，不允许重复处理
            if (record.getStatus() == 0) {
                return Optional.empty();
            }
            // 已处理完成，返回记录供后续判断
            return existing;
        }

        // 2. 不存在，插入新记录（状态为处理中）
        IdempotenceRecord record = new IdempotenceRecord();
        record.setIdempotenceKey(idempotenceKey);
        record.setBusinessType(businessType);
        record.setStatus(0);  // 处理中
        record.setExpireAt(LocalDateTime.now().plusHours(24));  // 24 小时过期

        try {
            record = repository.save(record);
            return Optional.of(record);
        } catch (DataIntegrityViolationException e) {
            // 唯一键冲突，说明其他线程刚插入
            return repository.findByIdempotenceKeyAndBusinessType(idempotenceKey, businessType);
        }
    }

    /**
     * 标记处理成功
     */
    @Transactional
    public void markSuccess(String idempotenceKey, String businessType, Object result) {
        repository.findByIdempotenceKeyAndBusinessType(idempotenceKey, businessType)
            .ifPresent(record -> {
                record.setStatus(1);  // 成功
                try {
                    record.setResult(objectMapper.writeValueAsString(result));
                } catch (JsonProcessingException e) {
                    log.warn("序列化结果失败", e);
                }
                repository.save(record);
            });
    }

    /**
     * 标记处理失败
     */
    @Transactional
    public void markFailed(String idempotenceKey, String businessType, String errorMessage) {
        repository.findByIdempotenceKeyAndBusinessType(idempotenceKey, businessType)
            .ifPresent(record -> {
                record.setStatus(2);  // 失败
                record.setResult(errorMessage);
                record.setRetryCount(record.getRetryCount() + 1);
                repository.save(record);
            });
    }
}

@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private IdempotenceService idempotenceService;

    @Autowired
    private OrderRepository orderRepository;

    @Override
    public Order createOrder(String orderNo, OrderRequest request) {
        String idempotenceKey = "order:" + orderNo;

        // 1. 尝试获取幂等锁
        Optional<IdempotenceRecord> lockOpt =
            idempotenceService.tryAcquireLock(idempotenceKey, "CREATE_ORDER");

        if (lockOpt.isEmpty()) {
            // 没有获取到锁，说明正在处理或已处理
            IdempotenceRecord record =
                idempotenceService.getRecord(idempotenceKey, "CREATE_ORDER").orElseThrow();
            if (record.getStatus() == 0) {
                throw new OrderProcessingException("订单正在处理中");
            }
            // 已处理完成，返回之前的结果
            return JSON.parseObject(record.getResult(), Order.class);
        }

        // 2. 执行业务逻辑
        try {
            Order order = doCreateOrder(request);
            // 3. 标记成功
            idempotenceService.markSuccess(idempotenceKey, "CREATE_ORDER", order);
            return order;
        } catch (Exception e) {
            // 4. 标记失败（允许重试）
            idempotenceService.markFailed(idempotenceKey, "CREATE_ORDER", e.getMessage());
            throw e;
        }
    }
}

// 订单支付回调
public void handlePaymentCallback(String orderNo, BigDecimal paidAmount) {
    Order order = orderRepository.findByOrderNo(orderNo);
    // [!code warning]
    // 问题：两次回调同时到达，都会进入这里
    if (order.getStatus() == "PAID") {
        return;  // 已支付
    }
    order.setStatus("PAID");
    order.setPaidAmount(paidAmount);
    orderRepository.save(order);  // [!code warning]
    // 如果没有乐观锁，两次都会更新成功！
}

public PaymentResult handlePaymentCallback(String orderNo, BigDecimal paidAmount) {
    Order order = orderRepository.findByOrderNo(orderNo);

    // 幂等：已经是 PAID 状态，直接返回成功
    if ("PAID".equals(order.getStatus())) {
        return PaymentResult.success("订单已支付");
    }

    // 使用乐观锁更新
    int rows = orderRepository.updatePaymentStatus(
        orderNo,
        "PENDING",     // 期望状态
        "PAID",        // 目标状态
        paidAmount,
        order.getVersion()
    );

    if (rows == 0) {
        // 乐观锁冲突，说明并发修改了
        // 可能是：1. 其他线程刚支付成功  2. 状态已被其他操作修改
        throw new ConcurrentModificationException("订单状态已被修改");
    }

    return PaymentResult.success("支付成功");
}

// CAS 的语义
// compareAndSwap(object, expectedValue, newValue)
// 如果 object 的当前值等于 expectedValue，则将其设置为 newValue
// 返回是否成功

// Java 中的 CAS
AtomicInteger balance = new AtomicInteger(100);
boolean success = balance.compareAndSet(100, 90);  // 如果当前是 100，改为 90

// 好的做法：使用业务唯一键
String orderNo = request.getOrderNo();  // 业务生成的订单号
Order order = new Order();
order.setOrderNo(orderNo);  // 用订单号作为幂等键
orderRepository.save(order);

// Snowflake ID 生成
public class SnowflakeIdGenerator {
    private final Sequence sequence;

    public SnowflakeIdGenerator(DataSource dataSource) {
        this.sequence = new Sequence(dataSource);
    }

    public long nextId() {
        return sequence.nextId();
    }
}

// 使用
Order order = new Order();
order.setId(snowflakeIdGenerator.nextId());  // 全局唯一 ID
orderRepository.save(order);

@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {

    Optional<Order> findByOrderNo(String orderNo);

    @Modifying
    @Query("UPDATE Order o SET o.status = :targetStatus, " +
           "o.version = o.version + 1 " +
           "WHERE o.orderNo = :orderNo " +
           "AND o.status = :expectedStatus " +
           "AND o.version = :expectedVersion")
    int updateStatusWithVersion(
        @Param("orderNo") String orderNo,
        @Param("targetStatus") String targetStatus,
        @Param("expectedStatus") String expectedStatus,
        @Param("expectedVersion") Integer expectedVersion
    );

    @Modifying
    @Query("UPDATE Order o SET o.status = :targetStatus, " +
           "o.paidAmount = :paidAmount, " +
           "o.version = o.version + 1 " +
           "WHERE o.orderNo = :orderNo " +
           "AND o.status = 'PROCESSING' " +
           "AND o.version = :expectedVersion")
    int confirmPayment(
        @Param("orderNo") String orderNo,
        @Param("targetStatus") String targetStatus,
        @Param("paidAmount") BigDecimal paidAmount,
        @Param("expectedVersion") Integer expectedVersion
    );
}