package solutions.bitbadger.documents

import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.assertThrows
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertNotSame
import kotlin.test.assertSame

/**
 * Unit tests for the `Parameters` object
 */
@DisplayName("Parameters")
class ParametersTest {

    /**
     * Reset the dialect
     */
    @AfterEach
    fun cleanUp() {
        Configuration.dialectValue = null
    }

    @Test
    @DisplayName("nameFields works with no changes")
    fun nameFieldsNoChange() {
        val fields = listOf(Field.equal("a", "", ":test"), Field.exists("q"), Field.equal("b", "", ":me"))
        val named = Parameters.nameFields(fields)
        assertEquals(fields.size, named.size, "There should have been 3 fields in the list")
        assertSame(fields.elementAt(0), named.elementAt(0), "The first field should be the same")
        assertSame(fields.elementAt(1), named.elementAt(1), "The second field should be the same")
        assertSame(fields.elementAt(2), named.elementAt(2), "The third field should be the same")
    }

    @Test
    @DisplayName("nameFields works when changing fields")
    fun nameFieldsChange() {
        val fields = listOf(
            Field.equal("a", ""), Field.equal("e", "", ":hi"), Field.equal("b", ""), Field.notExists("z"))
        val named = Parameters.nameFields(fields)
        assertEquals(fields.size, named.size, "There should have been 4 fields in the list")
        assertNotSame(fields.elementAt(0), named.elementAt(0), "The first field should not be the same")
        assertEquals(":field0", named.elementAt(0).parameterName, "First parameter name incorrect")
        assertSame(fields.elementAt(1), named.elementAt(1), "The second field should be the same")
        assertNotSame(fields.elementAt(2), named.elementAt(2), "The third field should not be the same")
        assertEquals(":field1", named.elementAt(2).parameterName, "Third parameter name incorrect")
        assertSame(fields.elementAt(3), named.elementAt(3), "The fourth field should be the same")
    }

    @Test
    @DisplayName("replaceNamesInQuery replaces successfully")
    fun replaceNamesInQuery() {
        val parameters = listOf(Parameter(":data", ParameterType.JSON, "{}"),
            Parameter(":data_ext", ParameterType.STRING, ""))
        val query = "SELECT data, data_ext FROM tbl WHERE data = :data AND data_ext = :data_ext AND more_data = :data"
        assertEquals("SELECT data, data_ext FROM tbl WHERE data = ? AND data_ext = ? AND more_data = ?",
            Parameters.replaceNamesInQuery(query, parameters), "Parameters not replaced correctly")
    }

    @Test
    @DisplayName("fieldNames generates a single parameter (PostgreSQL)")
    fun fieldNamesSinglePostgres() {
        Configuration.dialectValue = Dialect.POSTGRESQL
        val nameParams = Parameters.fieldNames(listOf("test"))
        assertEquals(1, nameParams.size, "There should be one name parameter")
        assertEquals(":name", nameParams[0].name, "The parameter name is incorrect")
        assertEquals(ParameterType.STRING, nameParams[0].type, "The parameter type is incorrect")
        assertEquals("{test}", nameParams[0].value, "The parameter value is incorrect")
    }

    @Test
    @DisplayName("fieldNames generates multiple parameters (PostgreSQL)")
    fun fieldNamesMultiplePostgres() {
        Configuration.dialectValue = Dialect.POSTGRESQL
        val nameParams = Parameters.fieldNames(listOf("test", "this", "today"))
        assertEquals(1, nameParams.size, "There should be one name parameter")
        assertEquals(":name", nameParams[0].name, "The parameter name is incorrect")
        assertEquals(ParameterType.STRING, nameParams[0].type, "The parameter type is incorrect")
        assertEquals("{test,this,today}", nameParams[0].value, "The parameter value is incorrect")
    }

    @Test
    @DisplayName("fieldNames generates a single parameter (SQLite)")
    fun fieldNamesSingleSQLite() {
        Configuration.dialectValue = Dialect.SQLITE
        val nameParams = Parameters.fieldNames(listOf("test"))
        assertEquals(1, nameParams.size, "There should be one name parameter")
        assertEquals(":name0", nameParams[0].name, "The parameter name is incorrect")
        assertEquals(ParameterType.STRING, nameParams[0].type, "The parameter type is incorrect")
        assertEquals("test", nameParams[0].value, "The parameter value is incorrect")
    }

    @Test
    @DisplayName("fieldNames generates multiple parameters (SQLite)")
    fun fieldNamesMultipleSQLite() {
        Configuration.dialectValue = Dialect.SQLITE
        val nameParams = Parameters.fieldNames(listOf("test", "this", "today"))
        assertEquals(3, nameParams.size, "There should be one name parameter")
        assertEquals(":name0", nameParams[0].name, "The first parameter name is incorrect")
        assertEquals(ParameterType.STRING, nameParams[0].type, "The first parameter type is incorrect")
        assertEquals("test", nameParams[0].value, "The first parameter value is incorrect")
        assertEquals(":name1", nameParams[1].name, "The second parameter name is incorrect")
        assertEquals(ParameterType.STRING, nameParams[1].type, "The second parameter type is incorrect")
        assertEquals("this", nameParams[1].value, "The second parameter value is incorrect")
        assertEquals(":name2", nameParams[2].name, "The third parameter name is incorrect")
        assertEquals(ParameterType.STRING, nameParams[2].type, "The third parameter type is incorrect")
        assertEquals("today", nameParams[2].value, "The third parameter value is incorrect")
    }

    @Test
    @DisplayName("fieldNames fails if dialect not set")
    fun fieldNamesFails() {
        assertThrows<DocumentException> { Parameters.fieldNames(listOf()) }
    }
}