Composition Root

from typing import Protocol


# entity
class Order:
    def __init__(self, id: int, total: int):
        self.id = id
        self.total = total

    @property
    def payable(self) -> int:
        if self.total < 200:
            return self.total
        return self.total - self.total // 10


# gateway
class Catalog(Protocol):
    def price(self, sku: str) -> int | None: ...


# repository
class Orders(Protocol):
    def save(self, order: Order) -> None: ...

    def count(self) -> int: ...


# output port
class Report(Protocol):
    def say(self, text: str) -> None: ...


# use case: asks for its parts, never builds them
class PlaceOrder:
    def __init__(self, catalog: Catalog, orders: Orders,
                 report: Report):
        self._catalog = catalog
        self._orders = orders
        self._report = report
        self._next_id = 1001

    def place(self, items: dict[str, int]) -> None:
        total = 0
        for sku, count in items.items():
            price = self._catalog.price(sku)
            if price is None:
                self._report.say(f"no {sku}")
                return
            total += price * count
        order = Order(self._next_id, total)
        self._next_id += 1
        self._orders.save(order)
        self._report.say(
            f"order {order.id} for {order.payable}")


# adapters
class MemoryCatalog:
    def price(self, sku: str) -> int | None:
        return {"pen": 30, "lamp": 190}.get(sku)


class MemoryOrders:
    def __init__(self):
        self._rows: list[Order] = []

    def save(self, order: Order) -> None:
        self._rows.append(order)

    def count(self) -> int:
        return len(self._rows)


class ConsoleReport:
    def say(self, text: str) -> None:
        print(text)


class SilentReport:
    def say(self, text: str) -> None:
        pass


# composition root: the only place that sees every
# layer at once, and the only place where an adapter is
# built. the two ready builds are classmethods, because
# the root also hands out the parts it has put together
class ShopApp:
    def __init__(self, catalog: Catalog, orders: Orders,
                 report: Report):
        self.orders = orders
        self.use_case = PlaceOrder(catalog, orders, report)

    @classmethod
    def loud(cls) -> "ShopApp":
        return cls(MemoryCatalog(), MemoryOrders(),
                   ConsoleReport())

    @classmethod
    def quiet(cls) -> "ShopApp":
        return cls(MemoryCatalog(), MemoryOrders(),
                   SilentReport())


# client code
app = ShopApp.loud()
app.use_case.place({"pen": 2, "lamp": 1})
app.use_case.place({"chair": 1})
print("saved", app.orders.count())

# a second root builds the same use case differently,
# and neither the scenario nor the entity knows it
night = ShopApp.quiet()
night.use_case.place({"lamp": 1})
night.use_case.place({"pen": 2})
print("saved at night", night.orders.count())

# no adapter is built outside the root: the client
# asks for a ready application and gets one, and the
# scenario it got is the same class in both builds
print("use case", type(app.use_case).__name__)
print("same class",
      type(app.use_case) is type(night.use_case))
# printed: order 1001 for 225
#          no chair
#          saved 1
#          saved at night 2
#          use case PlaceOrder
#          same class True