Mini Project: A Complete OOP System Design

class Product:
    def __init__(self, product_id: int, name: str, price: float, stock: int):
        self.product_id = product_id
        self.name = name
        self.price = price
        self.stock = stock

    def is_available(self, quantity: int = 1) -> bool:
        return self.stock >= quantity

class CartItem:
    def __init__(self, product: Product, quantity: int):
        self.product = product
        self.quantity = quantity

    def subtotal(self) -> float:
        return self.product.price * self.quantity

class Cart:
    def __init__(self):
        self.items: list[CartItem] = []

    def add_item(self, product: Product, quantity: int = 1):
        if not product.is_available(quantity):
            raise ValueError(f"Insufficient stock for {product.name} (Available: {product.stock})")
        self.items.append(CartItem(product, quantity))

    def remove_item(self, product_id: int):
        self.items = [item for item in self.items if item.product.product_id != product_id]

    def calculate_total(self) -> float:
        return sum(item.subtotal() for item in self.items)

    def clear(self):
        self.items.clear()

class Customer:
    def __init__(self, customer_id: int, name: str, email: str):
        self.customer_id = customer_id
        self.name = name
        self.email = email
        self.cart = Cart()  # Customer HAS-A Cart (Composition)

class OrderItem:
    def __init__(self, product: Product, quantity: int):
        self.product = product
        self.quantity = quantity
        self.unit_price = product.price  # Permanent immutable snapshot of catalog price

    def subtotal(self) -> float:
        return self.unit_price * self.quantity

class Order:
    def __init__(self, order_id: int, customer: Customer, cart_items: list[CartItem]):
        self.order_id = order_id
        self.customer = customer
        self.items = [OrderItem(item.product, item.quantity) for item in cart_items]
        self.status = "Pending"

    def calculate_total(self) -> float:
        return sum(item.subtotal() for item in self.items)

    def mark_as_paid(self):
        if self.status != "Pending":
            raise ValueError(f"Invalid state transition: Cannot mark {self.status} order as Paid")
        self.status = "Paid"

    def complete(self):
        if self.status != "Paid":
            raise ValueError("Order must be Paid before it can be marked Completed")
        self.status = "Completed"

    def cancel(self):
        if self.status == "Completed":
            raise ValueError("Cannot cancel an already completed order")
        self.status = "Cancelled"

from abc import ABC, abstractmethod

class PaymentMethod(ABC):
    @abstractmethod
    def pay(self, amount: float) -> bool:
        pass

class CardPayment(PaymentMethod):
    def pay(self, amount: float) -> bool:
        print(f"💳 [Card] Charged ${amount:.2f} via credit card successfully.")
        return True

class MobilePayment(PaymentMethod):
    def __init__(self, wallet_number: str):
        self.wallet_number = wallet_number

    def pay(self, amount: float) -> bool:
        print(f"📱 [Mobile Wallet] Charged ${amount:.2f} from wallet {self.wallet_number}.")
        return True

class NotificationService:
    def send_order_confirmation(self, order: Order):
        print(f"✉️ [Notification] Order #{order.order_id} confirmation dispatched to {order.customer.email}.")

class CheckoutService:
    def __init__(self, notification_service: NotificationService):
        # Injected dependency (Dependency Injection)
        self.notification_service = notification_service

    def checkout(self, customer: Customer, payment_method: PaymentMethod, order_id: int) -> Order:
        if not customer.cart.items:
            raise ValueError("Cannot checkout an empty cart!")

        # 1. Instantiate order with snapshotted items
        order = Order(order_id, customer, customer.cart.items)
        total = order.calculate_total()

        # 2. Polymorphic charge delegation
        if not payment_method.pay(total):
            raise ValueError("Payment transaction declined!")

        # 3. Transition order status & flush temporary cart
        order.mark_as_paid()
        customer.cart.clear()

        # 4. Dispatch notification receipt
        self.notification_service.send_order_confirmation(order)
        return order