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.WListDao
import it.unisannio.ding.ids.wedroid.app.data.entity.WList
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.ListService
import junit.framework.TestCase
import kotlinx.coroutines.runBlocking
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 WListRepositoryTest {
    private val reader = mockk<PreferenceReader>()
    private val webServer = MockWebServer()
    private lateinit var service: ListService

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

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

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

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

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

        val addNewListToDb = getPrivateFun(
            "addNewWListToDb", WListRepository::class
        )

        val repository = WListRepository(
            dao, service, reader
        )

        val list0 = WList("id0", "title0")
        val list1 = WList("id1", "title1")
        val list2 = WList("id2", "title2")

        runBlocking {
            addNewListToDb?.callSuspend(
                repository,
                listOf(list0, list1, list2)
            )
        }

        coVerifyAll {
            dao.insert(list0)
            dao.insert(list1)
            dao.insert(list2)
        }

        TestCase.assertEquals(3, count)
    }

    @Test
    fun deleteWListCallbackSuccess() {
        val dao = mockk<WListDao>()
        val response =
            mockk<Response<Void>>()

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

        val deleteWList = getPrivateFun(
            "deleteWListCallBack", WListRepository::class
        )

        val repository = WListRepository(
            dao, service, reader
        )

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

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

    @Test
    fun deleteWListCallbackError() {
        val dao = mockk<WListDao>()
        val response = mockk<Response<Void>>()

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

        val repository = WListRepository(dao, service, reader)

        val deleteWList = getPrivateFun(
            "deleteWListCallBack", WListRepository::class
        )

        runBlocking {
            deleteWList?.callSuspend(
                repository,
                response,
                "id"
            )
        }
        verify { Log.e("RETROFIT", "400 Error") }
    }

    @Test
    fun deleteOldWListFromDb() {
        val dao = mockk<WListDao>()
        val dbWLists = mockk<LiveData<List<WList>>>()

        val wList0 = WList("id0", "title0")
        val wList1 = WList("id1", "title1")
        val wList2 = WList("id2", "title2")
        val wList3 = WList("id2", "title3")

        every { dbWLists.value } returns listOf(
            wList0, wList1, wList2, wList3
        )
        coEvery { dao.allWList } returns dbWLists
        coEvery { dao.delete(any()) } answers {}

        val removeOldWLists = getPrivateFun(
            "removeOldWListsFromDb", WListRepository::class
        )

        val repository = WListRepository(
            dao, service, reader
        )

        runBlocking {
            removeOldWLists?.callSuspend(
                repository,
                listOf(
                    wList0, wList2, wList3
                )
            )
        }

        coVerify { dao.delete(wList1) }
    }

    @Test
    fun synchronizeCallbackError() {
        val dao = mockk<WListDao>()

        val response =
            mockk<Response<MutableList<it.unisannio.ding.ids.wedroid.wrapper.entity.WList>>>()

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

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

        val repository = WListRepository(
            dao, service, reader
        )

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

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

}