package com.example.hpostesting

import androidx.arch.core.executor.testing.InstantTaskExecutorRule
import androidx.lifecycle.Observer
import com.example.hpostesting.data.Result
import com.example.hpostesting.data.model.deviceprovision.DeviceProvisionRequest
import com.example.hpostesting.data.model.deviceprovision.DeviceProvisionResponse
import com.example.hpostesting.data.repository.Repository
import com.example.hpostesting.presentation.deviceprovision.DeviceProvisionViewModel
import com.example.hpostesting.util.TestCoroutineRule
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.runBlockingTest
import org.junit.After
import org.junit.Before
import org.junit.Rule
import org.junit.Test
import org.mockito.Mock
import org.mockito.Mockito
import org.mockito.MockitoAnnotations

@ExperimentalCoroutinesApi
class DeviceProvisionViewModelTest {

    // Rule to make LiveData updates instant
    @get:Rule
    val instantExecutorRule = InstantTaskExecutorRule()

    // Rule for testing coroutines
    @get:Rule
    val coroutineRule = TestCoroutineRule()

    // Mocks
    @Mock
    private lateinit var databaseRepository: Repository

    @Mock
    private lateinit var deviceProvisionObserver: Observer<Result<DeviceProvisionResponse>>

    // Class under test
    private lateinit var viewModel: DeviceProvisionViewModel

    @Before
    fun setUp() {
        MockitoAnnotations.openMocks(this)
        viewModel = DeviceProvisionViewModel(databaseRepository)
        viewModel.deviceProvisionResponse.observeForever(deviceProvisionObserver)
    }

    @After
    fun tearDown() {
        viewModel.deviceProvisionResponse.removeObserver(deviceProvisionObserver)
    }

    @Test
    fun `deviceProvision success`() = coroutineRule.runBlockingTest {
        // Arrange
        val deviceProvisionRequest = DeviceProvisionRequest(/* provide necessary parameters */)
        val expectedResult = Result.Success(DeviceProvisionResponse(/* provide necessary response data */))
        Mockito.`when`(databaseRepository.deviceProvision(deviceProvisionRequest)).thenReturn(expectedResult)

        // Act
        viewModel.deviceProvision(deviceProvisionRequest)

        // Assert
//        Mockito.verify(deviceProvisionObserver, Mockito.timeout(1000)).onChanged(Result.Loading())
        Mockito.verify(deviceProvisionObserver, Mockito.timeout(1000)).onChanged(expectedResult)
    }

    @Test
    fun `deviceProvision error`() = coroutineRule.runBlockingTest {
        // Arrange
        val deviceProvisionRequest = DeviceProvisionRequest(/* provide necessary parameters */)
        val expectedError = Result.Error(Exception("Test error"))
        Mockito.`when`(databaseRepository.deviceProvision(deviceProvisionRequest)).thenReturn(expectedError)

        // Act
        viewModel.deviceProvision(deviceProvisionRequest)

        // Assert
//        Mockito.verify(deviceProvisionObserver, Mockito.timeout(1000)).onChanged(Result.Loading())
        Mockito.verify(deviceProvisionObserver, Mockito.timeout(1000)).onChanged(expectedError)
    }
}