engine/matcher/

simple.rs

use crate::matcher::Matcher;
use crate::types::{FillEvent, MarketState, Order, OrderState, Side};

pub struct SimpleMatcher {
    orders: Vec<Order>,
}

impl Default for SimpleMatcher {
    fn default() -> Self {
        Self::new()
    }
}

impl SimpleMatcher {
    pub fn new() -> Self {
        Self { orders: Vec::new() }
    }
}

impl Matcher for SimpleMatcher {
    fn add_order(&mut self, order: Order) {
        self.orders.push(order);
    }

    fn cancel_order(&mut self, order_id: u64) {
        if let Some(order) = self.orders.iter_mut().find(|o| o.id == order_id) {
            order.state = OrderState::Cancelled;
        }
        self.orders.retain(|o| o.state == OrderState::Open);
    }

    fn cancel_all(&mut self) {
        self.orders.clear();
    }

    fn process_quote(&mut self, state: &MarketState) -> Vec<FillEvent> {
        let mut fills = Vec::new();
        let timestamp = state.timestamp;

        let best_ask = state.best_ask;
        let best_bid = state.best_bid;

        for order in self.orders.iter_mut() {
            if order.state != OrderState::Open {
                continue;
            }

            let mut filled = false;
            let mut fill_price = 0.0;

            match order.side {
                Side::Buy => {
                    // Check: Is My Limit Price >= Current Best Ask?
                    if order.limit_price >= best_ask {
                        filled = true;
                        fill_price = best_ask;
                    }
                }
                Side::Sell => {
                    // Check: Is My Limit Price <= Current Best Bid?
                    if order.limit_price <= best_bid {
                        filled = true;
                        fill_price = best_bid;
                    }
                }
            }

            if filled {
                order.state = OrderState::Filled;
                fills.push(FillEvent {
                    order_id: order.id,
                    timestamp, // Use copied timestamp
                    price: fill_price,
                    quantity: order.quantity,
                    side: order.side,
                });
            }
        }

        self.orders.retain(|o| o.state == OrderState::Open);

        fills
    }

    fn get_orders(&self) -> &Vec<Order> {
        &self.orders
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::types::Side;

    fn state(bid: f64, ask: f64) -> MarketState {
        MarketState {
            timestamp: 0.0,
            best_bid: bid,
            best_ask: ask,
            last_price: None,
            true_volatility: None,
            true_drift: None,
            parameters: None,
        }
    }

    #[test]
    fn test_buy_above_ask_fills_at_ask() {
        // A buy whose limit exceeds the best_ask must fill at best_ask (not at limit).
        let mut m = SimpleMatcher::new();
        m.add_order(Order::new(1, Side::Buy, 101.0, 1.0));
        let fills = m.process_quote(&state(99.0, 100.0));
        assert_eq!(fills.len(), 1);
        assert_eq!(fills[0].price, 100.0);
    }

    #[test]
    fn test_buy_below_ask_does_not_fill() {
        // A resting buy below the best_ask must not trigger a fill.
        let mut m = SimpleMatcher::new();
        m.add_order(Order::new(1, Side::Buy, 99.0, 1.0));
        let fills = m.process_quote(&state(99.0, 100.0));
        assert_eq!(fills.len(), 0);
    }

    #[test]
    fn test_sell_at_or_below_bid_fills_at_bid() {
        // A sell whose limit is at or below best_bid must fill at best_bid (not at limit).
        let mut m = SimpleMatcher::new();
        m.add_order(Order::new(1, Side::Sell, 98.5, 2.0));
        let fills = m.process_quote(&state(99.0, 100.0));
        assert_eq!(fills.len(), 1);
        assert_eq!(fills[0].price, 99.0);
        assert_eq!(fills[0].quantity, 2.0);
    }

    #[test]
    fn test_sell_above_bid_does_not_fill() {
        // A sell order priced above best_bid must not fill.
        let mut m = SimpleMatcher::new();
        m.add_order(Order::new(1, Side::Sell, 100.5, 1.0));
        let fills = m.process_quote(&state(99.0, 100.0));
        assert_eq!(fills.len(), 0);
    }

    #[test]
    fn test_multiple_bids_only_aggressive_fills() {
        // Two bids at different levels: only the one above the ask fills.
        let mut m = SimpleMatcher::new();
        m.add_order(Order::new(1, Side::Buy, 101.0, 1.0)); // above ask -> fills
        m.add_order(Order::new(2, Side::Buy, 99.0, 1.0)); // below ask -> stays
        let fills = m.process_quote(&state(99.5, 100.0));
        assert_eq!(fills.len(), 1);
        assert_eq!(fills[0].order_id, 1);
    }

    #[test]
    fn test_multiple_bids_both_aggressive_fill_independently() {
        // Two bids both above the ask must fill independently, each at best_ask.
        let mut m = SimpleMatcher::new();
        m.add_order(Order::new(1, Side::Buy, 101.0, 1.0));
        m.add_order(Order::new(2, Side::Buy, 102.0, 2.0));
        let fills = m.process_quote(&state(99.5, 100.0));
        assert_eq!(fills.len(), 2);
        for f in &fills {
            assert_eq!(f.price, 100.0);
        }
    }

    #[test]
    fn test_cancel_order_prevents_fill() {
        // Cancelling an order by ID before the quote must prevent it from filling.
        let mut m = SimpleMatcher::new();
        m.add_order(Order::new(1, Side::Buy, 101.0, 1.0));
        m.cancel_order(1);
        let fills = m.process_quote(&state(99.0, 100.0));
        assert_eq!(fills.len(), 0);
    }

    #[test]
    fn test_cancel_nonexistent_order_is_noop() {
        // Cancelling an order that was never submitted must not affect other orders.
        let mut m = SimpleMatcher::new();
        m.add_order(Order::new(1, Side::Buy, 101.0, 1.0));
        m.cancel_order(999);
        let fills = m.process_quote(&state(99.0, 100.0));
        assert_eq!(fills.len(), 1);
    }

    #[test]
    fn test_filled_order_removed_from_book() {
        // After a fill, the order must be removed so it cannot fill again on
        // the next call to process_quote.
        let mut m = SimpleMatcher::new();
        m.add_order(Order::new(1, Side::Buy, 101.0, 1.0));
        let fills1 = m.process_quote(&state(99.0, 100.0));
        assert_eq!(fills1.len(), 1);
        // No new orders added; book should be empty, so no further fills.
        let fills2 = m.process_quote(&state(99.0, 100.0));
        assert_eq!(fills2.len(), 0);
    }
}