package com.example

import io.r2dbc.h2.H2ConnectionConfiguration
import io.r2dbc.h2.H2ConnectionFactory
import io.r2dbc.spi.Result
import io.r2dbc.spi.Row
import io.r2dbc.spi.RowMetadata
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.reactive.awaitLast
import kotlinx.coroutines.reactive.awaitSingle
import kotlinx.coroutines.reactor.mono
import kotlinx.coroutines.runBlocking
import reactor.core.publisher.Mono
import reactor.core.publisher.toFlux
import reactor.core.publisher.toMono
import kotlin.test.BeforeTest
import kotlin.test.Test


class R2Dbc {

    var config: H2ConnectionConfiguration = H2ConnectionConfiguration.builder().inMemory("jdbc:h2:mem:r2dbc-test").build()

    @BeforeTest
    fun createH2() {
        config = H2ConnectionConfiguration.builder().inMemory("jdbc:h2:mem:r2dbc-test").build()
    }

    @Test
    fun firstTest() {
        val h2ConnectionFactory = H2ConnectionFactory(config)
        val connection = h2ConnectionFactory.create()
        val insert: Mono<MutableList<out Result>> = GlobalScope.mono {
            val con = connection.awaitSingle()
            con.createStatement(
                    // language=SQL
                    """create table messages(
                        |id integer not null primary key ,
                        |text varchar(10000) not null ,
                        |user_id integer  not null
                        |)""".trimMargin())
                    .execute()
                    .log("create-table").awaitSingle()
            con.createStatement(
                    //language=SQL
                    """insert into messages(id, text, user_id) values (?1, ?2, ?3)""")
                    .bind(0, 1000)
                    .bind(1, "こんにちわ")
                    .bind(2, 100)
                    .execute()
                    .toFlux()
                    .collectList()
                    .awaitSingle()
        }
        val mono: Mono<Triple<String, Int, Int>> = GlobalScope.mono {
            val a = insert.awaitLast()
            val rowUpdates = a.map { it.rowsUpdated.toMono().awaitSingle() }
            println(rowUpdates)
            val con = connection.awaitSingle()
            con.createStatement(
                    //language=SQL
                    """select text as text, id as id, user_id as user_id from messages""")
                    .execute()
                    .flatMap {
                        it.map { row: Row, _: RowMetadata ->
                            val text = row.get("text", String::class.java)
                            val id = row.get("id") as Int
                            val user = row.get("user_id") as Int
                            Triple(text, id, user)
                        }
                    }
                    .toMono().awaitSingle()
        }
        runBlocking {
            val result = mono.awaitSingle()
            println(result)
        }
    }
}