import arrow.Kind
import arrow.effects.ForIO
import arrow.effects.IO
import arrow.effects.extensions.io.async.async
import arrow.effects.fix
import arrow.effects.typeclasses.Async
import io.ktor.application.ApplicationCall
import io.ktor.application.call
import io.ktor.response.respond
import io.ktor.routing.Routing
import io.ktor.routing.get
import io.ktor.routing.routing
import io.ktor.server.engine.embeddedServer
import io.ktor.server.netty.Netty
import kotlinx.coroutines.Deferred
import kotlinx.coroutines.async
import kotlinx.coroutines.runBlocking
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException
import kotlin.coroutines.suspendCoroutine

interface Deferrable<F> {
    fun <A: Any> Kind<F, A>.deferred(): Deferred<A>
}

fun IO.Companion.deferrable(): Deferrable<ForIO> = object: Deferrable<ForIO> {
    override fun <A: Any> Kind<ForIO, A>.deferred(): Deferred<A> {
        val io = this.fix()

        return runBlocking {
            async {
                val result: A = suspendCoroutine { cont ->
                    io.unsafeRunAsync { result -> result.fold(cont::resumeWithException, cont::resume) }
                }
                result
            }
        }
    }
}

suspend fun <F, A: Any> ApplicationCall.respondWithDeferrable(value: Kind<F, A>, deferrable: Deferrable<F>) {
    val output: Any = deferrable.run { value.deferred() }.await()
    respond(output)
}

class DemoService<F>(private val async: Async<F>) {
    fun makeSomeWork(): Kind<F, String> = async.delay { "some work" }
}

class DemoRouting<F>(private val service: DemoService<F>, private val deferrable: Deferrable<F>) {
    fun Routing.demo() {
        get("/demo") {
            val work: Kind<F, String> = service.makeSomeWork()
            call.respondWithDeferrable(work, deferrable)
        }
    }
}

fun main() {

    val deferrable: Deferrable<ForIO> = IO.deferrable()
    val service: DemoService<ForIO> = DemoService(IO.async())
    val demoRouting: DemoRouting<ForIO> = DemoRouting(service, deferrable)

    val server = embeddedServer(Netty, port = 8080) {
        routing {
            with (demoRouting) { demo() }
        }
    }
    server.start(wait = true)

}