JSON Serialization

import java.io.StringReader
import java.io.StringWriter

// === Parser JSON sederhana tanpa library eksternal ===
// Mendukung: object { "k": v }, array [v, v], string, number, boolean, null

sealed class JsonValue {
    data class Str(val v: String) : JsonValue() {
        override fun toString() = "\"$v\""
    }
    data class Num(val v: Double) : JsonValue() {
        override fun toString() = if (v % 1.0 == 0.0) v.toInt().toString() else v.toString()
    }
    data class Bool(val v: Boolean) : JsonValue() {
        override fun toString() = v.toString()
    }
    object Null : JsonValue() {
        override fun toString() = "null"
    }
    data class Arr(val items: List<JsonValue>) : JsonValue() {
        override fun toString() = items.joinToString(", ", "[", "]")
    }
    data class Obj(val entries: List<Pair<String, JsonValue>>) : JsonValue() {
        override fun toString() = entries.joinToString(", ") { "\"${it.first}\": ${it.second}" }.let { "{$it}" }
    }
}

class JsonParser(private val src: String) {
    private var pos = 0

    fun parse(): JsonValue {
        skipWs()
        val v = parseValue()
        skipWs()
        require(pos == src.length) { "Karakter tersisa setelah JSON valid" }
        return v
    }

    private fun parseValue(): JsonValue {
        skipWs()
        return when (val c = peek()) {
            '"' -> JsonValue.Str(parseString())
            't', 'f' -> parseBool()
            'n' -> parseNull()
            '[' -> parseArray()
            '{' -> parseObject()
            else -> if (c == '-' || c.isDigit()) parseNumber() else throw IllegalArgumentException("Unexpected: $c at $pos")
        }
    }

    private fun parseString(): String {
        require(peek() == '"')
        pos++
        val sb = StringBuilder()
        while (peek() != '"') {
            val c = src[pos++]
            if (c == '\\') {
                when (val e = src[pos++]) {
                    'n' -> sb.append('\n')
                    't' -> sb.append('\t')
                    '"' -> sb.append('"')
                    '\\' -> sb.append('\\')
                    '/' -> sb.append('/')
                    else -> sb.append(e)
                }
            } else sb.append(c)
        }
        pos++
        return sb.toString()
    }

    private fun parseNumber(): JsonValue.Num {
        val start = pos
        if (peek() == '-') pos++
        while (pos < src.length && (src[pos].isDigit() || src[pos] == '.' || src[pos] == 'e' || src[pos] == 'E' || src[pos] == '+' || src[pos] == '-')) pos++
        return JsonValue.Num(src.substring(start, pos).toDouble())
    }

    private fun parseBool(): JsonValue.Bool {
        if (src.startsWith("true", pos)) { pos += 4; return JsonValue.Bool(true) }
        if (src.startsWith("false", pos)) { pos += 5; return JsonValue.Bool(false) }
        throw IllegalArgumentException("Invalid bool at $pos")
    }

    private fun parseNull(): JsonValue.Null {
        if (src.startsWith("null", pos)) { pos += 4; return JsonValue.Null }
        throw IllegalArgumentException("Invalid null at $pos")
    }

    private fun parseArray(): JsonValue.Arr {
        require(peek() == '['); pos++
        skipWs()
        val items = mutableListOf<JsonValue>()
        if (peek() == ']') { pos++; return JsonValue.Arr(items) }
        while (true) {
            items.add(parseValue())
            skipWs()
            when (peek()) {
                ',' -> { pos++; skipWs() }
                ']' -> { pos++; return JsonValue.Arr(items) }
                else -> throw IllegalArgumentException("Expected , or ] at $pos")
            }
        }
    }

    private fun parseObject(): JsonValue.Obj {
        require(peek() == '{'); pos++
        skipWs()
        val entries = mutableListOf<Pair<String, JsonValue>>()
        if (peek() == '}') { pos++; return JsonValue.Obj(entries) }
        while (true) {
            skipWs()
            val key = parseString()
            skipWs()
            require(peek() == ':'); pos++
            val value = parseValue()
            entries.add(key to value)
            skipWs()
            when (peek()) {
                ',' -> { pos++; skipWs() }
                '}' -> { pos++; return JsonValue.Obj(entries) }
                else -> throw IllegalArgumentException("Expected , or } at $pos")
            }
        }
    }

    private fun peek(): Char = src[pos]
    private fun skipWs() { while (pos < src.length && src[pos].isWhitespace()) pos++ }
}

fun main() {
    val jsonText = """
        {
            "nama": "Budi",
            "umur": 25,
            "menikah": false,
            "anak": ["Andi", "Citra"],
            "alamat": null
        }
    """.trimIndent()

    val parser = JsonParser(jsonText)
    val parsed = parser.parse()

    println("Parsed JSON:")
    println(parsed)
    println()

    // Akses field
    val obj = parsed as JsonValue.Obj
    for ((key, value) in obj.entries) {
        println("  $key = $value")
    }

    // Cek tipe
    val nama = obj.entries.find { it.first == "nama" }?.second
    println("\nNama: $nama (tipe: ${nama?.javaClass?.simpleName})")

    val anak = obj.entries.find { it.first == "anak" }?.second as JsonValue.Arr
    println("Jumlah anak: ${anak.items.size}")
    println("Anak pertama: ${anak.items[0]}")
}

Parsed JSON:
{"nama": "Budi", "umur": 25, "menikah": false, "anak": ["Andi", "Citra"], "alamat": null}

  nama = "Budi"
  umur = 25
  menikah = false
  anak = ["Andi", "Citra"]
  alamat = null

Nama: "Budi" (tipe: Str)
Jumlah anak: 2
Anak pertama: "Andi"

import kotlinx.serialization.*
import kotlinx.serialization.json.*

@Serializable
data class Pengguna(val nama: String, val umur: Int)

fun main() {
    val u = Pengguna("Budi", 25)
    val json = Json.encodeToString(u)
    println(json) // {"nama":"Budi","umur":25}

    val loaded = Json.decodeFromString<Pengguna>(json)
    println(loaded)
}