Observer Pattern

// Demo Observer Pattern: Publisher + Subscriber; StateFlow-like simple impl.

// === Classic Observer: Subject + Observer interface ===
interface Observer<T> {
    fun update(data: T)
}

class Subject<T> {
    private val observers = mutableListOf<Observer<T>>()
    private var state: T? = null

    fun attach(o: Observer<T>) {
        observers.add(o)
    }

    fun detach(o: Observer<T>) {
        observers.remove(o)
    }

    fun setState(newState: T) {
        state = newState
        notifyObservers()
    }

    private fun notifyObservers() {
        val s = state ?: return
        observers.forEach { it.update(s) }
    }
}

// === Idiomatic Kotlin: function-based observer ===
class Observable<T>(initial: T) {
    private var current = initial
    private val listeners = mutableListOf<(T) -> Unit>()

    var value: T
        get() = current
        set(newValue) {
            if (newValue != current) {
                current = newValue
                listeners.forEach { it(current) }
            }
        }

    fun subscribe(listener: (T) -> Unit) {
        listeners.add(listener)
        listener(current)  // emit current value immediately
    }
}

// === StateFlow-like (simplified) ===
class StateFlow<T>(initial: T) {
    private var value_ = initial
    private val subscribers = mutableListOf<(T) -> Unit>()

    val value: T get() = value_

    fun emit(newValue: T) {
        value_ = newValue
        subscribers.forEach { it(newValue) }
    }

    fun collect(collector: (T) -> Unit) {
        subscribers.add(collector)
        collector(value_)  // immediate emit
    }
}

// === Concrete observer: logger + threshold ===
class StokLogger : Observer<Int> {
    override fun update(data: Int) {
        println("[logger] Stok sekarang: $data")
    }
}

class StokAlerm(private val threshold: Int) : Observer<Int> {
    override fun update(data: Int) {
        if (data < threshold) {
            println("[alert] Stok di bawah $threshold: $data")
        }
    }
}

fun main() {
    println("=== Demo Observer Pattern ===")

    println("--- 1. Classic Observer (Subject + Observer) ---")
    val stok = Subject<Int>()
    stok.attach(StokLogger())
    stok.attach(StokAlerm(10))
    stok.setState(50)
    stok.setState(8)
    stok.setState(20)

    println()
    println("--- 2. Idiomatic Kotlin: function-based observer ---")
    val nama = Observable("Budi")
    nama.subscribe { println("  Listener 1: nama menjadi $it") }
    nama.subscribe { println("  Listener 2: nama berada di state $it") }
    nama.value = "Siti"
    nama.value = "Dewi"

    println()
    println("--- 3. StateFlow-like ---")
    val stateFlow = StateFlow(0)
    stateFlow.collect { println("  Collector A: $it") }
    stateFlow.emit(1)
    stateFlow.emit(2)
    stateFlow.collect { println("  Collector B (mulai belakangan): $it") }
    stateFlow.emit(3)
}

=== Demo Observer Pattern ===
--- 1. Classic Observer (Subject + Observer) ---
[logger] Stok sekarang: 50
[logger] Stok sekarang: 8
[alert] Stok di bawah 10: 8
[logger] Stok sekarang: 20

--- 2. Idiomatic Kotlin: function-based observer ---
  Listener 1: nama menjadi Budi
  Listener 2: nama berada di state Budi
  Listener 1: nama menjadi Siti
  Listener 2: nama berada di state Siti
  Listener 1: nama menjadi Dewi
  Listener 2: nama berada di state Dewi

--- 3. StateFlow-like ---
  Collector A: 0
  Collector A: 1
  Collector A: 2
  Collector B (mulai belakangan): 2
  Collector A: 3
  Collector B (mulai belakangan): 3