package com.jetbrains.jetstat.oneshot

import org.junit.jupiter.api.assertAll
import org.testcontainers.containers.ClickHouseContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers
import java.sql.Connection
import java.sql.DriverManager
import java.time.LocalDate as JavaTimeDate
import java.sql.Date as JavaSqlDate
import kotlin.test.*

@Testcontainers
class ClickhouseJdbcTest {
    @Container
    private val container = ClickHouseContainer("clickhouse/clickhouse-server:22.2")

    private inline fun withConnection(block: (Connection) -> Unit) =
        DriverManager
            .getConnection(container.jdbcUrl, container.username, container.password)
            .use(block)

    @BeforeTest
    fun `setup database`() {
        withConnection { conn ->
            conn.createStatement().use { statement ->
                statement.execute("CREATE TABLE example (a_date Date, b_dates Array(Date)) ENGINE = Log")
                statement.executeUpdate("INSERT INTO example(a_date, b_dates) VALUES ('2022-01-01', ['2022-01-02', '2022-01-03'])")
            }
        }
    }

    @Test
    fun `check that ClickHouse driver reports DATEs consistently`() {
        val expectedDateA = JavaTimeDate.of(2022, 1, 1)
        val expectedDatesB = listOf(
            JavaTimeDate.of(2022, 1, 2),
            JavaTimeDate.of(2022, 1, 3)
        )

        withConnection { conn ->
            conn.createStatement().use { statement ->
                val resultSet = statement.executeQuery("SELECT * FROM example")
                resultSet.next() // First
                val aDate = resultSet.getObject("a_date")
                val aDateDirect = resultSet.getDate("a_date")
                val bDatesArr = resultSet.getArray("b_dates").array
                val bDatesObj = resultSet.getObject("b_dates")

                println("Type of bDatesArr: ${bDatesArr.javaClass}")
                println("Type of bDatesObj: ${bDatesObj.javaClass}")

                assertEquals(JavaSqlDate.valueOf(expectedDateA), aDateDirect)

                when (aDate) {
                    is JavaSqlDate -> {
                        println("single date returned as JavaSqlDate")

                        assertEquals(JavaSqlDate.valueOf(expectedDateA), aDate)

                        val expected = expectedDatesB.map(JavaSqlDate::valueOf)
                        assertAll({
                            assertTrue(bDatesArr is Array<*> && bDatesArr.isArrayOf<JavaSqlDate>())
                            assertContentEquals(expected, bDatesArr.asList())                             
                        }, {
                            assertTrue(bDatesObj is Array<*> && bDatesObj.isArrayOf<JavaSqlDate>())
                            assertContentEquals(expected, bDatesObj.asList())
                        })
                    }

                    is JavaTimeDate -> {
                        println("single date returned as JavaTimeDate")
                        assertEquals(expectedDateA, aDate)

                        assertEquals(expectedDateA, aDate)
                        assertAll({
                            assertTrue(bDatesArr is Array<*> && bDatesArr.isArrayOf<JavaTimeDate>())
                            assertContentEquals(expectedDatesB, bDatesArr.asList())
                        }, {
                            assertTrue(bDatesObj is Array<*> && bDatesObj.isArrayOf<JavaTimeDate>())
                            assertContentEquals(expectedDatesB, bDatesObj.asList())
                        })
                    }

                    else -> {
                        error("Returned date as a weird type ${aDate.javaClass.name}")
                    }
                }

                val aDateExplicit = resultSet.getObject("a_date", JavaSqlDate::class.java)
                assertEquals(JavaSqlDate.valueOf(expectedDateA), aDateExplicit)
            }
        }
    }
}