Design Patterns

// Demo Design Patterns: overview GoF patterns dengan implementasi Kotlin idiomatic.
// Patterns: Creational, Structural, Behavioral.

// === CREATIONAL PATTERNS ===

// Singleton (Kotlin object)
object KonfigurasiApp {
    val versi = "1.0.0"
    val nama = "Kotlin Demo"
}

// Factory Method (companion object sebagai factory)
interface Hewan { fun bunyi(): String }
class Kucing : Hewan { override fun bunyi() = "meong" }
class Anjing : Hewan { override fun bunyi() = "guk" }

class HewanFactory {
    companion object {
        fun buat(jenis: String): Hewan = when (jenis.lowercase()) {
            "kucing" -> Kucing()
            "anjing" -> Anjing()
            else -> throw IllegalArgumentException("Jenis tidak dikenal: $jenis")
        }
    }
}

// Builder (idiomatic Kotlin: data class + copy + apply)
data class KonfigurasiServer(
    val host: String = "localhost",
    val port: Int = 8080,
    val timeout: Int = 30,
    val ssl: Boolean = false
)

// === STRUCTURAL PATTERNS ===

// Adapter
interface Target { fun request(): String }
class Adaptee { fun spesifikRequest() = "respons spesifik adaptee" }
class Adapter(private val adaptee: Adaptee) : Target {
    override fun request() = adaptee.spesifikRequest().uppercase()
}

// Decorator (via `by` delegation)
interface Notifier { fun kirim(pesan: String) }
class EmailNotifier : Notifier {
    override fun kirim(pesan: String) = println("[email] $pesan")
}
class LoggingNotifier(private val inner: Notifier) : Notifier by inner {
    override fun kirim(pesan: String) {
        println("[log] akan mengirim notifikasi")
        inner.kirim(pesan)
        println("[log] notifikasi terkirim")
    }
}

// Facade
class CPU { fun nyalakan() = "CPU on" }
class Memory { fun load() = "Memory loaded" }
class Disk { fun read() = "Disk read" }
class ComputerFacade {
    private val cpu = CPU()
    private val mem = Memory()
    private val disk = Disk()
    fun start(): String = "${cpu.nyalakan()}, ${mem.load()}, ${disk.read()}"
}

// === BEHAVIORAL PATTERNS ===

// Strategy (function as parameter — idiomatic Kotlin)
fun proses(data: List<Int>, strategi: (List<Int>) -> Int): Int = strategi(data)
val strategiSum: (List<Int>) -> Int = { it.sum() }
val strategiMax: (List<Int>) -> Int = { it.maxOrNull() ?: 0 }

// Observer (via StateFlow-like simple impl)
class Publisher<T> {
    private val subscribers = mutableListOf<(T) -> Unit>()
    fun subscribe(s: (T) -> Unit) = subscribers.add(s)
    fun publish(value: T) = subscribers.forEach { it(value) }
}

// Command
interface Command { fun execute(): String }
class CommandA : Command { override fun execute() = "Command A dieksekusi" }
class CommandB : Command { override fun execute() = "Command B dieksekusi" }
class Invoker {
    private val history = mutableListOf<Command>()
    fun run(c: Command): String {
        history.add(c)
        return c.execute()
    }
}

// Template Method
abstract class PesananTemplate {
    fun proses(): String {
        val a = validasi()
        val b = bayar()
        val c = kirim()
        return "$a -> $b -> $c"
    }
    abstract fun validasi(): String
    abstract fun bayar(): String
    abstract fun kirim(): String
}
class PesananDigital : PesananTemplate() {
    override fun validasi() = "validasi digital"
    override fun bayar() = "bayar digital"
    override fun kirim() = "kirim email"
}

fun main() {
    println("=== Demo Design Patterns ===")

    // Creational
    println("KonfigurasiApp: ${KonfigurasiApp.nama} v${KonfigurasiApp.versi}")
    println("Factory: ${HewanFactory.buat("kucing").bunyi()}")
    val cfg = KonfigurasiServer().copy(host = "production.example.com", ssl = true)
    println("Builder copy: $cfg")

    println()
    // Structural
    val adapter = Adapter(Adaptee())
    println("Adapter: ${adapter.request()}")
    println("--- Decorator ---")
    val notifier: Notifier = LoggingNotifier(EmailNotifier())
    notifier.kirim("halo")
    println("Facade: ${ComputerFacade().start()}")

    println()
    // Behavioral
    val data = listOf(1, 2, 3, 4, 5)
    println("Strategy sum: ${proses(data, strategiSum)}")
    println("Strategy max: ${proses(data, strategiMax)}")
    println("--- Observer ---")
    val pub = Publisher<String>()
    pub.subscribe { println("  Sub 1 menerima: $it") }
    pub.subscribe { println("  Sub 2 menerima: $it") }
    pub.publish("event")
    println("--- Command ---")
    val inv = Invoker()
    println(inv.run(CommandA()))
    println(inv.run(CommandB()))
    println("--- Template Method ---")
    println(PesananDigital().proses())
}

=== Demo Design Patterns ===
KonfigurasiApp: Kotlin Demo v1.0.0
Factory: meong
Builder copy: KonfigurasiServer(host=production.example.com, port=8080, timeout=30, ssl=true)

Adapter: RESPONS SPESIFIK ADAPTEE
--- Decorator ---
[log] akan mengirim notifikasi
[email] halo
[log] notifikasi terkirim
Facade: CPU on, Memory loaded, Disk read

Strategy sum: 15
Strategy max: 5
--- Observer ---
  Sub 1 menerima: event
  Sub 2 menerima: event
--- Command ---
Command A dieksekusi
Command B dieksekusi
--- Template Method ---
validasi digital -> bayar digital -> kirim email