Layered Architecture

// Demo layered architecture: presentation, application, domain, infrastructure.

// === Domain layer: aturan bisnis inti, tidak bergantung layer lain ===
data class Produk(val id: Int, val nama: String, val harga: Double)
data class Keranjang(val items: MutableList<Pair<Produk, Int>> = mutableListOf()) {
    fun tambah(p: Produk, jml: Int) = items.add(p to jml)
    fun total(): Double = items.sumOf { (p, j) -> p.harga * j }
}

// === Application layer: mengorkestrasi use case ===
class CheckoutUseCase(
    private val repo: ProdukRepository,        // interface dari domain
    private val payment: PaymentGateway,        // interface dari domain
    private val notifier: Notifier              // interface dari domain
) {
    data class Hasil(val total: Double, val pembayaran: String, val notifikasi: String)

    fun jalankan(produkIds: List<Pair<Int, Int>>): Hasil {
        val keranjang = Keranjang()
        for ((id, jml) in produkIds) {
            val p = repo.cari(id) ?: throw IllegalArgumentException("Produk $id tidak ada")
            keranjang.tambah(p, jml)
        }
        val total = keranjang.total()
        val trxId = payment.bayar(total)
        val notif = notifier.kirim("Pesanan dibayar: Rp$total")
        return Hasil(total, trxId, notif)
    }
}

// === Domain interfaces (ports) ===
interface ProdukRepository { fun cari(id: Int): Produk? }
interface PaymentGateway { fun bayar(jumlah: Double): String }
interface Notifier { fun kirim(pesan: String): String }

// === Infrastructure layer: implementasi konkret ===
class InMemoryProdukRepository(private val data: Map<Int, Produk>) : ProdukRepository {
    override fun cari(id: Int): Produk? = data[id]
}

class StripePaymentGateway : PaymentGateway {
    private var counter = 0
    override fun bayar(jumlah: Double): String {
        counter++
        return "TRX-$counter-Rp$jumlah"
    }
}

class EmailNotifier : Notifier {
    override fun kirim(pesan: String) = "Email dikirim: $pesan"
}

// === Presentation layer: user interface ===
class CliCheckout(private val useCase: CheckoutUseCase) {
    fun proses(input: String) {
        val pairs = input.split(",").map {
            val (id, jml) = it.split(":").let { p -> p[0].toInt() to p[1].toInt() }
            id to jml
        }
        val hasil = useCase.jalankan(pairs)
        println("=== Hasil Checkout ===")
        println("Total: Rp${hasil.total}")
        println("Pembayaran: ${hasil.pembayaran}")
        println("Notifikasi: ${hasil.notifikasi}")
    }
}

fun main() {
    println("=== Demo Layered Architecture ===")

    val repo = InMemoryProdukRepository(mapOf(
        1 to Produk(1, "Buku", 15_000.0),
        2 to Produk(2, "Pulpen", 5_000.0),
        3 to Produk(3, "Penggaris", 3_000.0)
    ))
    val payment = StripePaymentGateway()
    val notifier = EmailNotifier()
    val useCase = CheckoutUseCase(repo, payment, notifier)

    val cli = CliCheckout(useCase)
    cli.proses("1:2,2:3,3:1")
}

=== Demo Layered Architecture ===
=== Hasil Checkout ===
Total: Rp48000.0
Pembayaran: TRX-1-Rp48000.0
Notifikasi: Email dikirim: Pesanan dibayar: Rp48000.0