Modeling Real-World Systems with OOP

from abc import ABC, abstractmethod

# 1. Product and CartItem
class Product:
    def __init__(self, product_id: str, name: str, price: float):
        self.id = product_id
        self.name = name
        self.price = price

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):
        for item in self.items:
            if item.product.id == product.id:
                item.quantity += quantity
                return
        self.items.append(CartItem(product, quantity))

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

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

# 2. OrderItem (with Immutable Price Snapshot) & Order
class OrderItem:
    def __init__(self, product_id: str, product_name: str, quantity: int, unit_price: float):
        self.product_id = product_id
        self.product_name = product_name
        self.quantity = quantity
        self.unit_price = unit_price  # Price locked permanently at moment of purchase

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

class Order:
    def __init__(self, order_id: str, items: list[OrderItem]):
        self.order_id = order_id
        self.items = 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"

# 3. Payment Abstraction & Implementations
class PaymentMethod(ABC):
    @abstractmethod
    def pay(self, amount: float) -> bool:
        pass

class BkashPayment(PaymentMethod):
    def __init__(self, phone: str):
        self.phone = phone

    def pay(self, amount: float) -> bool:
        print(f"[bKash] Charged ${amount:.2f} successfully from wallet {self.phone}.")
        return True

# 4. Checkout Orchestration Service
class CheckoutService:
    def __init__(self, payment_method: PaymentMethod):
        self.payment_method = payment_method

    def checkout(self, cart: Cart, order_id: str) -> Order:
        if not cart.items:
            raise ValueError("Cannot checkout an empty shopping cart!")

        # Transform volatile CartItems into immutable, price-snapshotted OrderItems
        order_items = [
            OrderItem(item.product.id, item.product.name, item.quantity, item.product.price)
            for item in cart.items
        ]
        order = Order(order_id, order_items)
        total_amount = order.calculate_total()

        # Delegate charging to the payment gateway
        payment_success = self.payment_method.pay(total_amount)
        if payment_success:
            order.mark_as_paid()
            cart.clear()
            print(f"Order {order.order_id} processed successfully! Status: {order.status}")
            return order
        else:
            raise RuntimeError("Payment transaction declined. Please try another method.")

# 5. Executing the Simulation
keyboard = Product("P101", "Mechanical Keyboard", 85.00)
mouse = Product("P102", "Wireless Mouse", 35.00)

my_cart = Cart()
my_cart.add_item(keyboard, 1)
my_cart.add_item(mouse, 2)

bkash = BkashPayment("+15550198")
checkout_engine = CheckoutService(bkash)

# Run checkout
confirmed_order = checkout_engine.checkout(my_cart, "ORD-9901")
print(f"Items remaining in cart: {len(my_cart.items)}")