@SpringBootTest
public class CouponConcurrencyTest {

    @Autowired
    CouponService couponService;

    @Autowired
    CouponRepository couponRepository;

    @MockBean
    UserCouponRepository userCouponRepository;

    User user = User.createMockUser();

    Coupon coupon;

    int threadCount = 100;

    @BeforeEach
    void setUp() {
        coupon = Coupon.createMockCoupon(threadCount);
        couponRepository.save(coupon);
    }

    @Test
    void 쿠폰_다운로드_동시성_테스트_분산락_미적용() throws InterruptedException {
        // given
        given(userCouponRepository.existsByUserAndCoupon(any(User.class), any(Coupon.class)))
                .willReturn(false);
                
        // when
        ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
        CountDownLatch latch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            executorService.submit(() -> {
                try {
                    couponService.downloadCouponWithoutLock(coupon.getId(), user);
                } finally {
                    latch.countDown();
                }
            });
        }
        latch.await();

        // then
        int remainingCount = couponRepository.findById(coupon.getId()).orElseThrow().getRemainingCount();
        assertThat(remainingCount).isNotZero().isNotEqualTo(threadCount);

        System.out.println("\n[remainingCount]");
        System.out.println("Expected = 0");
        System.out.println("Actual = " + remainingCount);
    }
}

@Transactional
public UserCouponResponseDto downloadCouponWithoutLock(Long couponId, User user) {
    Coupon coupon = couponRepository.findById(couponId)
            .orElseThrow(() -> new CustomException(COUPON_NOT_FOUND));
    // 이미 다운로드 받은 쿠폰인지 확인
    if (userCouponRepository.existsByUserAndCoupon(user, coupon)) {
        throw new CustomException(ALREADY_DOWNLOADED_COUPON);
    }
    coupon.download();
    UserCoupon userCoupon = userCouponRepository.save(UserCoupon.of(user, coupon));
    return UserCouponResponseDto.of(userCoupon);
}

@Getter
public class UserCouponResponseDto {

    private final Long userCouponId;
    private final Long userId;
    private final Long couponId;

    private UserCouponResponseDto(UserCoupon userCoupon) {
        this.userCouponId = userCoupon.getId();
        this.userId = userCoupon.getUser().getId();
        this.couponId = userCoupon.getCoupon().getId();
    }

    public static UserCouponResponseDto of(UserCoupon userCoupon) {
        return new UserCouponResponseDto(userCoupon);
    }
    
}

@Test
void 쿠폰_다운로드_동시성_테스트_분산락_미적용() {
    // given
    given(userCouponRepository.existsByUserAndCoupon(any(User.class), any(Coupon.class)))
            .willReturn(false);

    // when
    IntStream.range(0, threadCount).parallel().forEach(i ->
            couponService.downloadCouponWithoutLock(coupon.getId(), user)
    );

    // then
    int remainingCount = couponRepository.findById(coupon.getId()).orElseThrow().getRemainingCount();
    assertThat(remainingCount).isNotZero().isNotEqualTo(threadCount);

    System.out.println("\n[remainingCount]");
    System.out.println("Expected = 0");
    System.out.println("Actual = " + remainingCount);
}

@Transactional
public UserCouponResponseDto downloadCouponWithoutLock(Long couponId, User user) {
    Coupon coupon = couponRepository.findById(couponId)
            .orElseThrow(() -> new CustomException(COUPON_NOT_FOUND));
    // 이미 다운로드 받은 쿠폰인지 확인
    if (userCouponRepository.existsByUserAndCoupon(user, coupon)) {
        throw new CustomException(ALREADY_DOWNLOADED_COUPON);
    }
    coupon.download();
    
    UserCoupon userCoupon = UserCoupon.of(user, coupon);
    userCouponRepository.save(userCoupon);
    
    return UserCouponResponseDto.of(userCoupon);
}

@Transactional
public UserCouponResponseDto downloadCoupon(Long couponId, User user) {
    RLock lock = redissonClient.getFairLock("couponDownloadLock_" + couponId); // 요청 들어온 순서대로 처리
    boolean locked = false;
    try {
        locked = lock.tryLock(10, 60, TimeUnit.SECONDS);
        if (locked) {
				    Coupon coupon = couponRepository.findById(couponId)
				            .orElseThrow(() -> new CustomException(COUPON_NOT_FOUND));
				    // 이미 다운로드 받은 쿠폰인지 확인
				    if (userCouponRepository.existsByUserAndCoupon(user, coupon)) {
				        throw new CustomException(ALREADY_DOWNLOADED_COUPON);
				    }
				    coupon.download();
				    
				    UserCoupon userCoupon = UserCoupon.of(user, coupon);
				    userCouponRepository.save(userCoupon);
				    
				    return UserCouponResponseDto.of(userCoupon);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        if (locked && lock.isHeldByCurrentThread()) {
            lock.unlock(); // 락을 획득했을 때만 해제
        }
    }
    return null;
}@Transactional
public UserCouponResponseDto downloadCoupon(Long couponId, User user) {
    RLock lock = redissonClient.getFairLock("couponDownloadLock_" + couponId); // 요청 들어온 순서대로 처리
    boolean locked = false;
    try {
        locked = lock.tryLock(10, 60, TimeUnit.SECONDS);
        if (locked) {
				    Coupon coupon = couponRepository.findById(couponId)
				            .orElseThrow(() -> new CustomException(COUPON_NOT_FOUND));
				    // 이미 다운로드 받은 쿠폰인지 확인
				    if (userCouponRepository.existsByUserAndCoupon(user, coupon)) {
				        throw new CustomException(ALREADY_DOWNLOADED_COUPON);
				    }
				    coupon.download();
				    
				    UserCoupon userCoupon = UserCoupon.of(user, coupon);
				    userCouponRepository.save(userCoupon);
				    
				    return UserCouponResponseDto.of(userCoupon);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        if (locked && lock.isHeldByCurrentThread()) {
            lock.unlock(); // 락을 획득했을 때만 해제
        }
    }
    return null;
}

@Slf4j
@Aspect
@Component
@RequiredArgsConstructor
public class DistributedLockAspect {

    private static final String REDISSON_LOCK_PREFIX = "LOCK:";

    private final RedissonClient redissonClient;
    private final TransactionForAop transactionForAop;

    @Around("@annotation(com.sparta.ezpzuser.common.lock.DistributedLock)")
    public Object lock(final ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        DistributedLock distributedLock = method.getAnnotation(DistributedLock.class);

        String key = REDISSON_LOCK_PREFIX +
                CustomSpELParser.getDynamicValue(
                        signature.getParameterNames(),
                        joinPoint.getArgs(),
                        distributedLock.key()
                );

        RLock rLock = redissonClient.getFairLock(key); // 선착순 보장

        try {
            log.info("try lock for key: {}", key);
            boolean available = rLock.tryLock(
                    distributedLock.waitTime(),
                    distributedLock.leaseTime(),
                    distributedLock.timeUnit()
            );
            if (!available) {
                throw new RuntimeException("lock failed for key: " + key);
            }
            // DistributedLock 어노테이션이 선언된 메서드를 별도의 트랜잭션으로 실행
            return transactionForAop.proceed(joinPoint);
        } catch (InterruptedException e) {
            throw new InterruptedException();
        } finally {
            // 반드시 트랜잭션 커밋 이후 락이 해제되도록 처리
            try {
                rLock.unlock();
            } catch (IllegalMonitorStateException e) {
                log.error("Redisson Lock is Already UnLocked");
            }
        }
    }

@Component
public class TransactionForAop {

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public Object proceed(final ProceedingJoinPoint joinPoint) throws Throwable {
        return joinPoint.proceed();
    }

}

@JsonIgnoreProperties(ignoreUnknown = true, value = {"pageable"})
public class RestPage<T> extends PageImpl<T> {
	
	@JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
	public RestPage(@JsonProperty("content") java.util.List<T> content,
					@JsonProperty("number") int page,
					@JsonProperty("size") int size,
					@JsonProperty("totalElements") long totalElements) {
		
		super(content, PageRequest.of(page, size), totalElements);
	}
	
	public RestPage(Page<T> page) {
		super(page.getContent(), page.getPageable(), page.getTotalElements());
	}
	
	public RestPage(List<T> content, Pageable pageable, Long total) {
		super(content, pageable, total);
	}
}

public Page<ReservationResponseDto> findReservations(Pageable pageable, String status, User user) {
		ReservationStatus reservationStatus = ReservationStatus.valueOf(status.toUpperCase());
		Page<Reservation> reservationPage = reservationRepository.findByUserIdAndStatus(user.getId(), reservationStatus, pageable);
		validatePageableWithPage(pageable, reservationPage);
		
		return reservationPage.map(r -> ReservationResponseDto.of(r, r.getSlot()));
	}

	@Cacheable(value = "reservations", key = "#user.id + ':' + #status + ':' + #pageable.pageNumber")
	public RestPage<ReservationResponseDto> findReservations(Pageable pageable, String status, User user) {
		ReservationStatus reservationStatus = ReservationStatus.valueOf(status.toUpperCase());
		Page<Reservation> reservationPage = reservationRepository.findByUserIdAndStatus(user.getId(), reservationStatus, pageable);
		validatePageableWithPage(pageable, reservationPage);
		
		return new RestPage<>(reservationPage.map(r -> ReservationResponseDto.of(r, r.getSlot())));
	}