Inheritance & Polymorphism

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

// Abstract polymorphic base class representing a delivery fleet partner.
// MANDATORY: Polymorphic base classes must define a virtual destructor!
class DeliveryPartner {
public:
    virtual ~DeliveryPartner() = default;

    [[nodiscard]] virtual std::string partnerType() const = 0;
    [[nodiscard]] virtual int estimateEtaMinutes(int distanceKm) const = 0;
    [[nodiscard]] virtual std::string dispatch(std::string_view orderId) = 0;
};

// Concrete derived class: Bike Courier.
// Marked 'final' so compiler can devirtualize calls when concrete type is known.
class BikeDeliveryPartner final : public DeliveryPartner {
private:
    std::string riderName_;
    std::string bikePlate_;

public:
    BikeDeliveryPartner(std::string riderName, std::string bikePlate)
        : riderName_(std::move(riderName)), bikePlate_(std::move(bikePlate)) {}

    [[nodiscard]] std::string partnerType() const override {
        return "Bike Courier";
    }

    [[nodiscard]] int estimateEtaMinutes(int distanceKm) const override {
        // Base: 5 mins prep + 3 mins per km in city traffic
        return 5 + (distanceKm * 3);
    }

    [[nodiscard]] std::string dispatch(std::string_view orderId) override {
        return std::format("[Bike] Assigned rider {} ({}) to order {}",
                           riderName_, bikePlate_, orderId);
    }

    [[nodiscard]] const std::string& riderName() const noexcept {
        return riderName_;
    }
};

// Concrete derived class: Autonomous Delivery Drone.
class DroneDeliveryPartner final : public DeliveryPartner {
private:
    std::string droneId_;
    int batteryPct_;

public:
    DroneDeliveryPartner(std::string droneId, int batteryPct)
        : droneId_(std::move(droneId)), batteryPct_(batteryPct) {}

    [[nodiscard]] std::string partnerType() const override {
        return "Autonomous Drone";
    }

    [[nodiscard]] int estimateEtaMinutes(int distanceKm) const override {
        // Direct flight: 3 mins prep + 1 min per km
        return 3 + (distanceKm * 1);
    }

    [[nodiscard]] std::string dispatch(std::string_view orderId) override {
        return std::format("[Drone] Launched drone {} (battery {}%) for order {}",
                           droneId_, batteryPct_, orderId);
    }

    [[nodiscard]] int batteryPct() const noexcept {
        return batteryPct_;
    }
};

// Polymorphic Dispatcher function: talks strictly to base interface references.
void dispatchFleetOrder(DeliveryPartner& partner, std::string_view orderId, int distanceKm) {
    int eta = partner.estimateEtaMinutes(distanceKm);
    std::string status = partner.dispatch(orderId);
    std::println("{}: ETA {} mins -> {}", partner.partnerType(), eta, status);
}

int main() {
    std::vector<std::unique_ptr<DeliveryPartner>> fleet;
    fleet.push_back(std::make_unique<BikeDeliveryPartner>("Rohan", "MH-12-AB-3421"));
    fleet.push_back(std::make_unique<DroneDeliveryPartner>("DRN-902", 88));

    std::println("--- Dispatching Order ORD-501 (3 km) ---");
    for (const auto& partner : fleet) {
        dispatchFleetOrder(*partner, "ORD-501", 3);
    }

    return 0;
}