21. Stock Brokerage System Advanced (Concurrency & Consistency)

class Broker {
  Order placeOrder(Account account, Stock stock, Side side,
                    int quantity, OrderType type, Money limitPrice);
  // throws InsufficientFundsException, InsufficientHoldingsException, InvalidOrderException

  void cancelOrder(OrderId orderId);
  // throws OrderNotFoundException, InvalidOrderStateException

  void deposit(Account account, Money amount);
  void withdraw(Account account, Money amount);        // throws InsufficientFundsException
}

interface ExecutionStrategy {
  Optional<Money> tryExecute(Order order, Money currentPrice);
}

interface MarketDataFeed {
  Money getPrice(Symbol symbol);
  void  subscribe(Symbol symbol, PriceListener listener);
}

class Account {
  void reserve(Money amount);    // throws InsufficientFundsException
  void release(Money amount);
  void deposit(Money amount);
  void withdraw(Money amount);   // throws InsufficientFundsException
}

class Broker {
  Order placeOrder(Account account, Stock stock, Side side, int quantity,
                    OrderType type, Money limitPrice)
      throws InsufficientFundsException, InsufficientHoldingsException, InvalidOrderException {
    throw new UnsupportedOperationException();
  }

  void cancelOrder(OrderId orderId)
      throws OrderNotFoundException, InvalidOrderStateException { throw new UnsupportedOperationException(); }

  void deposit(Account account, Money amount) { throw new UnsupportedOperationException(); }
  void withdraw(Account account, Money amount) throws InsufficientFundsException { throw new UnsupportedOperationException(); }
}

interface ExecutionStrategy {
  Optional<Money> tryExecute(Order order, Money currentPrice);
}

interface MarketDataFeed {
  Money getPrice(Symbol symbol);
  void subscribe(Symbol symbol, PriceListener listener);
}

class Account {
  void reserve(Money amount) throws InsufficientFundsException { throw new UnsupportedOperationException(); }
  void release(Money amount) { throw new UnsupportedOperationException(); }
  void deposit(Money amount) { throw new UnsupportedOperationException(); }
  void withdraw(Money amount) throws InsufficientFundsException { throw new UnsupportedOperationException(); }
}

class Broker {
public:
  std::shared_ptr<Order> placeOrder(std::shared_ptr<Account> account, std::shared_ptr<Stock> stock,
                                     Side side, int quantity, OrderType type, Money limitPrice) {
    // throws InsufficientFundsException, InsufficientHoldingsException, InvalidOrderException
    throw std::logic_error("not implemented");
  }

  void cancelOrder(OrderId orderId) {
    // throws OrderNotFoundException, InvalidOrderStateException
    throw std::logic_error("not implemented");
  }

  void deposit(std::shared_ptr<Account> account, Money amount) { throw std::logic_error("not implemented"); }
  void withdraw(std::shared_ptr<Account> account, Money amount) { throw std::logic_error("not implemented"); }  // throws InsufficientFundsException
};

class ExecutionStrategy {
public:
  virtual std::optional<Money> tryExecute(const Order& order, Money currentPrice) = 0;
  virtual ~ExecutionStrategy() = default;
};

class MarketDataFeed {
public:
  virtual Money getPrice(const Symbol& symbol) = 0;
  virtual void subscribe(const Symbol& symbol, PriceListener listener) = 0;
  virtual ~MarketDataFeed() = default;
};

class Account {
public:
  void reserve(Money amount) { throw std::logic_error("not implemented"); }   // throws InsufficientFundsException
  void release(Money amount) { throw std::logic_error("not implemented"); }
  void deposit(Money amount) { throw std::logic_error("not implemented"); }
  void withdraw(Money amount) { throw std::logic_error("not implemented"); }  // throws InsufficientFundsException
};

class Broker {
  placeOrder(account, stock, side, quantity, type, limitPrice) {
    // throws InsufficientFundsException / InsufficientHoldingsException / InvalidOrderException
    throw new Error('not implemented');
  }

  cancelOrder(orderId) {
    // throws OrderNotFoundException / InvalidOrderStateException
    throw new Error('not implemented');
  }

  deposit(account, amount) { throw new Error('not implemented'); }
  withdraw(account, amount) { throw new Error('not implemented'); }   // throws InsufficientFundsException
}

// interface ExecutionStrategy: tryExecute(order, currentPrice) -> Money | null
// interface MarketDataFeed: getPrice(symbol), subscribe(symbol, listener)

class Account {
  reserve(amount) { throw new Error('not implemented'); }   // throws InsufficientFundsException
  release(amount) { throw new Error('not implemented'); }
  deposit(amount) { throw new Error('not implemented'); }
  withdraw(amount) { throw new Error('not implemented'); }  // throws InsufficientFundsException
}

class Broker {
  placeOrder(account: Account, stock: Stock, side: Side, quantity: number,
             type: OrderType, limitPrice: Money): Order {
    // throws InsufficientFundsException / InsufficientHoldingsException / InvalidOrderException
    throw new Error('not implemented');
  }

  cancelOrder(orderId: OrderId): void {
    // throws OrderNotFoundException / InvalidOrderStateException
    throw new Error('not implemented');
  }

  deposit(account: Account, amount: Money): void { throw new Error('not implemented'); }
  withdraw(account: Account, amount: Money): void { throw new Error('not implemented'); }   // throws InsufficientFundsException
}

interface ExecutionStrategy {
  tryExecute(order: Order, currentPrice: Money): Money | null;
}

interface MarketDataFeed {
  getPrice(symbol: Symbol): Money;
  subscribe(symbol: Symbol, listener: PriceListener): void;
}

class Account {
  reserve(amount: Money): void { throw new Error('not implemented'); }    // throws InsufficientFundsException
  release(amount: Money): void { throw new Error('not implemented'); }
  deposit(amount: Money): void { throw new Error('not implemented'); }
  withdraw(amount: Money): void { throw new Error('not implemented'); }   // throws InsufficientFundsException
}

placeOrder(account, stock, side, qty, type, limitPrice):
  if side == BUY:
    estimatedCost = qty * (type == MARKET ? feed.getPrice(stock) : limitPrice)
    account.reserve(estimatedCost)              // throws InsufficientFundsException
  else:
    account.portfolio.reserveShares(stock, qty)  // throws InsufficientHoldingsException

  order = Order.create(account, stock, side, qty, type, limitPrice)
  strategy = strategyFor(type, limitPrice)
  price = feed.getPrice(stock)
  result = strategy.tryExecute(order, price)     // must be atomic w.r.t. account state — see W

  if result is present:
    settle(order, result)
  else:
    order.status = PENDING
    feed.subscribe(stock, order)                 // re-checked on future price ticks
  return order

onPriceUpdate(stock, newPrice):                   // Observer callback, not polling
  for order in pendingOrdersFor(stock):
    result = order.strategy.tryExecute(order, newPrice)
    if result is present: settle(order, result)

settle(order, executionPrice):
  if order.side == BUY:
    account.release(order.reservedEstimate)
    account.withdraw(executionPrice * order.quantity)
    portfolio.addHolding(order.stock, order.quantity)
  else:
    portfolio.settle(order.stock, order.quantity, SELL)   // removes reserved shares
    account.deposit(executionPrice * order.quantity)
  order.status = EXECUTED

cancelOrder(orderId):
  order = orderRepository.find(orderId)
  if order.status != PENDING: raise InvalidOrderStateException
  releaseReservation(order)                        // cash or shares, by side
  order.status = CANCELLED

Order placeOrder(Account account, Stock stock, Side side, int qty, OrderType type, Money limitPrice)
    throws InsufficientFundsException, InsufficientHoldingsException {
  if (side == Side.BUY) {
    Money estimatedCost = (type == OrderType.MARKET ? feed.getPrice(stock.getSymbol()) : limitPrice).times(qty);
    account.reserve(estimatedCost);                       // throws InsufficientFundsException
  } else {
    account.getPortfolio().reserveShares(stock, qty);      // throws InsufficientHoldingsException
  }

  Order order = Order.create(account, stock, side, qty, type, limitPrice);
  ExecutionStrategy strategy = strategyFor(type, limitPrice);
  Money price = feed.getPrice(stock.getSymbol());
  Optional<Money> result = strategy.tryExecute(order, price);   // must be atomic w.r.t. account state — see W

  if (result.isPresent()) {
    settle(order, result.get());
  } else {
    order.setStatus(OrderStatus.PENDING);
    feed.subscribe(stock.getSymbol(), order);              // re-checked on future price ticks
  }
  return order;
}

void onPriceUpdate(Symbol symbol, Money newPrice) {          // Observer callback, not polling
  for (Order order : pendingOrdersFor(symbol)) {
    Optional<Money> result = order.getStrategy().tryExecute(order, newPrice);
    result.ifPresent(price -> settle(order, price));
  }
}

void settle(Order order, Money executionPrice) {
  if (order.getSide() == Side.BUY) {
    account.release(order.getReservedEstimate());
    account.withdraw(executionPrice.times(order.getQuantity()));
    portfolio.addHolding(order.getStock(), order.getQuantity());
  } else {
    portfolio.settle(order.getStock(), order.getQuantity(), Side.SELL);   // removes reserved shares
    account.deposit(executionPrice.times(order.getQuantity()));
  }
  order.setStatus(OrderStatus.EXECUTED);
}

void cancelOrder(OrderId orderId) throws InvalidOrderStateException {
  Order order = orderRepository.find(orderId);
  if (order.getStatus() != OrderStatus.PENDING) throw new InvalidOrderStateException();
  releaseReservation(order);                                  // cash or shares, by side
  order.setStatus(OrderStatus.CANCELLED);
}

std::shared_ptr<Order> placeOrder(std::shared_ptr<Account> account, std::shared_ptr<Stock> stock,
                                   Side side, int qty, OrderType type, Money limitPrice) {
  if (side == Side::BUY) {
    Money estimatedCost = (type == OrderType::MARKET ? feed.getPrice(stock->symbol) : limitPrice) * qty;
    account->reserve(estimatedCost);                     // throws InsufficientFundsException
  } else {
    account->portfolio.reserveShares(stock, qty);         // throws InsufficientHoldingsException
  }

  auto order = Order::create(account, stock, side, qty, type, limitPrice);
  auto strategy = strategyFor(type, limitPrice);
  Money price = feed.getPrice(stock->symbol);
  std::optional<Money> result = strategy->tryExecute(*order, price);   // must be atomic w.r.t. account state — see W

  if (result.has_value()) {
    settle(order, *result);
  } else {
    order->status = OrderStatus::PENDING;
    feed.subscribe(stock->symbol, order);                // re-checked on future price ticks
  }
  return order;
}

void onPriceUpdate(const Symbol& symbol, Money newPrice) {   // Observer callback, not polling
  for (auto& order : pendingOrdersFor(symbol)) {
    auto result = order->strategy->tryExecute(*order, newPrice);
    if (result.has_value()) settle(order, *result);
  }
}

void settle(std::shared_ptr<Order> order, Money executionPrice) {
  if (order->side == Side::BUY) {
    account->release(order->reservedEstimate);
    account->withdraw(executionPrice * order->quantity);
    portfolio.addHolding(order->stock, order->quantity);
  } else {
    portfolio.settle(order->stock, order->quantity, Side::SELL);   // removes reserved shares
    account->deposit(executionPrice * order->quantity);
  }
  order->status = OrderStatus::EXECUTED;
}

void cancelOrder(OrderId orderId) {
  auto order = orderRepository.find(orderId);
  if (order->status != OrderStatus::PENDING) throw InvalidOrderStateException();
  releaseReservation(order);                                // cash or shares, by side
  order->status = OrderStatus::CANCELLED;
}

function placeOrder(account, stock, side, qty, type, limitPrice) {
  if (side === Side.BUY) {
    const estimatedCost = (type === OrderType.MARKET ? feed.getPrice(stock.symbol) : limitPrice) * qty;
    account.reserve(estimatedCost);                      // throws InsufficientFundsException
  } else {
    account.portfolio.reserveShares(stock, qty);          // throws InsufficientHoldingsException
  }

  const order = Order.create(account, stock, side, qty, type, limitPrice);
  const strategy = strategyFor(type, limitPrice);
  const price = feed.getPrice(stock.symbol);
  const result = strategy.tryExecute(order, price);       // must be atomic w.r.t. account state — see W

  if (result !== null) {
    settle(order, result);
  } else {
    order.status = 'PENDING';
    feed.subscribe(stock.symbol, order);                   // re-checked on future price ticks
  }
  return order;
}

function onPriceUpdate(symbol, newPrice) {                  // Observer callback, not polling
  for (const order of pendingOrdersFor(symbol)) {
    const result = order.strategy.tryExecute(order, newPrice);
    if (result !== null) settle(order, result);
  }
}

function settle(order, executionPrice) {
  if (order.side === Side.BUY) {
    account.release(order.reservedEstimate);
    account.withdraw(executionPrice * order.quantity);
    portfolio.addHolding(order.stock, order.quantity);
  } else {
    portfolio.settle(order.stock, order.quantity, Side.SELL);   // removes reserved shares
    account.deposit(executionPrice * order.quantity);
  }
  order.status = 'EXECUTED';
}

function cancelOrder(orderId) {
  const order = orderRepository.find(orderId);
  if (order.status !== 'PENDING') throw new Error('InvalidOrderStateException');
  releaseReservation(order);                                 // cash or shares, by side
  order.status = 'CANCELLED';
}

function placeOrder(account: Account, stock: Stock, side: Side, qty: number,
                    type: OrderType, limitPrice: Money): Order {
  if (side === Side.BUY) {
    const estimatedCost: Money = (type === OrderType.MARKET ? feed.getPrice(stock.symbol) : limitPrice) * qty;
    account.reserve(estimatedCost);                      // throws InsufficientFundsException
  } else {
    account.portfolio.reserveShares(stock, qty);          // throws InsufficientHoldingsException
  }

  const order: Order = Order.create(account, stock, side, qty, type, limitPrice);
  const strategy: ExecutionStrategy = strategyFor(type, limitPrice);
  const price: Money = feed.getPrice(stock.symbol);
  const result: Money | null = strategy.tryExecute(order, price);   // must be atomic w.r.t. account state — see W

  if (result !== null) {
    settle(order, result);
  } else {
    order.status = OrderStatus.PENDING;
    feed.subscribe(stock.symbol, order);                   // re-checked on future price ticks
  }
  return order;
}

function onPriceUpdate(symbol: Symbol, newPrice: Money): void {   // Observer callback, not polling
  for (const order of pendingOrdersFor(symbol)) {
    const result: Money | null = order.strategy.tryExecute(order, newPrice);
    if (result !== null) settle(order, result);
  }
}

function settle(order: Order, executionPrice: Money): void {
  if (order.side === Side.BUY) {
    account.release(order.reservedEstimate);
    account.withdraw(executionPrice * order.quantity);
    portfolio.addHolding(order.stock, order.quantity);
  } else {
    portfolio.settle(order.stock, order.quantity, Side.SELL);   // removes reserved shares
    account.deposit(executionPrice * order.quantity);
  }
  order.status = OrderStatus.EXECUTED;
}

function cancelOrder(orderId: OrderId): void {
  const order: Order = orderRepository.find(orderId);
  if (order.status !== OrderStatus.PENDING) throw new Error('InvalidOrderStateException');
  releaseReservation(order);                                 // cash or shares, by side
  order.status = OrderStatus.CANCELLED;
}

// Problem 21: Stock Brokerage System
// Patterns: Strategy (ExecutionStrategy), Observer (MarketDataFeed -> Broker), Facade (Broker)
// Concurrency: per-account lock guards reserve+execute+settle so cash/holdings never corrupt
// under concurrent orders (badge: Advanced, Concurrency & Consistency).
import java.util.*;
import java.util.concurrent.locks.ReentrantLock;

public class p21 {

    // ---------- Exceptions ----------
    static class InsufficientFundsException extends RuntimeException { InsufficientFundsException(String m) { super(m); } }
    static class InsufficientHoldingsException extends RuntimeException { InsufficientHoldingsException(String m) { super(m); } }
    static class InvalidOrderStateException extends RuntimeException { InvalidOrderStateException(String m) { super(m); } }
    static class OrderNotFoundException extends RuntimeException { OrderNotFoundException(String m) { super(m); } }

    enum Side { BUY, SELL }
    enum OrderType { MARKET, LIMIT }
    enum OrderStatus { PENDING, EXECUTED, CANCELLED }

    // ---------- Stock ----------
    static class Stock {
        final String symbol;
        volatile double currentPrice;
        Stock(String symbol, double currentPrice) { this.symbol = symbol; this.currentPrice = currentPrice; }
        void updatePrice(double newPrice) { this.currentPrice = newPrice; }
    }

    // ---------- Portfolio (owned by Account) ----------
    static class Portfolio {
        private final Map<String, Integer> holdings = new HashMap<>();
        private final Map<String, Integer> reserved = new HashMap<>();

        void reserveShares(Stock stock, int qty) {
            int owned = holdings.getOrDefault(stock.symbol, 0);
            int alreadyReserved = reserved.getOrDefault(stock.symbol, 0);
            if (owned - alreadyReserved < qty) throw new InsufficientHoldingsException("Not enough shares of " + stock.symbol);
            reserved.merge(stock.symbol, qty, Integer::sum);
        }

        void releaseShares(Stock stock, int qty) {
            reserved.merge(stock.symbol, -qty, Integer::sum);
        }

        void addHolding(Stock stock, int qty) {
            holdings.merge(stock.symbol, qty, Integer::sum);
        }

        // Removes settled (sold) shares from both holdings and their reservation.
        void settle(Stock stock, int qty, Side side) {
            if (side == Side.SELL) {
                holdings.merge(stock.symbol, -qty, Integer::sum);
                reserved.merge(stock.symbol, -qty, Integer::sum);
            }
        }

        int holdingOf(String symbol) { return holdings.getOrDefault(symbol, 0); }
    }

    // ---------- Account (owns Portfolio) ----------
    static class Account {
        final String id;
        double cashBalance;
        double reservedCash;
        final Portfolio portfolio = new Portfolio();
        final ReentrantLock lock = new ReentrantLock(); // guards reserve/execute/settle atomicity

        Account(String id, double initialCash) { this.id = id; this.cashBalance = initialCash; }

        void reserve(double amount) {
            if (cashBalance - reservedCash < amount) throw new InsufficientFundsException("Insufficient funds in " + id);
            reservedCash += amount;
        }
        void release(double amount) { reservedCash = Math.max(0, reservedCash - amount); }
        void deposit(double amount) { cashBalance += amount; }
        void withdraw(double amount) {
            if (cashBalance < amount) throw new InsufficientFundsException("Insufficient funds in " + id);
            cashBalance -= amount;
        }
    }

    // ---------- Order (abstract) ----------
    static abstract class Order {
        final String id;
        final Account account;
        final Stock stock;
        final int quantity;
        final OrderType type;
        final double limitPrice; // unused for MARKET
        double reservedEstimate;
        OrderStatus status = OrderStatus.PENDING;
        final long createdAt = System.nanoTime();

        Order(String id, Account account, Stock stock, int quantity, OrderType type, double limitPrice) {
            this.id = id; this.account = account; this.stock = stock;
            this.quantity = quantity; this.type = type; this.limitPrice = limitPrice;
        }

        abstract Side getSide();

        void cancel() {
            if (status != OrderStatus.PENDING) throw new InvalidOrderStateException("Order not cancellable: " + status);
            status = OrderStatus.CANCELLED;
        }
    }

    static class BuyOrder extends Order {
        BuyOrder(String id, Account account, Stock stock, int quantity, OrderType type, double limitPrice) {
            super(id, account, stock, quantity, type, limitPrice);
        }
        @Override Side getSide() { return Side.BUY; }
    }

    static class SellOrder extends Order {
        SellOrder(String id, Account account, Stock stock, int quantity, OrderType type, double limitPrice) {
            super(id, account, stock, quantity, type, limitPrice);
        }
        @Override Side getSide() { return Side.SELL; }
    }

    // ---------- ExecutionStrategy ----------
    interface ExecutionStrategy {
        OptionalDouble tryExecute(Order order, double currentPrice);
    }

    static class MarketExecutionStrategy implements ExecutionStrategy {
        @Override public OptionalDouble tryExecute(Order order, double currentPrice) {
            return OptionalDouble.of(currentPrice); // market orders always execute immediately
        }
    }

    static class LimitExecutionStrategy implements ExecutionStrategy {
        @Override public OptionalDouble tryExecute(Order order, double currentPrice) {
            boolean conditionMet = order.getSide() == Side.BUY
                    ? currentPrice <= order.limitPrice
                    : currentPrice >= order.limitPrice;
            return conditionMet ? OptionalDouble.of(currentPrice) : OptionalDouble.empty();
        }
    }

    // ---------- MarketDataFeed ----------
    interface PriceListener {
        void onPriceUpdate(String symbol, double newPrice);
    }

    interface MarketDataFeed {
        double getPrice(String symbol);
        void subscribe(String symbol, PriceListener listener);
    }

    static class SimpleMarketDataFeed implements MarketDataFeed {
        private final Map<String, Stock> stocks;
        private final Map<String, List<PriceListener>> listeners = new HashMap<>();

        SimpleMarketDataFeed(Map<String, Stock> stocks) { this.stocks = stocks; }

        @Override public double getPrice(String symbol) { return stocks.get(symbol).currentPrice; }

        @Override public void subscribe(String symbol, PriceListener listener) {
            List<PriceListener> ls = listeners.computeIfAbsent(symbol, k -> new ArrayList<>());
            if (!ls.contains(listener)) ls.add(listener);
        }

        void updatePrice(String symbol, double newPrice) {
            stocks.get(symbol).updatePrice(newPrice);
            for (PriceListener l : listeners.getOrDefault(symbol, Collections.emptyList())) {
                l.onPriceUpdate(symbol, newPrice); // push, don't poll
            }
        }
    }

    // ---------- Broker (Facade) ----------
    static class Broker implements PriceListener {
        private final Map<String, Account> accounts = new HashMap<>();
        private final Map<String, Order> ordersById = new HashMap<>();
        private final Map<String, List<Order>> pendingOrdersBySymbol = new HashMap<>();
        private final MarketDataFeed feed;
        private final ExecutionStrategy marketStrategy = new MarketExecutionStrategy();
        private final ExecutionStrategy limitStrategy = new LimitExecutionStrategy();
        private int nextOrderId = 1;

        Broker(MarketDataFeed feed) { this.feed = feed; }

        void addAccount(Account account) { accounts.put(account.id, account); }

        void deposit(Account account, double amount) { account.deposit(amount); }

        void withdraw(Account account, double amount) { account.withdraw(amount); }

        Order placeOrder(Account account, Stock stock, Side side, int quantity, OrderType type, double limitPrice) {
            account.lock.lock(); // guard reserve + execution-attempt + settle atomically
            try {
                ExecutionStrategy strategy = (type == OrderType.MARKET) ? marketStrategy : limitStrategy;
                double currentPrice = feed.getPrice(stock.symbol);
                String id = "ORD-" + (nextOrderId++);
                Order order;

                if (side == Side.BUY) {
                    double estimatedCost = quantity * (type == OrderType.MARKET ? currentPrice : limitPrice);
                    account.reserve(estimatedCost); // throws InsufficientFundsException
                    order = new BuyOrder(id, account, stock, quantity, type, limitPrice);
                    order.reservedEstimate = estimatedCost;
                } else {
                    account.portfolio.reserveShares(stock, quantity); // throws InsufficientHoldingsException
                    order = new SellOrder(id, account, stock, quantity, type, limitPrice);
                }
                ordersById.put(order.id, order);

                OptionalDouble result = strategy.tryExecute(order, currentPrice);
                if (result.isPresent()) {
                    settle(order, result.getAsDouble());
                } else {
                    order.status = OrderStatus.PENDING;
                    pendingOrdersBySymbol.computeIfAbsent(stock.symbol, k -> new ArrayList<>()).add(order);
                    feed.subscribe(stock.symbol, this); // re-checked on future price ticks
                }
                return order;
            } finally {
                account.lock.unlock();
            }
        }

        @Override public void onPriceUpdate(String symbol, double newPrice) {
            List<Order> pending = pendingOrdersBySymbol.get(symbol);
            if (pending == null) return;
            List<Order> stillPending = new ArrayList<>();
            for (Order order : new ArrayList<>(pending)) {
                if (order.status != OrderStatus.PENDING) continue; // already cancelled/executed
                order.account.lock.lock();
                try {
                    ExecutionStrategy strategy = (order.type == OrderType.MARKET) ? marketStrategy : limitStrategy;
                    OptionalDouble result = strategy.tryExecute(order, newPrice);
                    if (result.isPresent()) {
                        settle(order, result.getAsDouble());
                    } else {
                        stillPending.add(order);
                    }
                } finally {
                    order.account.lock.unlock();
                }
            }
            pendingOrdersBySymbol.put(symbol, stillPending);
        }

        // Must be called while holding order.account.lock.
        private void settle(Order order, double executionPrice) {
            Account account = order.account;
            if (order.getSide() == Side.BUY) {
                account.release(order.reservedEstimate);
                account.withdraw(executionPrice * order.quantity);
                account.portfolio.addHolding(order.stock, order.quantity);
            } else {
                account.portfolio.settle(order.stock, order.quantity, Side.SELL); // removes reserved shares
                account.deposit(executionPrice * order.quantity);
            }
            order.status = OrderStatus.EXECUTED;
        }

        void cancelOrder(String orderId) {
            Order order = ordersById.get(orderId);
            if (order == null) throw new OrderNotFoundException("No such order: " + orderId);
            order.account.lock.lock();
            try {
                if (order.status != OrderStatus.PENDING) throw new InvalidOrderStateException("Order not cancellable: " + order.status);
                if (order.getSide() == Side.BUY) order.account.release(order.reservedEstimate);
                else order.account.portfolio.releaseShares(order.stock, order.quantity);
                order.status = OrderStatus.CANCELLED;
            } finally {
                order.account.lock.unlock();
            }
        }
    }

    // ---------- Demo ----------
    public static void main(String[] args) throws InterruptedException {
        Stock appl = new Stock("AAPL", 150.0);
        Map<String, Stock> stocks = new HashMap<>();
        stocks.put("AAPL", appl);
        SimpleMarketDataFeed feed = new SimpleMarketDataFeed(stocks);

        Broker broker = new Broker(feed);
        Account account = new Account("A1", 10000.0);
        broker.addAccount(account);

        // Market buy: executes immediately.
        Order buy = broker.placeOrder(account, appl, Side.BUY, 10, OrderType.MARKET, 0);
        System.out.println("Market buy status=" + buy.status + " cash=" + account.cashBalance + " holdings=" + account.portfolio.holdingOf("AAPL"));

        // Limit sell above current price: stays pending until price rises.
        Order limitSell = broker.placeOrder(account, appl, Side.SELL, 5, OrderType.LIMIT, 160.0);
        System.out.println("Limit sell status=" + limitSell.status);

        feed.updatePrice("AAPL", 161.0); // Observer push triggers re-check
        System.out.println("After price tick, limit sell status=" + limitSell.status + " cash=" + account.cashBalance);

        // Place another limit sell, then cancel it before it executes.
        Order toCancel = broker.placeOrder(account, appl, Side.SELL, 2, OrderType.LIMIT, 500.0);
        broker.cancelOrder(toCancel.id);
        System.out.println("Cancelled order status=" + toCancel.status + " holdings=" + account.portfolio.holdingOf("AAPL"));

        // Concurrency demo: two threads race to sell the last 3 shares concurrently.
        Account raceAccount = new Account("A2", 5000.0);
        broker.addAccount(raceAccount);
        broker.placeOrder(raceAccount, appl, Side.BUY, 3, OrderType.MARKET, 0); // gives raceAccount exactly 3 shares

        Runnable trySell = () -> {
            try {
                broker.placeOrder(raceAccount, appl, Side.SELL, 3, OrderType.MARKET, 0);
            } catch (InsufficientHoldingsException e) {
                System.out.println("Thread correctly rejected: " + e.getMessage());
            }
        };
        Thread t1 = new Thread(trySell);
        Thread t2 = new Thread(trySell);
        t1.start(); t2.start();
        t1.join(); t2.join();
        System.out.println("Race account final holdings=" + raceAccount.portfolio.holdingOf("AAPL") + " (never negative)");
    }
}

// Problem 21: Stock Brokerage System
// Patterns: Strategy (ExecutionStrategy), Observer (MarketDataFeed -> Broker), Facade (Broker)
// Concurrency: per-account mutex guards reserve+execute+settle so cash/holdings never corrupt
// under concurrent orders (badge: Advanced, Concurrency & Consistency).
#include <iostream>
#include <vector>
#include <map>
#include <memory>
#include <string>
#include <optional>
#include <mutex>
#include <thread>
#include <stdexcept>
#include <algorithm>

using namespace std;

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

enum class Side { BUY, SELL };
enum class OrderType { MARKET, LIMIT };
enum class OrderStatus { PENDING, EXECUTED, CANCELLED };

// ---------- Stock ----------
struct Stock {
    string symbol;
    double currentPrice;
    Stock(string symbol_, double price) : symbol(move(symbol_)), currentPrice(price) {}
    void updatePrice(double newPrice) { currentPrice = newPrice; }
};

// ---------- Portfolio (owned by Account) ----------
class Portfolio {
    map<string, int> holdings;
    map<string, int> reserved;
public:
    void reserveShares(const Stock& stock, int qty) {
        int owned = holdings.count(stock.symbol) ? holdings[stock.symbol] : 0;
        int alreadyReserved = reserved.count(stock.symbol) ? reserved[stock.symbol] : 0;
        if (owned - alreadyReserved < qty) throw InsufficientHoldingsException("Not enough shares of " + stock.symbol);
        reserved[stock.symbol] += qty;
    }
    void releaseShares(const Stock& stock, int qty) { reserved[stock.symbol] -= qty; }
    void addHolding(const Stock& stock, int qty) { holdings[stock.symbol] += qty; }

    // Removes settled (sold) shares from both holdings and their reservation.
    void settle(const Stock& stock, int qty, Side side) {
        if (side == Side::SELL) {
            holdings[stock.symbol] -= qty;
            reserved[stock.symbol] -= qty;
        }
    }
    int holdingOf(const string& symbol) { return holdings.count(symbol) ? holdings[symbol] : 0; }
};

// ---------- Account (owns Portfolio) ----------
class Account {
public:
    string id;
    double cashBalance;
    double reservedCash = 0;
    Portfolio portfolio;
    mutex lockMutex; // guards reserve/execute/settle atomicity

    Account(string id_, double initialCash) : id(move(id_)), cashBalance(initialCash) {}

    void reserve(double amount) {
        if (cashBalance - reservedCash < amount) throw InsufficientFundsException("Insufficient funds in " + id);
        reservedCash += amount;
    }
    void release(double amount) { reservedCash = max(0.0, reservedCash - amount); }
    void deposit(double amount) { cashBalance += amount; }
    void withdraw(double amount) {
        if (cashBalance < amount) throw InsufficientFundsException("Insufficient funds in " + id);
        cashBalance -= amount;
    }
};

// ---------- Order (abstract) ----------
class Order {
public:
    string id;
    shared_ptr<Account> account;
    shared_ptr<Stock> stock;
    int quantity;
    OrderType type;
    double limitPrice; // unused for MARKET
    double reservedEstimate = 0;
    OrderStatus status = OrderStatus::PENDING;

    Order(string id_, shared_ptr<Account> account_, shared_ptr<Stock> stock_, int quantity_, OrderType type_, double limitPrice_)
        : id(move(id_)), account(account_), stock(stock_), quantity(quantity_), type(type_), limitPrice(limitPrice_) {}
    virtual ~Order() = default;

    virtual Side getSide() const = 0;

    void cancel() {
        if (status != OrderStatus::PENDING) throw InvalidOrderStateException("Order not cancellable");
        status = OrderStatus::CANCELLED;
    }
};

class BuyOrder : public Order {
public:
    using Order::Order;
    Side getSide() const override { return Side::BUY; }
};
class SellOrder : public Order {
public:
    using Order::Order;
    Side getSide() const override { return Side::SELL; }
};

// ---------- ExecutionStrategy ----------
class ExecutionStrategy {
public:
    virtual ~ExecutionStrategy() = default;
    virtual optional<double> tryExecute(Order& order, double currentPrice) = 0;
};

class MarketExecutionStrategy : public ExecutionStrategy {
public:
    optional<double> tryExecute(Order&, double currentPrice) override { return currentPrice; } // always executes
};

class LimitExecutionStrategy : public ExecutionStrategy {
public:
    optional<double> tryExecute(Order& order, double currentPrice) override {
        bool conditionMet = order.getSide() == Side::BUY
            ? currentPrice <= order.limitPrice
            : currentPrice >= order.limitPrice;
        return conditionMet ? optional<double>(currentPrice) : nullopt;
    }
};

// ---------- MarketDataFeed ----------
class PriceListener {
public:
    virtual ~PriceListener() = default;
    virtual void onPriceUpdate(const string& symbol, double newPrice) = 0;
};

class MarketDataFeed {
public:
    virtual ~MarketDataFeed() = default;
    virtual double getPrice(const string& symbol) = 0;
    virtual void subscribe(const string& symbol, PriceListener* listener) = 0;
};

class SimpleMarketDataFeed : public MarketDataFeed {
    map<string, shared_ptr<Stock>> stocks;
    map<string, vector<PriceListener*>> listeners;
public:
    SimpleMarketDataFeed(map<string, shared_ptr<Stock>> stocks_) : stocks(move(stocks_)) {}

    double getPrice(const string& symbol) override { return stocks[symbol]->currentPrice; }

    void subscribe(const string& symbol, PriceListener* listener) override {
        auto& ls = listeners[symbol];
        if (find(ls.begin(), ls.end(), listener) == ls.end()) ls.push_back(listener);
    }

    void updatePrice(const string& symbol, double newPrice) {
        stocks[symbol]->updatePrice(newPrice);
        for (auto* l : listeners[symbol]) l->onPriceUpdate(symbol, newPrice); // push, don't poll
    }
};

// ---------- Broker (Facade) ----------
class Broker : public PriceListener {
    map<string, shared_ptr<Account>> accounts;
    map<string, shared_ptr<Order>> ordersById;
    map<string, vector<shared_ptr<Order>>> pendingOrdersBySymbol;
    MarketDataFeed* feed;
    MarketExecutionStrategy marketStrategy;
    LimitExecutionStrategy limitStrategy;
    int nextOrderId = 1;

public:
    Broker(MarketDataFeed* feed_) : feed(feed_) {}

    void addAccount(shared_ptr<Account> account) { accounts[account->id] = account; }
    void deposit(shared_ptr<Account> account, double amount) { account->deposit(amount); }
    void withdraw(shared_ptr<Account> account, double amount) { account->withdraw(amount); }

    shared_ptr<Order> placeOrder(shared_ptr<Account> account, shared_ptr<Stock> stock, Side side,
                                  int quantity, OrderType type, double limitPrice) {
        lock_guard<mutex> guard(account->lockMutex); // guard reserve + execution-attempt + settle atomically
        ExecutionStrategy* strategy = (type == OrderType::MARKET) ? (ExecutionStrategy*)&marketStrategy : (ExecutionStrategy*)&limitStrategy;
        double currentPrice = feed->getPrice(stock->symbol);
        string id = "ORD-" + to_string(nextOrderId++);
        shared_ptr<Order> order;

        if (side == Side::BUY) {
            double estimatedCost = quantity * (type == OrderType::MARKET ? currentPrice : limitPrice);
            account->reserve(estimatedCost); // throws InsufficientFundsException
            order = make_shared<BuyOrder>(id, account, stock, quantity, type, limitPrice);
            order->reservedEstimate = estimatedCost;
        } else {
            account->portfolio.reserveShares(*stock, quantity); // throws InsufficientHoldingsException
            order = make_shared<SellOrder>(id, account, stock, quantity, type, limitPrice);
        }
        ordersById[order->id] = order;

        auto result = strategy->tryExecute(*order, currentPrice);
        if (result.has_value()) {
            settle(*order, *result);
        } else {
            order->status = OrderStatus::PENDING;
            pendingOrdersBySymbol[stock->symbol].push_back(order);
            feed->subscribe(stock->symbol, this); // re-checked on future price ticks
        }
        return order;
    }

    void onPriceUpdate(const string& symbol, double newPrice) override {
        auto it = pendingOrdersBySymbol.find(symbol);
        if (it == pendingOrdersBySymbol.end()) return;
        vector<shared_ptr<Order>> stillPending;
        for (auto& order : it->second) {
            if (order->status != OrderStatus::PENDING) continue;
            lock_guard<mutex> guard(order->account->lockMutex);
            ExecutionStrategy* strategy = (order->type == OrderType::MARKET) ? (ExecutionStrategy*)&marketStrategy : (ExecutionStrategy*)&limitStrategy;
            auto result = strategy->tryExecute(*order, newPrice);
            if (result.has_value()) settle(*order, *result);
            else stillPending.push_back(order);
        }
        it->second = stillPending;
    }

    void cancelOrder(const string& orderId) {
        auto it = ordersById.find(orderId);
        if (it == ordersById.end()) throw OrderNotFoundException("No such order: " + orderId);
        auto order = it->second;
        lock_guard<mutex> guard(order->account->lockMutex);
        if (order->status != OrderStatus::PENDING) throw InvalidOrderStateException("Order not cancellable");
        if (order->getSide() == Side::BUY) order->account->release(order->reservedEstimate);
        else order->account->portfolio.releaseShares(*order->stock, order->quantity);
        order->status = OrderStatus::CANCELLED;
    }

private:
    // Must be called while holding order.account->lockMutex.
    void settle(Order& order, double executionPrice) {
        auto account = order.account;
        if (order.getSide() == Side::BUY) {
            account->release(order.reservedEstimate);
            account->withdraw(executionPrice * order.quantity);
            account->portfolio.addHolding(*order.stock, order.quantity);
        } else {
            account->portfolio.settle(*order.stock, order.quantity, Side::SELL); // removes reserved shares
            account->deposit(executionPrice * order.quantity);
        }
        order.status = OrderStatus::EXECUTED;
    }
};

string statusName(OrderStatus s) {
    switch (s) {
        case OrderStatus::PENDING: return "PENDING";
        case OrderStatus::EXECUTED: return "EXECUTED";
        case OrderStatus::CANCELLED: return "CANCELLED";
    }
    return "?";
}

// ---------- Demo ----------
int main() {
    auto appl = make_shared<Stock>("AAPL", 150.0);
    map<string, shared_ptr<Stock>> stocks = {{"AAPL", appl}};
    SimpleMarketDataFeed feed(stocks);

    Broker broker(&feed);
    auto account = make_shared<Account>("A1", 10000.0);
    broker.addAccount(account);

    auto buy = broker.placeOrder(account, appl, Side::BUY, 10, OrderType::MARKET, 0);
    cout << "Market buy status=" << statusName(buy->status) << " cash=" << account->cashBalance
         << " holdings=" << account->portfolio.holdingOf("AAPL") << endl;

    auto limitSell = broker.placeOrder(account, appl, Side::SELL, 5, OrderType::LIMIT, 160.0);
    cout << "Limit sell status=" << statusName(limitSell->status) << endl;

    feed.updatePrice("AAPL", 161.0); // Observer push triggers re-check
    cout << "After price tick, limit sell status=" << statusName(limitSell->status) << " cash=" << account->cashBalance << endl;

    auto toCancel = broker.placeOrder(account, appl, Side::SELL, 2, OrderType::LIMIT, 500.0);
    broker.cancelOrder(toCancel->id);
    cout << "Cancelled order status=" << statusName(toCancel->status) << " holdings=" << account->portfolio.holdingOf("AAPL") << endl;

    // Concurrency demo: two threads race to sell the last 3 shares concurrently.
    auto raceAccount = make_shared<Account>("A2", 5000.0);
    broker.addAccount(raceAccount);
    broker.placeOrder(raceAccount, appl, Side::BUY, 3, OrderType::MARKET, 0);

    auto trySell = [&]() {
        try {
            broker.placeOrder(raceAccount, appl, Side::SELL, 3, OrderType::MARKET, 0);
        } catch (InsufficientHoldingsException& e) {
            cout << "Thread correctly rejected: " << e.what() << endl;
        }
    };
    thread t1(trySell), t2(trySell);
    t1.join(); t2.join();
    cout << "Race account final holdings=" << raceAccount->portfolio.holdingOf("AAPL") << " (never negative)" << endl;

    return 0;
}

// Problem 21: Stock Brokerage System
// Patterns: Strategy (ExecutionStrategy), Observer (MarketDataFeed -> Broker), Facade (Broker)
// Concurrency note: Node.js runs this synchronous demo on a single thread, so there is no
// real data race to guard against here -- but we still model a per-account Lock explicitly
// (mirroring the Java/C++ versions' mutex) so that the *shape* of the critical section
// (reserve -> tryExecute -> settle, all atomic w.r.t. one account) is structurally faithful
// and would compose correctly if ported to a worker/thread-based environment.

class InsufficientFundsException extends Error {}
class InsufficientHoldingsException extends Error {}
class InvalidOrderStateException extends Error {}
class OrderNotFoundException extends Error {}

const Side = Object.freeze({ BUY: 'BUY', SELL: 'SELL' });
const OrderType = Object.freeze({ MARKET: 'MARKET', LIMIT: 'LIMIT' });
const OrderStatus = Object.freeze({ PENDING: 'PENDING', EXECUTED: 'EXECUTED', CANCELLED: 'CANCELLED' });

// Trivial synchronous lock: acquire/release bracket the critical section explicitly,
// keeping the code shape identical to the Java/C++ mutex-guarded versions.
class Lock {
  acquire() { /* no-op: single-threaded event loop, but marks the critical section */ }
  release() { /* no-op */ }
}

// ---------- Stock ----------
class Stock {
  constructor(symbol, currentPrice) { this.symbol = symbol; this.currentPrice = currentPrice; }
  updatePrice(newPrice) { this.currentPrice = newPrice; }
}

// ---------- Portfolio (owned by Account) ----------
class Portfolio {
  constructor() { this.holdings = new Map(); this.reserved = new Map(); }

  reserveShares(stock, qty) {
    const owned = this.holdings.get(stock.symbol) || 0;
    const alreadyReserved = this.reserved.get(stock.symbol) || 0;
    if (owned - alreadyReserved < qty) throw new InsufficientHoldingsException(`Not enough shares of ${stock.symbol}`);
    this.reserved.set(stock.symbol, alreadyReserved + qty);
  }
  releaseShares(stock, qty) {
    this.reserved.set(stock.symbol, (this.reserved.get(stock.symbol) || 0) - qty);
  }
  addHolding(stock, qty) {
    this.holdings.set(stock.symbol, (this.holdings.get(stock.symbol) || 0) + qty);
  }
  // Removes settled (sold) shares from both holdings and their reservation.
  settle(stock, qty, side) {
    if (side === Side.SELL) {
      this.holdings.set(stock.symbol, (this.holdings.get(stock.symbol) || 0) - qty);
      this.reserved.set(stock.symbol, (this.reserved.get(stock.symbol) || 0) - qty);
    }
  }
  holdingOf(symbol) { return this.holdings.get(symbol) || 0; }
}

// ---------- Account (owns Portfolio) ----------
class Account {
  constructor(id, initialCash) {
    this.id = id; this.cashBalance = initialCash; this.reservedCash = 0;
    this.portfolio = new Portfolio();
    this.lock = new Lock(); // guards reserve/execute/settle atomicity
  }
  reserve(amount) {
    if (this.cashBalance - this.reservedCash < amount) throw new InsufficientFundsException(`Insufficient funds in ${this.id}`);
    this.reservedCash += amount;
  }
  release(amount) { this.reservedCash = Math.max(0, this.reservedCash - amount); }
  deposit(amount) { this.cashBalance += amount; }
  withdraw(amount) {
    if (this.cashBalance < amount) throw new InsufficientFundsException(`Insufficient funds in ${this.id}`);
    this.cashBalance -= amount;
  }
}

// ---------- Order (abstract) ----------
class Order {
  constructor(id, account, stock, quantity, type, limitPrice) {
    if (new.target === Order) throw new Error('Order is abstract');
    this.id = id; this.account = account; this.stock = stock;
    this.quantity = quantity; this.type = type; this.limitPrice = limitPrice;
    this.reservedEstimate = 0;
    this.status = OrderStatus.PENDING;
  }
  getSide() { throw new Error('abstract method'); }
  cancel() {
    if (this.status !== OrderStatus.PENDING) throw new InvalidOrderStateException('Order not cancellable');
    this.status = OrderStatus.CANCELLED;
  }
}

class BuyOrder extends Order { getSide() { return Side.BUY; } }
class SellOrder extends Order { getSide() { return Side.SELL; } }

// ---------- ExecutionStrategy ----------
class MarketExecutionStrategy {
  tryExecute(order, currentPrice) { return currentPrice; } // always executes, market orders take the going price
}
class LimitExecutionStrategy {
  tryExecute(order, currentPrice) {
    const conditionMet = order.getSide() === Side.BUY ? currentPrice <= order.limitPrice : currentPrice >= order.limitPrice;
    return conditionMet ? currentPrice : null;
  }
}

// ---------- MarketDataFeed ----------
class SimpleMarketDataFeed {
  constructor(stocks) { this.stocks = stocks; this.listeners = new Map(); } // symbol -> Stock, symbol -> listeners[]

  getPrice(symbol) { return this.stocks.get(symbol).currentPrice; }

  subscribe(symbol, listener) {
    if (!this.listeners.has(symbol)) this.listeners.set(symbol, []);
    const ls = this.listeners.get(symbol);
    if (!ls.includes(listener)) ls.push(listener);
  }

  updatePrice(symbol, newPrice) {
    this.stocks.get(symbol).updatePrice(newPrice);
    for (const l of this.listeners.get(symbol) || []) l.onPriceUpdate(symbol, newPrice); // push, don't poll
  }
}

// ---------- Broker (Facade) ----------
class Broker {
  constructor(feed) {
    this.feed = feed;
    this.accounts = new Map();
    this.ordersById = new Map();
    this.pendingOrdersBySymbol = new Map();
    this.marketStrategy = new MarketExecutionStrategy();
    this.limitStrategy = new LimitExecutionStrategy();
    this.nextOrderId = 1;
  }

  addAccount(account) { this.accounts.set(account.id, account); }
  deposit(account, amount) { account.deposit(amount); }
  withdraw(account, amount) { account.withdraw(amount); }

  placeOrder(account, stock, side, quantity, type, limitPrice) {
    account.lock.acquire(); // guard reserve + execution-attempt + settle atomically
    try {
      const strategy = type === OrderType.MARKET ? this.marketStrategy : this.limitStrategy;
      const currentPrice = this.feed.getPrice(stock.symbol);
      const id = `ORD-${this.nextOrderId++}`;
      let order;

      if (side === Side.BUY) {
        const estimatedCost = quantity * (type === OrderType.MARKET ? currentPrice : limitPrice);
        account.reserve(estimatedCost); // throws InsufficientFundsException
        order = new BuyOrder(id, account, stock, quantity, type, limitPrice);
        order.reservedEstimate = estimatedCost;
      } else {
        account.portfolio.reserveShares(stock, quantity); // throws InsufficientHoldingsException
        order = new SellOrder(id, account, stock, quantity, type, limitPrice);
      }
      this.ordersById.set(order.id, order);

      const result = strategy.tryExecute(order, currentPrice);
      if (result !== null) {
        this._settle(order, result);
      } else {
        order.status = OrderStatus.PENDING;
        if (!this.pendingOrdersBySymbol.has(stock.symbol)) this.pendingOrdersBySymbol.set(stock.symbol, []);
        this.pendingOrdersBySymbol.get(stock.symbol).push(order);
        this.feed.subscribe(stock.symbol, this); // re-checked on future price ticks
      }
      return order;
    } finally {
      account.lock.release();
    }
  }

  onPriceUpdate(symbol, newPrice) {
    const pending = this.pendingOrdersBySymbol.get(symbol);
    if (!pending) return;
    const stillPending = [];
    for (const order of pending) {
      if (order.status !== OrderStatus.PENDING) continue;
      order.account.lock.acquire();
      try {
        const strategy = order.type === OrderType.MARKET ? this.marketStrategy : this.limitStrategy;
        const result = strategy.tryExecute(order, newPrice);
        if (result !== null) this._settle(order, result);
        else stillPending.push(order);
      } finally {
        order.account.lock.release();
      }
    }
    this.pendingOrdersBySymbol.set(symbol, stillPending);
  }

  cancelOrder(orderId) {
    const order = this.ordersById.get(orderId);
    if (!order) throw new OrderNotFoundException(`No such order: ${orderId}`);
    order.account.lock.acquire();
    try {
      if (order.status !== OrderStatus.PENDING) throw new InvalidOrderStateException('Order not cancellable');
      if (order.getSide() === Side.BUY) order.account.release(order.reservedEstimate);
      else order.account.portfolio.releaseShares(order.stock, order.quantity);
      order.status = OrderStatus.CANCELLED;
    } finally {
      order.account.lock.release();
    }
  }

  // Must be called while holding order.account.lock.
  _settle(order, executionPrice) {
    const account = order.account;
    if (order.getSide() === Side.BUY) {
      account.release(order.reservedEstimate);
      account.withdraw(executionPrice * order.quantity);
      account.portfolio.addHolding(order.stock, order.quantity);
    } else {
      account.portfolio.settle(order.stock, order.quantity, Side.SELL); // removes reserved shares
      account.deposit(executionPrice * order.quantity);
    }
    order.status = OrderStatus.EXECUTED;
  }
}

// ---------- Demo ----------
function main() {
  const appl = new Stock('AAPL', 150.0);
  const stocks = new Map([['AAPL', appl]]);
  const feed = new SimpleMarketDataFeed(stocks);

  const broker = new Broker(feed);
  const account = new Account('A1', 10000.0);
  broker.addAccount(account);

  const buy = broker.placeOrder(account, appl, Side.BUY, 10, OrderType.MARKET, 0);
  console.log(`Market buy status=${buy.status} cash=${account.cashBalance} holdings=${account.portfolio.holdingOf('AAPL')}`);

  const limitSell = broker.placeOrder(account, appl, Side.SELL, 5, OrderType.LIMIT, 160.0);
  console.log(`Limit sell status=${limitSell.status}`);

  feed.updatePrice('AAPL', 161.0); // Observer push triggers re-check
  console.log(`After price tick, limit sell status=${limitSell.status} cash=${account.cashBalance}`);

  const toCancel = broker.placeOrder(account, appl, Side.SELL, 2, OrderType.LIMIT, 500.0);
  broker.cancelOrder(toCancel.id);
  console.log(`Cancelled order status=${toCancel.status} holdings=${account.portfolio.holdingOf('AAPL')}`);

  // Sequential "race": both attempts guarded by the same lock discipline as Java/C++;
  // the second is correctly rejected because the first already consumed all shares.
  const raceAccount = new Account('A2', 5000.0);
  broker.addAccount(raceAccount);
  broker.placeOrder(raceAccount, appl, Side.BUY, 3, OrderType.MARKET, 0);

  const trySell = () => {
    try {
      broker.placeOrder(raceAccount, appl, Side.SELL, 3, OrderType.MARKET, 0);
    } catch (e) {
      console.log('Rejected as expected:', e.message);
    }
  };
  trySell();
  trySell();
  console.log(`Race account final holdings=${raceAccount.portfolio.holdingOf('AAPL')} (never negative)`);
}

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

module.exports = {
  Account, Portfolio, Stock, Order, BuyOrder, SellOrder,
  MarketExecutionStrategy, LimitExecutionStrategy, SimpleMarketDataFeed, Broker,
  Side, OrderType, OrderStatus,
};

// Problem 21: Stock Brokerage System
// Patterns: Strategy (ExecutionStrategy), Observer (MarketDataFeed -> Broker), Facade (Broker)
// Concurrency note: this synchronous demo runs on a single thread, so there is no real data
// race to guard against here -- but we still model a per-account Lock explicitly (mirroring
// the Java/C++ versions' mutex) so the *shape* of the critical section (reserve -> tryExecute
// -> settle, all atomic w.r.t. one account) is structurally faithful and would compose
// correctly if ported to a worker/thread-based environment.

class InsufficientFundsException extends Error {}
class InsufficientHoldingsException extends Error {}
class InvalidOrderStateException extends Error {}
class OrderNotFoundException extends Error {}

enum Side { BUY = 'BUY', SELL = 'SELL' }
enum OrderType { MARKET = 'MARKET', LIMIT = 'LIMIT' }
enum OrderStatus { PENDING = 'PENDING', EXECUTED = 'EXECUTED', CANCELLED = 'CANCELLED' }

// Trivial synchronous lock: acquire/release bracket the critical section explicitly,
// keeping the code shape identical to the Java/C++ mutex-guarded versions.
class Lock {
  acquire(): void { /* no-op: single-threaded event loop, but marks the critical section */ }
  release(): void { /* no-op */ }
}

// ---------- Stock ----------
class Stock {
  constructor(public symbol: string, public currentPrice: number) {}
  updatePrice(newPrice: number): void { this.currentPrice = newPrice; }
}

// ---------- Portfolio (owned by Account) ----------
class Portfolio {
  private holdings = new Map<string, number>();
  private reserved = new Map<string, number>();

  reserveShares(stock: Stock, qty: number): void {
    const owned = this.holdings.get(stock.symbol) || 0;
    const alreadyReserved = this.reserved.get(stock.symbol) || 0;
    if (owned - alreadyReserved < qty) throw new InsufficientHoldingsException(`Not enough shares of ${stock.symbol}`);
    this.reserved.set(stock.symbol, alreadyReserved + qty);
  }
  releaseShares(stock: Stock, qty: number): void {
    this.reserved.set(stock.symbol, (this.reserved.get(stock.symbol) || 0) - qty);
  }
  addHolding(stock: Stock, qty: number): void {
    this.holdings.set(stock.symbol, (this.holdings.get(stock.symbol) || 0) + qty);
  }
  // Removes settled (sold) shares from both holdings and their reservation.
  settle(stock: Stock, qty: number, side: Side): void {
    if (side === Side.SELL) {
      this.holdings.set(stock.symbol, (this.holdings.get(stock.symbol) || 0) - qty);
      this.reserved.set(stock.symbol, (this.reserved.get(stock.symbol) || 0) - qty);
    }
  }
  holdingOf(symbol: string): number { return this.holdings.get(symbol) || 0; }
}

// ---------- Account (owns Portfolio) ----------
class Account {
  cashBalance: number;
  reservedCash = 0;
  readonly portfolio = new Portfolio();
  readonly lock = new Lock(); // guards reserve/execute/settle atomicity

  constructor(public id: string, initialCash: number) { this.cashBalance = initialCash; }

  reserve(amount: number): void {
    if (this.cashBalance - this.reservedCash < amount) throw new InsufficientFundsException(`Insufficient funds in ${this.id}`);
    this.reservedCash += amount;
  }
  release(amount: number): void { this.reservedCash = Math.max(0, this.reservedCash - amount); }
  deposit(amount: number): void { this.cashBalance += amount; }
  withdraw(amount: number): void {
    if (this.cashBalance < amount) throw new InsufficientFundsException(`Insufficient funds in ${this.id}`);
    this.cashBalance -= amount;
  }
}

// ---------- Order (abstract) ----------
abstract class Order {
  reservedEstimate = 0;
  status: OrderStatus = OrderStatus.PENDING;

  constructor(
    public id: string, public account: Account, public stock: Stock,
    public quantity: number, public type: OrderType, public limitPrice: number,
  ) {}

  abstract getSide(): Side;

  cancel(): void {
    if (this.status !== OrderStatus.PENDING) throw new InvalidOrderStateException('Order not cancellable');
    this.status = OrderStatus.CANCELLED;
  }
}

class BuyOrder extends Order { getSide(): Side { return Side.BUY; } }
class SellOrder extends Order { getSide(): Side { return Side.SELL; } }

// ---------- ExecutionStrategy ----------
interface ExecutionStrategy {
  tryExecute(order: Order, currentPrice: number): number | null;
}

class MarketExecutionStrategy implements ExecutionStrategy {
  tryExecute(_order: Order, currentPrice: number): number | null { return currentPrice; } // always executes
}
class LimitExecutionStrategy implements ExecutionStrategy {
  tryExecute(order: Order, currentPrice: number): number | null {
    const conditionMet = order.getSide() === Side.BUY ? currentPrice <= order.limitPrice : currentPrice >= order.limitPrice;
    return conditionMet ? currentPrice : null;
  }
}

// ---------- MarketDataFeed ----------
interface PriceListener {
  onPriceUpdate(symbol: string, newPrice: number): void;
}

interface MarketDataFeed {
  getPrice(symbol: string): number;
  subscribe(symbol: string, listener: PriceListener): void;
}

class SimpleMarketDataFeed implements MarketDataFeed {
  private listeners = new Map<string, PriceListener[]>();
  constructor(private stocks: Map<string, Stock>) {}

  getPrice(symbol: string): number { return this.stocks.get(symbol)!.currentPrice; }

  subscribe(symbol: string, listener: PriceListener): void {
    if (!this.listeners.has(symbol)) this.listeners.set(symbol, []);
    const ls = this.listeners.get(symbol)!;
    if (!ls.includes(listener)) ls.push(listener);
  }

  updatePrice(symbol: string, newPrice: number): void {
    this.stocks.get(symbol)!.updatePrice(newPrice);
    for (const l of this.listeners.get(symbol) || []) l.onPriceUpdate(symbol, newPrice); // push, don't poll
  }
}

// ---------- Broker (Facade) ----------
class Broker implements PriceListener {
  private accounts = new Map<string, Account>();
  private ordersById = new Map<string, Order>();
  private pendingOrdersBySymbol = new Map<string, Order[]>();
  private marketStrategy = new MarketExecutionStrategy();
  private limitStrategy = new LimitExecutionStrategy();
  private nextOrderId = 1;

  constructor(private feed: MarketDataFeed) {}

  addAccount(account: Account): void { this.accounts.set(account.id, account); }
  deposit(account: Account, amount: number): void { account.deposit(amount); }
  withdraw(account: Account, amount: number): void { account.withdraw(amount); }

  placeOrder(account: Account, stock: Stock, side: Side, quantity: number, type: OrderType, limitPrice: number): Order {
    account.lock.acquire(); // guard reserve + execution-attempt + settle atomically
    try {
      const strategy: ExecutionStrategy = type === OrderType.MARKET ? this.marketStrategy : this.limitStrategy;
      const currentPrice = this.feed.getPrice(stock.symbol);
      const id = `ORD-${this.nextOrderId++}`;
      let order: Order;

      if (side === Side.BUY) {
        const estimatedCost = quantity * (type === OrderType.MARKET ? currentPrice : limitPrice);
        account.reserve(estimatedCost); // throws InsufficientFundsException
        order = new BuyOrder(id, account, stock, quantity, type, limitPrice);
        order.reservedEstimate = estimatedCost;
      } else {
        account.portfolio.reserveShares(stock, quantity); // throws InsufficientHoldingsException
        order = new SellOrder(id, account, stock, quantity, type, limitPrice);
      }
      this.ordersById.set(order.id, order);

      const result = strategy.tryExecute(order, currentPrice);
      if (result !== null) {
        this.settle(order, result);
      } else {
        order.status = OrderStatus.PENDING;
        if (!this.pendingOrdersBySymbol.has(stock.symbol)) this.pendingOrdersBySymbol.set(stock.symbol, []);
        this.pendingOrdersBySymbol.get(stock.symbol)!.push(order);
        this.feed.subscribe(stock.symbol, this); // re-checked on future price ticks
      }
      return order;
    } finally {
      account.lock.release();
    }
  }

  onPriceUpdate(symbol: string, newPrice: number): void {
    const pending = this.pendingOrdersBySymbol.get(symbol);
    if (!pending) return;
    const stillPending: Order[] = [];
    for (const order of pending) {
      if (order.status !== OrderStatus.PENDING) continue;
      order.account.lock.acquire();
      try {
        const strategy: ExecutionStrategy = order.type === OrderType.MARKET ? this.marketStrategy : this.limitStrategy;
        const result = strategy.tryExecute(order, newPrice);
        if (result !== null) this.settle(order, result);
        else stillPending.push(order);
      } finally {
        order.account.lock.release();
      }
    }
    this.pendingOrdersBySymbol.set(symbol, stillPending);
  }

  cancelOrder(orderId: string): void {
    const order = this.ordersById.get(orderId);
    if (!order) throw new OrderNotFoundException(`No such order: ${orderId}`);
    order.account.lock.acquire();
    try {
      if (order.status !== OrderStatus.PENDING) throw new InvalidOrderStateException('Order not cancellable');
      if (order.getSide() === Side.BUY) order.account.release(order.reservedEstimate);
      else order.account.portfolio.releaseShares(order.stock, order.quantity);
      order.status = OrderStatus.CANCELLED;
    } finally {
      order.account.lock.release();
    }
  }

  // Must be called while holding order.account.lock.
  private settle(order: Order, executionPrice: number): void {
    const account = order.account;
    if (order.getSide() === Side.BUY) {
      account.release(order.reservedEstimate);
      account.withdraw(executionPrice * order.quantity);
      account.portfolio.addHolding(order.stock, order.quantity);
    } else {
      account.portfolio.settle(order.stock, order.quantity, Side.SELL); // removes reserved shares
      account.deposit(executionPrice * order.quantity);
    }
    order.status = OrderStatus.EXECUTED;
  }
}

// ---------- Demo ----------
function main(): void {
  const appl = new Stock('AAPL', 150.0);
  const stocks = new Map<string, Stock>([['AAPL', appl]]);
  const feed = new SimpleMarketDataFeed(stocks);

  const broker = new Broker(feed);
  const account = new Account('A1', 10000.0);
  broker.addAccount(account);

  const buy = broker.placeOrder(account, appl, Side.BUY, 10, OrderType.MARKET, 0);
  console.log(`Market buy status=${buy.status} cash=${account.cashBalance} holdings=${account.portfolio.holdingOf('AAPL')}`);

  const limitSell = broker.placeOrder(account, appl, Side.SELL, 5, OrderType.LIMIT, 160.0);
  console.log(`Limit sell status=${limitSell.status}`);

  feed.updatePrice('AAPL', 161.0); // Observer push triggers re-check
  console.log(`After price tick, limit sell status=${limitSell.status} cash=${account.cashBalance}`);

  const toCancel = broker.placeOrder(account, appl, Side.SELL, 2, OrderType.LIMIT, 500.0);
  broker.cancelOrder(toCancel.id);
  console.log(`Cancelled order status=${toCancel.status} holdings=${account.portfolio.holdingOf('AAPL')}`);

  // Sequential "race": both attempts guarded by the same lock discipline as Java/C++;
  // the second is correctly rejected because the first already consumed all shares.
  const raceAccount = new Account('A2', 5000.0);
  broker.addAccount(raceAccount);
  broker.placeOrder(raceAccount, appl, Side.BUY, 3, OrderType.MARKET, 0);

  const trySell = () => {
    try {
      broker.placeOrder(raceAccount, appl, Side.SELL, 3, OrderType.MARKET, 0);
    } catch (e) {
      console.log('Rejected as expected:', (e as Error).message);
    }
  };
  trySell();
  trySell();
  console.log(`Race account final holdings=${raceAccount.portfolio.holdingOf('AAPL')} (never negative)`);
}

main();

export {
  Account, Portfolio, Stock, Order, BuyOrder, SellOrder,
  ExecutionStrategy, MarketExecutionStrategy, LimitExecutionStrategy,
  MarketDataFeed, SimpleMarketDataFeed, Broker, Side, OrderType, OrderStatus,
};