One-Call Checkout Across Five Subsystems

#include <format>
#include <print>
#include <string>
#include <unordered_set>

struct OrderRequest {
    std::string orderId;
    std::string customerId;
    std::string restaurantId;
    std::string itemName;
    int amountRupees;
};

// 1. Cart Validator Subsystem
class CartValidator {
public:
    bool validate(const OrderRequest& req) {
        if (req.amountRupees <= 0 || req.itemName.empty()) {
            std::println("[CartValidator] Invalid order request: {}", req.orderId);
            return false;
        }
        std::println("[CartValidator] Cart valid for order {}", req.orderId);
        return true;
    }
};

// 2. Inventory Lock Subsystem
class InventoryLock {
    std::unordered_set<std::string> activeLocks_;
    int lockCounter_{100};
public:
    std::string acquireLock(const std::string& restaurantId, const std::string& item) {
        std::string lockId = std::format("LOCK_{}_{}", restaurantId, ++lockCounter_);
        activeLocks_.insert(lockId);
        std::println("[InventoryLock] Acquired {} for item '{}' (Active locks: {})",
                     lockId, item, activeLocks_.size());
        return lockId;
    }

    void releaseLock(const std::string& lockId) {
        activeLocks_.erase(lockId);
        std::println("[InventoryLock] Released {} (Active locks: {})", lockId, activeLocks_.size());
    }

    void commitLock(const std::string& lockId) {
        activeLocks_.erase(lockId);
        std::println("[InventoryLock] Committed {} permanently (Active locks: {})", lockId, activeLocks_.size());
    }

    [[nodiscard]] size_t activeLockCount() const { return activeLocks_.size(); }
};

// 3. Payment Gateway Subsystem
struct PaymentResult {
    bool success;
    std::string txId;
};

class PaymentGateway {
public:
    PaymentResult charge(const std::string& customerId, int amountRupees, bool shouldFail = false) {
        if (shouldFail) {
            std::println("[PaymentGateway] Declined payment of Rs.{} for {}", amountRupees, customerId);
            return {false, ""};
        }
        std::string txId = std::format("TXN_{}", amountRupees * 7);
        std::println("[PaymentGateway] Charged Rs.{} to {} (Tx: {})", amountRupees, customerId, txId);
        return {true, txId};
    }
};

// 4. Rider Dispatcher Subsystem
class RiderDispatcher {
public:
    std::string dispatchRider(const std::string& restaurantId) {
        std::string riderId = "RIDER_42";
        std::println("[RiderDispatcher] Assigned {} for pickup at {}", riderId, restaurantId);
        return riderId;
    }
};

// 5. Notification Bus Subsystem
class NotificationBus {
public:
    void notify(const std::string& channel, const std::string& message) {
        std::println("[NotificationBus:{}] {}", channel, message);
    }
};

// Naive: MobileController juggles all 5 subsystems by hand and forgets rollback!
class NaiveMobileOrderController {
    CartValidator validator_;
    InventoryLock inventory_;
    PaymentGateway payment_;
    RiderDispatcher dispatcher_;
    NotificationBus notifications_;
public:
    void handleMobileCheckout(const OrderRequest& req, bool forcePaymentFailure) {
        std::println("--- Naive Mobile Checkout Initiated ---");
        if (!validator_.validate(req)) return;

        std::string lockId = inventory_.acquireLock(req.restaurantId, req.itemName);

        auto pay = payment_.charge(req.customerId, req.amountRupees, forcePaymentFailure);
        if (!pay.success) {
            std::println("[NaiveMobileController] Payment failed! Returning error to user.");
            // BUG: Developer forgot inventory_.releaseLock(lockId)!
            // The item remains locked indefinitely, blocking other customers!
            return;
        }

        std::string riderId = dispatcher_.dispatchRider(req.restaurantId);
        inventory_.commitLock(lockId);
        notifications_.notify("Customer", "Order placed successfully!");
    }

    [[nodiscard]] size_t leakedLocks() const { return inventory_.activeLockCount(); }
};

int main() {
    NaiveMobileOrderController mobileController;
    OrderRequest req{"ORD-801", "cust_99", "REST_MUM_01", "Tandoori Chicken", 480};

    // Simulate payment failure where naive controller forgets rollback
    mobileController.handleMobileCheckout(req, true);

    std::println("\n[ALERT] Leaked active locks in inventory subsystem: {}",
                 mobileController.leakedLocks());
    return 0;
}