Domain Modeling

// Demo domain modeling: value objects, entities, aggregates, bounded contexts.

import java.time.LocalDate

// === Value Object: tidak punya identitas, dibedakan dari nilai ===
@JvmInline
value class Email(val nilai: String) {
    init {
        require(nilai.contains("@")) { "Email tidak valid: $nilai" }
    }
}

@JvmInline
value class JumlahUang(val nilai: Double) : Comparable<JumlahUang> {
    operator fun plus(lain: JumlahUang) = JumlahUang(nilai + lain.nilai)
    operator fun minus(lain: JumlahUang) = JumlahUang(nilai - lain.nilai)
    override fun compareTo(other: JumlahUang): Int = nilai.compareTo(other.nilai)
}

data class TanggalPesanan(val tanggal: LocalDate)

// === Entity: punya identitas (id), mutable state terkontrol ===
data class ItemPesanan(val id: Int, val nama: String, val harga: JumlahUang, val jumlah: Int) {
    fun subtotal(): JumlahUang = JumlahUang(harga.nilai * jumlah)
}

// === Aggregate Root: Pesanan adalah root; ItemPesanan ada di dalam aggregate ===
class Pesanan(val id: Int, val pelanggan: String) {
    private val items = mutableListOf<ItemPesanan>()
    private var status: StatusPesanan = StatusPesanan.DRAFT
    val tanggalDibuat = TanggalPesanan(LocalDate.of(2026, 1, 15))

    fun tambahItem(item: ItemPesanan) {
        require(status == StatusPesanan.DRAFT) {
            "Tidak bisa tambah item: status sudah $status"
        }
        items.add(item)
    }

    fun total(): JumlahUang = items.fold(JumlahUang(0.0)) { acc, i -> acc + i.subtotal() }

    fun kirim() {
        require(status == StatusPesanan.DRAFT) { "Pesanan sudah dikirim" }
        require(items.isNotEmpty()) { "Tidak bisa kirim pesanan kosong" }
        status = StatusPesanan.DIKIRIM
    }

    fun ringkas(): String = "Pesanan #$id ($pelanggan) ${items.size} item total=${total().nilai} status=$status"
}

enum class StatusPesanan { DRAFT, DIKIRIM, SELESAI }

// === Bounded Context: konteks Inventaris berbeda dari konteks Penjualan ===
// ItemPesanan di konteks Penjualan = harga + jumlah
// Item di konteks Inventaris = stok + lokasi rak
data class ItemInventaris(val sku: String, val stok: Int, val lokasiRak: String)

class LayananInventaris {
    private val stok = mutableMapOf<String, Int>()

    fun daftar(item: ItemInventaris) {
        stok[item.sku] = (stok[item.sku] ?: 0) + item.stok
    }

    fun kurangi(sku: String, jumlah: Int): Boolean {
        val saatIni = stok[sku] ?: return false
        if (saatIni < jumlah) return false
        stok[sku] = saatIni - jumlah
        return true
    }

    fun stokSaatIni(sku: String): Int = stok[sku] ?: 0
}

fun main() {
    println("=== Demo Domain Modeling ===")

    // Value object
    val email = Email("[email protected]")
    println("Email valid: ${email.nilai}")

    val harga = JumlahUang(15_000.0)
    val tambahan = JumlahUang(5_000.0)
    println("Harga + tambahan: ${(harga + tambahan).nilai}")

    // Aggregate root
    val p = Pesanan(101, "Budi")
    p.tambahItem(ItemPesanan(1, "Buku", JumlahUang(15_000.0), 2))
    p.tambahItem(ItemPesanan(2, "Pulpen", JumlahUang(5_000.0), 3))
    println(p.ringkas())
    p.kirim()
    println(p.ringkas())

    println()
    println("--- Bounded Context: Inventaris ---")
    val inv = LayananInventaris()
    inv.daftar(ItemInventaris("BK001", 100, "Rak A1"))
    inv.daftar(ItemInventaris("PL001", 50, "Rak A2"))
    println("Stok awal BK001: ${inv.stokSaatIni("BK001")}")
    inv.kurangi("BK001", 5)
    println("Stok setelah kurangi 5: ${inv.stokSaatIni("BK001")}")
}

=== Demo Domain Modeling ===
Email valid: [email protected]
Harga + tambahan: 20000.0
Pesanan #101 (Budi) 2 item total=45000.0 status=DRAFT
Pesanan #101 (Budi) 2 item total=45000.0 status=DIKIRIM

--- Bounded Context: Inventaris ---
Stok awal BK001: 100
Stok setelah kurangi 5: 95