CREATE TABLE inventory (
    sku       VARCHAR(64) PRIMARY KEY,
    available INT    NOT NULL,
    -- Chốt chặn cuối cùng: dù code sai thì DB vẫn không cho available âm
    CONSTRAINT chk_inventory_available CHECK (available >= 0)
);

INSERT INTO inventory (sku, available) VALUES ('HEADPHONE-01', 100);

@Entity
@Table(name = "inventory")
@Getter
@Setter
public class Inventory {

    @Id
    private String sku;

    private int available;

    // Cố ý KHÔNG có @Version ở entity dùng chung này.
    // Optimistic lock (cách 4) dùng một entity riêng, xem phần 6.
}

// Exception nghiệp vụ để controller trả về 409 Conflict
public class OutOfStockException extends RuntimeException {
    public OutOfStockException(String sku) {
        super("SKU '" + sku + "' đã hết hàng");
    }
}

@Service
@RequiredArgsConstructor
public class NaiveInventoryService {

    private final InventoryRepository inventoryRepository;

    // Đừng dùng: check-then-act race condition
    @Transactional
    public void reserve(String sku, int qty) {
        Inventory inv = inventoryRepository.findById(sku).orElseThrow();

        if (inv.getAvailable() < qty) {
            throw new OutOfStockException(sku);
        }

        inv.setAvailable(inv.getAvailable() - qty);
        inventoryRepository.save(inv);
    }
}

public interface InventoryRepository extends JpaRepository<Inventory, String> {

    // Trả về số dòng bị ảnh hưởng: 1 = trừ thành công, 0 = không đủ hàng
    @Modifying
    @Query("""
        UPDATE Inventory i
           SET i.available = i.available - :qty
         WHERE i.sku = :sku
           AND i.available >= :qty
        """)
    int decreaseIfEnough(@Param("sku") String sku, @Param("qty") int qty);
}

@Service
@RequiredArgsConstructor
public class AtomicInventoryService {

    private final InventoryRepository inventoryRepository;

    @Transactional
    public void reserve(String sku, int qty) {
        int updated = inventoryRepository.decreaseIfEnough(sku, qty);
        if (updated == 0) {
            throw new OutOfStockException(sku);
        }
    }
}

public interface InventoryRepository extends JpaRepository<Inventory, String> {

    // Sinh ra SELECT ... FOR UPDATE, các transaction khác phải chờ
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("SELECT i FROM Inventory i WHERE i.sku = :sku")
    Optional<Inventory> findBySkuForUpdate(@Param("sku") String sku);
}

@Service
@RequiredArgsConstructor
public class PessimisticInventoryService {

    private final InventoryRepository inventoryRepository;

    @Transactional
    public void reserve(String sku, int qty) {
        // Từ đây tới commit, không ai khác sửa được dòng này
        Inventory inv = inventoryRepository.findBySkuForUpdate(sku).orElseThrow();

        if (inv.getAvailable() < qty) {
            throw new OutOfStockException(sku);
        }
        inv.setAvailable(inv.getAvailable() - qty);
    }
}

ALTER TABLE inventory ADD COLUMN version BIGINT NOT NULL DEFAULT 0;

@Entity
@Table(name = "inventory")
@Getter
@Setter
public class VersionedInventory {

    @Id
    private String sku;

    private int available;

    @Version
    private long version;
}

public interface VersionedInventoryRepository extends JpaRepository<VersionedInventory, String> {
}

@Service
@RequiredArgsConstructor
public class OptimisticInventoryService {

    private static final int MAX_RETRY = 3;

    private final InventoryTxService txService;

    public void reserve(String sku, int qty) {
        for (int attempt = 1; attempt <= MAX_RETRY; attempt++) {
            try {
                txService.decrease(sku, qty);
                return;
            } catch (ObjectOptimisticLockingFailureException ex) {
                // Có request khác sửa dòng trước mình, đọc lại rồi thử lần nữa
                if (attempt == MAX_RETRY) {
                    throw ex;
                }
            }
        }
    }
}

@Service
@RequiredArgsConstructor
public class InventoryTxService {

    private final VersionedInventoryRepository versionedRepository;

    // Mỗi lần retry phải là một transaction mới, nên tách thành bean riêng
    @Transactional
    public void decrease(String sku, int qty) {
        VersionedInventory inv = versionedRepository.findById(sku).orElseThrow();

        if (inv.getAvailable() < qty) {
            throw new OutOfStockException(sku);
        }
        inv.setAvailable(inv.getAvailable() - qty);
        // Khi flush, Hibernate sinh: UPDATE ... WHERE sku = ? AND version = ?
        // Nếu 0 dòng bị ảnh hưởng => ném lỗi optimistic locking
    }
}

-- KEYS[1] = stock:{sku}, ARGV[1] = qty
local stock = tonumber(redis.call('GET', KEYS[1]))
if stock == nil then
    return -1   -- key chưa được warm-up
end
if stock < tonumber(ARGV[1]) then
    return 0    -- không đủ hàng
end
redis.call('DECRBY', KEYS[1], ARGV[1])
return 1        -- trừ thành công

@Service
public class RedisStockGate {

    private final StringRedisTemplate redis;
    private final DefaultRedisScript<Long> reserveScript;

    public RedisStockGate(StringRedisTemplate redis) {
        this.redis = redis;
        this.reserveScript = new DefaultRedisScript<>();
        // Đọc file src/main/resources/scripts/reserve_stock.lua
        this.reserveScript.setLocation(new ClassPathResource("scripts/reserve_stock.lua"));
        this.reserveScript.setResultType(Long.class);
    }

    /** Nạp tồn kho từ DB lên Redis trước giờ mở bán */
    public void warmUp(String sku, int available) {
        redis.opsForValue().set(key(sku), String.valueOf(available));
    }

    public boolean tryReserve(String sku, int qty) {
        Long result = redis.execute(reserveScript, List.of(key(sku)), String.valueOf(qty));
        if (result == null || result == -1L) {
            throw new IllegalStateException("Stock của " + sku + " chưa được warm-up");
        }
        return result == 1L;
    }

    /** Hoàn lại khi bước sau (ghi DB) thất bại */
    public void rollback(String sku, int qty) {
        redis.opsForValue().increment(key(sku), qty);
    }

    private String key(String sku) {
        return "stock:" + sku;
    }
}

@Service
@RequiredArgsConstructor
public class GatedInventoryService {

    private final RedisStockGate gate;
    private final AtomicInventoryService dbService; // cách 2

    public void reserve(String sku, int qty) {
        if (!gate.tryReserve(sku, qty)) {
            // Chặn ngay ở Redis, không chạm database
            throw new OutOfStockException(sku);
        }
        try {
            dbService.reserve(sku, qty); // atomic UPDATE vẫn là chốt chặn cuối
        } catch (RuntimeException ex) {
            gate.rollback(sku, qty);     // ghi DB lỗi thì trả lại hàng ở Redis
            throw ex;
        }
    }
}

CREATE TABLE stock_reservation (
    id         UUID PRIMARY KEY,
    order_id   VARCHAR(64) NOT NULL UNIQUE,  -- idempotency: một order chỉ giữ chỗ một lần
    sku        VARCHAR(64) NOT NULL,
    qty        INT         NOT NULL,
    status     VARCHAR(16) NOT NULL,         -- HELD | CONFIRMED | RELEASED | EXPIRED
    expires_at TIMESTAMPTZ NOT NULL          -- có múi giờ, ứng dụng làm việc với Instant (UTC)
);
CREATE INDEX idx_reservation_status_expires ON stock_reservation (status, expires_at);

@Entity
@Table(name = "stock_reservation")
@Getter
@Setter
public class StockReservation {

    @Id
    private UUID id;

    @Column(name = "order_id", nullable = false, unique = true)
    private String orderId;

    private String sku;

    private int qty;

    // HELD | CONFIRMED | RELEASED | EXPIRED (có thể đổi sang enum nếu anh em thích)
    private String status;

    @Column(name = "expires_at", nullable = false)
    private Instant expiresAt;
}

public interface ReservationRepository extends JpaRepository<StockReservation, UUID> {

    Optional<StockReservation> findByOrderId(String orderId);

    List<StockReservation> findTop100ByStatusAndExpiresAtBefore(String status, Instant now);

    // Chuyển trạng thái có điều kiện: chỉ một bên "thắng" khi confirm và expire đụng nhau
    @Modifying
    @Query("UPDATE StockReservation r SET r.status = :to WHERE r.id = :id AND r.status = :from")
    int transition(@Param("id") UUID id, @Param("from") String from, @Param("to") String to);
}

@Service
@RequiredArgsConstructor
public class ReservationService {

    private static final Duration HOLD_TIME = Duration.ofMinutes(10);

    private final InventoryRepository inventoryRepository;
    private final ReservationRepository reservationRepository;

    @Transactional
    public StockReservation reserve(String orderId, String sku, int qty) {
        // Retry tuần tự của cùng một đơn: trả lại kết quả cũ, không trừ kho lần nữa
        // (hai request đồng thời vẫn có thể lọt qua đây, constraint UNIQUE sẽ chặn ở bước save)
        Optional<StockReservation> existing = reservationRepository.findByOrderId(orderId);
        if (existing.isPresent()) {
            return existing.get();
        }

        // Trừ kho bằng atomic UPDATE ở cách 2
        if (inventoryRepository.decreaseIfEnough(sku, qty) == 0) {
            throw new OutOfStockException(sku);
        }

        StockReservation r = new StockReservation();
        r.setId(UUID.randomUUID());
        r.setOrderId(orderId);
        r.setSku(sku);
        r.setQty(qty);
        r.setStatus("HELD");
        r.setExpiresAt(Instant.now().plus(HOLD_TIME));
        // saveAndFlush để lỗi UNIQUE nổ ra ngay tại đây, trong transaction, thay vì lúc commit
        return reservationRepository.saveAndFlush(r);
    }

    /** Gọi khi payment thành công */
    @Transactional
    public void confirm(UUID reservationId) {
        int changed = reservationRepository.transition(reservationId, "HELD", "CONFIRMED");
        if (changed == 0) {
            throw new IllegalStateException("Reservation đã hết hạn hoặc bị huỷ");
        }
    }

    /** Gọi khi user huỷ đơn hoặc job dọn dẹp phát hiện quá hạn */
    @Transactional
    public void release(StockReservation r, String finalStatus) {
        // Chỉ khi chuyển trạng thái thành công mới trả hàng, nên chạy lại bao nhiêu lần cũng an toàn
        if (reservationRepository.transition(r.getId(), "HELD", finalStatus) == 1) {
            inventoryRepository.increase(r.getSku(), r.getQty());
        }
    }
}

@Service
@RequiredArgsConstructor
public class ReservationFacade {

    private final ReservationService reservationService;
    private final ReservationRepository reservationRepository;

    // Cố ý KHÔNG có @Transactional: transaction của reserve() đã rollback khi tới được đây
    public StockReservation reserve(String orderId, String sku, int qty) {
        try {
            return reservationService.reserve(orderId, sku, qty);
        } catch (DataIntegrityViolationException ex) {
            // Request khác cùng orderId đã thắng, trả về kết quả của nó (kho chỉ bị trừ một lần)
            return reservationRepository.findByOrderId(orderId).orElseThrow(() -> ex);
        }
    }
}

@Modifying
@Query("UPDATE Inventory i SET i.available = i.available + :qty WHERE i.sku = :sku")
int increase(@Param("sku") String sku, @Param("qty") int qty);

@Component
@RequiredArgsConstructor
public class ReservationExpiryJob {

    private final ReservationRepository reservationRepository;
    private final ReservationService reservationService;

    // Cần @EnableScheduling ở một class @Configuration
    @Scheduled(fixedDelay = 30_000)
    public void releaseExpired() {
        List<StockReservation> expired =
                reservationRepository.findTop100ByStatusAndExpiresAtBefore("HELD", Instant.now());

        for (StockReservation r : expired) {
            reservationService.release(r, "EXPIRED");
        }
    }
}

@SpringBootTest
class InventoryConcurrencyTest {

    @Autowired AtomicInventoryService service;       // thay bằng NaiveInventoryService để so sánh
    @Autowired InventoryRepository inventoryRepository;
    @Autowired JdbcTemplate jdbcTemplate;

    // Đưa kho về 100 trước mỗi lần chạy để các lần test không ảnh hưởng nhau
    @BeforeEach
    void resetStock() {
        jdbcTemplate.update("UPDATE inventory SET available = 100 WHERE sku = 'HEADPHONE-01'");
    }

    @Test
    void shouldNotOversell() throws Exception {
        int threads = 200;
        ExecutorService pool = Executors.newFixedThreadPool(threads);
        CountDownLatch start = new CountDownLatch(1);
        AtomicInteger success = new AtomicInteger();
        AtomicInteger soldOut = new AtomicInteger();
        AtomicInteger errors = new AtomicInteger();

        List<Future<?>> futures = new ArrayList<>();
        for (int i = 0; i < threads; i++) {
            futures.add(pool.submit(() -> {
                start.await();                       // chờ tín hiệu để cùng chạy
                try {
                    service.reserve("HEADPHONE-01", 1);
                    success.incrementAndGet();
                } catch (OutOfStockException e) {
                    soldOut.incrementAndGet();
                } catch (Exception e) {
                    // Lỗi khác (hết connection, optimistic lock sau khi retry hết lượt, vi phạm CHECK...)
                    errors.incrementAndGet();
                }
                return null;
            }));
        }

        start.countDown();
        for (Future<?> f : futures) f.get();
        pool.shutdown();

        int left = inventoryRepository.findById("HEADPHONE-01").orElseThrow().getAvailable();
        System.out.printf("success=%d, soldOut=%d, errors=%d, available=%d%n",
                success.get(), soldOut.get(), errors.get(), left);

        // Bất biến quan trọng nhất: số đơn thành công và số hàng còn lại phải khớp với tồn kho ban đầu
        assertThat(success.get() + left).isEqualTo(100);
        assertThat(left).isGreaterThanOrEqualTo(0);
    }
}