orderbook.cpp

#include "orderbook.h"
#include <algorithm>
#include <iostream>

OrderBook::OrderBook() {
    // Reserve space for better performance
    orders.reserve(10000);
}

OrderBook::~OrderBook() = default;

void OrderBook::processAction(const MBORecord& record, std::vector<MBPRecord>& output) {
    // Handle 'N' side trades - ignore them
    if (record.side == 'N') {
        return;
    }
    
    // Handle trade sequences (T->F->C)
    if (record.action == 'T') {
        trade_buffer.trade_record = record;
        trade_buffer.has_trade = true;
        return; // Wait for F and C
    }
    
    if (record.action == 'F' && trade_buffer.has_trade) {
        trade_buffer.fill_record = record;
        trade_buffer.has_fill = true;
        return; // Wait for C
    }
    
    if (record.action == 'C' && trade_buffer.has_trade && trade_buffer.has_fill) {
        trade_buffer.cancel_record = record;
        trade_buffer.has_cancel = true;
        processTradeSequence();
        
        // Generate MBP record for the trade
        MBPRecord mbp_record;
        mbp_record.ts_recv = record.ts_recv;
        mbp_record.ts_event = record.ts_event;
        mbp_record.rtype = record.rtype;
        mbp_record.publisher_id = record.publisher_id;
        mbp_record.instrument_id = record.instrument_id;
        mbp_record.action = 'T'; // Combined T->F->C becomes T
        mbp_record.side = (trade_buffer.fill_record.side == 'A') ? 'B' : 'A'; // Opposite side
        mbp_record.price = trade_buffer.trade_record.price;
        mbp_record.size = trade_buffer.trade_record.size;
        mbp_record.flags = record.flags;
        mbp_record.order_id = 0; // Trade has no order_id
        mbp_record.priority = record.priority;
        mbp_record.channel_id = record.channel_id;
        mbp_record.ts_in_delta = record.ts_in_delta;
        mbp_record.symbol = record.symbol;
        
        output.push_back(mbp_record);
        trade_buffer.reset();
        return;
    }
    
    // Handle regular actions and generate MBP records for orderbook changes
    bool orderbook_changed = false;
    
    switch (record.action) {
        case 'A':
            addOrder(record);
            orderbook_changed = true;
            break;
        case 'C':
            // Only process standalone cancels (not part of T->F->C sequence)
            if (!trade_buffer.has_trade) {
                cancelOrder(record);
                orderbook_changed = true;
            }
            break;
        case 'M':
            modifyOrder(record);
            orderbook_changed = true;
            break;
        case 'R':
            // Clear orderbook - ignore as per requirements
            break;
        default:
            // Unknown action, ignore
            break;
    }
    
    // Generate MBP record for orderbook state changes
    if (orderbook_changed) {
        MBPRecord mbp_record;
        mbp_record.ts_recv = record.ts_recv;
        mbp_record.ts_event = record.ts_event;
        mbp_record.rtype = record.rtype;
        mbp_record.publisher_id = record.publisher_id;
        mbp_record.instrument_id = record.instrument_id;
        mbp_record.action = record.action;
        mbp_record.side = record.side;
        mbp_record.price = record.price;
        mbp_record.size = record.size;
        mbp_record.flags = record.flags;
        mbp_record.order_id = record.order_id;
        mbp_record.priority = record.priority;
        mbp_record.channel_id = record.channel_id;
        mbp_record.ts_in_delta = record.ts_in_delta;
        mbp_record.symbol = record.symbol;
        
        output.push_back(mbp_record);
    }
}

void OrderBook::addOrder(const MBORecord& record) {
    std::string order_key = std::to_string(record.order_id);
    
    // Check if order already exists (shouldn't happen with proper data)
    if (orders.find(order_key) != orders.end()) {
        std::cerr << "Warning: Order " << record.order_id << " already exists, replacing" << std::endl;
    }
    
    // Add to orders map
    orders[order_key] = Order(order_key, record.side, record.price, record.size, record.priority);
    
    // Update price level
    updatePriceLevel(record.side, record.price, static_cast<int32_t>(record.size));
}

void OrderBook::cancelOrder(const MBORecord& record) {
    std::string order_key = std::to_string(record.order_id);
    
    auto it = orders.find(order_key);
    if (it != orders.end()) {
        const Order& order = it->second;
        
        // Use the size from the cancel record, not the original order
        // This handles partial cancellations correctly
        uint32_t cancel_size = record.size > 0 ? record.size : order.size;
        
        // Update price level (subtract size)
        updatePriceLevel(order.side, order.price, -static_cast<int32_t>(cancel_size));
        
        // If this is a full cancellation, remove the order
        if (cancel_size >= order.size) {
            orders.erase(it);
        } else {
            // Partial cancellation - update order size
            Order& mutable_order = const_cast<Order&>(order);
            mutable_order.size -= cancel_size;
        }
    } else {
        // Order not found - this might be a cancel for an order we haven't seen
        // or it could be part of a trade sequence
        std::cerr << "Warning: Cancel for unknown order " << record.order_id << std::endl;
    }
}

void OrderBook::modifyOrder(const MBORecord& record) {
    std::string order_key = std::to_string(record.order_id);
    
    auto it = orders.find(order_key);
    if (it != orders.end()) {
        Order& order = it->second;
        
        // Update price level (remove old size, add new size)
        updatePriceLevel(order.side, order.price, -static_cast<int32_t>(order.size));
        updatePriceLevel(record.side, record.price, static_cast<int32_t>(record.size));
        
        // Update order
        order.side = record.side;
        order.price = record.price;
        order.size = record.size;
        order.priority = record.priority;
    } else {
        std::cerr << "Warning: Modify for unknown order " << record.order_id << std::endl;
    }
}

void OrderBook::processTradeSequence() {
    if (!trade_buffer.is_complete()) {
        return;
    }
    
    // The trade affects the side where the order exists (opposite of trade side)
    // F and C records show the actual side being modified
    char affected_side = trade_buffer.fill_record.side;
    double price = trade_buffer.fill_record.price;
    uint32_t size = trade_buffer.fill_record.size;
    
    // Reduce quantity from the affected side
    updatePriceLevel(affected_side, price, -static_cast<int32_t>(size));
}

void OrderBook::updatePriceLevel(char side, double price, int32_t size_delta) {
    if (side == 'B') {
        auto it = bids.find(price);
        if (it != bids.end()) {
            // Protect against underflow
            if (size_delta < 0) {
                uint32_t reduction = static_cast<uint32_t>(-size_delta);
                if (reduction > it->second.total_size) {
                    std::cerr << "Warning: Size underflow at price " << price 
                              << ", current: " << it->second.total_size 
                              << ", delta: " << size_delta 
                              << " - setting to 0" << std::endl;
                    it->second.total_size = 0;
                    it->second.order_count = 0;
                } else {
                    it->second.total_size -= reduction;
                    it->second.order_count = std::max(0u, it->second.order_count - 1);
                }
            } else {
                it->second.total_size += size_delta;
                it->second.order_count++;
            }
            
            if (it->second.total_size <= 0) {
                bids.erase(it);
            }
        } else if (size_delta > 0) {
            bids[price] = PriceLevel(price, size_delta);
        } else {
            // Trying to reduce from non-existent price level
            std::cerr << "Warning: Trying to reduce " << (-size_delta) 
                      << " from non-existent bid price level " << price << std::endl;
        }
    } else if (side == 'A') {
        auto it = asks.find(price);
        if (it != asks.end()) {
            // Protect against underflow
            if (size_delta < 0) {
                uint32_t reduction = static_cast<uint32_t>(-size_delta);
                if (reduction > it->second.total_size) {
                    std::cerr << "Warning: Size underflow at price " << price 
                              << ", current: " << it->second.total_size 
                              << ", delta: " << size_delta 
                              << " - setting to 0" << std::endl;
                    it->second.total_size = 0;
                    it->second.order_count = 0;
                } else {
                    it->second.total_size -= reduction;
                    it->second.order_count = std::max(0u, it->second.order_count - 1);
                }
            } else {
                it->second.total_size += size_delta;
                it->second.order_count++;
            }
            
            if (it->second.total_size <= 0) {
                asks.erase(it);
            }
        } else if (size_delta > 0) {
            asks[price] = PriceLevel(price, size_delta);
        } else {
            // Trying to reduce from non-existent price level
            std::cerr << "Warning: Trying to reduce " << (-size_delta) 
                      << " from non-existent ask price level " << price << std::endl;
        }
    }
}

std::vector<MBPRecord> OrderBook::generateMBP10() const {
    std::vector<MBPRecord> result;
    result.reserve(20); // Up to 10 bids + 10 asks
    
    // Add top 10 bids (highest prices first)
    int count = 0;
    for (const auto& [price, level] : bids) {
        if (count >= 10) break;
        
        MBPRecord record;
        record.action = 'A';
        record.side = 'B';
        record.price = price;
        record.size = level.total_size;
        result.push_back(record);
        count++;
    }
    
    // Add top 10 asks (lowest prices first)
    count = 0;
    for (const auto& [price, level] : asks) {
        if (count >= 10) break;
        
        MBPRecord record;
        record.action = 'A';
        record.side = 'A';
        record.price = price;
        record.size = level.total_size;
        result.push_back(record);
        count++;
    }
    
    return result;
}

void OrderBook::printOrderBook() const {
    std::cout << "\n=== ORDER BOOK ===" << std::endl;
    std::cout << "ASKS:" << std::endl;
    
    // Print asks in reverse order (highest to lowest)
    auto ask_it = asks.rbegin();
    for (int i = 0; i < 5 && ask_it != asks.rend(); ++ask_it, ++i) {
        std::cout << std::fixed << std::setprecision(2) 
                  << "  " << ask_it->first << " x " << ask_it->second.total_size 
                  << " (" << ask_it->second.order_count << " orders)" << std::endl;
    }
    
    std::cout << "--- SPREAD ---" << std::endl;
    
    // Print bids (highest to lowest)
    auto bid_it = bids.begin();
    for (int i = 0; i < 5 && bid_it != bids.end(); ++bid_it, ++i) {
        std::cout << std::fixed << std::setprecision(2) 
                  << "  " << bid_it->first << " x " << bid_it->second.total_size 
                  << " (" << bid_it->second.order_count << " orders)" << std::endl;
    }
    
    std::cout << "BIDS:" << std::endl;
    
    // Calculate spread
    if (!bids.empty() && !asks.empty()) {
        double best_bid = bids.begin()->first;
        double best_ask = asks.begin()->first;
        double spread = best_ask - best_bid;
        std::cout << "Spread: " << std::fixed << std::setprecision(4) << spread << std::endl;
    }
    
    std::cout << "Orders: " << orders.size() << ", Bid levels: " << bids.size() 
              << ", Ask levels: " << asks.size() << std::endl;
}