testImplementation("io.mockk:mockk:1.13.12")

import io.mockk.mockk
import io.mockk.every
import org.junit.Test
import kotlin.test.assertEquals

interface UserApi {
    fun getUser(id: String): User
    fun deleteUser(id: String): Boolean
}

class UserApiTest {
    @Test
    fun `getUser 호출 시 지정한 값을 반환한다`() {
        // mockk(): UserApi의 가짜 구현체 생성 (실제 네트워크 호출 없음)
        val fakeApi = mockk<UserApi>()

        // every { }: 특정 함수 호출 시 반환할 값을 미리 지정 (스터빙)
        every { fakeApi.getUser("user-1") } returns User(id = "user-1", name = "홍길동")

        val user = fakeApi.getUser("user-1")

        assertEquals("홍길동", user.name)  // 지정한 값이 실제로 반환됨
    }
}

class ProductServiceTest {
    private val mockApi = mockk<ProductApi>()

    @Test
    fun `다양한 스터빙 패턴`() {
        // 1. 고정값 반환
        every { mockApi.getPrice("A001") } returns 10000

        // 2. 파라미터에 관계없이 항상 같은 값 반환
        every { mockApi.getDiscountRate(any()) } returns 0.1

        // 3. 예외를 던지도록 스터빙
        every { mockApi.getPrice("INVALID") } throws IllegalArgumentException("잘못된 상품 코드")

        // 4. 호출마다 다른 값을 순서대로 반환 (andThen 체이닝)
        every { mockApi.getStock("A001") } returns 10 andThen 5 andThen 0

        assertEquals(10000, mockApi.getPrice("A001"))
        assertEquals(0.1, mockApi.getDiscountRate("아무값"))

        assertFailsWith<IllegalArgumentException> {
            mockApi.getPrice("INVALID")
        }

        // 호출할 때마다 andThen에 지정한 순서대로 값이 반환됨
        assertEquals(10, mockApi.getStock("A001"))  // 1번째 호출
        assertEquals(5,  mockApi.getStock("A001"))  // 2번째 호출
        assertEquals(0,  mockApi.getStock("A001"))  // 3번째 호출 (품절)
    }
}

import io.mockk.verify
import io.mockk.Runs
import io.mockk.just

class OrderServiceTest {
    private val mockNotifier = mockk<NotificationService>()
    private val mockRepository = mockk<OrderRepository>()

    @Test
    fun `주문 완료 시 알림을 발송한다`() {
        // Unit을 반환하는 함수는 just Runs로 스터빙
        every { mockRepository.save(any()) } just Runs
        every { mockNotifier.send(any(), any()) } just Runs

        val orderService = OrderService(mockRepository, mockNotifier)
        orderService.completeOrder(orderId = "order-1", userId = "user-1")

        // verify: 정확히 지정된 인자로 호출되었는지 검증
        verify { mockNotifier.send(userId = "user-1", message = "주문이 완료되었습니다") }

        // verify(exactly = n): 정확히 n번 호출되었는지 검증
        verify(exactly = 1) { mockRepository.save(any()) }

        // verify(exactly = 0): 호출되지 않았음을 검증 (음성 테스트)
        verify(exactly = 0) { mockNotifier.send(match { it != "user-1" }, any()) }
    }
}

@Test
fun `relaxed mock은 스터빙하지 않은 함수도 기본값을 반환`() {
    // relaxed = true: 스터빙 안 한 함수 호출 시 예외 대신 기본값(0, "", false, null 등) 반환
    val relaxedApi = mockk<ProductApi>(relaxed = true)

    // getPrice를 스터빙하지 않았지만 예외 없이 0 반환 (Int의 기본값)
    val price = relaxedApi.getPrice("아무거나")
    assertEquals(0, price)

    // 필요한 것만 골라서 스터빙 가능
    every { relaxedApi.getPrice("A001") } returns 5000
    assertEquals(5000, relaxedApi.getPrice("A001"))
}

class UserViewModel(private val repository: UserRepository) {
    var uiState = UserUiState()
        private set

    suspend fun loadUser(id: String) {
        uiState = uiState.copy(isLoading = true)
        try {
            val user = repository.fetchUser(id)
            uiState = uiState.copy(user = user, isLoading = false)
        } catch (e: Exception) {
            uiState = uiState.copy(errorMessage = e.message, isLoading = false)
        }
    }
}

class UserViewModelTest {
    private val mockRepository = mockk<UserRepository>()

    @Test
    fun `사용자 로드 성공 시 uiState에 반영된다`() = runTest {
        // Given: 성공 시나리오 스터빙
        coEvery { mockRepository.fetchUser("user-1") } returns User("user-1", "홍길동")

        val viewModel = UserViewModel(mockRepository)

        // When
        viewModel.loadUser("user-1")

        // Then
        assertEquals("홍길동", viewModel.uiState.user?.name)
        assertEquals(false, viewModel.uiState.isLoading)
        coVerify(exactly = 1) { mockRepository.fetchUser("user-1") }
    }

    @Test
    fun `사용자 로드 실패 시 에러 메시지가 설정된다`() = runTest {
        // Given: 실패 시나리오 스터빙
        coEvery { mockRepository.fetchUser(any()) } throws RuntimeException("네트워크 오류")

        val viewModel = UserViewModel(mockRepository)

        viewModel.loadUser("user-1")

        assertEquals("네트워크 오류", viewModel.uiState.errorMessage)
    }
}