@Entity
public class Stock {

    @Id @GeneratedValue
    private Long id;

    private Long productId;

    private Long quantity;

    public void decrease(Long count) {
        if (this.quantity - count < 0) {
            throw new IllegalArgumentException("재고는 0개 미만이 될 수 없습니다.");
        }
        this.quantity -= count;
    }
}

@Entity
public class Stock {

    @Id @GeneratedValue
    private Long id;

    private Long productId;
    private Long quantity;

    @Version
    private Long version;   // Long/Integer 권장 (Instant도 가능, Timestamp는 비권장)

    public void decrease(Long count) {
        if (this.quantity - count < 0) {
            throw new IllegalArgumentException("재고는 0개 미만이 될 수 없습니다.");
        }
        this.quantity -= count;
    }
}

public interface StockRepository extends JpaRepository<Stock, Long> {

    @Lock(LockModeType.OPTIMISTIC)
    @Query("select s from Stock s where s.id = :id")
    Stock findByIdWithOptimisticLock(@Param("id") Long id);
}

@Lock(LockModeType.OPTIMISTIC_FORCE_INCREMENT)
@Query("select b from Board b where b.id = :id")
Board findByIdForUpdate(@Param("id") Long id);

@Service
@RequiredArgsConstructor
public class StockService {

    private final StockRepository stockRepository;

    @Transactional
    public void decrease(Long id, Long count) {
        Stock stock = stockRepository.findByIdWithOptimisticLock(id);
        stock.decrease(count);
        stockRepository.saveAndFlush(stock);   // 커밋 전에 충돌을 앞당겨 확인
    }
}

@Component
@RequiredArgsConstructor
public class OptimisticLockStockFacade {

    private final StockService stockService;

    // 트랜잭션 밖에서 재시도 루프를 돈다
    public void decrease(Long id, Long count) throws InterruptedException {
        while (true) {
            try {
                stockService.decrease(id, count);
                break;
            } catch (ObjectOptimisticLockingFailureException e) {
                Thread.sleep(50);   // 잠깐 대기 후 재시도
            }
        }
    }
}

// 바깥: 재시도만 담당 (트랜잭션 없음). 위의 수동 래퍼 구현을 이걸로 대체한다
@Component
@RequiredArgsConstructor
public class OptimisticLockStockRetryFacade {

    private final StockService stockService;

    @Retryable(
        retryFor = ObjectOptimisticLockingFailureException.class,
        maxAttempts = 3,
        backoff = @Backoff(delay = 50, multiplier = 2)  // 50 → 100 → 200ms 지수 백오프
    )
    public void decrease(Long id, Long count) {
        stockService.decrease(id, count);   // 매 재시도마다 새 트랜잭션
    }

    // 재시도를 다 써도 실패하면 호출됨 (로그/알림 등)
    @Recover
    public void recover(ObjectOptimisticLockingFailureException e, Long id, Long count) {
        throw new IllegalStateException("재고 차감 재시도 초과: id=" + id, e);
    }
}

public interface StockRepository extends JpaRepository<Stock, Long> {

    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("select s from Stock s where s.id = :id")
    Stock findByIdWithPessimisticLock(@Param("id") Long id);
}

@Service
@RequiredArgsConstructor
public class PessimisticLockStockService {

    private final StockRepository stockRepository;

    @Transactional
    public void decrease(Long id, Long count) {
        // 이 시점에 SELECT ... FOR UPDATE 가 나가고, 락을 잡는다
        Stock stock = stockRepository.findByIdWithPessimisticLock(id);
        stock.decrease(count);
    }
}

@Lock(LockModeType.PESSIMISTIC_WRITE)
@QueryHints({
    // 락 획득을 3초만 기다리고, 못 잡으면 예외
    @QueryHint(name = "jakarta.persistence.lock.timeout", value = "3000")
})
@Query("select s from Stock s where s.id = :id")
Stock findByIdWithPessimisticLock(@Param("id") Long id);

@Service
@RequiredArgsConstructor
public class TransferService {

    private final AccountRepository accountRepository;

    // 데드락이 나는 코드 — 파라미터로 받은 순서 그대로 락을 잡는다
    @Transactional
    public void transfer(Long fromId, Long toId, Long amount) {
        Account from = accountRepository.findByIdWithPessimisticLock(fromId); // 락 1
        Account to   = accountRepository.findByIdWithPessimisticLock(toId);   // 락 2
        from.withdraw(amount);
        to.deposit(amount);
    }
}

@Transactional
public void transfer(Long fromId, Long toId, Long amount) {
    // 같은 테이블 안에서는 항상 작은 ID부터 락을 건다
    Long firstId  = Math.min(fromId, toId);
    Long secondId = Math.max(fromId, toId);
    accountRepository.findByIdWithPessimisticLock(firstId);
    accountRepository.findByIdWithPessimisticLock(secondId);

    Account from = accountRepository.getReferenceById(fromId);
    Account to   = accountRepository.getReferenceById(toId);
    from.withdraw(amount);
    to.deposit(amount);
}

// 락 전용 Repository (네이티브 쿼리)
public interface LockRepository extends JpaRepository<Stock, Long> {

    @Query(value = "SELECT GET_LOCK(:key, 3)", nativeQuery = true)
    Integer getLock(@Param("key") String key);

    @Query(value = "SELECT RELEASE_LOCK(:key)", nativeQuery = true)
    Integer releaseLock(@Param("key") String key);
}

@Component
@RequiredArgsConstructor
public class NamedLockStockFacade {

    private final LockRepository lockRepository;
    private final PessimisticLockStockService stockService;  // 실제 차감은 REQUIRES_NEW로

    public void decrease(Long id, Long count) {
        String key = "stock:" + id;
        try {
            Integer result = lockRepository.getLock(key);
            if (result == null || result != 1) {
                throw new IllegalStateException("락 획득 실패: " + key);
            }
            // 락을 잡은 상태에서 별도 트랜잭션으로 비즈니스 로직 실행
            stockService.decrease(id, count);
        } finally {
            lockRepository.releaseLock(key);   // 예외가 나도 반드시 해제
        }
    }
}

@Component
@RequiredArgsConstructor
public class RedissonLockStockFacade {

    private final RedissonClient redissonClient;
    private final PessimisticLockStockService stockService;

    public void decrease(Long id, Long count) {
        RLock lock = redissonClient.getLock("stock:" + id);
        try {
            // 최대 10초 대기, 획득하면 3초간 점유(3초 뒤 자동 해제)
            // leaseTime을 생략하면(tryLock(10, SECONDS)) watchdog이 자동 연장한다
            boolean available = lock.tryLock(10, 3, TimeUnit.SECONDS);
            if (!available) {
                throw new IllegalStateException("락 획득 실패");
            }
            stockService.decrease(id, count);   // REQUIRES_NEW 권장
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        } finally {
            if (lock.isHeldByCurrentThread()) {  // 내가 잡은 락만 해제
                lock.unlock();
            }
        }
    }
}

@Component
@RequiredArgsConstructor
public class SimpleRedisLock {

    private final StringRedisTemplate redisTemplate;

    // 내 토큰일 때만 삭제 (검사 + 삭제를 원자적으로)
    private static final String UNLOCK_SCRIPT =
        "if redis.call('get', KEYS[1]) == ARGV[1] then " +
        "  return redis.call('del', KEYS[1]) " +
        "else return 0 end";

    public boolean tryLock(String key, String token, Duration ttl) {
        Boolean success = redisTemplate.opsForValue()
            .setIfAbsent(key, token, ttl);   // SET key token NX PX ttl
        return Boolean.TRUE.equals(success);
    }

    public void unlock(String key, String token) {
        redisTemplate.execute(
            new DefaultRedisScript<>(UNLOCK_SCRIPT, Long.class),
            List.of(key),
            token   // 락 획득 시 발급한 고유 토큰 (예: UUID)
        );
    }
}

public void decrease(Long id, Long count) {
    String key = "stock:" + id;
    String token = UUID.randomUUID().toString();   // 락 소유자 식별
    if (!redisLock.tryLock(key, token, Duration.ofSeconds(3))) {
        throw new IllegalStateException("락 획득 실패");
    }
    try {
        stockService.decrease(id, count);
    } finally {
        redisLock.unlock(key, token);   // 내 토큰일 때만 풀린다
    }
}

// 동시에 들어오면 둘 다 통과하는 경쟁 조건
if (paymentRepository.findByOrderId(orderId) == null) {  // ① 둘 다 null 확인
    paymentRepository.save(new Payment(orderId, ...));    // ② 둘 다 INSERT → 중복!
}

// 안쪽: INSERT만. 중복이면 예외를 던지고 트랜잭션 롤백
@Service
@RequiredArgsConstructor
public class PaymentService {

    private final PaymentRepository paymentRepository;

    @Transactional
    public Payment create(String idempotencyKey, Long orderId, ...) {
        return paymentRepository.save(new Payment(idempotencyKey, orderId, ...));
    }

    @Transactional(readOnly = true)
    public Payment findByKey(String idempotencyKey) {
        return paymentRepository.findByIdempotencyKey(idempotencyKey);
    }
}

// 바깥: 제약 위반은 트랜잭션 밖에서 잡아, 새 트랜잭션으로 기존 결과를 조회
@Component
@RequiredArgsConstructor
public class PaymentFacade {

    private final PaymentService paymentService;

    public Payment pay(String idempotencyKey, Long orderId, ...) {
        try {
            return paymentService.create(idempotencyKey, orderId, ...);
        } catch (DataIntegrityViolationException e) {
            // 이미 같은 키로 결제됨 → 기존 결과를 반환 (재시도도 같은 응답)
            return paymentService.findByKey(idempotencyKey);
        }
    }
}

Payment p = paymentRepository.findByIdWithPessimisticLock(paymentId); // FOR UPDATE
if (p.getStatus() != READY) {
    throw new AlreadyPaidException();   // 중복 승인 차단
}
p.markPaid();