main.cpp

#include "src/matchEngine.h"

#include <charconv>
#include <cstdint>
#include <iostream>
#include <sstream>
#include <string>
#include <string_view>

namespace {

bool parseUint64(std::string_view token, uint64_t& value) {
    const char* begin = token.data();
    const char* end = begin + token.size();
    auto [ptr, ec] = std::from_chars(begin, end, value);
    return ec == std::errc{} && ptr == end;
}

bool parseQty(std::string_view token, Qty& qty) {
    uint64_t value = 0;
    if (!parseUint64(token, value) || value > UINT16_MAX) {
        return false;
    }

    qty = static_cast<Qty>(value);
    return true;
}

bool parseSide(const std::string& token, Side& side) {
    if (token == "BUY") {
        side = Side::Bid;
        return true;
    }

    if (token == "SELL") {
        side = Side::Ask;
        return true;
    }

    return false;
}

bool parsePriceType(const std::string& token, PriceType& priceType) {
    if (token == "LIMIT") {
        priceType = PriceType::Limit;
        return true;
    }

    if (token == "MARKET") {
        priceType = PriceType::Market;
        return true;
    }

    return false;
}

bool parseOrderType(const std::string& token, OrderType& orderType) {
    if (token == "GTC") {
        orderType = OrderType::GTC;
        return true;
    }

    if (token == "IOC") {
        orderType = OrderType::IOC;
        return true;
    }

    return false;
}

void printUsage(std::ostream& out) {
    out << "Commands:\n"
        << "  BUY  <LIMIT|MARKET> <GTC|IOC> <price> <qty> <order_id>\n"
        << "  SELL <LIMIT|MARKET> <GTC|IOC> <price> <qty> <order_id>\n"
        << "  CANCEL <order_id>\n"
        << "  MODIFY <order_id> <new_price> <new_qty>\n";
}

} // namespace

int main() {
    MatchEngine engine;

    std::string line;
    uint64_t lineNumber = 0;

    while (std::getline(std::cin, line)) {
        ++lineNumber;

        if (line.empty() || line.front() == '#') {
            continue;
        }

        std::istringstream input(line);
        std::string command;
        input >> command;

        if (command == "BUY" || command == "SELL") {
            std::string priceTypeToken;
            std::string orderTypeToken;
            std::string priceToken;
            std::string qtyToken;
            std::string orderIdToken;

            if (!(input >> priceTypeToken >> orderTypeToken >> priceToken >> qtyToken >> orderIdToken)) {
                std::cout << "ERROR line " << lineNumber << ": invalid order command\n";
                continue;
            }

            Side side = Side::Bid;
            PriceType priceType = PriceType::Limit;
            OrderType orderType = OrderType::GTC;
            Price price = 0;
            Qty qty = 0;
            OrderId orderId = 0;

            if (!parseSide(command, side) ||
                !parsePriceType(priceTypeToken, priceType) ||
                !parseOrderType(orderTypeToken, orderType) ||
                !parseUint64(priceToken, price) ||
                !parseQty(qtyToken, qty) ||
                !parseUint64(orderIdToken, orderId)) {
                std::cout << "ERROR line " << lineNumber << ": invalid order values\n";
                continue;
            }

            engine.addOrder(Order{orderId, side, priceType, orderType, price, qty});
            std::cout << "SUBMITTED " << command << " " << orderId << "\n";
        } else if (command == "CANCEL") {
            std::string orderIdToken;
            if (!(input >> orderIdToken)) {
                std::cout << "ERROR line " << lineNumber << ": invalid cancel command\n";
                continue;
            }

            OrderId orderId = 0;
            if (!parseUint64(orderIdToken, orderId)) {
                std::cout << "ERROR line " << lineNumber << ": invalid order id\n";
                continue;
            }

            engine.cancelOrder(orderId);
            std::cout << "CANCELLED " << orderId << "\n";
        } else if (command == "MODIFY") {
            std::string orderIdToken;
            std::string priceToken;
            std::string qtyToken;

            if (!(input >> orderIdToken >> priceToken >> qtyToken)) {
                std::cout << "ERROR line " << lineNumber << ": invalid modify command\n";
                continue;
            }

            OrderId orderId = 0;
            Price price = 0;
            Qty qty = 0;

            if (!parseUint64(orderIdToken, orderId) ||
                !parseUint64(priceToken, price) ||
                !parseQty(qtyToken, qty)) {
                std::cout << "ERROR line " << lineNumber << ": invalid modify values\n";
                continue;
            }

            engine.modifyOrder(orderId, price, qty);
            std::cout << "MODIFIED " << orderId << "\n";
        } else if (command == "HELP") {
            printUsage(std::cout);
        } else {
            std::cout << "ERROR line " << lineNumber << ": unknown command\n";
        }
    }

    return 0;
}