var session: WampSession? = null

fun createSession(url: String, sessionListener: WampSession.WampSessionListener) {
    WampClient(OkHttpWebSocketFactory()).createSession(
        uri = url,
        sessionListener = sessionListener
    ) { result ->
        result.onSuccess {
            println("Session created successfully")
            session = it
        }
        result.onFailure {
            println("Could not create session: ${it.message}")
            session = null
        }
    }
}

suspend fun realm() {
    session?.join("myrealm")
    session?.leave() // underlying WebSocket stays open, can join again afterwards
    session?.shutdown() // session now terminally shut down, WebSocket closed, cannot join again
}

suspend fun subscribe() {
    val subscription = session?.subscribe("mytopic") ?: return
    subscription.consumeEach {
        when (it) {
            is SubscriptionEstablished -> println("Subscription established. SubscriptionId = ${it.subscriptionId}")
            is Payload                 -> println("Received event: Arguments = ${it.arguments} ArgumentsKw = ${it.argumentsKw}")
            SubscriptionClosed         -> println("Subscription has ended.")
            is SubscriptionFailed      -> println("Subscription failed with ${it.errorUri}")
            is UnsubscriptionFailed    -> println("Unsubscription failed with ${it.errorUri}")
        }
    }
    println("Subscription lifetime ended.")
}

suspend fun unsubscribe(subscriptionId: SubscriptionId) {
    session?.unsubscribe(subscriptionId) // if this fails for some reason, you will get an UnsubscriptionFailed on the original subscription channel
}

suspend fun publish() {
    // if acknowledge is `false` you will not be notified about the delivery and the publication channel is closed immediately
    val publication =
        session?.publish(
            topic = "mytopic",
            arguments = jsonArray { +"some arg" }, // can be null
            argumentsKw = json { "answer" to 42 }, // can be null
            acknowledge = true // `false` for "fire-and-forget"
        ) ?: return
    publication.consumeEach {
        when (it) {
            is PublicationSucceeded -> println("Event successfully published")
            is PublicationFailed    -> println("Event could not be published: ${it.errorUri}")
        }
    }
    println("Event was published (or not ;))")
}

suspend fun registerFunction() {
    val registration = session?.register("myfunction") ?: return
    registration.consumeEach {
        when (it) {
            is ProcedureRegistered  -> println("Procedure registered successfully! RegistrationId = ${it.registrationId}")
            is Invocation           -> {
                println("Someone wants to call us. Arguments = ${it.arguments} ArgumentsKw = ${it.argumentsKw}")
                // don't forget to actually respond!
                it.returnResult(CallSucceeded(arguments = jsonArray { +"It worked!" }))
            }
            ProcedureUnregistered   -> println("Procedure unregistered successfully!")
            is RegistrationFailed   -> println("Registration failed with ${it.errorUri}")
            is UnregistrationFailed -> println("Unregisration failed with ${it.errorUri}")
        }
    }
    println("Registration lifetime ended.")
}

suspend fun unregisterFunction(registrationId: RegistrationId) {
    session?.unregister(registrationId) // if this fails for some reason, you will get an UnregistrationFailed on the original registration channel
}

suspend fun callFunction() {
    val call = session?.call(
        "myfunction",
        arguments = jsonArray { +"some parameter" },
        argumentsKw = json { "additional" to "parameter" }) ?: return
    call.consumeEach {
        when (it) {
            is CallSucceeded -> println("Call succeeded!")
            is CallFailed    -> println("Call failed!")
        }
    }
    println("Call finished.")
}