Date-Time Best Practices

import java.time.Duration
import java.time.Instant
import java.time.LocalDate
import java.time.LocalDateTime
import java.time.ZoneId
import java.time.ZonedDateTime
import java.time.format.DateTimeFormatter
import java.util.Locale

// Demonstrasi praktik terbaik pengelolaan tanggal:
// 1. Simpan momen sebagai Instant (UTC) di backend.
// 2. Tampilkan ke pengguna sebagai ZonedDateTime di zona lokal.
// 3. Hindari java.util.Date / java.util.Calendar lawas.
// 4. Gunakan ISO-8601 untuk pertukaran antar sistem.

data class CatatanAudit(
    val id: Long,
    val waktuUtc: Instant,           // selalu UTC
    val pelaku: String,
    val aksi: String,
)

data class TampilanJadwal(
    val judul: String,
    val waktuLokal: String,          // sudah terformat per pengguna
)

fun main() {
    // 1. Penyimpanan: Instant UTC
    val instanTetap: Instant = Instant.parse("2026-01-15T08:30:00Z")
    val catatan = CatatanAudit(
        id = 1,
        waktuUtc = instanTetap,
        pelaku = "Budi",
        aksi = "LOGIN",
    )
    println("=== Praktik 1: Simpan Instant UTC ===")
    println("catatan.waktuUtc : ${catatan.waktuUtc}")
    println("JSON (ISO-8601)  : \"${catatan.waktuUtc}\"")

    // 2. Tampilan: konversi ke zona lokal pengguna
    println()
    println("=== Praktik 2: Tampilkan sebagai ZonedDateTime ===")
    val zonaJakarta: ZoneId = ZoneId.of("Asia/Jakarta")
    val zonaTokyo: ZoneId = ZoneId.of("Asia/Tokyo")
    val zonaNewYork: ZoneId = ZoneId.of("America/New_York")

    val tampilJakarta = formatLokal(catatan.waktuUtc, zonaJakarta, Locale.of("id", "ID"))
    val tampilTokyo = formatLokal(catatan.waktuUtc, zonaTokyo, Locale.JAPAN)
    val tampilNY = formatLokal(catatan.waktuUtc, zonaNewYork, Locale.US)

    println("Jakarta  : $tampilJakarta")
    println("Tokyo    : $tampilTokyo")
    println("New York : $tampilNY")

    // 3. Menghindari API lawas: java.util.Date vs Instant
    println()
    println("=== Praktik 3: Hindari java.util.Date ===")
    val dateLawas = java.util.Date.from(instanTetap)
    val instanDariDate: Instant = dateLawas.toInstant()
    println("java.util.Date   : $dateLawas (zone ambiguitas)")
    println("Date.toInstant() : $instanDariDate (UTC eksplisit)")
    println("setara Instant?  : ${instanDariDate == instanTetap}")

    // 4. Selisih waktu dengan benar (Duration untuk jam, Period untuk kalender)
    println()
    println("=== Praktik 4: Duration vs Period ===")
    val mulai: Instant = Instant.parse("2026-01-15T08:00:00Z")
    val selesai: Instant = Instant.parse("2026-01-15T10:45:00Z")
    val durasiSesi: Duration = Duration.between(mulai, selesai)
    println("durasiSesi       : $durasiSesi (${durasiSesi.toMinutes()} menit)")

    val tanggalAwal: LocalDate = LocalDate.of(2026, 1, 15)
    val tanggalAkhir: LocalDate = LocalDate.of(2026, 3, 2)
    val periodeAktif: java.time.Period = java.time.Period.between(tanggalAwal, tanggalAkhir)
    println("periodeAktif     : $periodeAktif (${periodeAktif.days} hari di komponen Period)")

    // 5. Validasi tanggal input pengguna dengan STRICT resolver
    println()
    println("=== Praktik 5: Validasi input ===")
    val input = "2026-02-30"   // tanggal invalid
    val fmt = DateTimeFormatter.ISO_LOCAL_DATE
        .withResolverStyle(java.time.format.ResolverStyle.STRICT)
    val hasil: LocalDate? = try {
        LocalDate.parse(input, fmt)
    } catch (e: java.time.format.DateTimeParseException) {
        null
    }
    println("input            : $input")
    println("hasil validasi   : ${hasil ?: "ditolak (bukan tanggal valid)"}")

    // 6. Tampilan ZonedDateTime di serialisasi: sertakan zona
    println()
    println("=== Praktik 6: Sertakan zona saat tampilkan ===")
    val zdtJakarta: ZonedDateTime = catatan.waktuUtc.atZone(zonaJakarta)
    val zdtTokyo: ZonedDateTime = catatan.waktuUtc.atZone(zonaTokyo)
    println("zdt Jakarta      : $zdtJakarta")
    println("zdt Tokyo         : $zdtTokyo")
    println("toInstant sama?  : ${zdtJakarta.toInstant() == zdtTokyo.toInstant()}")
}

fun formatLokal(instan: Instant, zona: ZoneId, locale: Locale): String {
    val zdt: ZonedDateTime = instan.atZone(zona)
    val fmt = DateTimeFormatter
        .ofPattern("dd MMM yyyy HH:mm z", locale)
        .withZone(zona)
    return fmt.format(instan)
}

=== Praktik 1: Simpan Instant UTC ===
catatan.waktuUtc : 2026-01-15T08:30:00Z
JSON (ISO-8601)  : "2026-01-15T08:30:00Z"

=== Praktik 2: Tampilkan sebagai ZonedDateTime ===
Jakarta  : 15 Jan 2026 15:30 WIB
Tokyo    : 15 1月 2026 17:30 JST
New York : 15 Jan 2026 03:30 EST

=== Praktik 3: Hindari java.util.Date ===
java.util.Date   : Thu Jan 15 08:30:00 UTC 2026 (zone ambiguitas)
Date.toInstant() : 2026-01-15T08:30:00Z (UTC eksplisit)
setara Instant?  : true

=== Praktik 4: Duration vs Period ===
durasiSesi       : PT2H45M (165 menit)
periodeAktif     : P1M15D (15 hari di komponen Period)

=== Praktik 5: Validasi input ===
input            : 2026-02-30
hasil validasi   : ditolak (bukan tanggal valid)

=== Praktik 6: Sertakan zona saat tampilkan ===
zdt Jakarta      : 2026-01-15T15:30+07:00[Asia/Jakarta]
zdt Tokyo         : 2026-01-15T17:30+09:00[Asia/Tokyo]
toInstant sama?  : true

// commonMain: pemodelan data
import kotlinx.datetime.Instant
data class Sesi(val mulai: Instant, val durasi: kotlin.time.Duration)

// jvmMain: formatting untuk HTTP response
import java.time.format.DateTimeFormatter
fun Sesi.formatHttp(): String = ...