19. E-commerce Shopping Cart & Checkout Intermediate → Advanced

interface PricingStep {
  Money apply(Money runningTotal, Cart cart);
}

class CheckoutService {
  Order checkout(Cart cart, String couponCode);            // reserves inventory, returns PENDING_PAYMENT order
  Order confirmPayment(String orderId, PaymentResult result, String idempotencyKey);
}

interface PricingStep {
  Money apply(Money runningTotal, Cart cart);
}

class CheckoutService {
  Order checkout(Cart cart, String couponCode);            // reserves inventory, returns PENDING_PAYMENT order
  Order confirmPayment(String orderId, PaymentResult result, String idempotencyKey);
}

class PricingStep {
public:
  virtual Money apply(Money runningTotal, std::shared_ptr<Cart> cart) = 0;
};

class CheckoutService {
public:
  std::shared_ptr<Order> checkout(std::shared_ptr<Cart> cart, const std::string& couponCode);            // reserves inventory, returns PENDING_PAYMENT order
  std::shared_ptr<Order> confirmPayment(const std::string& orderId, PaymentResult result, const std::string& idempotencyKey);
};

class PricingStep {
  apply(runningTotal, cart) { throw new Error('not implemented'); }
}

class CheckoutService {
  checkout(cart, couponCode) {}            // reserves inventory, returns PENDING_PAYMENT order
  confirmPayment(orderId, result, idempotencyKey) {}
}

interface PricingStep {
  apply(runningTotal: Money, cart: Cart): Money;
}

class CheckoutService {
  checkout(cart: Cart, couponCode: string): Order {}            // reserves inventory, returns PENDING_PAYMENT order
  confirmPayment(orderId: string, result: PaymentResult, idempotencyKey: string): Order {}
}

CheckoutService.checkout(cart, couponCode):
  orderedProductIds = sort(cart.items.map(i => i.product.id))   // canonical order, avoids cross-cart deadlock
  reserved = []
  try:
    for productId in orderedProductIds:
      lock(productId)
      product = productFor(productId)
      qty = cart.quantityFor(productId)
      if product.stock < qty: rollback(reserved); reject "out of stock"
      product.stock -= qty
      reserved.append(productId)
    total = cart.subtotal()   // includes decorator-priced add-ons
    for step in pricingPipeline: total = step.apply(total, cart)
    order = new Order(freeze(cart.items), total, status = PENDING_PAYMENT)
    return order
  finally:
    for productId in reserved: unlock(productId)

CheckoutService.confirmPayment(orderId, result, idempotencyKey):
  if alreadyProcessed(idempotencyKey): return existingOrderFor(idempotencyKey)
  order = orderFor(orderId)
  if result.success: order.transitionTo(PAID)
  else: order.transitionTo(CANCELLED); restoreInventory(order)
  recordProcessed(idempotencyKey, order)
  return order

Order checkout(Cart cart, String couponCode) {
  List<String> orderedProductIds = sort(cart.getItems().stream().map(i -> i.getProduct().getId()).collect(toList()));   // canonical order, avoids cross-cart deadlock
  List<String> reserved = new ArrayList<>();
  try {
    for (String productId : orderedProductIds) {
      lock(productId);
      Product product = productFor(productId);
      int qty = cart.quantityFor(productId);
      if (product.getStock() < qty) { rollback(reserved); throw new OutOfStockException("out of stock"); }
      product.setStock(product.getStock() - qty);
      reserved.add(productId);
    }
    Money total = cart.subtotal();   // includes decorator-priced add-ons
    for (PricingStep step : pricingPipeline) { total = step.apply(total, cart); }
    Order order = new Order(freeze(cart.getItems()), total, /* status = */ PENDING_PAYMENT);
    return order;
  } finally {
    for (String productId : reserved) { unlock(productId); }
  }
}

Order confirmPayment(String orderId, PaymentResult result, String idempotencyKey) {
  if (alreadyProcessed(idempotencyKey)) { return existingOrderFor(idempotencyKey); }
  Order order = orderFor(orderId);
  if (result.isSuccess()) {
    order.transitionTo(PAID);
  } else {
    order.transitionTo(CANCELLED);
    restoreInventory(order);
  }
  recordProcessed(idempotencyKey, order);
  return order;
}

std::shared_ptr<Order> CheckoutService::checkout(std::shared_ptr<Cart> cart, const std::string& couponCode) {
  auto orderedProductIds = sort(mapToProductIds(cart->items));   // canonical order, avoids cross-cart deadlock
  std::vector<std::string> reserved;
  try {
    for (auto& productId : orderedProductIds) {
      lock(productId);
      auto product = productFor(productId);
      int qty = cart->quantityFor(productId);
      if (product->stock < qty) { rollback(reserved); throw std::runtime_error("out of stock"); }
      product->stock -= qty;
      reserved.push_back(productId);
    }
    Money total = cart->subtotal();   // includes decorator-priced add-ons
    for (auto& step : pricingPipeline) { total = step->apply(total, cart); }
    auto order = std::make_shared<Order>(freeze(cart->items), total, /* status = */ PENDING_PAYMENT);
    for (auto& productId : reserved) { unlock(productId); }
    return order;
  } catch (...) {
    for (auto& productId : reserved) { unlock(productId); }
    throw;
  }
}

std::shared_ptr<Order> CheckoutService::confirmPayment(const std::string& orderId, PaymentResult result, const std::string& idempotencyKey) {
  if (alreadyProcessed(idempotencyKey)) { return existingOrderFor(idempotencyKey); }
  auto order = orderFor(orderId);
  if (result.success) {
    order->transitionTo(PAID);
  } else {
    order->transitionTo(CANCELLED);
    restoreInventory(order);
  }
  recordProcessed(idempotencyKey, order);
  return order;
}

checkout(cart, couponCode) {
  const orderedProductIds = sort(cart.items.map(i => i.product.id));   // canonical order, avoids cross-cart deadlock
  const reserved = [];
  try {
    for (const productId of orderedProductIds) {
      lock(productId);
      const product = productFor(productId);
      const qty = cart.quantityFor(productId);
      if (product.stock < qty) { rollback(reserved); throw new Error("out of stock"); }
      product.stock -= qty;
      reserved.push(productId);
    }
    let total = cart.subtotal();   // includes decorator-priced add-ons
    for (const step of pricingPipeline) { total = step.apply(total, cart); }
    const order = new Order(freeze(cart.items), total, /* status = */ PENDING_PAYMENT);
    return order;
  } finally {
    for (const productId of reserved) { unlock(productId); }
  }
}

confirmPayment(orderId, result, idempotencyKey) {
  if (alreadyProcessed(idempotencyKey)) { return existingOrderFor(idempotencyKey); }
  const order = orderFor(orderId);
  if (result.success) {
    order.transitionTo(PAID);
  } else {
    order.transitionTo(CANCELLED);
    restoreInventory(order);
  }
  recordProcessed(idempotencyKey, order);
  return order;
}

checkout(cart: Cart, couponCode: string): Order {
  const orderedProductIds = sort(cart.items.map(i => i.product.id));   // canonical order, avoids cross-cart deadlock
  const reserved: string[] = [];
  try {
    for (const productId of orderedProductIds) {
      lock(productId);
      const product = productFor(productId);
      const qty = cart.quantityFor(productId);
      if (product.stock < qty) { rollback(reserved); throw new Error("out of stock"); }
      product.stock -= qty;
      reserved.push(productId);
    }
    let total = cart.subtotal();   // includes decorator-priced add-ons
    for (const step of pricingPipeline) { total = step.apply(total, cart); }
    const order = new Order(freeze(cart.items), total, /* status = */ PENDING_PAYMENT);
    return order;
  } finally {
    for (const productId of reserved) { unlock(productId); }
  }
}

confirmPayment(orderId: string, result: PaymentResult, idempotencyKey: string): Order {
  if (alreadyProcessed(idempotencyKey)) { return existingOrderFor(idempotencyKey); }
  const order = orderFor(orderId);
  if (result.success) {
    order.transitionTo(PAID);
  } else {
    order.transitionTo(CANCELLED);
    restoreInventory(order);
  }
  recordProcessed(idempotencyKey, order);
  return order;
}

// Problem 19: E-commerce Shopping Cart & Checkout
// Patterns: Decorator (add-ons on CartItem), Strategy (pricing pipeline), State (Order lifecycle), Facade (CheckoutService)
import java.util.*;

public class p19 {

    // ---------- Exceptions ----------
    static class OutOfStockException extends RuntimeException {
        OutOfStockException(String msg) { super(msg); }
    }
    static class OrderNotFoundException extends RuntimeException {
        OrderNotFoundException(String msg) { super(msg); }
    }

    // ---------- Catalog ----------
    static class Product {
        final String id;
        final String name;
        final double price;
        int stock;

        Product(String id, String name, double price, int stock) {
            this.id = id; this.name = name; this.price = price; this.stock = stock;
        }

        void decrementStock(int qty) {
            if (stock < qty) throw new OutOfStockException("Insufficient stock for " + id);
            stock -= qty;
        }

        void restoreStock(int qty) { stock += qty; }
    }

    // ---------- CartItem (component) + Decorator ----------
    static class CartItem {
        final Product product;
        final int quantity;

        CartItem(Product product, int quantity) {
            this.product = product; this.quantity = quantity;
        }

        double getPrice() { return product.price * quantity; }
        Product getProduct() { return product; }
        int getQuantity() { return quantity; }
    }

    // Abstract decorator: subclasses CartItem so it's substitutable everywhere a CartItem is
    // expected, but wraps another CartItem to layer one stackable add-on charge on top.
    static abstract class CartItemDecorator extends CartItem {
        protected final CartItem wrapped;

        CartItemDecorator(CartItem wrapped) {
            super(wrapped.getProduct(), wrapped.getQuantity());
            this.wrapped = wrapped;
        }

        @Override
        abstract double getPrice(); // delegates to wrapped.getPrice() + adds its own charge
    }

    static class GiftWrapDecorator extends CartItemDecorator {
        private static final double FEE = 2.99;
        GiftWrapDecorator(CartItem wrapped) { super(wrapped); }
        @Override double getPrice() { return wrapped.getPrice() + FEE; }
    }

    static class EngravingDecorator extends CartItemDecorator {
        private static final double FEE = 5.00;
        EngravingDecorator(CartItem wrapped) { super(wrapped); }
        @Override double getPrice() { return wrapped.getPrice() + FEE; }
    }

    // ---------- Cart ----------
    static class Cart {
        private final List<CartItem> items = new ArrayList<>();

        void addItem(CartItem item) { items.add(item); }

        void removeItem(String productId) {
            items.removeIf(i -> i.getProduct().id.equals(productId));
        }

        double subtotal() {
            double total = 0;
            for (CartItem i : items) total += i.getPrice();
            return total;
        }

        int quantityFor(String productId) {
            int qty = 0;
            for (CartItem i : items) if (i.getProduct().id.equals(productId)) qty += i.getQuantity();
            return qty;
        }

        List<CartItem> getItems() { return items; }
    }

    // ---------- Pricing pipeline (Strategy) ----------
    interface PricingStep {
        double apply(double runningTotal, Cart cart);
    }

    static class TaxPricingStep implements PricingStep {
        private final double rate;
        TaxPricingStep(double rate) { this.rate = rate; }
        @Override public double apply(double runningTotal, Cart cart) { return runningTotal + runningTotal * rate; }
    }

    static class CouponDiscountPricingStep implements PricingStep {
        private final String couponCode;
        private final Map<String, Double> validCoupons;
        CouponDiscountPricingStep(String couponCode, Map<String, Double> validCoupons) {
            this.couponCode = couponCode; this.validCoupons = validCoupons;
        }
        @Override public double apply(double runningTotal, Cart cart) {
            if (couponCode == null || !validCoupons.containsKey(couponCode)) return runningTotal;
            double discount = validCoupons.get(couponCode);
            return runningTotal * (1 - discount);
        }
    }

    // ---------- Order lifecycle (State) ----------
    enum OrderStatus { PENDING_PAYMENT, PAID, SHIPPED, DELIVERED, CANCELLED }

    interface OrderState {
        OrderState onPaid(Order order);
        OrderState onShipped(Order order);
        OrderState onDelivered(Order order);
        OrderState onCancelled(Order order);
    }

    static class PendingPaymentState implements OrderState {
        @Override public OrderState onPaid(Order order) { order.status = OrderStatus.PAID; return new PaidState(); }
        @Override public OrderState onShipped(Order order) { throw new IllegalStateException("Cannot ship before payment"); }
        @Override public OrderState onDelivered(Order order) { throw new IllegalStateException("Cannot deliver before payment"); }
        @Override public OrderState onCancelled(Order order) { order.status = OrderStatus.CANCELLED; return new CancelledState(); }
    }

    static class PaidState implements OrderState {
        @Override public OrderState onPaid(Order order) { return this; }
        @Override public OrderState onShipped(Order order) { order.status = OrderStatus.SHIPPED; return new ShippedState(); }
        @Override public OrderState onDelivered(Order order) { throw new IllegalStateException("Cannot deliver before shipping"); }
        @Override public OrderState onCancelled(Order order) { order.status = OrderStatus.CANCELLED; return new CancelledState(); } // refund path
    }

    static class ShippedState implements OrderState {
        @Override public OrderState onPaid(Order order) { return this; }
        @Override public OrderState onShipped(Order order) { return this; }
        @Override public OrderState onDelivered(Order order) { order.status = OrderStatus.DELIVERED; return new DeliveredState(); }
        @Override public OrderState onCancelled(Order order) { throw new IllegalStateException("Cannot cancel a shipped order"); }
    }

    static class DeliveredState implements OrderState {
        @Override public OrderState onPaid(Order order) { return this; }
        @Override public OrderState onShipped(Order order) { return this; }
        @Override public OrderState onDelivered(Order order) { return this; }
        @Override public OrderState onCancelled(Order order) { throw new IllegalStateException("Cannot cancel a delivered order"); }
    }

    static class CancelledState implements OrderState {
        @Override public OrderState onPaid(Order order) { throw new IllegalStateException("Order is cancelled"); }
        @Override public OrderState onShipped(Order order) { throw new IllegalStateException("Order is cancelled"); }
        @Override public OrderState onDelivered(Order order) { throw new IllegalStateException("Order is cancelled"); }
        @Override public OrderState onCancelled(Order order) { return this; }
    }

    // ---------- Order (immutable snapshot + lifecycle) ----------
    static class Order {
        final String id;
        final List<CartItem> lineItems; // frozen at checkout time
        final double totalPrice;
        OrderStatus status;
        private OrderState state;

        Order(String id, List<CartItem> lineItems, double totalPrice) {
            this.id = id;
            this.lineItems = Collections.unmodifiableList(new ArrayList<>(lineItems));
            this.totalPrice = totalPrice;
            this.status = OrderStatus.PENDING_PAYMENT;
            this.state = new PendingPaymentState();
        }

        Order transitionTo(OrderStatus target) {
            switch (target) {
                case PAID: state = state.onPaid(this); break;
                case SHIPPED: state = state.onShipped(this); break;
                case DELIVERED: state = state.onDelivered(this); break;
                case CANCELLED: state = state.onCancelled(this); break;
                default: throw new IllegalArgumentException("Unsupported transition: " + target);
            }
            return this;
        }
    }

    static class PaymentResult {
        final boolean success;
        PaymentResult(boolean success) { this.success = success; }
    }

    // ---------- CheckoutService (Facade) ----------
    static class CheckoutService {
        private final List<PricingStep> pricingPipeline;
        private final Map<String, Order> ordersById = new HashMap<>();
        private final Map<String, Order> processedIdempotencyKeys = new HashMap<>();
        private int nextOrderId = 1;

        CheckoutService(List<PricingStep> pricingPipeline) {
            this.pricingPipeline = pricingPipeline;
        }

        Order checkout(Cart cart, String couponCode) {
            List<String> orderedProductIds = new ArrayList<>();
            for (CartItem item : cart.getItems()) {
                if (!orderedProductIds.contains(item.getProduct().id)) orderedProductIds.add(item.getProduct().id);
            }
            Collections.sort(orderedProductIds); // canonical order avoids cross-cart deadlock

            List<Product> reserved = new ArrayList<>();
            List<Integer> reservedQty = new ArrayList<>();
            try {
                for (String productId : orderedProductIds) {
                    Product product = productFor(cart, productId);
                    int qty = cart.quantityFor(productId);
                    product.decrementStock(qty); // throws OutOfStockException on failure
                    reserved.add(product);
                    reservedQty.add(qty);
                }
            } catch (OutOfStockException e) {
                for (int i = 0; i < reserved.size(); i++) reserved.get(i).restoreStock(reservedQty.get(i));
                throw e;
            }

            double total = cart.subtotal(); // includes decorator-priced add-ons
            for (PricingStep step : pricingPipeline) total = step.apply(total, cart);
            if (couponCode != null) {
                // coupon step is applied like any other pipeline step if wired in; here we allow ad-hoc override
            }

            Order order = new Order("ORD-" + (nextOrderId++), cart.getItems(), total);
            ordersById.put(order.id, order);
            return order;
        }

        Order confirmPayment(String orderId, PaymentResult result, String idempotencyKey) {
            if (processedIdempotencyKeys.containsKey(idempotencyKey)) {
                return processedIdempotencyKeys.get(idempotencyKey); // already processed: return same result, no double effect
            }
            Order order = ordersById.get(orderId);
            if (order == null) throw new OrderNotFoundException("No such order: " + orderId);

            if (result.success) {
                order.transitionTo(OrderStatus.PAID);
            } else {
                order.transitionTo(OrderStatus.CANCELLED);
                restoreInventory(order);
            }
            processedIdempotencyKeys.put(idempotencyKey, order);
            return order;
        }

        private void restoreInventory(Order order) {
            for (CartItem item : order.lineItems) item.getProduct().restoreStock(item.getQuantity());
        }

        private Product productFor(Cart cart, String productId) {
            for (CartItem item : cart.getItems()) if (item.getProduct().id.equals(productId)) return item.getProduct();
            throw new IllegalStateException("Product not in cart: " + productId);
        }
    }

    // ---------- Demo ----------
    public static void main(String[] args) {
        Product laptop = new Product("P1", "Laptop", 1000.0, 5);
        Product mug = new Product("P2", "Mug", 15.0, 10);

        Cart cart = new Cart();
        cart.addItem(new GiftWrapDecorator(new CartItem(laptop, 1))); // laptop + gift wrap
        cart.addItem(new EngravingDecorator(new CartItem(mug, 2)));   // 2 mugs + engraving

        System.out.println("Subtotal (with add-ons): " + cart.subtotal());

        Map<String, Double> coupons = new HashMap<>();
        coupons.put("SAVE10", 0.10);

        List<PricingStep> pipeline = new ArrayList<>();
        pipeline.add(new CouponDiscountPricingStep("SAVE10", coupons));
        pipeline.add(new TaxPricingStep(0.08));

        CheckoutService checkoutService = new CheckoutService(pipeline);
        Order order = checkoutService.checkout(cart, "SAVE10");
        System.out.println("Order created: " + order.id + " total=" + order.totalPrice + " status=" + order.status);
        System.out.println("Laptop stock after checkout: " + laptop.stock);

        Order confirmed = checkoutService.confirmPayment(order.id, new PaymentResult(true), "idem-key-1");
        System.out.println("After payment: " + confirmed.status);

        // Retried webhook with same idempotency key must not double-process
        Order retried = checkoutService.confirmPayment(order.id, new PaymentResult(true), "idem-key-1");
        System.out.println("Retry same order id? " + (retried == confirmed));

        confirmed.transitionTo(OrderStatus.SHIPPED);
        confirmed.transitionTo(OrderStatus.DELIVERED);
        System.out.println("Final status: " + confirmed.status);
    }
}

// Problem 19: E-commerce Shopping Cart & Checkout
// Patterns: Decorator (add-ons on CartItem), Strategy (pricing pipeline), State (Order lifecycle), Facade (CheckoutService)
#include <iostream>
#include <vector>
#include <map>
#include <memory>
#include <string>
#include <algorithm>
#include <stdexcept>

using namespace std;

// ---------- Exceptions ----------
struct OutOfStockException : runtime_error { OutOfStockException(const string& m) : runtime_error(m) {} };
struct OrderNotFoundException : runtime_error { OrderNotFoundException(const string& m) : runtime_error(m) {} };

// ---------- Catalog ----------
struct Product {
    string id, name;
    double price;
    int stock;
    Product(string id_, string name_, double price_, int stock_)
        : id(move(id_)), name(move(name_)), price(price_), stock(stock_) {}

    void decrementStock(int qty) {
        if (stock < qty) throw OutOfStockException("Insufficient stock for " + id);
        stock -= qty;
    }
    void restoreStock(int qty) { stock += qty; }
};

// ---------- CartItem (component) + Decorator ----------
class CartItem {
public:
    Product* product;
    int quantity;
    CartItem(Product* product_, int quantity_) : product(product_), quantity(quantity_) {}
    virtual ~CartItem() = default;
    virtual double getPrice() const { return product->price * quantity; }
    Product* getProduct() const { return product; }
    int getQuantity() const { return quantity; }
};

// Abstract decorator: subclasses CartItem so it's substitutable everywhere a CartItem is
// expected, but wraps another CartItem to layer one stackable add-on charge on top.
class CartItemDecorator : public CartItem {
protected:
    shared_ptr<CartItem> wrapped;
public:
    CartItemDecorator(shared_ptr<CartItem> wrapped_)
        : CartItem(wrapped_->getProduct(), wrapped_->getQuantity()), wrapped(wrapped_) {}
};

class GiftWrapDecorator : public CartItemDecorator {
    static constexpr double FEE = 2.99;
public:
    GiftWrapDecorator(shared_ptr<CartItem> wrapped_) : CartItemDecorator(wrapped_) {}
    double getPrice() const override { return wrapped->getPrice() + FEE; }
};

class EngravingDecorator : public CartItemDecorator {
    static constexpr double FEE = 5.00;
public:
    EngravingDecorator(shared_ptr<CartItem> wrapped_) : CartItemDecorator(wrapped_) {}
    double getPrice() const override { return wrapped->getPrice() + FEE; }
};

// ---------- Cart ----------
class Cart {
    vector<shared_ptr<CartItem>> items;
public:
    void addItem(shared_ptr<CartItem> item) { items.push_back(item); }

    void removeItem(const string& productId) {
        items.erase(remove_if(items.begin(), items.end(),
            [&](const shared_ptr<CartItem>& i) { return i->getProduct()->id == productId; }), items.end());
    }

    double subtotal() const {
        double total = 0;
        for (auto& i : items) total += i->getPrice();
        return total;
    }

    int quantityFor(const string& productId) const {
        int qty = 0;
        for (auto& i : items) if (i->getProduct()->id == productId) qty += i->getQuantity();
        return qty;
    }

    const vector<shared_ptr<CartItem>>& getItems() const { return items; }
};

// ---------- Pricing pipeline (Strategy) ----------
class PricingStep {
public:
    virtual ~PricingStep() = default;
    virtual double apply(double runningTotal, const Cart& cart) = 0;
};

class TaxPricingStep : public PricingStep {
    double rate;
public:
    TaxPricingStep(double rate_) : rate(rate_) {}
    double apply(double runningTotal, const Cart& cart) override { return runningTotal + runningTotal * rate; }
};

class CouponDiscountPricingStep : public PricingStep {
    string couponCode;
    map<string, double> validCoupons;
public:
    CouponDiscountPricingStep(string couponCode_, map<string, double> validCoupons_)
        : couponCode(move(couponCode_)), validCoupons(move(validCoupons_)) {}
    double apply(double runningTotal, const Cart& cart) override {
        auto it = validCoupons.find(couponCode);
        if (it == validCoupons.end()) return runningTotal;
        return runningTotal * (1 - it->second);
    }
};

// ---------- Order lifecycle (State) ----------
enum class OrderStatus { PENDING_PAYMENT, PAID, SHIPPED, DELIVERED, CANCELLED };

class Order; // fwd decl

class OrderState {
public:
    virtual ~OrderState() = default;
    virtual unique_ptr<OrderState> onPaid(Order& order) = 0;
    virtual unique_ptr<OrderState> onShipped(Order& order) = 0;
    virtual unique_ptr<OrderState> onDelivered(Order& order) = 0;
    virtual unique_ptr<OrderState> onCancelled(Order& order) = 0;
};

class Order {
public:
    string id;
    vector<shared_ptr<CartItem>> lineItems; // frozen at checkout time
    double totalPrice;
    OrderStatus status;
    unique_ptr<OrderState> state;

    Order(string id_, vector<shared_ptr<CartItem>> lineItems_, double totalPrice_);
    Order* transitionTo(OrderStatus target);
};

class PendingPaymentState : public OrderState {
public:
    unique_ptr<OrderState> onPaid(Order& order) override;
    unique_ptr<OrderState> onShipped(Order& order) override { throw runtime_error("Cannot ship before payment"); }
    unique_ptr<OrderState> onDelivered(Order& order) override { throw runtime_error("Cannot deliver before payment"); }
    unique_ptr<OrderState> onCancelled(Order& order) override;
};
class PaidState : public OrderState {
public:
    unique_ptr<OrderState> onPaid(Order& order) override;
    unique_ptr<OrderState> onShipped(Order& order) override;
    unique_ptr<OrderState> onDelivered(Order& order) override { throw runtime_error("Cannot deliver before shipping"); }
    unique_ptr<OrderState> onCancelled(Order& order) override; // refund path
};
class ShippedState : public OrderState {
public:
    unique_ptr<OrderState> onPaid(Order& order) override;
    unique_ptr<OrderState> onShipped(Order& order) override;
    unique_ptr<OrderState> onDelivered(Order& order) override;
    unique_ptr<OrderState> onCancelled(Order& order) override { throw runtime_error("Cannot cancel a shipped order"); }
};
class DeliveredState : public OrderState {
public:
    unique_ptr<OrderState> onPaid(Order& order) override;
    unique_ptr<OrderState> onShipped(Order& order) override;
    unique_ptr<OrderState> onDelivered(Order& order) override;
    unique_ptr<OrderState> onCancelled(Order& order) override { throw runtime_error("Cannot cancel a delivered order"); }
};
class CancelledState : public OrderState {
public:
    unique_ptr<OrderState> onPaid(Order& order) override { throw runtime_error("Order is cancelled"); }
    unique_ptr<OrderState> onShipped(Order& order) override { throw runtime_error("Order is cancelled"); }
    unique_ptr<OrderState> onDelivered(Order& order) override { throw runtime_error("Order is cancelled"); }
    unique_ptr<OrderState> onCancelled(Order& order) override;
};

unique_ptr<OrderState> PendingPaymentState::onPaid(Order& order) { order.status = OrderStatus::PAID; return make_unique<PaidState>(); }
unique_ptr<OrderState> PendingPaymentState::onCancelled(Order& order) { order.status = OrderStatus::CANCELLED; return make_unique<CancelledState>(); }
unique_ptr<OrderState> PaidState::onPaid(Order& order) { return make_unique<PaidState>(); }
unique_ptr<OrderState> PaidState::onShipped(Order& order) { order.status = OrderStatus::SHIPPED; return make_unique<ShippedState>(); }
unique_ptr<OrderState> PaidState::onCancelled(Order& order) { order.status = OrderStatus::CANCELLED; return make_unique<CancelledState>(); }
unique_ptr<OrderState> ShippedState::onPaid(Order& order) { return make_unique<ShippedState>(); }
unique_ptr<OrderState> ShippedState::onShipped(Order& order) { return make_unique<ShippedState>(); }
unique_ptr<OrderState> ShippedState::onDelivered(Order& order) { order.status = OrderStatus::DELIVERED; return make_unique<DeliveredState>(); }
unique_ptr<OrderState> DeliveredState::onPaid(Order& order) { return make_unique<DeliveredState>(); }
unique_ptr<OrderState> DeliveredState::onShipped(Order& order) { return make_unique<DeliveredState>(); }
unique_ptr<OrderState> DeliveredState::onDelivered(Order& order) { return make_unique<DeliveredState>(); }
unique_ptr<OrderState> CancelledState::onCancelled(Order& order) { return make_unique<CancelledState>(); }

Order::Order(string id_, vector<shared_ptr<CartItem>> lineItems_, double totalPrice_)
    : id(move(id_)), lineItems(move(lineItems_)), totalPrice(totalPrice_),
      status(OrderStatus::PENDING_PAYMENT), state(make_unique<PendingPaymentState>()) {}

Order* Order::transitionTo(OrderStatus target) {
    switch (target) {
        case OrderStatus::PAID: state = state->onPaid(*this); break;
        case OrderStatus::SHIPPED: state = state->onShipped(*this); break;
        case OrderStatus::DELIVERED: state = state->onDelivered(*this); break;
        case OrderStatus::CANCELLED: state = state->onCancelled(*this); break;
    }
    return this;
}

struct PaymentResult { bool success; };

string statusToString(OrderStatus s) {
    switch (s) {
        case OrderStatus::PENDING_PAYMENT: return "PENDING_PAYMENT";
        case OrderStatus::PAID: return "PAID";
        case OrderStatus::SHIPPED: return "SHIPPED";
        case OrderStatus::DELIVERED: return "DELIVERED";
        case OrderStatus::CANCELLED: return "CANCELLED";
    }
    return "?";
}

// ---------- CheckoutService (Facade) ----------
class CheckoutService {
    vector<shared_ptr<PricingStep>> pricingPipeline;
    map<string, shared_ptr<Order>> ordersById;
    map<string, shared_ptr<Order>> processedIdempotencyKeys;
    int nextOrderId = 1;
public:
    CheckoutService(vector<shared_ptr<PricingStep>> pipeline) : pricingPipeline(move(pipeline)) {}

    shared_ptr<Order> checkout(Cart& cart, const string& couponCode) {
        vector<string> orderedProductIds;
        for (auto& item : cart.getItems()) {
            if (find(orderedProductIds.begin(), orderedProductIds.end(), item->getProduct()->id) == orderedProductIds.end())
                orderedProductIds.push_back(item->getProduct()->id);
        }
        sort(orderedProductIds.begin(), orderedProductIds.end()); // canonical order avoids cross-cart deadlock

        vector<Product*> reserved;
        vector<int> reservedQty;
        try {
            for (auto& productId : orderedProductIds) {
                Product* product = productFor(cart, productId);
                int qty = cart.quantityFor(productId);
                product->decrementStock(qty); // throws OutOfStockException on failure
                reserved.push_back(product);
                reservedQty.push_back(qty);
            }
        } catch (OutOfStockException&) {
            for (size_t i = 0; i < reserved.size(); i++) reserved[i]->restoreStock(reservedQty[i]);
            throw;
        }

        double total = cart.subtotal(); // includes decorator-priced add-ons
        for (auto& step : pricingPipeline) total = step->apply(total, cart);

        auto order = make_shared<Order>("ORD-" + to_string(nextOrderId++), cart.getItems(), total);
        ordersById[order->id] = order;
        return order;
    }

    shared_ptr<Order> confirmPayment(const string& orderId, PaymentResult result, const string& idempotencyKey) {
        auto found = processedIdempotencyKeys.find(idempotencyKey);
        if (found != processedIdempotencyKeys.end()) return found->second;

        auto it = ordersById.find(orderId);
        if (it == ordersById.end()) throw OrderNotFoundException("No such order: " + orderId);
        auto order = it->second;

        if (result.success) {
            order->transitionTo(OrderStatus::PAID);
        } else {
            order->transitionTo(OrderStatus::CANCELLED);
            restoreInventory(*order);
        }
        processedIdempotencyKeys[idempotencyKey] = order;
        return order;
    }

private:
    void restoreInventory(Order& order) {
        for (auto& item : order.lineItems) item->getProduct()->restoreStock(item->getQuantity());
    }

    Product* productFor(Cart& cart, const string& productId) {
        for (auto& item : cart.getItems()) if (item->getProduct()->id == productId) return item->getProduct();
        throw runtime_error("Product not in cart: " + productId);
    }
};

// ---------- Demo ----------
int main() {
    Product laptop("P1", "Laptop", 1000.0, 5);
    Product mug("P2", "Mug", 15.0, 10);

    Cart cart;
    cart.addItem(make_shared<GiftWrapDecorator>(make_shared<CartItem>(&laptop, 1)));
    cart.addItem(make_shared<EngravingDecorator>(make_shared<CartItem>(&mug, 2)));

    cout << "Subtotal (with add-ons): " << cart.subtotal() << endl;

    map<string, double> coupons = {{"SAVE10", 0.10}};
    vector<shared_ptr<PricingStep>> pipeline;
    pipeline.push_back(make_shared<CouponDiscountPricingStep>("SAVE10", coupons));
    pipeline.push_back(make_shared<TaxPricingStep>(0.08));

    CheckoutService checkoutService(pipeline);
    auto order = checkoutService.checkout(cart, "SAVE10");
    cout << "Order created: " << order->id << " total=" << order->totalPrice << " status=" << statusToString(order->status) << endl;
    cout << "Laptop stock after checkout: " << laptop.stock << endl;

    auto confirmed = checkoutService.confirmPayment(order->id, PaymentResult{true}, "idem-key-1");
    cout << "After payment: " << statusToString(confirmed->status) << endl;

    auto retried = checkoutService.confirmPayment(order->id, PaymentResult{true}, "idem-key-1");
    cout << "Retry same order id? " << (retried == confirmed) << endl;

    confirmed->transitionTo(OrderStatus::SHIPPED);
    confirmed->transitionTo(OrderStatus::DELIVERED);
    cout << "Final status: " << statusToString(confirmed->status) << endl;

    return 0;
}

// Problem 19: E-commerce Shopping Cart & Checkout
// Patterns: Decorator (add-ons on CartItem), Strategy (pricing pipeline), State (Order lifecycle), Facade (CheckoutService)

class OutOfStockException extends Error {}
class OrderNotFoundException extends Error {}

// ---------- Catalog ----------
class Product {
  constructor(id, name, price, stock) {
    this.id = id; this.name = name; this.price = price; this.stock = stock;
  }
  decrementStock(qty) {
    if (this.stock < qty) throw new OutOfStockException(`Insufficient stock for ${this.id}`);
    this.stock -= qty;
  }
  restoreStock(qty) { this.stock += qty; }
}

// ---------- CartItem (component) + Decorator ----------
class CartItem {
  constructor(product, quantity) {
    this.product = product; this.quantity = quantity;
  }
  getPrice() { return this.product.price * this.quantity; }
  getProduct() { return this.product; }
  getQuantity() { return this.quantity; }
}

// Abstract decorator: subclasses CartItem so it's substitutable everywhere a CartItem is
// expected, but wraps another CartItem to layer one stackable add-on charge on top.
class CartItemDecorator extends CartItem {
  constructor(wrapped) {
    super(wrapped.getProduct(), wrapped.getQuantity());
    this.wrapped = wrapped;
  }
  getPrice() { throw new Error('abstract method'); }
}

class GiftWrapDecorator extends CartItemDecorator {
  getPrice() { return this.wrapped.getPrice() + 2.99; }
}

class EngravingDecorator extends CartItemDecorator {
  getPrice() { return this.wrapped.getPrice() + 5.00; }
}

// ---------- Cart ----------
class Cart {
  constructor() { this.items = []; }
  addItem(item) { this.items.push(item); }
  removeItem(productId) { this.items = this.items.filter(i => i.getProduct().id !== productId); }
  subtotal() { return this.items.reduce((sum, i) => sum + i.getPrice(), 0); }
  quantityFor(productId) {
    return this.items.filter(i => i.getProduct().id === productId).reduce((sum, i) => sum + i.getQuantity(), 0);
  }
  getItems() { return this.items; }
}

// ---------- Pricing pipeline (Strategy) ----------
class TaxPricingStep {
  constructor(rate) { this.rate = rate; }
  apply(runningTotal, cart) { return runningTotal + runningTotal * this.rate; }
}

class CouponDiscountPricingStep {
  constructor(couponCode, validCoupons) { this.couponCode = couponCode; this.validCoupons = validCoupons; }
  apply(runningTotal, cart) {
    if (!this.validCoupons.has(this.couponCode)) return runningTotal;
    return runningTotal * (1 - this.validCoupons.get(this.couponCode));
  }
}

// ---------- Order lifecycle (State) ----------
const OrderStatus = Object.freeze({
  PENDING_PAYMENT: 'PENDING_PAYMENT', PAID: 'PAID', SHIPPED: 'SHIPPED',
  DELIVERED: 'DELIVERED', CANCELLED: 'CANCELLED',
});

class PendingPaymentState {
  onPaid(order) { order.status = OrderStatus.PAID; return new PaidState(); }
  onShipped() { throw new Error('Cannot ship before payment'); }
  onDelivered() { throw new Error('Cannot deliver before payment'); }
  onCancelled(order) { order.status = OrderStatus.CANCELLED; return new CancelledState(); }
}
class PaidState {
  onPaid() { return this; }
  onShipped(order) { order.status = OrderStatus.SHIPPED; return new ShippedState(); }
  onDelivered() { throw new Error('Cannot deliver before shipping'); }
  onCancelled(order) { order.status = OrderStatus.CANCELLED; return new CancelledState(); } // refund path
}
class ShippedState {
  onPaid() { return this; }
  onShipped() { return this; }
  onDelivered(order) { order.status = OrderStatus.DELIVERED; return new DeliveredState(); }
  onCancelled() { throw new Error('Cannot cancel a shipped order'); }
}
class DeliveredState {
  onPaid() { return this; }
  onShipped() { return this; }
  onDelivered() { return this; }
  onCancelled() { throw new Error('Cannot cancel a delivered order'); }
}
class CancelledState {
  onPaid() { throw new Error('Order is cancelled'); }
  onShipped() { throw new Error('Order is cancelled'); }
  onDelivered() { throw new Error('Order is cancelled'); }
  onCancelled() { return this; }
}

// ---------- Order (immutable snapshot + lifecycle) ----------
class Order {
  constructor(id, lineItems, totalPrice) {
    this.id = id;
    this.lineItems = Object.freeze([...lineItems]);
    this.totalPrice = totalPrice;
    this.status = OrderStatus.PENDING_PAYMENT;
    this.state = new PendingPaymentState();
  }

  transitionTo(target) {
    switch (target) {
      case OrderStatus.PAID: this.state = this.state.onPaid(this); break;
      case OrderStatus.SHIPPED: this.state = this.state.onShipped(this); break;
      case OrderStatus.DELIVERED: this.state = this.state.onDelivered(this); break;
      case OrderStatus.CANCELLED: this.state = this.state.onCancelled(this); break;
      default: throw new Error(`Unsupported transition: ${target}`);
    }
    return this;
  }
}

// ---------- CheckoutService (Facade) ----------
class CheckoutService {
  constructor(pricingPipeline) {
    this.pricingPipeline = pricingPipeline;
    this.ordersById = new Map();
    this.processedIdempotencyKeys = new Map();
    this.nextOrderId = 1;
  }

  checkout(cart, couponCode) {
    const orderedProductIds = [...new Set(cart.getItems().map(i => i.getProduct().id))].sort(); // canonical order

    const reserved = [];
    try {
      for (const productId of orderedProductIds) {
        const product = this._productFor(cart, productId);
        const qty = cart.quantityFor(productId);
        product.decrementStock(qty); // throws OutOfStockException on failure
        reserved.push({ product, qty });
      }
    } catch (e) {
      for (const r of reserved) r.product.restoreStock(r.qty);
      throw e;
    }

    let total = cart.subtotal(); // includes decorator-priced add-ons
    for (const step of this.pricingPipeline) total = step.apply(total, cart);

    const order = new Order(`ORD-${this.nextOrderId++}`, cart.getItems(), total);
    this.ordersById.set(order.id, order);
    return order;
  }

  confirmPayment(orderId, result, idempotencyKey) {
    if (this.processedIdempotencyKeys.has(idempotencyKey)) {
      return this.processedIdempotencyKeys.get(idempotencyKey); // already processed: no double effect
    }
    const order = this.ordersById.get(orderId);
    if (!order) throw new OrderNotFoundException(`No such order: ${orderId}`);

    if (result.success) {
      order.transitionTo(OrderStatus.PAID);
    } else {
      order.transitionTo(OrderStatus.CANCELLED);
      this._restoreInventory(order);
    }
    this.processedIdempotencyKeys.set(idempotencyKey, order);
    return order;
  }

  _restoreInventory(order) {
    for (const item of order.lineItems) item.getProduct().restoreStock(item.getQuantity());
  }

  _productFor(cart, productId) {
    const item = cart.getItems().find(i => i.getProduct().id === productId);
    if (!item) throw new Error(`Product not in cart: ${productId}`);
    return item.getProduct();
  }
}

// ---------- Demo ----------
function main() {
  const laptop = new Product('P1', 'Laptop', 1000.0, 5);
  const mug = new Product('P2', 'Mug', 15.0, 10);

  const cart = new Cart();
  cart.addItem(new GiftWrapDecorator(new CartItem(laptop, 1)));
  cart.addItem(new EngravingDecorator(new CartItem(mug, 2)));

  console.log('Subtotal (with add-ons):', cart.subtotal());

  const coupons = new Map([['SAVE10', 0.10]]);
  const pipeline = [new CouponDiscountPricingStep('SAVE10', coupons), new TaxPricingStep(0.08)];

  const checkoutService = new CheckoutService(pipeline);
  const order = checkoutService.checkout(cart, 'SAVE10');
  console.log(`Order created: ${order.id} total=${order.totalPrice} status=${order.status}`);
  console.log('Laptop stock after checkout:', laptop.stock);

  const confirmed = checkoutService.confirmPayment(order.id, { success: true }, 'idem-key-1');
  console.log('After payment:', confirmed.status);

  const retried = checkoutService.confirmPayment(order.id, { success: true }, 'idem-key-1');
  console.log('Retry same order id?', retried === confirmed);

  confirmed.transitionTo(OrderStatus.SHIPPED);
  confirmed.transitionTo(OrderStatus.DELIVERED);
  console.log('Final status:', confirmed.status);
}

if (require.main === module) main();

module.exports = {
  Product, CartItem, CartItemDecorator, GiftWrapDecorator, EngravingDecorator,
  Cart, TaxPricingStep, CouponDiscountPricingStep, Order, OrderStatus, CheckoutService,
};

// Problem 19: E-commerce Shopping Cart & Checkout
// Patterns: Decorator (add-ons on CartItem), Strategy (pricing pipeline), State (Order lifecycle), Facade (CheckoutService)

class OutOfStockException extends Error {}
class OrderNotFoundException extends Error {}

// ---------- Catalog ----------
class Product {
  constructor(public id: string, public name: string, public price: number, public stock: number) {}

  decrementStock(qty: number): void {
    if (this.stock < qty) throw new OutOfStockException(`Insufficient stock for ${this.id}`);
    this.stock -= qty;
  }
  restoreStock(qty: number): void { this.stock += qty; }
}

// ---------- CartItem (component) + Decorator ----------
class CartItem {
  constructor(protected product: Product, protected quantity: number) {}

  getPrice(): number { return this.product.price * this.quantity; }
  getProduct(): Product { return this.product; }
  getQuantity(): number { return this.quantity; }
}

// Abstract decorator: subclasses CartItem so it's substitutable everywhere a CartItem is
// expected, but wraps another CartItem to layer one stackable add-on charge on top.
abstract class CartItemDecorator extends CartItem {
  constructor(protected wrapped: CartItem) {
    super(wrapped.getProduct(), wrapped.getQuantity());
  }
  abstract getPrice(): number;
}

class GiftWrapDecorator extends CartItemDecorator {
  private static readonly FEE = 2.99;
  getPrice(): number { return this.wrapped.getPrice() + GiftWrapDecorator.FEE; }
}

class EngravingDecorator extends CartItemDecorator {
  private static readonly FEE = 5.00;
  getPrice(): number { return this.wrapped.getPrice() + EngravingDecorator.FEE; }
}

// ---------- Cart ----------
class Cart {
  private items: CartItem[] = [];

  addItem(item: CartItem): void { this.items.push(item); }
  removeItem(productId: string): void { this.items = this.items.filter(i => i.getProduct().id !== productId); }
  subtotal(): number { return this.items.reduce((sum, i) => sum + i.getPrice(), 0); }
  quantityFor(productId: string): number {
    return this.items.filter(i => i.getProduct().id === productId).reduce((sum, i) => sum + i.getQuantity(), 0);
  }
  getItems(): CartItem[] { return this.items; }
}

// ---------- Pricing pipeline (Strategy) ----------
interface PricingStep {
  apply(runningTotal: number, cart: Cart): number;
}

class TaxPricingStep implements PricingStep {
  constructor(private rate: number) {}
  apply(runningTotal: number, _cart: Cart): number { return runningTotal + runningTotal * this.rate; }
}

class CouponDiscountPricingStep implements PricingStep {
  constructor(private couponCode: string, private validCoupons: Map<string, number>) {}
  apply(runningTotal: number, _cart: Cart): number {
    if (!this.validCoupons.has(this.couponCode)) return runningTotal;
    return runningTotal * (1 - this.validCoupons.get(this.couponCode)!);
  }
}

// ---------- Order lifecycle (State) ----------
enum OrderStatus { PENDING_PAYMENT = 'PENDING_PAYMENT', PAID = 'PAID', SHIPPED = 'SHIPPED', DELIVERED = 'DELIVERED', CANCELLED = 'CANCELLED' }

interface OrderState {
  onPaid(order: Order): OrderState;
  onShipped(order: Order): OrderState;
  onDelivered(order: Order): OrderState;
  onCancelled(order: Order): OrderState;
}

class PendingPaymentState implements OrderState {
  onPaid(order: Order): OrderState { order.status = OrderStatus.PAID; return new PaidState(); }
  onShipped(): OrderState { throw new Error('Cannot ship before payment'); }
  onDelivered(): OrderState { throw new Error('Cannot deliver before payment'); }
  onCancelled(order: Order): OrderState { order.status = OrderStatus.CANCELLED; return new CancelledState(); }
}
class PaidState implements OrderState {
  onPaid(): OrderState { return this; }
  onShipped(order: Order): OrderState { order.status = OrderStatus.SHIPPED; return new ShippedState(); }
  onDelivered(): OrderState { throw new Error('Cannot deliver before shipping'); }
  onCancelled(order: Order): OrderState { order.status = OrderStatus.CANCELLED; return new CancelledState(); } // refund path
}
class ShippedState implements OrderState {
  onPaid(): OrderState { return this; }
  onShipped(): OrderState { return this; }
  onDelivered(order: Order): OrderState { order.status = OrderStatus.DELIVERED; return new DeliveredState(); }
  onCancelled(): OrderState { throw new Error('Cannot cancel a shipped order'); }
}
class DeliveredState implements OrderState {
  onPaid(): OrderState { return this; }
  onShipped(): OrderState { return this; }
  onDelivered(): OrderState { return this; }
  onCancelled(): OrderState { throw new Error('Cannot cancel a delivered order'); }
}
class CancelledState implements OrderState {
  onPaid(): OrderState { throw new Error('Order is cancelled'); }
  onShipped(): OrderState { throw new Error('Order is cancelled'); }
  onDelivered(): OrderState { throw new Error('Order is cancelled'); }
  onCancelled(): OrderState { return this; }
}

// ---------- Order (immutable snapshot + lifecycle) ----------
class Order {
  readonly id: string;
  readonly lineItems: ReadonlyArray<CartItem>;
  readonly totalPrice: number;
  status: OrderStatus;
  private state: OrderState;

  constructor(id: string, lineItems: CartItem[], totalPrice: number) {
    this.id = id;
    this.lineItems = Object.freeze([...lineItems]);
    this.totalPrice = totalPrice;
    this.status = OrderStatus.PENDING_PAYMENT;
    this.state = new PendingPaymentState();
  }

  transitionTo(target: OrderStatus): Order {
    switch (target) {
      case OrderStatus.PAID: this.state = this.state.onPaid(this); break;
      case OrderStatus.SHIPPED: this.state = this.state.onShipped(this); break;
      case OrderStatus.DELIVERED: this.state = this.state.onDelivered(this); break;
      case OrderStatus.CANCELLED: this.state = this.state.onCancelled(this); break;
      default: throw new Error(`Unsupported transition: ${target}`);
    }
    return this;
  }
}

interface PaymentResult { success: boolean; }

// ---------- CheckoutService (Facade) ----------
class CheckoutService {
  private ordersById = new Map<string, Order>();
  private processedIdempotencyKeys = new Map<string, Order>();
  private nextOrderId = 1;

  constructor(private pricingPipeline: PricingStep[]) {}

  checkout(cart: Cart, _couponCode: string | null): Order {
    const orderedProductIds = [...new Set(cart.getItems().map(i => i.getProduct().id))].sort(); // canonical order

    const reserved: { product: Product; qty: number }[] = [];
    try {
      for (const productId of orderedProductIds) {
        const product = this.productFor(cart, productId);
        const qty = cart.quantityFor(productId);
        product.decrementStock(qty); // throws OutOfStockException on failure
        reserved.push({ product, qty });
      }
    } catch (e) {
      for (const r of reserved) r.product.restoreStock(r.qty);
      throw e;
    }

    let total = cart.subtotal(); // includes decorator-priced add-ons
    for (const step of this.pricingPipeline) total = step.apply(total, cart);

    const order = new Order(`ORD-${this.nextOrderId++}`, cart.getItems(), total);
    this.ordersById.set(order.id, order);
    return order;
  }

  confirmPayment(orderId: string, result: PaymentResult, idempotencyKey: string): Order {
    if (this.processedIdempotencyKeys.has(idempotencyKey)) {
      return this.processedIdempotencyKeys.get(idempotencyKey)!; // already processed: no double effect
    }
    const order = this.ordersById.get(orderId);
    if (!order) throw new OrderNotFoundException(`No such order: ${orderId}`);

    if (result.success) {
      order.transitionTo(OrderStatus.PAID);
    } else {
      order.transitionTo(OrderStatus.CANCELLED);
      this.restoreInventory(order);
    }
    this.processedIdempotencyKeys.set(idempotencyKey, order);
    return order;
  }

  private restoreInventory(order: Order): void {
    for (const item of order.lineItems) item.getProduct().restoreStock(item.getQuantity());
  }

  private productFor(cart: Cart, productId: string): Product {
    const item = cart.getItems().find(i => i.getProduct().id === productId);
    if (!item) throw new Error(`Product not in cart: ${productId}`);
    return item.getProduct();
  }
}

// ---------- Demo ----------
function main(): void {
  const laptop = new Product('P1', 'Laptop', 1000.0, 5);
  const mug = new Product('P2', 'Mug', 15.0, 10);

  const cart = new Cart();
  cart.addItem(new GiftWrapDecorator(new CartItem(laptop, 1)));
  cart.addItem(new EngravingDecorator(new CartItem(mug, 2)));

  console.log('Subtotal (with add-ons):', cart.subtotal());

  const coupons = new Map<string, number>([['SAVE10', 0.10]]);
  const pipeline: PricingStep[] = [new CouponDiscountPricingStep('SAVE10', coupons), new TaxPricingStep(0.08)];

  const checkoutService = new CheckoutService(pipeline);
  const order = checkoutService.checkout(cart, 'SAVE10');
  console.log(`Order created: ${order.id} total=${order.totalPrice} status=${order.status}`);
  console.log('Laptop stock after checkout:', laptop.stock);

  const confirmed = checkoutService.confirmPayment(order.id, { success: true }, 'idem-key-1');
  console.log('After payment:', confirmed.status);

  const retried = checkoutService.confirmPayment(order.id, { success: true }, 'idem-key-1');
  console.log('Retry same order id?', retried === confirmed);

  confirmed.transitionTo(OrderStatus.SHIPPED);
  confirmed.transitionTo(OrderStatus.DELIVERED);
  console.log('Final status:', confirmed.status);
}

main();

export {
  Product, CartItem, CartItemDecorator, GiftWrapDecorator, EngravingDecorator,
  Cart, PricingStep, TaxPricingStep, CouponDiscountPricingStep, Order, OrderStatus, CheckoutService,
};