// settings.gradle.kts
dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
    }
}

// build.gradle.kts
kotlin {
    jvm()
    android { /* ... */ }

    sourceSets {
        commonMain.dependencies {
            implementation(libs.kurpc)
        }
        jvmMain.dependencies {
            // One entry per platform the JVM application runs on.
            implementation(project.dependencies.variantOf(libs.kurpc.natives.jvm) { classifier("linux-x86_64") })
            implementation(project.dependencies.variantOf(libs.kurpc.natives.jvm) { classifier("macos-aarch64") })
            implementation(project.dependencies.variantOf(libs.kurpc.natives.jvm) { classifier("windows-x86_64") })
        }
    }
}

// build.gradle.kts
dependencies {
    implementation(libs.kurpc)
    implementation(variantOf(libs.kurpc.natives.jvm) { classifier("linux-x86_64") })
}

// build.gradle.kts
dependencies {
    implementation(libs.kurpc)
}

// build.gradle.kts
dependencies {
    implementation("io.github.xchacha20-poly1305:kurpc:0.2.0")
    // JVM only:
    implementation("io.github.xchacha20-poly1305:kurpc-natives-jvm:0.2.0:linux-x86_64")
}

import io.github.xchacha20_poly1305.kurpc.*

val channel = Channel(
    ChannelConfig(
        transport = Transport.Tcp("127.0.0.1", 50051),
        authority = "localhost",
    ),
)

channel.use {
    // calls
}

val reply: ByteArray = channel.unary(
    method = "/helloworld.Greeter/SayHello",
    request = HelloRequest.newBuilder().setName("kurpc").build().toByteArray(),
)
println(HelloReply.parseFrom(reply).message)

val response: UnaryResponse = channel.unaryCall("/helloworld.Greeter/SayHello", request)
val requestId = response.headers.text("x-request-id")

// Server streaming
channel.serverStreaming("/example.Feed/Subscribe", request).collect { bytes ->
    println(Event.parseFrom(bytes))
}

// Client streaming: sends every element, half-closes, returns the single response.
val summary: ByteArray = channel.clientStreaming(
    "/example.Upload/Send",
    flowOf(chunk1, chunk2, chunk3),
)

// Bidirectional streaming: requests are sent while responses are collected.
channel.bidiStreaming("/example.Chat/Talk", outgoing).collect { bytes ->
    println(ChatMessage.parseFrom(bytes))
}

// build.gradle.kts
import com.google.protobuf.gradle.id

plugins {
    id("com.google.protobuf") version "0.10.0"
}

dependencies {
    implementation(libs.kurpc)
    implementation("com.google.protobuf:protobuf-javalite:4.36.2")
}

protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:4.36.2"
    }
    plugins {
        id("kurpc") {
            // The `all` jar is self-contained; the plugin runs it with `java -jar`.
            artifact = "io.github.xchacha20-poly1305:protoc-gen-kurpc:0.1.1:all@jar"
        }
    }
    generateProtoTasks {
        all().configureEach {
            builtins {
                named("java") { option("lite") }
            }
            plugins {
                id("kurpc")
            }
        }
    }
}

val greeter = GreeterClient(channel)
val reply: HelloReply = greeter.sayHello(
    HelloRequest.newBuilder().setName("kurpc").build(),
    CallOptions(timeout = 5.seconds),
)

fun <Request, Response> CallInvoker.retrying(
    method: MethodDescriptor<Request, Response>,
    request: Request,
): Flow<Response> = serverStreaming(method, request).retry { it is TransportException }

import kotlin.time.Duration.Companion.seconds

val options = CallOptions(
    timeout = 5.seconds,
    metadata = Metadata.of("authorization" to "Bearer $token") +
        Metadata.ofBinary("trace-bin" to traceBytes),
    waitForReady = false, // fail fast with UNAVAILABLE instead of waiting for a connection
)
channel.unary("/helloworld.Greeter/SayHello", request, options)

try {
    channel.unary("/helloworld.Greeter/SayHello", request)
} catch (e: StatusException) {
    when (e.code) {
        Status.Code.NOT_FOUND -> println("not found: ${e.description}")
        Status.Code.DEADLINE_EXCEEDED -> println("timed out")
        else -> throw e
    }
}

// Unix domain socket, also supported on Windows 10 1803+.
// A path starting with "\u0000" is a Linux / Android abstract socket.
Transport.Unix("/run/app/grpc.sock")

// Windows named pipe.
Transport.WindowsNamedPipe("""\\.\pipe\app""")

// A connected socket file descriptor (Unix only); kurpc takes ownership of it.
Transport.FileDescriptor { connectAndReturnFd() }

// Any byte stream. The connector runs again for every reconnect.
Transport.Custom {
    val socket = Socket("example.com", 50051)
    Connection.of(socket.getInputStream(), socket.getOutputStream())
}

val channel = Channel(
    ChannelConfig(
        transport = Transport.Custom {
            Connection.tls(Socket("api.example.com", 443), serverName = "api.example.com")
        },
        authority = "api.example.com",
        secure = true,
    ),
)

import kotlin.time.Duration.Companion.seconds

ChannelConfig(
    transport = Transport.Tcp("127.0.0.1", 50051),
    connectTimeout = 5.seconds,
    keepAlive = KeepAlive(interval = 30.seconds, timeout = 10.seconds, whileIdle = true),
    userAgent = "my-app/1.0",
)

// Worker threads of the shared native runtime. Call before creating the first Channel.
Kurpc.configure(workerThreads = 2)