Composition Over Inheritance

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

// --- Pluggable Strategy 1: Pricing Rule ---
class PricingRule {
public:
    virtual ~PricingRule() = default;
    [[nodiscard]] virtual int64_t calculateDiscountPaise(int64_t subtotalPaise) const = 0;
    [[nodiscard]] virtual std::string ruleName() const = 0;
};

class NoDiscountRule final : public PricingRule {
public:
    [[nodiscard]] int64_t calculateDiscountPaise(int64_t) const override {
        return 0;
    }
    [[nodiscard]] std::string ruleName() const override {
        return "No Discount";
    }
};

class FlatDiscountRule final : public PricingRule {
private:
    int64_t discountPaise_;
    int64_t minSubtotalPaise_;

public:
    FlatDiscountRule(int64_t discountPaise, int64_t minSubtotalPaise)
        : discountPaise_(discountPaise), minSubtotalPaise_(minSubtotalPaise) {}

    [[nodiscard]] int64_t calculateDiscountPaise(int64_t subtotalPaise) const override {
        return (subtotalPaise >= minSubtotalPaise_) ? discountPaise_ : 0;
    }

    [[nodiscard]] std::string ruleName() const override {
        return std::format("Flat Rs.{:.2f} Off (min Rs.{:.2f})",
                           static_cast<double>(discountPaise_) / 100.0,
                           static_cast<double>(minSubtotalPaise_) / 100.0);
    }
};

class PercentageDiscountRule final : public PricingRule {
private:
    int percent_;
    int64_t maxDiscountPaise_;

public:
    PercentageDiscountRule(int percent, int64_t maxDiscountPaise)
        : percent_(percent), maxDiscountPaise_(maxDiscountPaise) {}

    [[nodiscard]] int64_t calculateDiscountPaise(int64_t subtotalPaise) const override {
        int64_t raw = (subtotalPaise * percent_) / 100;
        return std::min(raw, maxDiscountPaise_);
    }

    [[nodiscard]] std::string ruleName() const override {
        return std::format("{}% Off (capped at Rs.{:.2f})",
                           percent_,
                           static_cast<double>(maxDiscountPaise_) / 100.0);
    }
};

// --- Pluggable Strategy 2: Delivery Policy ---
class DeliveryPolicy {
public:
    virtual ~DeliveryPolicy() = default;
    [[nodiscard]] virtual int64_t deliveryFeePaise() const = 0;
    [[nodiscard]] virtual int estimatedMinutes() const = 0;
    [[nodiscard]] virtual std::string policyName() const = 0;
};

class StandardDeliveryPolicy final : public DeliveryPolicy {
public:
    [[nodiscard]] int64_t deliveryFeePaise() const override { return 3'000; } // Rs.30.00
    [[nodiscard]] int estimatedMinutes() const override { return 35; }
    [[nodiscard]] std::string policyName() const override { return "Standard Delivery (35 mins)"; }
};

class ExpressDeliveryPolicy final : public DeliveryPolicy {
public:
    [[nodiscard]] int64_t deliveryFeePaise() const override { return 7'500; } // Rs.75.00
    [[nodiscard]] int estimatedMinutes() const override { return 15; }
    [[nodiscard]] std::string policyName() const override { return "Express Priority (15 mins)"; }
};

// --- Composite Context: FoodOrder HAS-A PricingRule and HAS-A DeliveryPolicy ---
class FoodOrder {
private:
    std::string orderId_;
    int64_t subtotalPaise_;
    std::unique_ptr<PricingRule> pricingRule_;
    std::unique_ptr<DeliveryPolicy> deliveryPolicy_;

public:
    FoodOrder(std::string orderId,
              int64_t subtotalPaise,
              std::unique_ptr<PricingRule> pricing,
              std::unique_ptr<DeliveryPolicy> delivery)
        : orderId_(std::move(orderId)),
          subtotalPaise_(subtotalPaise),
          pricingRule_(std::move(pricing)),
          deliveryPolicy_(std::move(delivery)) {}

    void setPricingRule(std::unique_ptr<PricingRule> newRule) noexcept {
        pricingRule_ = std::move(newRule);
    }

    void setDeliveryPolicy(std::unique_ptr<DeliveryPolicy> newPolicy) noexcept {
        deliveryPolicy_ = std::move(newPolicy);
    }

    [[nodiscard]] int64_t calculateTotalPaise() const noexcept {
        int64_t discount = pricingRule_->calculateDiscountPaise(subtotalPaise_);
        int64_t discountedSubtotal = std::max<int64_t>(0, subtotalPaise_ - discount);
        return discountedSubtotal + deliveryPolicy_->deliveryFeePaise();
    }

    void printReceipt() const {
        int64_t discount = pricingRule_->calculateDiscountPaise(subtotalPaise_);
        int64_t fee = deliveryPolicy_->deliveryFeePaise();
        int64_t total = calculateTotalPaise();

        std::println("--- Order Receipt: {} ---", orderId_);
        std::println("Subtotal:       Rs.{:.2f}", static_cast<double>(subtotalPaise_) / 100.0);
        std::println("Pricing Rule:   {} (-Rs.{:.2f})", pricingRule_->ruleName(), static_cast<double>(discount) / 100.0);
        std::println("Delivery Mode:  {} (+Rs.{:.2f})", deliveryPolicy_->policyName(), static_cast<double>(fee) / 100.0);
        std::println("Final Total:    Rs.{:.2f} (ETA: {} mins)",
                     static_cast<double>(total) / 100.0,
                     deliveryPolicy_->estimatedMinutes());
    }
};

int main() {
    FoodOrder order("ORD-902",
                    60'000, // Rs.600 subtotal
                    std::make_unique<NoDiscountRule>(),
                    std::make_unique<StandardDeliveryPolicy>());
    order.printReceipt();

    std::println("\n[Customer applies coupon 'SAVE20' and selects Express Delivery]");
    order.setPricingRule(std::make_unique<PercentageDiscountRule>(20, 10'000)); // 20% capped at Rs.100
    order.setDeliveryPolicy(std::make_unique<ExpressDeliveryPolicy>());
    order.printReceipt();

    return 0;
}