Order Lifecycle & Cancel Rules

#include <print>
#include <string>

enum class OrderStatus {
    Placed,
    Accepted,
    Cooking,
    PickedUp,
    Delivered,
    Cancelled
};

// Naive Order: every lifecycle method contains a switch over OrderStatus.
// Adding a new state or transition rule requires editing every single method!
class NaiveOrder {
    std::string orderId_;
    OrderStatus status_{OrderStatus::Placed};
    std::string riderId_;
public:
    explicit NaiveOrder(std::string id) : orderId_(std::move(id)) {}

    bool accept() {
        switch (status_) {
            case OrderStatus::Placed:
                status_ = OrderStatus::Accepted;
                std::println("[{}] Restaurant accepted the order.", orderId_);
                return true;
            default:
                std::println("[{}] Cannot accept in current state.", orderId_);
                return false;
        }
    }

    bool startCooking() {
        switch (status_) {
            case OrderStatus::Accepted:
                status_ = OrderStatus::Cooking;
                std::println("[{}] Kitchen started cooking.", orderId_);
                return true;
            default:
                std::println("[{}] Cannot start cooking unless accepted.", orderId_);
                return false;
        }
    }

    bool pickUp(const std::string& riderId) {
        switch (status_) {
            case OrderStatus::Cooking:
                status_ = OrderStatus::PickedUp;
                riderId_ = riderId;
                std::println("[{}] Rider {} picked up the order.", orderId_, riderId_);
                return true;
            default:
                std::println("[{}] Cannot pick up order in current state.", orderId_);
                return false;
        }
    }

    bool deliver() {
        switch (status_) {
            case OrderStatus::PickedUp:
                status_ = OrderStatus::Delivered;
                std::println("[{}] Delivered to customer successfully!", orderId_);
                return true;
            default:
                std::println("[{}] Cannot deliver order unless picked up.", orderId_);
                return false;
        }
    }

    bool cancel() {
        switch (status_) {
            case OrderStatus::Placed:
            case OrderStatus::Accepted:
                status_ = OrderStatus::Cancelled;
                std::println("[{}] Order cancelled. Full refund issued.", orderId_);
                return true;
            case OrderStatus::Cooking:
                std::println("[{}] Cannot cancel: Kitchen is actively preparing food!", orderId_);
                return false;
            case OrderStatus::PickedUp:
                std::println("[{}] Cannot cancel: Rider is already en route!", orderId_);
                return false;
            case OrderStatus::Delivered:
                std::println("[{}] Cannot cancel: Already delivered.", orderId_);
                return false;
            case OrderStatus::Cancelled:
                std::println("[{}] Already cancelled.", orderId_);
                return false;
        }
        return false;
    }

    [[nodiscard]] OrderStatus status() const { return status_; }
};

int main() {
    NaiveOrder order("ORD-401");
    order.accept();
    order.startCooking();
    // Cancellation should fail now because it is already cooking!
    order.cancel();
    order.pickUp("RIDER-7");
    order.deliver();
}