package com.bookmate.app.reader.tracker

import com.bookmate.domain.model.Book
import com.bookmate.domain.model.ICard
import com.bookmate.domain.model.LibraryCard
import com.bookmate.domain.usecase.book.ChangeBookStateUsecase
import com.bookmate.reader.book.tracking.BookProgressChanges.PageNumerationState.Empty
import com.bookmate.reader.book.tracking.BookProgressChanges.ProgressFragment.EmptyProgressFragment
import com.bookmate.reader.book.tracking.ProgressTracker.ProgressHandler.Info
import com.nhaarman.mockitokotlin2.*
import org.junit.Before
import org.junit.Test
import rx.Single

class MoveToInProgressHandlerTest {

    private val randomValidInfo = Info(
            Empty, "dgfsdg34902", "sfaj2qw2312i3", true, false, false, false
    )
    private val randomEmptyProgressFragment = EmptyProgressFragment(0.1242142)

    private lateinit var handler: MoveToInProgressHandler
    private lateinit var changeBookStateUsecase: ChangeBookStateUsecase
    private lateinit var onBookMovedToInProgressListener: (Book) -> Unit
    private lateinit var getBook: () -> Book

    @Before
    fun setUp() {
        changeBookStateUsecase = mock()
        onBookMovedToInProgressListener = mock()
        getBook = mock()

        handler = MoveToInProgressHandler(getBook, changeBookStateUsecase, onBookMovedToInProgressListener)
    }

    @Test
    fun handle_isNotConfirmed_doesNothing() {
        // given
        val info = randomValidInfo.copy(isConfirmed = false)
        val progressFragment = randomEmptyProgressFragment

        // when
        handler.handle(progressFragment, info)

        // then
        verify(getBook, never()).invoke()
        verify(changeBookStateUsecase, never()).execute(any(), any(), any(), any())
        verify(onBookMovedToInProgressListener, never()).invoke(any())
    }

    @Test
    fun handle_isLaunchPage_doesNothing() {
        // given
        val info = randomValidInfo.copy(isLaunchPage = true)
        val progressFragment = randomEmptyProgressFragment

        // when
        handler.handle(progressFragment, info)

        // then
        verify(getBook, never()).invoke()
        verify(changeBookStateUsecase, never()).execute(any(), any(), any(), any())
        verify(onBookMovedToInProgressListener, never()).invoke(any())
    }

    @Test
    fun handle_isLastPage_doesNothing() {
        // given
        val info = randomValidInfo.copy(isLastPage = true)
        val progressFragment = randomEmptyProgressFragment

        // when
        handler.handle(progressFragment, info)

        // then
        verify(getBook, never()).invoke()
        verify(changeBookStateUsecase, never()).execute(any(), any(), any(), any())
        verify(onBookMovedToInProgressListener, never()).invoke(any())
    }

    @Test
    fun handle_bookIsInLibrary_stateIsInProgress_doesNothing() {
        // given
        val mockBook = mock<Book>()
        val mockCard = mock<LibraryCard>()
        whenever(mockCard.state).thenReturn(ICard.State.IN_PROGRESS)
        whenever(mockBook.isInLibrary).thenReturn(true)
        whenever(mockBook.card).thenReturn(mockCard)
        whenever(getBook.invoke()) doReturn (mockBook)

        val info = randomValidInfo
        val progressFragment = randomEmptyProgressFragment

        // when
        handler.handle(progressFragment, info)

        // then
        verify(changeBookStateUsecase, never()).execute(any(), any(), any(), any())
        verify(onBookMovedToInProgressListener, never()).invoke(any())
    }

    @Test
    fun handle_bookIsInLibrary_stateIsFinished_doesNothing() {
        // given
        val mockBook = mock<Book>()
        val mockCard = mock<LibraryCard>()
        whenever(mockCard.state).thenReturn(ICard.State.FINISHED)
        whenever(mockBook.isInLibrary).thenReturn(true)
        whenever(mockBook.card).thenReturn(mockCard)
        whenever(getBook.invoke()) doReturn (mockBook)

        val info = randomValidInfo
        val progressFragment = randomEmptyProgressFragment

        // when
        handler.handle(progressFragment, info)

        // then
        verify(changeBookStateUsecase, never()).execute(any(), any(), any(), any())
        verify(onBookMovedToInProgressListener, never()).invoke(any())
    }

    @Test
    fun handle_bookIsInLibrary_stateIsPending_changesStateToInProgress() {
        // given
        val mockBook = mock<Book>()
        val mockCard = mock<LibraryCard>()
        whenever(mockCard.state).thenReturn(ICard.State.PENDING)
        whenever(mockBook.isInLibrary).thenReturn(true)
        whenever(mockBook.card).thenReturn(mockCard)
        whenever(getBook.invoke()) doReturn (mockBook)

        whenever(
                changeBookStateUsecase.execute(eq(mockBook), any(), eq(ICard.State.IN_PROGRESS), any())
        ) doReturn (Single.just<Book>(mockBook))

        val info = randomValidInfo
        val progressFragment = randomEmptyProgressFragment

        // when
        handler.handle(progressFragment, info)

        // then
        verify(changeBookStateUsecase, only()).execute(eq(mockBook), any(), eq(ICard.State.IN_PROGRESS), any())
        verify(onBookMovedToInProgressListener, only()).invoke(eq(mockBook))
    }

    @Test
    fun handle_bookIsNotInLibrary_doesNothing() {
        // given
        val mockBook = mock<Book>()
        whenever(mockBook.isInLibrary).thenReturn(false)
        whenever(getBook.invoke()) doReturn (mockBook)

        val info = randomValidInfo
        val progressFragment = randomEmptyProgressFragment

        // when
        handler.handle(progressFragment, info)

        // then
        verify(changeBookStateUsecase, never()).execute(any(), any(), any(), any())
        verify(onBookMovedToInProgressListener, never()).invoke(any())
    }

}