Capstone: Design a Complete Online Food Ordering Platform

// Every legal transition returns the NEXT state; illegal ones throw.
interface OrderState {
    OrderState confirm(Order order);
    OrderState startPreparing(Order order);
    OrderState markPickedUp(Order order);
    OrderState markDelivered(Order order);
    OrderState complete(Order order);
    OrderState cancel(Order order);
    String name();
}
 
abstract class BaseOrderState implements OrderState {
    public OrderState confirm(Order order)        { return illegal("confirm"); }
    public OrderState startPreparing(Order order) { return illegal("startPreparing"); }
    public OrderState markPickedUp(Order order)   { return illegal("markPickedUp"); }
    public OrderState markDelivered(Order order)  { return illegal("markDelivered"); }
    public OrderState complete(Order order)       { return illegal("complete"); }
    public OrderState cancel(Order order)         { return illegal("cancel"); }
 
    private OrderState illegal(String action) {
        throw new IllegalStateException("Cannot " + action + " an order in state " + name());
    }
}

class PlacedState extends BaseOrderState {
    public String name() { return "PLACED"; }
 
    @Override public OrderState confirm(Order order) {
        order.notifyObservers("CONFIRMED");
        return new ConfirmedState();
    }
 
    @Override public OrderState cancel(Order order) {
        order.notifyObservers("CANCELLED");
        return new CancelledState();
    }
}
 
class ConfirmedState extends BaseOrderState {
    public String name() { return "CONFIRMED"; }
 
    @Override public OrderState startPreparing(Order order) {
        order.notifyObservers("PREPARING");
        return new PreparingState();
    }
 
    @Override public OrderState cancel(Order order) {
        order.notifyObservers("CANCELLED");
        return new CancelledState();
    }
}
 
class PreparingState extends BaseOrderState {
    public String name() { return "PREPARING"; }
 
    @Override public OrderState markPickedUp(Order order) {
        order.notifyObservers("PICKED_UP");
        return new PickedUpState();
    }
 
    @Override public OrderState cancel(Order order) {
        order.notifyObservers("CANCELLED"); // admin-approved exceptional path
        return new CancelledState();
    }
}
 
class PickedUpState extends BaseOrderState {
    public String name() { return "PICKED_UP"; }
 
    @Override public OrderState markDelivered(Order order) {
        order.notifyObservers("DELIVERED");
        return new DeliveredState();
    }
    // No cancel() override: food is out for delivery, cancellation is no
    // longer a state transition — it becomes a post-delivery refund case.
}
 
class DeliveredState extends BaseOrderState {
    public String name() { return "DELIVERED"; }
 
    @Override public OrderState complete(Order order) {
        order.notifyObservers("COMPLETED");
        return new CompletedState();
    }
}
 
class CompletedState extends BaseOrderState {
    public String name() { return "COMPLETED"; } // terminal — every transition is illegal
}
 
class CancelledState extends BaseOrderState {
    public String name() { return "CANCELLED"; } // terminal — every transition is illegal
}

class Order {
    private final String id;
    private final String idempotencyKey;
    private final List<OrderStatusObserver> observers = new ArrayList<>();
    private OrderState state;
 
    Order(String id, String idempotencyKey) {
        this.id = id;
        this.idempotencyKey = idempotencyKey;
        this.state = new PlacedState(); // an Order is only ever constructed post-checkout
    }
 
    void addObserver(OrderStatusObserver observer) { observers.add(observer); }
 
    void notifyObservers(String newStatus) {
        for (OrderStatusObserver observer : observers) {
            observer.onStatusChanged(this, newStatus);
        }
    }
 
    void confirm()        { state = state.confirm(this); }
    void startPreparing() { state = state.startPreparing(this); }
    void markPickedUp()   { state = state.markPickedUp(this); }
    void markDelivered()  { state = state.markDelivered(this); }
    void complete()       { state = state.complete(this); }
    void cancel()         { state = state.cancel(this); }
 
    String currentStatus() { return state.name(); }
    String getId() { return id; }
}

class Cart {
    private final String id;
    private final Customer owner;
    private final Restaurant restaurant;
    private final List<CartItem> items = new ArrayList<>();
 
    Cart(String id, Customer owner, Restaurant restaurant) {
        this.id = id;
        this.owner = owner;
        this.restaurant = restaurant;
    }
 
    void addItem(MenuItem item, ItemVariant variant, int quantity, List<AddOn> addOns) {
        if (!item.isAvailable()) {
            throw new IllegalStateException(item.getName() + " is currently unavailable");
        }
        items.add(new CartItem(item, variant, quantity, addOns));
    }
 
    void removeItem(String cartItemId) {
        items.removeIf(ci -> ci.getId().equals(cartItemId));
    }
 
    double subtotal() {
        return items.stream().mapToDouble(CartItem::lineTotal).sum();
    }
 
    List<CartItem> getItems() { return Collections.unmodifiableList(items); }
 
    Order checkout(Address deliveryAddress, PricingCalculator pricing, String idempotencyKey) {
        if (items.isEmpty()) {
            throw new IllegalStateException("Cannot checkout an empty cart");
        }
        // Re-validate availability at checkout time, not just at add-to-cart time —
        // an item can go out of stock while it's sitting in the cart.
        for (CartItem ci : items) {
            if (!ci.getMenuItem().isAvailable()) {
                throw new IllegalStateException(ci.getMenuItem().getName() + " is no longer available");
            }
        }
        Order order = new Order(UUID.randomUUID().toString(), idempotencyKey);
        // ... map CartItems -> OrderItems, attach restaurant/address/priceBreakdown
        return order;
    }
}
 
class CartItem {
    private final String id = UUID.randomUUID().toString();
    private final MenuItem menuItem;
    private final ItemVariant variant; // nullable — not every item has variants
    private int quantity;
    private final List<AddOn> addOns;
 
    CartItem(MenuItem menuItem, ItemVariant variant, int quantity, List<AddOn> addOns) {
        this.menuItem = menuItem;
        this.variant = variant;
        this.quantity = quantity;
        this.addOns = new ArrayList<>(addOns);
    }
 
    double lineTotal() {
        double unitPrice = menuItem.getBasePrice() + (variant != null ? variant.getPriceDelta() : 0);
        double addOnTotal = addOns.stream().mapToDouble(AddOn::getPrice).sum();
        return (unitPrice + addOnTotal) * quantity;
    }
 
    String getId() { return id; }
    MenuItem getMenuItem() { return menuItem; }
}

class MenuItem {
    private final String id;
    private final String name;
    private final double basePrice;
    private boolean available;
    private final List<ItemVariant> variants;
    private final List<AddOn> availableAddOns;
 
    MenuItem(String id, String name, double basePrice, List<ItemVariant> variants, List<AddOn> availableAddOns) {
        this.id = id;
        this.name = name;
        this.basePrice = basePrice;
        this.available = true;
        this.variants = variants;
        this.availableAddOns = availableAddOns;
    }
 
    boolean isAvailable() { return available; }
    void setAvailable(boolean available) { this.available = available; } // restaurant owner toggles this
    double getBasePrice() { return basePrice; }
    String getName() { return name; }
}
 
class ItemVariant {
    private final String id;
    private final String label;      // "Half", "Full", "Large"
    private final double priceDelta; // added on top of MenuItem.basePrice
 
    ItemVariant(String id, String label, double priceDelta) {
        this.id = id;
        this.label = label;
        this.priceDelta = priceDelta;
    }
 
    double getPriceDelta() { return priceDelta; }
}
 
class AddOn {
    private final String id;
    private final String name; // "Extra cheese", "Extra spicy"
    private final double price;
 
    AddOn(String id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }
 
    double getPrice() { return price; }
}

class PriceContext {
    final double itemsSubtotal;
    final double distanceKm;
    final String city;
 
    PriceContext(double itemsSubtotal, double distanceKm, String city) {
        this.itemsSubtotal = itemsSubtotal;
        this.distanceKm = distanceKm;
        this.city = city;
    }
}
 
interface TaxStrategy {
    double computeTax(PriceContext context, double taxableAmount);
}
 
class GstTaxStrategy implements TaxStrategy {
    private final double ratePercent; // GST slab varies by restaurant category/locality
 
    GstTaxStrategy(double ratePercent) { this.ratePercent = ratePercent; }
 
    public double computeTax(PriceContext context, double taxableAmount) {
        return taxableAmount * ratePercent / 100.0;
    }
}
 
interface DeliveryFeeStrategy {
    double computeFee(PriceContext context);
}
 
class DistanceBasedDeliveryFee implements DeliveryFeeStrategy {
    private static final double BASE_FEE = 25.0;
    private static final double PER_KM = 6.0;
 
    public double computeFee(PriceContext context) {
        return BASE_FEE + context.distanceKm * PER_KM;
    }
}

// Decorator chain: each layer wraps the previous total and adds exactly one term.
interface PricingComponent {
    double amount(PriceContext context);
    String label();
}
 
class ItemsSubtotalComponent implements PricingComponent {
    public double amount(PriceContext context) { return context.itemsSubtotal; }
    public String label() { return "Items subtotal"; }
}
 
abstract class PricingDecorator implements PricingComponent {
    protected final PricingComponent wrapped;
    PricingDecorator(PricingComponent wrapped) { this.wrapped = wrapped; }
}
 
class TaxDecorator extends PricingDecorator {
    private final TaxStrategy taxStrategy;
 
    TaxDecorator(PricingComponent wrapped, TaxStrategy taxStrategy) {
        super(wrapped);
        this.taxStrategy = taxStrategy;
    }
 
    public double amount(PriceContext context) {
        double base = wrapped.amount(context);
        return base + taxStrategy.computeTax(context, base);
    }
    public String label() { return wrapped.label() + " + tax"; }
}
 
class DeliveryFeeDecorator extends PricingDecorator {
    private final DeliveryFeeStrategy feeStrategy;
 
    DeliveryFeeDecorator(PricingComponent wrapped, DeliveryFeeStrategy feeStrategy) {
        super(wrapped);
        this.feeStrategy = feeStrategy;
    }
 
    public double amount(PriceContext context) {
        return wrapped.amount(context) + feeStrategy.computeFee(context);
    }
    public String label() { return wrapped.label() + " + delivery fee"; }
}
 
class DiscountDecorator extends PricingDecorator {
    private final Coupon coupon;
 
    DiscountDecorator(PricingComponent wrapped, Coupon coupon) {
        super(wrapped);
        this.coupon = coupon;
    }
 
    public double amount(PriceContext context) {
        double runningTotal = wrapped.amount(context);
        double discount = coupon.discountFor(context.itemsSubtotal);
        return Math.max(runningTotal - discount, 0);
    }
    public String label() { return wrapped.label() + " - coupon(" + coupon.getCode() + ")"; }
}

class PricingCalculator {
    double calculateTotal(PriceContext context, TaxStrategy tax, DeliveryFeeStrategy fee, Coupon coupon) {
        PricingComponent chain = new ItemsSubtotalComponent();
        chain = new TaxDecorator(chain, tax);
        chain = new DeliveryFeeDecorator(chain, fee);
        if (coupon != null) {
            chain = new DiscountDecorator(chain, coupon);
        }
        return chain.amount(context);
    }
}

abstract class CouponValidator {
    private CouponValidator next;
 
    CouponValidator linkWith(CouponValidator next) {
        this.next = next;
        return next;
    }
 
    final void validate(Coupon coupon, Customer customer, double orderSubtotal) {
        check(coupon, customer, orderSubtotal);
        if (next != null) {
            next.validate(coupon, customer, orderSubtotal);
        }
    }
 
    protected abstract void check(Coupon coupon, Customer customer, double orderSubtotal);
}
 
class ExpiryValidator extends CouponValidator {
    protected void check(Coupon coupon, Customer customer, double orderSubtotal) {
        if (LocalDate.now().isAfter(coupon.getExpiryDate())) {
            throw new CouponInvalidException(coupon.getCode() + " has expired");
        }
    }
}
 
class MinimumOrderValidator extends CouponValidator {
    protected void check(Coupon coupon, Customer customer, double orderSubtotal) {
        if (orderSubtotal < coupon.getMinimumOrderValue()) {
            throw new CouponInvalidException(
                "Order must be at least " + coupon.getMinimumOrderValue() + " to use " + coupon.getCode());
        }
    }
}
 
class UserEligibilityValidator extends CouponValidator {
    protected void check(Coupon coupon, Customer customer, double orderSubtotal) {
        if (coupon.isUserSpecific() && !coupon.getEligibleUserIds().contains(customer.getId())) {
            throw new CouponInvalidException(coupon.getCode() + " is not valid for this account");
        }
    }
}
 
class UsageLimitValidator extends CouponValidator {
    private final CouponUsageRepository usageRepository;
 
    UsageLimitValidator(CouponUsageRepository usageRepository) {
        this.usageRepository = usageRepository;
    }
 
    protected void check(Coupon coupon, Customer customer, double orderSubtotal) {
        int timesUsed = usageRepository.countUsage(coupon.getCode(), customer.getId());
        if (timesUsed >= coupon.getPerUserLimit()) {
            throw new CouponInvalidException(coupon.getCode() + " usage limit reached for this account");
        }
    }
}

CouponValidator chain = new ExpiryValidator();
chain.linkWith(new MinimumOrderValidator())
     .linkWith(new UserEligibilityValidator())
     .linkWith(new UsageLimitValidator(usageRepository));
 
// Throws CouponInvalidException on the first failing rule; the exception
// message is exactly what the client should surface to the customer.
chain.validate(coupon, customer, cart.subtotal());

class DeliveryPartner {
    private final String id;
    private GeoPoint currentLocation;
    private DeliveryPartnerStatus status; // AVAILABLE, ON_DELIVERY, OFFLINE
    private int activeDeliveries;
    private static final int MAX_CONCURRENT_DELIVERIES = 2; // batched-pickup capacity
 
    boolean hasCapacity() { return activeDeliveries < MAX_CONCURRENT_DELIVERIES; }
    GeoPoint getCurrentLocation() { return currentLocation; }
    String getId() { return id; }
}
 
interface DeliveryAssignmentStrategy {
    Optional<DeliveryPartner> assign(Order order, Restaurant restaurant);
}
 
class NearestAvailablePartnerStrategy implements DeliveryAssignmentStrategy {
    private static final double SEARCH_RADIUS_KM = 5.0;
    private final DeliveryPartnerRepository partnerRepository;
 
    NearestAvailablePartnerStrategy(DeliveryPartnerRepository partnerRepository) {
        this.partnerRepository = partnerRepository;
    }
 
    public Optional<DeliveryPartner> assign(Order order, Restaurant restaurant) {
        GeoPoint pickupPoint = restaurant.getAddress().toGeoPoint();
        return partnerRepository.findAvailableNear(pickupPoint, SEARCH_RADIUS_KM).stream()
            .filter(DeliveryPartner::hasCapacity)
            .min(Comparator.comparingDouble(p -> distanceKm(p.getCurrentLocation(), pickupPoint)));
    }
 
    private double distanceKm(GeoPoint a, GeoPoint b) {
        // Haversine distance — omitted for brevity
        return 0.0;
    }
}

class DeliveryAssignmentService {
    private final DeliveryPartnerRepository partnerRepository;
 
    DeliveryAssignment assign(Order order, DeliveryPartner candidate) {
        // Atomic compare-and-set: only succeeds if the partner is still AVAILABLE.
        boolean claimed = partnerRepository.compareAndSetStatus(
            candidate.getId(), DeliveryPartnerStatus.AVAILABLE, DeliveryPartnerStatus.ON_DELIVERY);
 
        if (!claimed) {
            throw new PartnerAlreadyAssignedException(candidate.getId());
            // caller catches this and retries assignment with the next-nearest candidate
        }
        return new DeliveryAssignment(order, candidate, Instant.now());
    }
}

interface OrderStatusObserver {
    void onStatusChanged(Order order, String newStatus);
}
 
class CustomerAppNotifier implements OrderStatusObserver {
    private final PushNotificationGateway pushGateway;
 
    CustomerAppNotifier(PushNotificationGateway pushGateway) { this.pushGateway = pushGateway; }
 
    public void onStatusChanged(Order order, String newStatus) {
        pushGateway.send(order.getCustomerId(), "Your order is now " + newStatus);
    }
}
 
class RestaurantDashboardNotifier implements OrderStatusObserver {
    private final WebSocketHub dashboardHub;
 
    RestaurantDashboardNotifier(WebSocketHub dashboardHub) { this.dashboardHub = dashboardHub; }
 
    public void onStatusChanged(Order order, String newStatus) {
        dashboardHub.broadcast(order.getRestaurantId(), new OrderStatusEvent(order.getId(), newStatus));
    }
}
 
class DeliveryPartnerAppNotifier implements OrderStatusObserver {
    private final PushNotificationGateway pushGateway;
 
    DeliveryPartnerAppNotifier(PushNotificationGateway pushGateway) { this.pushGateway = pushGateway; }
 
    public void onStatusChanged(Order order, String newStatus) {
        // Pre-alert the partner while food is still being prepared, so they
        // can be en route before it's ready — not just notified at pickup.
        if (newStatus.equals("CONFIRMED") || newStatus.equals("PREPARING")) {
            pushGateway.send(order.getAssignedPartnerId(), "Order " + order.getId() + " is " + newStatus);
        }
    }
}

Order order = new Order(orderId, idempotencyKey);
order.addObserver(new CustomerAppNotifier(pushGateway));
order.addObserver(new RestaurantDashboardNotifier(dashboardHub));
order.addObserver(new DeliveryPartnerAppNotifier(pushGateway));
 
order.confirm(); // ConfirmedState fires notifyObservers("CONFIRMED") — all three channels update

class PaymentService {
    private final IdempotencyKeyStore keyStore;
    private final PaymentGateway gateway;
 
    PaymentResult charge(String idempotencyKey, Order order, PaymentMethod method) {
        Optional<PaymentResult> existing = keyStore.lookup(idempotencyKey);
        if (existing.isPresent()) {
            return existing.get(); // safe replay: same result, gateway never re-charged
        }
 
        PaymentResult result;
        try {
            result = gateway.charge(order.getId(), order.getTotalPayable(), method);
        } catch (GatewayTimeoutException e) {
            // Outcome is UNKNOWN — the charge may have gone through at the gateway
            // even though this call timed out. Do NOT store a result here, and do
            // NOT let the caller blindly retry; force a status reconciliation instead.
            throw new PaymentUncertainException(idempotencyKey, e);
        }
 
        keyStore.store(idempotencyKey, result); // atomic put-if-absent (unique constraint)
        return result;
    }
}

class OrderPlacementSaga {
    private final InventoryService inventoryService;
    private final PaymentService paymentService;
    private final RestaurantService restaurantService;
 
    void execute(Order order, PaymentMethod method, String idempotencyKey) {
        List<Runnable> compensations = new ArrayList<>();
        try {
            inventoryService.reserve(order);
            compensations.add(() -> inventoryService.release(order));
 
            PaymentResult payment = paymentService.charge(idempotencyKey, order, method);
            compensations.add(() -> paymentService.refund(payment.getTransactionId()));
 
            restaurantService.sendForConfirmation(order);
            compensations.add(() -> restaurantService.cancelConfirmationRequest(order));
 
            order.confirm(); // flips state ONLY once every step has succeeded
        } catch (SagaStepException e) {
            Collections.reverse(compensations);
            for (Runnable compensate : compensations) {
                compensate.run(); // best-effort — see the callout below
            }
            order.cancel();
            throw e;
        }
    }
}