package dev.inmo.postssystem.core.exposed

import dev.inmo.postssystem.core.post.SimplePost
import kotlinx.coroutines.runBlocking
import org.jetbrains.exposed.sql.Database
import org.jetbrains.exposed.sql.transactions.transactionManager
import java.io.File
import java.sql.Connection
import kotlin.test.*

class ExposedPostsRepoCommonTests {
    private val tempFolder = System.getProperty("java.io.tmpdir")!!

    private val numberOfDatabases = 8
    private lateinit var databaseFiles: List<File>
    private lateinit var apis: List<ExposedPostsRepo>

    @BeforeTest
    fun prepare() {
        databaseFiles = (0 until numberOfDatabases).map {
            File("$tempFolder/ExposedPostsAPICommonTestsDB$it.db")
        }
        apis = databaseFiles.map {
            val database = Database.connect("jdbc:sqlite:${it.absolutePath}").also {
                it.transactionManager.defaultIsolationLevel = Connection.TRANSACTION_SERIALIZABLE
            }
            ExposedPostsRepo(
                database
            )
        }
    }

    @Test
    fun `Test that it is possible to use several different databases at one time`() {
        val posts = apis.mapIndexed { i, api ->
            val content = runBlocking { api.createPost(SimplePost(listOf(i.toString()))) }
            assert(content != null)
            assert(runBlocking { api.getPostsIds().size == 1 })
            content!!
        }

        posts.forEachIndexed { i, post ->
            apis.forEachIndexed { j, api ->
                assert(
                    runBlocking {
                        api.getPostById(post.id) == (if (i != j) null else post)
                    }
                )
                assert(
                    runBlocking {
                        api.deletePost(post.id) == (i == j)
                    }
                )
            }
        }
    }

    @AfterTest
    fun `Close and delete databases`() {
        databaseFiles.forEach {
            it.delete()
        }
    }
}