Designing an E-commerce Cart System

import threading
import uuid
from abc import ABC, abstractmethod
from typing import Optional

# ─── Product ────────────────────────────────────────────
class Product:
    def __init__(self, product_id: str, name: str, price: float, category: str):
        self._id = product_id
        self._name = name
        self._price = price
        self._category = category

    @property
    def id(self) -> str: return self._id
    @property
    def name(self) -> str: return self._name
    @property
    def price(self) -> float: return self._price
    @property
    def category(self) -> str: return self._category

    def __str__(self) -> str:
        return f"{self._name} (₹{self._price:.2f})"

# ─── CartItem ───────────────────────────────────────────
class CartItem:
    def __init__(self, product: Product, quantity: int):
        self._product = product
        self._quantity = quantity

    @property
    def product(self) -> Product: return self._product
    @property
    def quantity(self) -> int: return self._quantity

    @quantity.setter
    def quantity(self, value: int):
        if value < 0:
            raise ValueError("Quantity cannot be negative")
        self._quantity = value

    @property
    def subtotal(self) -> float:
        return self._product.price * self._quantity

    def __str__(self) -> str:
        return f"{self._product.name} x{self._quantity} = ₹{self.subtotal:.2f}"

# ─── Discount Strategy Interface ────────────────────────
class DiscountStrategy(ABC):
    @abstractmethod
    def calculate_discount(self, items: list[CartItem]) -> float: pass

    @abstractmethod
    def description(self) -> str: pass

# ─── Percentage Discount ────────────────────────────────
class PercentageDiscount(DiscountStrategy):
    def __init__(self, percentage: float):
        if not 0 <= percentage <= 100:
            raise ValueError("Percentage must be 0-100")
        self._percentage = percentage

    def calculate_discount(self, items: list[CartItem]) -> float:
        subtotal = sum(item.subtotal for item in items)
        return subtotal * self._percentage / 100.0

    def description(self) -> str:
        return f"{self._percentage}% off"

# ─── Flat Discount ──────────────────────────────────────
class FlatDiscount(DiscountStrategy):
    def __init__(self, amount: float):
        self._amount = amount

    def calculate_discount(self, items: list[CartItem]) -> float:
        subtotal = sum(item.subtotal for item in items)
        return min(self._amount, subtotal)

    def description(self) -> str:
        return f"₹{self._amount:.2f} off"

# ─── Buy X Get Y Free ───────────────────────────────────
class BuyXGetYDiscount(DiscountStrategy):
    def __init__(self, product_id: str, buy_count: int, free_count: int):
        self._product_id = product_id
        self._buy_count = buy_count
        self._free_count = free_count

    def calculate_discount(self, items: list[CartItem]) -> float:
        for item in items:
            if item.product.id == self._product_id:
                qty = item.quantity
                sets = qty // (self._buy_count + self._free_count)
                free_items = sets * self._free_count
                return free_items * item.product.price
        return 0

    def description(self) -> str:
        return f"Buy {self._buy_count} Get {self._free_count} Free"

# ─── Coupon ─────────────────────────────────────────────
class Coupon:
    def __init__(self, code: str, strategy: DiscountStrategy, min_cart_value: float = 0):
        self._code = code
        self._strategy = strategy
        self._min_cart_value = min_cart_value
        self._active = True

    @property
    def code(self) -> str: return self._code

    def is_applicable(self, cart_subtotal: float) -> bool:
        return self._active and cart_subtotal >= self._min_cart_value

    def apply(self, items: list[CartItem]) -> float:
        return self._strategy.calculate_discount(items)

    def __str__(self) -> str:
        return f"Coupon[{self._code}: {self._strategy.description()}]"

# ─── Stock Observer Interface ───────────────────────────
class StockObserver(ABC):
    @abstractmethod
    def on_stock_updated(self, product_id: str, new_qty: int): pass

    @abstractmethod
    def on_out_of_stock(self, product_id: str): pass

# ─── Stock Service ──────────────────────────────────────
class StockService:
    def __init__(self):
        self._stock: dict[str, int] = {}
        self._lock = threading.Lock()
        self._observers: list[StockObserver] = []

    def add_observer(self, observer: StockObserver):
        self._observers.append(observer)

    def set_stock(self, product_id: str, quantity: int):
        with self._lock:
            self._stock[product_id] = quantity

    def is_available(self, product_id: str, required_qty: int) -> bool:
        with self._lock:
            return self._stock.get(product_id, 0) >= required_qty

    def reserve(self, product_id: str, quantity: int) -> bool:
        with self._lock:
            current = self._stock.get(product_id, 0)
            if current < quantity:
                return False
            self._stock[product_id] = current - quantity
            if self._stock[product_id] == 0:
                for obs in self._observers:
                    obs.on_out_of_stock(product_id)
            return True

    def release(self, product_id: str, quantity: int):
        with self._lock:
            self._stock[product_id] = self._stock.get(product_id, 0) + quantity
            for obs in self._observers:
                obs.on_stock_updated(product_id, self._stock[product_id])

    def get_stock(self, product_id: str) -> int:
        with self._lock:
            return self._stock.get(product_id, 0)

# ─── Tax Calculator ─────────────────────────────────────
class TaxCalculator:
    def __init__(self):
        self._category_rates = {
            "electronics": 18.0,
            "clothing": 5.0,
            "food": 0.0,
            "furniture": 12.0,
        }

    def calculate_tax(self, item: CartItem) -> float:
        category = item.product.category.lower()
        rate = self._category_rates.get(category, 18.0)
        return item.subtotal * rate / 100.0

    def calculate_total_tax(self, items: list[CartItem]) -> float:
        return sum(self.calculate_tax(item) for item in items)

# ─── Order ──────────────────────────────────────────────
class Order:
    def __init__(self, order_id: str, items: list[CartItem], subtotal: float,
                 discount: float, tax: float, total: float, applied_coupons: list[str]):
        self.order_id = order_id
        self.items = items
        self.subtotal = subtotal
        self.discount = discount
        self.tax = tax
        self.total = total
        self.applied_coupons = applied_coupons

    def print_summary(self):
        print("\n╔══════════════════════════════════════╗")
        print("║        ORDER SUMMARY                 ║")
        print("╠══════════════════════════════════════╣")
        print(f"  Order ID: {self.order_id}")
        print("  Items:")
        for item in self.items:
            print(f"    - {item}")
        print("  ─────────────────────────────────────")
        print(f"  Subtotal:   ₹{self.subtotal:.2f}")
        print(f"  Discount:  -₹{self.discount:.2f}")
        if self.applied_coupons:
            print(f"  Coupons:    {', '.join(self.applied_coupons)}")
        print(f"  Tax (GST):  ₹{self.tax:.2f}")
        print("  ─────────────────────────────────────")
        print(f"  TOTAL:      ₹{self.total:.2f}")
        print("╚══════════════════════════════════════╝")

# ─── Order Builder ──────────────────────────────────────
class OrderBuilder:
    def __init__(self):
        self._order_id = uuid.uuid4().hex[:10]
        self._items = []
        self._subtotal = 0
        self._discount = 0
        self._tax = 0
        self._total = 0
        self._applied_coupons = []

    def order_id(self, oid: str): self._order_id = oid; return self
    def items(self, items: list[CartItem]): self._items = list(items); return self
    def subtotal(self, s: float): self._subtotal = s; return self
    def discount(self, d: float): self._discount = d; return self
    def tax(self, t: float): self._tax = t; return self
    def total(self, t: float): self._total = t; return self
    def applied_coupons(self, c: list[str]): self._applied_coupons = c; return self

    def build(self) -> Order:
        return Order(self._order_id, self._items, self._subtotal,
                     self._discount, self._tax, self._total, self._applied_coupons)

# ─── Cart ───────────────────────────────────────────────
class Cart:
    def __init__(self, stock_service: StockService):
        self._items: dict[str, CartItem] = {}
        self._applied_coupons: list[Coupon] = []
        self._stock_service = stock_service
        self._tax_calculator = TaxCalculator()
        self._lock = threading.Lock()

    def add_item(self, product: Product, quantity: int):
        with self._lock:
            if quantity <= 0:
                raise ValueError("Quantity must be positive")
            if not self._stock_service.is_available(product.id, quantity):
                raise RuntimeError(f"Insufficient stock for {product.name}")

            if product.id in self._items:
                existing = self._items[product.id]
                new_qty = existing.quantity + quantity
                if not self._stock_service.is_available(product.id, new_qty):
                    raise RuntimeError("Insufficient stock for total quantity")
                existing.quantity = new_qty
            else:
                self._items[product.id] = CartItem(product, quantity)

    def remove_item(self, product_id: str):
        with self._lock:
            if product_id not in self._items:
                raise RuntimeError(f"Product not in cart: {product_id}")
            del self._items[product_id]

    def update_quantity(self, product_id: str, new_quantity: int):
        with self._lock:
            if product_id not in self._items:
                raise RuntimeError(f"Product not in cart: {product_id}")
            if new_quantity <= 0:
                del self._items[product_id]
                return
            if not self._stock_service.is_available(product_id, new_quantity):
                raise RuntimeError("Insufficient stock")
            self._items[product_id].quantity = new_quantity

    def apply_coupon(self, coupon: Coupon):
        with self._lock:
            if not coupon.is_applicable(self.subtotal):
                raise RuntimeError("Coupon not applicable. Min cart value not met.")
            self._applied_coupons.append(coupon)

    @property
    def subtotal(self) -> float:
        return sum(item.subtotal for item in self._items.values())

    def checkout(self) -> Order:
        with self._lock:
            if not self._items:
                raise RuntimeError("Cart is empty")

            for item in self._items.values():
                if not self._stock_service.is_available(item.product.id, item.quantity):
                    raise RuntimeError(f"Stock unavailable for: {item.product.name}")

            item_list = list(self._items.values())
            subtotal = self.subtotal

            total_discount = 0
            coupon_codes = []
            for coupon in self._applied_coupons:
                total_discount += coupon.apply(item_list)
                coupon_codes.append(coupon.code)
            total_discount = min(total_discount, subtotal)

            taxable_amount = subtotal - total_discount
            tax = self._tax_calculator.calculate_total_tax(item_list) * (taxable_amount / subtotal)
            total = taxable_amount + tax

            for item in item_list:
                self._stock_service.reserve(item.product.id, item.quantity)

            order = (OrderBuilder()
                     .items(item_list)
                     .subtotal(subtotal)
                     .discount(total_discount)
                     .tax(tax)
                     .total(total)
                     .applied_coupons(coupon_codes)
                     .build())

            self._items.clear()
            self._applied_coupons.clear()
            return order

    def display_cart(self):
        print("\n--- Cart Contents ---")
        if not self._items:
            print("  (empty)")
            return
        for item in self._items.values():
            print(f"  {item}")
        print(f"  Subtotal: ₹{self.subtotal:.2f}")

# ─── Main Demo ──────────────────────────────────────────
def main():
    print("═══════════════════════════════════════")
    print("     E-COMMERCE CART - LLD DEMO       ")
    print("═══════════════════════════════════════\n")

    stock_service = StockService()

    class LoggingStockObserver(StockObserver):
        def on_stock_updated(self, product_id, new_qty):
            print(f"  [STOCK] {product_id} updated to {new_qty}")
        def on_out_of_stock(self, product_id):
            print(f"  [STOCK] {product_id} is OUT OF STOCK!")

    stock_service.add_observer(LoggingStockObserver())

    phone = Product("P001", "iPhone 15", 79999.0, "electronics")
    shirt = Product("P002", "Cotton Shirt", 999.0, "clothing")
    rice = Product("P003", "Basmati Rice 5kg", 450.0, "food")
    laptop = Product("P004", "MacBook Air", 114999.0, "electronics")

    stock_service.set_stock("P001", 10)
    stock_service.set_stock("P002", 50)
    stock_service.set_stock("P003", 100)
    stock_service.set_stock("P004", 5)

    cart = Cart(stock_service)

    print("--- Adding Items to Cart ---")
    cart.add_item(phone, 1)
    cart.add_item(shirt, 3)
    cart.add_item(rice, 2)
    cart.display_cart()

    print("\n--- Updating Shirt Quantity to 5 ---")
    cart.update_quantity("P002", 5)
    cart.display_cart()

    print("\n--- Applying Coupons ---")
    percent_off = Coupon("SAVE10", PercentageDiscount(10), 1000)
    flat_off = Coupon("FLAT500", FlatDiscount(500), 5000)
    cart.apply_coupon(percent_off)
    print(f"Applied: {percent_off}")
    cart.apply_coupon(flat_off)
    print(f"Applied: {flat_off}")

    print("\n--- Removing Rice ---")
    cart.remove_item("P003")
    cart.display_cart()

    print("\n--- Checkout ---")
    order = cart.checkout()
    order.print_summary()

    print("\nCart after checkout:")
    cart.display_cart()

    print("\n--- Out of Stock Test ---")
    try:
        cart.add_item(laptop, 10)
    except RuntimeError as e:
        print(f"Expected: {e}")

    print("\n--- Buy 2 Get 1 Free Demo ---")
    cart2 = Cart(stock_service)
    cart2.add_item(shirt, 6)
    bogo = Coupon("B2G1", BuyXGetYDiscount("P002", 2, 1), 0)
    cart2.apply_coupon(bogo)
    cart2.display_cart()
    order2 = cart2.checkout()
    order2.print_summary()

    print("\n═══════════════════════════════════════")
    print("           DEMO COMPLETE               ")
    print("═══════════════════════════════════════")

if __name__ == "__main__":
    main()

#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
#include <mutex>
#include <memory>
#include <algorithm>
#include <iomanip>
#include <sstream>
#include <random>
#include <functional>
#include <atomic>

// ─── Generate ID ────────────────────────────────────────
std::string generateId() {
    static std::mt19937 gen(std::random_device{}());
    static std::uniform_int_distribution<int> dist(0, 15);
    static const char* hex = "0123456789abcdef";
    std::string id;
    for (int i = 0; i < 10; ++i) id += hex[dist(gen)];
    return id;
}

// ─── Product ────────────────────────────────────────────
class Product {
private:
    std::string id, name, category;
    double price;
public:
    Product(std::string id, std::string name, double price, std::string category)
        : id(std::move(id)), name(std::move(name)), price(price), category(std::move(category)) {}

    const std::string& getId() const { return id; }
    const std::string& getName() const { return name; }
    double getPrice() const { return price; }
    const std::string& getCategory() const { return category; }
};

// ─── CartItem ───────────────────────────────────────────
class CartItem {
private:
    std::shared_ptr<Product> product;
    int quantity;
public:
    CartItem(std::shared_ptr<Product> product, int quantity)
        : product(std::move(product)), quantity(quantity) {}

    const std::shared_ptr<Product>& getProduct() const { return product; }
    int getQuantity() const { return quantity; }
    void setQuantity(int q) { quantity = q; }
    double getSubtotal() const { return product->getPrice() * quantity; }

    std::string toString() const {
        std::ostringstream ss;
        ss << product->getName() << " x" << quantity
           << " = Rs" << std::fixed << std::setprecision(2) << getSubtotal();
        return ss.str();
    }
};

// ─── Discount Strategy ──────────────────────────────────
class DiscountStrategy {
public:
    virtual ~DiscountStrategy() = default;
    virtual double calculateDiscount(const std::vector<CartItem>& items) = 0;
    virtual std::string getDescription() = 0;
};

class PercentageDiscount : public DiscountStrategy {
    double percentage;
public:
    PercentageDiscount(double pct) : percentage(pct) {}
    double calculateDiscount(const std::vector<CartItem>& items) override {
        double subtotal = 0;
        for (auto& item : items) subtotal += item.getSubtotal();
        return subtotal * percentage / 100.0;
    }
    std::string getDescription() override {
        return std::to_string((int)percentage) + "% off";
    }
};

class FlatDiscount : public DiscountStrategy {
    double amount;
public:
    FlatDiscount(double amt) : amount(amt) {}
    double calculateDiscount(const std::vector<CartItem>& items) override {
        double subtotal = 0;
        for (auto& item : items) subtotal += item.getSubtotal();
        return std::min(amount, subtotal);
    }
    std::string getDescription() override {
        std::ostringstream ss;
        ss << "Rs" << std::fixed << std::setprecision(2) << amount << " off";
        return ss.str();
    }
};

class BuyXGetYDiscount : public DiscountStrategy {
    std::string productId;
    int buyCount, freeCount;
public:
    BuyXGetYDiscount(std::string pid, int buy, int free)
        : productId(std::move(pid)), buyCount(buy), freeCount(free) {}
    double calculateDiscount(const std::vector<CartItem>& items) override {
        for (auto& item : items) {
            if (item.getProduct()->getId() == productId) {
                int qty = item.getQuantity();
                int sets = qty / (buyCount + freeCount);
                return sets * freeCount * item.getProduct()->getPrice();
            }
        }
        return 0;
    }
    std::string getDescription() override {
        return "Buy " + std::to_string(buyCount) + " Get " + std::to_string(freeCount) + " Free";
    }
};

// ─── Coupon ─────────────────────────────────────────────
class Coupon {
    std::string code;
    std::shared_ptr<DiscountStrategy> strategy;
    double minCartValue;
    bool active;
public:
    Coupon(std::string code, std::shared_ptr<DiscountStrategy> strategy, double minVal)
        : code(std::move(code)), strategy(std::move(strategy)), minCartValue(minVal), active(true) {}

    bool isApplicable(double subtotal) { return active && subtotal >= minCartValue; }
    double apply(const std::vector<CartItem>& items) { return strategy->calculateDiscount(items); }
    const std::string& getCode() const { return code; }
    std::string getDescription() { return strategy->getDescription(); }
};

// ─── Stock Service ──────────────────────────────────────
class StockService {
    std::unordered_map<std::string, std::atomic<int>> stock;
    std::mutex mtx;
public:
    void setStock(const std::string& productId, int qty) {
        stock[productId] = qty;
    }
    bool isAvailable(const std::string& productId, int required) {
        auto it = stock.find(productId);
        return it != stock.end() && it->second.load() >= required;
    }
    bool reserve(const std::string& productId, int qty) {
        auto it = stock.find(productId);
        if (it == stock.end()) return false;
        int current = it->second.load();
        while (current >= qty) {
            if (it->second.compare_exchange_weak(current, current - qty)) {
                return true;
            }
        }
        return false;
    }
    int getStock(const std::string& productId) {
        auto it = stock.find(productId);
        return it != stock.end() ? it->second.load() : 0;
    }
};

// ─── Tax Calculator ─────────────────────────────────────
class TaxCalculator {
    std::unordered_map<std::string, double> rates;
public:
    TaxCalculator() {
        rates["electronics"] = 18.0;
        rates["clothing"] = 5.0;
        rates["food"] = 0.0;
        rates["furniture"] = 12.0;
    }
    double calculateTotalTax(const std::vector<CartItem>& items) {
        double total = 0;
        for (auto& item : items) {
            auto it = rates.find(item.getProduct()->getCategory());
            double rate = (it != rates.end()) ? it->second : 18.0;
            total += item.getSubtotal() * rate / 100.0;
        }
        return total;
    }
};

// ─── Order ──────────────────────────────────────────────
class Order {
public:
    std::string orderId;
    std::vector<CartItem> items;
    double subtotal, discount, tax, total;
    std::vector<std::string> appliedCoupons;

    void printSummary() {
        std::cout << "\n+======================================+\n";
        std::cout << "|        ORDER SUMMARY                 |\n";
        std::cout << "+======================================+\n";
        std::cout << "  Order ID: " << orderId << "\n";
        std::cout << "  Items:\n";
        for (auto& item : items) {
            std::cout << "    - " << item.toString() << "\n";
        }
        std::cout << std::fixed << std::setprecision(2);
        std::cout << "  Subtotal:   Rs" << subtotal << "\n";
        std::cout << "  Discount:  -Rs" << discount << "\n";
        std::cout << "  Tax (GST):  Rs" << tax << "\n";
        std::cout << "  TOTAL:      Rs" << total << "\n";
        std::cout << "+======================================+\n";
    }
};

// ─── Cart ───────────────────────────────────────────────
class Cart {
    std::unordered_map<std::string, CartItem> items;
    std::vector<std::shared_ptr<Coupon>> appliedCoupons;
    std::shared_ptr<StockService> stockService;
    TaxCalculator taxCalc;
    std::mutex mtx;

public:
    Cart(std::shared_ptr<StockService> ss) : stockService(std::move(ss)) {}

    void addItem(std::shared_ptr<Product> product, int qty) {
        std::lock_guard<std::mutex> lock(mtx);
        if (!stockService->isAvailable(product->getId(), qty))
            throw std::runtime_error("Insufficient stock for " + product->getName());

        auto it = items.find(product->getId());
        if (it != items.end()) {
            it->second.setQuantity(it->second.getQuantity() + qty);
        } else {
            items.emplace(product->getId(), CartItem(product, qty));
        }
    }

    void removeItem(const std::string& productId) {
        std::lock_guard<std::mutex> lock(mtx);
        items.erase(productId);
    }

    void updateQuantity(const std::string& productId, int newQty) {
        std::lock_guard<std::mutex> lock(mtx);
        if (newQty <= 0) { items.erase(productId); return; }
        auto it = items.find(productId);
        if (it != items.end()) it->second.setQuantity(newQty);
    }

    void applyCoupon(std::shared_ptr<Coupon> coupon) {
        std::lock_guard<std::mutex> lock(mtx);
        if (!coupon->isApplicable(getSubtotal()))
            throw std::runtime_error("Coupon not applicable");
        appliedCoupons.push_back(std::move(coupon));
    }

    double getSubtotal() {
        double total = 0;
        for (auto& [_, item] : items) total += item.getSubtotal();
        return total;
    }

    Order checkout() {
        std::lock_guard<std::mutex> lock(mtx);
        if (items.empty()) throw std::runtime_error("Cart is empty");

        std::vector<CartItem> itemList;
        for (auto& [_, item] : items) itemList.push_back(item);

        double subtotal = 0;
        for (auto& item : itemList) subtotal += item.getSubtotal();

        double totalDiscount = 0;
        std::vector<std::string> codes;
        for (auto& coupon : appliedCoupons) {
            totalDiscount += coupon->apply(itemList);
            codes.push_back(coupon->getCode());
        }
        totalDiscount = std::min(totalDiscount, subtotal);

        double taxable = subtotal - totalDiscount;
        double tax = taxCalc.calculateTotalTax(itemList) * (taxable / subtotal);
        double total = taxable + tax;

        for (auto& item : itemList) {
            stockService->reserve(item.getProduct()->getId(), item.getQuantity());
        }

        Order order;
        order.orderId = generateId();
        order.items = std::move(itemList);
        order.subtotal = subtotal;
        order.discount = totalDiscount;
        order.tax = tax;
        order.total = total;
        order.appliedCoupons = std::move(codes);

        items.clear();
        appliedCoupons.clear();
        return order;
    }

    void displayCart() {
        std::cout << "\n--- Cart Contents ---\n";
        if (items.empty()) { std::cout << "  (empty)\n"; return; }
        for (auto& [_, item] : items) {
            std::cout << "  " << item.toString() << "\n";
        }
        std::cout << std::fixed << std::setprecision(2)
                  << "  Subtotal: Rs" << getSubtotal() << "\n";
    }
};

// ─── Main Demo ──────────────────────────────────────────
int main() {
    std::cout << "=======================================\n";
    std::cout << "     E-COMMERCE CART - LLD DEMO       \n";
    std::cout << "=======================================\n\n";

    auto stockService = std::make_shared<StockService>();
    auto phone = std::make_shared<Product>("P001", "iPhone 15", 79999.0, "electronics");
    auto shirt = std::make_shared<Product>("P002", "Cotton Shirt", 999.0, "clothing");
    auto rice = std::make_shared<Product>("P003", "Basmati Rice 5kg", 450.0, "food");
    auto laptop = std::make_shared<Product>("P004", "MacBook Air", 114999.0, "electronics");

    stockService->setStock("P001", 10);
    stockService->setStock("P002", 50);
    stockService->setStock("P003", 100);
    stockService->setStock("P004", 5);

    Cart cart(stockService);

    std::cout << "--- Adding Items to Cart ---\n";
    cart.addItem(phone, 1);
    cart.addItem(shirt, 3);
    cart.addItem(rice, 2);
    cart.displayCart();

    std::cout << "\n--- Updating Shirt Quantity to 5 ---\n";
    cart.updateQuantity("P002", 5);
    cart.displayCart();

    std::cout << "\n--- Applying Coupons ---\n";
    auto percentOff = std::make_shared<Coupon>("SAVE10",
        std::make_shared<PercentageDiscount>(10), 1000);
    auto flatOff = std::make_shared<Coupon>("FLAT500",
        std::make_shared<FlatDiscount>(500), 5000);
    cart.applyCoupon(percentOff);
    cart.applyCoupon(flatOff);

    std::cout << "\n--- Removing Rice ---\n";
    cart.removeItem("P003");
    cart.displayCart();

    std::cout << "\n--- Checkout ---\n";
    Order order = cart.checkout();
    order.printSummary();

    std::cout << "\n--- Out of Stock Test ---\n";
    try {
        cart.addItem(laptop, 10);
    } catch (const std::runtime_error& e) {
        std::cout << "Expected: " << e.what() << "\n";
    }

    std::cout << "\n--- Buy 2 Get 1 Free Demo ---\n";
    Cart cart2(stockService);
    cart2.addItem(shirt, 6);
    auto bogo = std::make_shared<Coupon>("B2G1",
        std::make_shared<BuyXGetYDiscount>("P002", 2, 1), 0);
    cart2.applyCoupon(bogo);
    Order order2 = cart2.checkout();
    order2.printSummary();

    std::cout << "\n=======================================\n";
    std::cout << "           DEMO COMPLETE               \n";
    std::cout << "=======================================\n";
    return 0;
}