parsec3/src/jvmTest/kotlin/net/sergeych/parsec3/WsServerKtTest.kt

package net.sergeych.parsec3

import assertThrows
import io.ktor.server.engine.*
import io.ktor.server.netty.*
import kotlinx.coroutines.runBlocking
import kotlinx.serialization.Serializable
import net.sergeych.mp_logger.Log
import net.sergeych.tools.Opt
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue

internal class WsServerKtTest {

    data class TestSession(var buzz: String = "BuZZ"): WithAdapter()

    @Serializable
    data class TestStruct(val foobar: String)

    object TestApiServer: CommandHost<TestSession>() {
        val foo by command<String,String>()
        val ping by command<Unit,String>()
        val nullable1 by command<Boolean, Opt<TestStruct>>()
        val nullable2 by command<Boolean,String?>()
    }
    object TestApiClient: CommandHost<WithAdapter>() {
        val bar by command<String,String>()
    }

    @Test
    fun testWsServer() {

        embeddedServer(Netty, port = 8089) {
            parsec3TransportServer(
                TestApiServer,
            ) {
                newSession { TestSession() }
                on(api.foo) {
                    it + buzz + "-foo"
                }
            }
        }.start(wait = false)

        val client = Parsec3WSClient("ws://localhost:8089/api/p3", TestApiClient) {
            on(api.bar) {
                "bar:$it"
            }
        }
        runBlocking {
            val x = TestApiServer.foo.invoke(client.adapter(), "*great*")
            assertEquals("*great*BuZZ-foo", x)
            client.close()
        }

    }
    @Test
    fun testWsServerNullables() {

        embeddedServer(Netty, port = 8081) {
            parsec3TransportServer(
                TestApiServer,
            ) {
                newSession { TestSession() }
                on(api.foo) {
                    it + buzz + "-foo"
                }
                on(api.nullable2) {
                    if( it ) null else "not null"
                }
                on(api.nullable1) {
                    if( it ) Opt(null) else Opt(TestStruct("not null"))
                }
            }
        }.start(wait = false)

        val client = Parsec3WSClient("ws://localhost:8081/api/p3", TestApiClient) {}

        runBlocking {
            val x = TestApiServer.foo.invoke(client.adapter(), "*great*")
            assertEquals("*great*BuZZ-foo", x)
            assertEquals(TestApiServer.nullable2.invoke(client.adapter(), true),null)
            assertEquals(TestApiServer.nullable2.invoke(client.adapter(), false),"not null")
            assertEquals(TestApiServer.nullable1.invoke(client.adapter(), true),Opt<TestStruct>(null))

            assertTrue { TestApiServer.nullable1.invoke(client.adapter(), true).isNull }
            assertTrue { TestApiServer.nullable1.invoke(client.adapter(), false).isNotNull }
            assertEquals(TestApiServer.nullable1.invoke(client.adapter(), false),Opt(TestStruct("not null")))
            assertTrue { TestApiServer.nullable1.invoke(client.adapter(), false).value == TestStruct("not null") }
            client.close()

            assertEquals("bar", Opt<String>("bar").orElse { "foobar" } )
            assertEquals("foobar", Opt<String>(null).orElse { "foobar" } )
        }

    }
    @Test
    fun testWsServerReconnect() {

        embeddedServer(Netty, port = 8090) {
            parsec3TransportServer(
                TestApiServer,
            ) {
                newSession { TestSession() }
                var count = 0
                on(api.foo) {
                    adapter.cancel()
                    "cancelled:${count++}"
                }
                on(api.ping) { "pong!"}
            }
        }.start(wait = false)

        Log.connectConsole(Log.Level.DEBUG)
        val client = Parsec3WSClient("ws://localhost:8090/api/p3", TestApiClient) {
            on(api.bar) {
                "bar:$it"
            }
        }
        runBlocking {
            assertEquals("pong!", TestApiServer.ping.invoke(client.adapter()))
            assertThrows<Adapter.CloseError> { TestApiServer.foo.invoke(client.adapter(), "*great*") }
            assertEquals("pong!", TestApiServer.ping.invoke(client.adapter()))
            assertThrows<Adapter.CloseError> { TestApiServer.foo.invoke(client.adapter(), "*great*") }
        }

    }

    @Test
    fun testWsServerWaitForConnect() {

        val client = Parsec3WSClient("ws://localhost:8084/api/p3", TestApiClient) {
            on(api.bar) {
                "bar:$it"
            }
        }
        println("---1")
        embeddedServer(Netty, port = 8084) {
            parsec3TransportServer(
                TestApiServer,
            ) {
                newSession { TestSession() }
                on(api.foo) {
                    it + buzz + "-foo"
                }
            }
        }.start(wait = false)


        runBlocking {
            println("----2")
            val x = TestApiServer.foo.invoke(client.adapter(), "*great*")
            println(">> $x")
            assertEquals("*great*BuZZ-foo", x)
            client.close()
        }

    }

}