Dasar Kotlin.

brew install kotlin
kotlinc main.kt -include-runtime -d main.jar && java -jar main.jar

fun main() {
    val appName = "NotiFly"          // read-only (seperti const/final)
    var retryCount = 0               // bisa diubah
    retryCount += 1

    val retentionDays: Int = 30      // tipe eksplisit (opsional, biasanya di-infer)
    val postTime = 1_727_500_000_000L

    // if, when, dan try adalah ekspresi → bisa langsung di-assign
    val label = if (retryCount > 1) "retry" else "first"
    println("$appName: $label, simpan $retentionDays hari, t=${postTime / 1000}")
}

data class Notif(val title: String?, val text: String?, val bigText: String?)

fun body(n: Notif): String {
    // ?. safe call, ?: elvis (nilai cadangan)
    val len = n.title?.length ?: 0
    // pilih teks terpanjang yang tersedia
    return n.bigText ?: n.text ?: "(tanpa isi) judul=$len karakter"
}

fun main() {
    val n = Notif(title = "Transfer masuk", text = null, bigText = null)
    println(body(n))

    n.text?.let { println("Ada teks: $it") }   // blok hanya jalan bila tidak null
    val panjang = n.title!!.length              // !! = "yakin tidak null" → crash bila salah
    println(panjang)
}

data class AppConfig(
    val serverUrl: String = "",
    val apiKey: String = "",
    val bankPackages: Set<String> = emptySet(),
    val retentionDays: Int = 30,
) {
    val isServerConfigured: Boolean
        get() = serverUrl.isNotBlank() && apiKey.isNotBlank()
}

fun main() {
    val awal = AppConfig()
    val baru = awal.copy(serverUrl = "https://api.example.com", apiKey = "demo")
    println(baru.isServerConfigured)       // true
    println(awal == AppConfig())           // true (equals berdasarkan isi)
    val (url, _, packages) = baru          // destructuring
    println("$url ${packages.size}")
}

enum class SendStatus { PENDING, SENDING, SENT, FAILED }

sealed interface SendResult {
    data object Success : SendResult
    data class Retryable(val message: String) : SendResult
    data class Permanent(val code: Int, val message: String) : SendResult
}

fun classify(httpCode: Int): SendResult = when (httpCode) {
    in 200..299 -> SendResult.Success
    408, 429, in 500..599 -> SendResult.Retryable("HTTP $httpCode, coba lagi")
    else -> SendResult.Permanent(httpCode, "Ditolak server")
}

fun main() {
    for (code in listOf(200, 503, 401)) {
        // when atas sealed type harus exhaustive → tanpa else
        val msg = when (val r = classify(code)) {
            SendResult.Success -> "terkirim"
            is SendResult.Retryable -> "ulang: ${r.message}"
            is SendResult.Permanent -> "gagal ${r.code}: ${r.message}"
        }
        println(msg)
    }
}

fun String.maskSecret(visible: Int = 4): String =
    if (length <= visible) "*".repeat(length)
    else "*".repeat(length - visible) + takeLast(visible)

val Long.asSeconds: Long get() = this / 1000   // extension property

fun main() {
    println("sk_live_abcdef123456".maskSecret())   // ****************3456
    println(1_727_500_000_000L.asSeconds)
}

data class Item(val pkg: String, val status: String, val postTime: Long)

fun main() {
    val items = listOf(
        Item("com.bank.a", "SENT", 3), Item("com.bank.b", "FAILED", 2),
        Item("com.bank.a", "PENDING", 1),
    )

    val failed = items.filter { it.status == "FAILED" }
    val perApp = items.groupingBy { it.pkg }.eachCount()        // {com.bank.a=2, com.bank.b=1}
    val terbaru = items.sortedByDescending { it.postTime }.map(Item::pkg)
    val adaPending = items.any { it.status == "PENDING" }
    println("$failed\n$perApp\n$terbaru\n$adaPending")

    // fungsi yang menerima lambda
    fun retry(times: Int, block: (attempt: Int) -> Boolean): Boolean {
        repeat(times) { if (block(it + 1)) return true }
        return false
    }
    println(retry(3) { attempt -> println("percobaan $attempt"); attempt == 2 })
}

// dependensi: org.jetbrains.kotlinx:kotlinx-coroutines-core
import kotlinx.coroutines.*

suspend fun sendToServer(id: Long): Boolean {
    delay(300)                 // suspend, tidak memblokir thread
    return id % 2 == 0L
}

fun main() = runBlocking {
    // launch: fire-and-forget, async: mengembalikan Deferred<T>
    val job = launch { println("log: mulai kirim") }

    val hasil = listOf(1L, 2L, 3L).map { id ->
        async(Dispatchers.IO) { id to sendToServer(id) }
    }.awaitAll()                // ketiganya jalan paralel (~300 ms total)

    job.join()
    println(hasil)             // [(1, false), (2, true), (3, false)]

    val r = withTimeoutOrNull(100) { sendToServer(4) }
    println("dengan timeout: $r")  // null karena lebih dari 100 ms
}