order_book.h

#ifndef ORDER_BOOK_H
#define ORDER_BOOK_H

#include <map>
#include <queue>
#include <cstdint>
#include <cstring>

enum Side { BUY, SELL };

struct Order {
    uint64_t order_id;
    char symbol[8];
    Side side;
    double price;
    int quantity;
    uint64_t timestamp;
};

struct PriceLevel {
    double price;
    int total_quantity;
    std::queue<Order> orders;

    PriceLevel() : price(0.0), total_quantity(0) {}
    explicit PriceLevel(double p) : price(p), total_quantity(0) {}
};

class OrderBook {
private:
    char symbol_[8];
    std::map<double, PriceLevel, std::greater<double>> bids_;  // descending
    std::map<double, PriceLevel, std::less<double>> asks_;     // ascending

public:
    explicit OrderBook(const char* symbol) {
        snprintf(symbol_, sizeof(symbol_), "%s", symbol);
    }

    void add_order(const Order& order) {
        if (order.side == BUY) {
            auto& level = bids_[order.price];
            level.price = order.price;
            level.orders.push(order);
            level.total_quantity += order.quantity;
        } else {
            auto& level = asks_[order.price];
            level.price = order.price;
            level.orders.push(order);
            level.total_quantity += order.quantity;
        }
    }

    bool get_best_bid(double& price, int& quantity) {
        if (bids_.empty()) return false;
        auto& level = bids_.begin()->second;
        price = level.price;
        quantity = level.total_quantity;
        return true;
    }

    bool get_best_ask(double& price, int& quantity) {
        if (asks_.empty()) return false;
        auto& level = asks_.begin()->second;
        price = level.price;
        quantity = level.total_quantity;
        return true;
    }

    Order* get_top_bid() {
        if (bids_.empty()) return nullptr;
        auto& level = bids_.begin()->second;
        if (level.orders.empty()) {
            bids_.erase(bids_.begin());
            return get_top_bid();
        }
        return &level.orders.front();
    }

    Order* get_top_ask() {
        if (asks_.empty()) return nullptr;
        auto& level = asks_.begin()->second;
        if (level.orders.empty()) {
            asks_.erase(asks_.begin());
            return get_top_ask();
        }
        return &level.orders.front();
    }

    void remove_quantity_from_top_bid(int qty) {
        if (bids_.empty()) return;
        auto it = bids_.begin();
        auto& level = it->second;

        while (qty > 0 && !level.orders.empty()) {
            auto& order = level.orders.front();
            if (order.quantity <= qty) {
                qty -= order.quantity;
                level.total_quantity -= order.quantity;
                level.orders.pop();
            } else {
                order.quantity -= qty;
                level.total_quantity -= qty;
                qty = 0;
            }
        }

        if (level.orders.empty()) {
            bids_.erase(it);
        }
    }

    void remove_quantity_from_top_ask(int qty) {
        if (asks_.empty()) return;
        auto it = asks_.begin();
        auto& level = it->second;

        while (qty > 0 && !level.orders.empty()) {
            auto& order = level.orders.front();
            if (order.quantity <= qty) {
                qty -= order.quantity;
                level.total_quantity -= order.quantity;
                level.orders.pop();
            } else {
                order.quantity -= qty;
                level.total_quantity -= qty;
                qty = 0;
            }
        }

        if (level.orders.empty()) {
            asks_.erase(it);
        }
    }

    const char* symbol() const { return symbol_; }
};

#endif