Composition Root

//entity
class Order(val id: Int, val total: Int) {
    val payable: Int
        get() = if (total >= 200) total - total / 10
                else total
}

//gateway
interface Catalog {
    fun price(sku: String): Int?
}

//repository
interface Orders {
    fun save(order: Order)
    fun count(): Int
}

//output port
interface Report {
    fun say(text: String)
}

//use case: asks for its parts, never builds them
class PlaceOrder(
    private val catalog: Catalog,
    private val orders: Orders,
    private val report: Report
) {
    private var nextId = 1001

    fun place(items: Map<String, Int>) {
        var total = 0
        for ((sku, count) in items) {
            val price = catalog.price(sku)
            if (price == null) {
                report.say("no $sku")
                return
            }
            total += price * count
        }
        val order = Order(nextId++, total)
        orders.save(order)
        report.say(
            "order ${order.id} for ${order.payable}")
    }
}

//adapter
class MemoryCatalog: Catalog {
    private val prices = mapOf("pen" to 30, "lamp" to 190)

    override fun price(sku: String): Int? {
        return prices[sku]
    }
}

//adapter
class MemoryOrders: Orders {
    private val rows = mutableListOf<Order>()

    override fun save(order: Order) {
        rows.add(order)
    }

    override fun count(): Int {
        return rows.size
    }
}

//adapter
class ConsoleReport: Report {
    override fun say(text: String) {
        println(text)
    }
}

//adapter
class SilentReport: Report {
    override fun say(text: String) {
    }
}

//composition root: the only place that sees every layer
//at once, and the only place where an adapter is built
class ShopApp(
    catalog: Catalog,
    val orders: Orders,
    report: Report
) {
    val useCase = PlaceOrder(catalog, orders, report)

    //a companion object holds the ready recipes
    companion object {
        fun loud(): ShopApp {
            return ShopApp(MemoryCatalog(),
                           MemoryOrders(),
                           ConsoleReport())
        }

        fun quiet(): ShopApp {
            return ShopApp(MemoryCatalog(),
                           MemoryOrders(),
                           SilentReport())
        }
    }
}

//client code
val app = ShopApp.loud()
app.useCase.place(linkedMapOf("pen" to 2, "lamp" to 1))
app.useCase.place(mapOf("chair" to 1))

//a second root builds the same use case differently
val night = ShopApp.quiet()
night.useCase.place(mapOf("lamp" to 1))
println("saved ${night.orders.count()}")
//printed: order 1001 for 225
//         no chair
//         saved 1