Integrating a Partner Restaurant's Legacy API

#include <cstdint>
#include <format>
#include <memory>
#include <print>
#include <string>
#include <string_view>

struct OrderRequest {
    std::string orderId;
    std::string customerPhone;
    std::string itemName;
    double priceRupees;
};

struct OrderResponse {
    bool success;
    std::string confirmationId;
    std::string message;
};

// Target interface standard in our modern platform
class RestaurantPartner {
public:
    virtual ~RestaurantPartner() = default;
    virtual OrderResponse placeOrder(const OrderRequest& order) = 0;
};

class StandardRestaurantPartner : public RestaurantPartner {
public:
    OrderResponse placeOrder(const OrderRequest& order) override {
        std::println("[StandardPartner] Accepted order {} for {} (Rs.{:.2f})",
                     order.orderId, order.itemName, order.priceRupees);
        return {true, std::format("CONF_{}", order.orderId), "Order accepted"};
    }
};

// Legacy 3rd-party vendor SDK (we do NOT own or modify this class!)
struct LegacyTicketResult {
    int statusCode; // 0 = SUCCESS, 1 = INVALID_ITEM, 2 = NETWORK_ERROR
    std::string legacyTicketRef;
};

class LegacyPizzaSdk {
public:
    LegacyTicketResult submitLegacyTicket(const char* itemCode, int64_t amountPaise, const char* phoneStr) {
        std::println("[LegacyPizzaSdk] Submitting legacy ticket: code='{}', amountPaise={}, phone='{}'",
                     itemCode, amountPaise, phoneStr);
        if (std::string_view(itemCode) == "UNKNOWN") {
            return {1, ""};
        }
        return {0, std::format("LEGACY_TKT_{}", amountPaise % 10000)};
    }
};

// Naive OrderService: mixes legacy vendor branching and unit conversions directly in business logic!
class NaiveOrderService {
    std::shared_ptr<RestaurantPartner> standardPartner_;
    LegacyPizzaSdk legacySdk_;
public:
    explicit NaiveOrderService(std::shared_ptr<RestaurantPartner> partner)
        : standardPartner_(std::move(partner)), legacySdk_() {}

    OrderResponse dispatchOrder(const OrderRequest& req, bool isLegacyPizzaPartner) {
        std::println("--- Dispatching Order {} ---", req.orderId);
        if (isLegacyPizzaPartner) {
            // Naive code smell: translating vendor formats directly inside core service!
            int64_t paise = static_cast<int64_t>(req.priceRupees * 100.0 + 0.5);
            std::string code = (req.itemName == "Margherita") ? "PZ_MARG_01" :
                               (req.itemName == "Pepperoni")  ? "PZ_PEP_02" : "UNKNOWN";

            auto legacyRes = legacySdk_.submitLegacyTicket(code.c_str(), paise, req.customerPhone.c_str());
            if (legacyRes.statusCode == 0) {
                return {true, legacyRes.legacyTicketRef, "Legacy pizza order placed successfully"};
            } else {
                return {false, "", "Legacy pizza SDK rejected ticket"};
            }
        } else {
            return standardPartner_->placeOrder(req);
        }
    }
};

int main() {
    auto standard = std::make_shared<StandardRestaurantPartner>();
    NaiveOrderService service(standard);

    OrderRequest o1{"ORD-101", "+919876543210", "Paneer Tikka Roll", 220.0};
    service.dispatchOrder(o1, false);

    OrderRequest o2{"ORD-102", "+919123456789", "Pepperoni", 450.50};
    service.dispatchOrder(o2, true);

    return 0;
}