package com.chameth.yaotp.viewmodel

import androidx.arch.core.executor.testing.InstantTaskExecutorRule
import androidx.lifecycle.Observer
import com.chameth.yaotp.algos.Otp
import com.nhaarman.mockitokotlin2.argThat
import com.nhaarman.mockitokotlin2.doReturn
import com.nhaarman.mockitokotlin2.mock
import com.nhaarman.mockitokotlin2.verify
import org.junit.Assert.assertEquals
import org.junit.Rule
import org.junit.Test

class OtpItemViewModelTest {

    @get:Rule
    val instantTaskExecutorRule = InstantTaskExecutorRule()

    private val viewModel = OtpItemViewModel()

    @Test
    fun testCalculateTimeLeft_withFutureTimes() {
        assertEquals(1, viewModel.calculateTimeLeft(100L, 99L))
        assertEquals(1000, viewModel.calculateTimeLeft(1000L, 0L))
        assertEquals(1000, viewModel.calculateTimeLeft(99999991000L, 99999990000L))
    }

    @Test
    fun testCalculateTimeLeft_withPastTimes() {
        assertEquals(0, viewModel.calculateTimeLeft(100L, 100L))
        assertEquals(0, viewModel.calculateTimeLeft(100L, 1000L))
        assertEquals(0, viewModel.calculateTimeLeft(100L, 100000000000L))
    }

    @Test
    fun testSetAccount_updatesLabel() {
        val observer = mock<Observer<String>>()
        viewModel.label.observeForever(observer)
        viewModel.account = mock { on { label } doReturn "My label" }
        verify(observer).onChanged("My label")
    }

    @Test
    fun testSetAccount_updatesOtp() {
        val otp = mock<Otp>()
        val observer = mock<Observer<Otp>>()
        viewModel.otp.observeForever(observer)
        viewModel.account = mock { on { generateOtp() } doReturn otp }
        verify(observer).onChanged(otp)
    }

    @Test
    fun testSetAccount_updatesShowTime_withTimeBasedAccount() {
        val observer = mock<Observer<Boolean>>()
        viewModel.showTime.observeForever(observer)
        viewModel.account = mock { on { timeBased } doReturn true }
        verify(observer).onChanged(true)
    }

    @Test
    fun testSetAccount_updatesShowTime_withNonTimeBasedAccount() {
        val observer = mock<Observer<Boolean>>()
        viewModel.showTime.observeForever(observer)
        viewModel.account = mock { on { timeBased } doReturn false }
        verify(observer).onChanged(false)
    }

    @Test
    fun testSetAccount_updatesTimeLeft_withTimeBasedAccount() {
        val otp = mock<Otp> { on { expiresAt } doReturn (System.currentTimeMillis() / 1000) + 10 }
        val observer = mock<Observer<String>>()
        viewModel.timeLeft.observeForever(observer)
        viewModel.account = mock { on { generateOtp() } doReturn otp; on { timeBased } doReturn true }
        verify(observer).onChanged(argThat { matches(Regex("(9|10)s")) })
    }

    @Test
    fun testSetAccount_updatesTimeLeft_withNonTimeBasedAccount() {
        val otp = mock<Otp>()
        val observer = mock<Observer<String>>()
        viewModel.timeLeft.observeForever(observer)
        viewModel.account = mock { on { generateOtp() } doReturn otp; on { timeBased } doReturn false }
        verify(observer).onChanged("")
    }

}