package it.unisannio.ding.ids.wedroid.app.data.repository

import android.util.Log
import androidx.lifecycle.LiveData
import io.mockk.*
import it.unisannio.ding.ids.wedroid.app.data.dao.BoardDao
import it.unisannio.ding.ids.wedroid.app.data.entity.Board
import it.unisannio.ding.ids.wedroid.app.getPrivateFun
import it.unisannio.ding.ids.wedroid.app.util.PreferenceReader
import it.unisannio.ding.ids.wedroid.wrapper.api.BoardService
import junit.framework.TestCase.*
import kotlinx.coroutines.*
import okhttp3.mockwebserver.MockWebServer
import org.junit.After
import org.junit.Before
import org.junit.Test
import retrofit2.Response
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import kotlin.reflect.full.callSuspend

class BoardRepositoryTest {
    private val reader = mockk<PreferenceReader>()
    private val webServer = MockWebServer()
    private lateinit var service: BoardService

    @Before
    fun setUp() {
        webServer.start()
        service = Retrofit.Builder()
            .baseUrl(webServer.url("/"))
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(BoardService::class.java)

        mockkStatic(Log::class)
        every { reader.userId } returns "user id"
        every { Log.e(any(), any()) } returns 0
    }

    @After
    fun teardown() {
        webServer.close()
    }

    @Test
    fun addNewBoardsToDb() {
        val dao = mockk<BoardDao>()
        var count = 0

        coEvery {
            dao.insert(any())
        } answers {
            count++
        }

        val addNewBoardToDb = getPrivateFun(
            "addNewBoardToDb", BoardRepository::class
        )

        val repository = BoardRepository(
            dao, service, reader
        )

        val board0 = Board("id0", "title0")
        val board1 = Board("id1", "title1")
        val board2 = Board("id2", "title2")

        runBlocking {
            addNewBoardToDb?.callSuspend(
                repository,
                listOf(board0, board1, board2)
            )
        }

        coVerifyAll {
            dao.insert(board0)
            dao.insert(board1)
            dao.insert(board2)
        }

        assertEquals(3, count)
    }

    @Test
    fun insertBoardCallbackSuccess() {
        val dao = mockk<BoardDao>()
        val response =
            mockk<Response<it.unisannio.ding.ids.wedroid.wrapper.entity.Board>>()
        val board = mockk<it.unisannio.ding.ids.wedroid.wrapper.entity.Board>()

        every { response.isSuccessful } returns true
        every { response.body() } returns board
        every { board.id } returns "id"
        coEvery { dao.insert(any()) } answers {}

        val insertBoard = getPrivateFun(
            "insertBoardCallback", BoardRepository::class
        )

        val repository = BoardRepository(
            dao, service, reader
        )

        runBlocking {
            insertBoard?.callSuspend(
                repository,
                response,
                "title"
            )
        }

        coVerify { dao.insert(Board("id", "title")) }
    }

    @Test
    fun insertBoardCallbackEmptyBody() {
        val dao = mockk<BoardDao>()
        val response =
            mockk<Response<it.unisannio.ding.ids.wedroid.wrapper.entity.Board>>()

        every { response.isSuccessful } returns true
        every { response.body() } returns null

        val insertBoard = getPrivateFun(
            "insertBoardCallback", BoardRepository::class
        )

        val repository = BoardRepository(
            dao, service, reader
        )

        runBlocking {
            insertBoard?.callSuspend(
                repository,
                response,
                "title"
            )
        }

        verify { Log.e("RETROFIT", "empty body") }
    }

    @Test
    fun insertBoardCallbackError() {
        val dao = mockk<BoardDao>()
        val response =
            mockk<Response<it.unisannio.ding.ids.wedroid.wrapper.entity.Board>>()

        every { response.isSuccessful } returns false
        every { response.code() } returns 400
        every { response.message() } returns "Error"

        val insertBoard = getPrivateFun(
            "insertBoardCallback", BoardRepository::class
        )

        val repository = BoardRepository(
            dao, service, reader
        )

        runBlocking {
            insertBoard?.callSuspend(
                repository,
                response,
                "title"
            )
        }

        verify { Log.e("RETROFIT", "400 Error") }
    }

    @Test
    fun deleteBoardCallbackSuccess() {
        val dao = mockk<BoardDao>()
        val response =
            mockk<Response<Void>>()

        every { response.isSuccessful } returns true
        coEvery { dao.delete(any()) } answers {}

        val deleteBoard = getPrivateFun(
            "deleteBoardCallback", BoardRepository::class
        )

        val repository = BoardRepository(
            dao, service, reader
        )

        runBlocking {
            deleteBoard?.callSuspend(
                repository,
                response,
                "id"
            )
        }

        coVerify { dao.delete(Board("id")) }
    }

    @Test
    fun deleteBoardCallbackError() {
        val dao = mockk<BoardDao>()
        val response =
            mockk<Response<Void>>()

        every { response.isSuccessful } returns false
        every { response.code() } returns 400
        every { response.message() } returns "Error"

        val deleteBoard = getPrivateFun(
            "deleteBoardCallback", BoardRepository::class
        )

        val repository = BoardRepository(
            dao, service, reader
        )

        runBlocking {
            deleteBoard?.callSuspend(
                repository,
                response,
                "id"
            )
        }

        verify { Log.e("RETROFIT", "400 Error") }
    }

    @Test
    fun deleteOldBoardFromDb() {
        val dao = mockk<BoardDao>()
        val dbBoards = mockk<LiveData<List<Board>>>()

        val board0 = Board("id0", "title0")
        val board1 = Board("id1", "title1")
        val board2 = Board("id2", "title2")
        val board3 = Board("id2", "title3")

        every { dbBoards.value } returns listOf(
            board0, board1, board2, board3
        )
        coEvery { dao.getAllBoard() } returns dbBoards
        coEvery { dao.delete(any()) } answers {}

        val removeOldBoards = getPrivateFun(
            "removeOldBoardsFromDb", BoardRepository::class
        )

        val repository = BoardRepository(
            dao, service, reader
        )

        runBlocking {
            removeOldBoards?.callSuspend(
                repository,
                listOf(
                    board0, board1, board3
                )
            )
        }

        coVerify { dao.delete(board2) }
    }

    @Test
    fun synchronizeCallbackError() {
        val dao = mockk<BoardDao>()
        val response =
            mockk<Response<MutableList<it.unisannio.ding.ids.wedroid.wrapper.entity.Board>>>()

        every { response.isSuccessful } returns false
        every { response.code() } returns 400
        every { response.message() } returns "Error"

        val synchronize = getPrivateFun(
            "synchronizeCallback", BoardRepository::class
        )

        val repository = BoardRepository(
            dao, service, reader
        )

        runBlocking {
            synchronize?.callSuspend(
                repository,
                response
            )
        }

        verify { Log.e("RETROFIT", "400 Error") }
    }

    @Test
    fun synchronizeCallbackEmptyBody() {
        val dao = mockk<BoardDao>()
        val response =
            mockk<Response<MutableList<it.unisannio.ding.ids.wedroid.wrapper.entity.Board>>>()

        every { response.isSuccessful } returns true
        every { response.body() } returns null

        val synchronize = getPrivateFun(
            "synchronizeCallback", BoardRepository::class
        )

        val repository = BoardRepository(
            dao, service, reader
        )

        runBlocking {
            synchronize?.callSuspend(
                repository,
                response
            )
        }
    }
}