/**
 * Rest docs를 편리하게 사용하기 위한 Support 클래스
 * @author seunggyu-kim 
 */
@Disabled
@Import(RestDocsConfig.class)
@ExtendWith({RestDocumentationExtension.class})
public abstract class RestDocSupport {
    @Autowired
    protected MockMvc mockMvc;

    @Autowired
    protected ObjectMapper objectMapper;

    @Autowired
    protected RestDocumentationResultHandler restDoc;

    // 관리자 여부 테스트 용으로 사용
    // ex) BDDMockito.given(adminCheckService.isAdmin(Mockito.anyLong())).willReturn(true);
    @MockBean
    protected AdminCheckService adminCheckService;

    /**
     * Spring Rest Docs를 사용하기 위한 설정
     *
     * @param webApplicationContext
     * @param restDocumentationContextProvider
     */
    @BeforeEach
    public void setup(
            final WebApplicationContext webApplicationContext,
            final RestDocumentationContextProvider restDocumentationContextProvider
    ) {
        this.mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext)
                .apply(MockMvcRestDocumentation.documentationConfiguration(restDocumentationContextProvider))
                .alwaysDo(MockMvcResultHandlers.print())
                .alwaysDo(restDoc)
                .addFilters(new CharacterEncodingFilter("UTF-8", true))     // 한글 깨짐 방지 처리
                .build();
    }
}

@WebMvcTest(AdminCheckController.class)
class AdminCheckControllerTest extends RestDocSupport {
    /**
     * 관리자 여부 확인 테스트
     * <p>사용자가 관리자 권한을 갖고있는 경우
     *
     * @throws Exception
     */
    @DisplayName("관리자 여부 확인 - 관리자인 경우")
    @Test
    void checkAdmin_true() throws Exception {
        // given
        Long userId = Mockito.anyLong();
        BDDMockito.given(adminCheckService.isAdmin(userId)).willReturn(true);

        // when
        String response = mockMvc.perform(
                        MockMvcRequestBuilders.get("/v1/admin/check")
                                .header("X-USER-ID", userId))
                .andExpectAll(
                        MockMvcResultMatchers.status().isOk()
                )
                .andReturn().getResponse().getContentAsString();

        // then
        CommonHeader commonHeader = CommonHeader.builder().httpStatus(HttpStatus.OK).resultMessage("Success").build();
        CommonResponse<AdminCheckResponse> commonResponse =
                CommonResponse.<AdminCheckResponse>builder().header(commonHeader).result(new AdminCheckResponse(true))
                        .build();
        String expected = objectMapper.writeValueAsString(commonResponse);
        Assertions.assertThat(response).isEqualTo(expected);
    }
    ...(생략)
}

@ExtendWith(MockitoExtension.class)
class CartServiceImplTest {
    @InjectMocks
    private CartServiceImpl cartService;
    @Mock
    private CartRepository cartRepository;
    @Mock
    private UserRepository userRepository;
    @Mock
    private BookRepository bookRepository;

    ...(생략)...

    @Test
    @DisplayName("장바구니에 책 추가 - 책이 없을 경우")
    void addBookToCartWhenBookNotFound() {
        try (MockedStatic<XUserIdThreadLocal> utilities = mockStatic(XUserIdThreadLocal.class)) {
            // given
            CartItemRequest request = new CartItemRequest(1L, 1);
            given(XUserIdThreadLocal.getXUserId()).willReturn(1L);
            given(cartRepository.findByUser_IdAndBook_Id(1L, 1L)).willReturn(Optional.empty());
            given(userRepository.findById(1L)).willReturn(Optional.of(User.builder().id(1L).build()));
            given(bookRepository.findById(1L)).willReturn(Optional.empty());

            // when & then
            assertThatThrownBy(() -> cartService.addBookToCart(request))
                    .isInstanceOf(CartBadRequestException.class)
                    .hasMessageContaining("Book not found (book id: 1)");
            verify(cartRepository, never()).save(Mockito.any(Cart.class));
        }
    }
}

@DataJpaTest
class CartRepositoryImplTest {
    @Autowired
    private TestEntityManager entityManager;

    @Autowired
    private CartRepository cartRepository;

    ...(생략)...

    @Test
    @DisplayName("사용자 ID로 장바구니 아이템 조회")
    void getCartItemsByUser() {
        // given
        Cart cart1 = Cart.builder()
                .cartAmount(1)
                .user(user)
                .book(book1)
                .build();
        entityManager.persist(cart1);

        Cart cart2 = Cart.builder()
                .cartAmount(2)
                .user(user)
                .book(book2)
                .build();
        entityManager.persist(cart2);

        // when
        List<CartItemResponse> cartItemResponses = cartRepository.getCartItemsByUser(user.getId());

        // then
        List<CartItemResponse> expectedCartItemResponses = new ArrayList<>();
        CartItemResponse expectedCartItemResponse1 = new CartItemResponse(
                book1.getId(),
                book1.getBookTitle(),
                book1.getBookPrice(),
                book1.getBookSalePrice(),
                book1.getBookThumbnailUrl(),
                book1.getBookStock(),
                cart1.getCartAmount()
        );
        expectedCartItemResponses.add(expectedCartItemResponse1);
        CartItemResponse expectedCartItemResponse2 = new CartItemResponse(
                book2.getId(),
                book2.getBookTitle(),
                book2.getBookPrice(),
                book2.getBookSalePrice(),
                book2.getBookThumbnailUrl(),
                book2.getBookStock(),
                cart2.getCartAmount()
        );
        expectedCartItemResponses.add(expectedCartItemResponse2);

        assertThat(cartItemResponses).usingRecursiveComparison().isEqualTo(expectedCartItemResponses);
    }
}