NetworkInterface.cpp

#include "NetworkInterface.h"

// Constructor: Initializes the socket and binds it to the given port
NetworkInterface::NetworkInterface(int port) : port(port), isRunning(true) {
    // Create a UDP socket
    socket_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (socket_fd < 0) {
        throw std::runtime_error("Failed to create socket.");
    }

    // Bind the socket to the specified port
    sockaddr_in serverAddr{};
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = INADDR_ANY;
    serverAddr.sin_port = htons(port);

    if (bind(socket_fd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
        close(socket_fd);
        throw std::runtime_error("Failed to bind socket to port.");
    }
}

// Destructor: Cleans up the socket
NetworkInterface::~NetworkInterface() {
    close(socket_fd);
}

// Prepares the socket for communication (used for initialization)
void NetworkInterface::prepareSocket() {
    if (socket_fd <= 0) {
        throw std::runtime_error("Invalid socket descriptor.");
    }
}

// Gracefully stops the network interface
void NetworkInterface::stop() {
    isRunning = false;
}

// Receives and processes incoming orders from clients
void NetworkInterface::receiveOrders(MatchingEngine& engine) {
    std::vector<char> buffer(1024);  // Buffer to store incoming data
    Logger& logger = Logger::getInstance();

    while (isRunning) {
        sockaddr_in clientAddr;
        socklen_t addrLen = sizeof(clientAddr);

        // Receive data from the client
        int bytesReceived = recvfrom(socket_fd, buffer.data(), buffer.size(), 0, (struct sockaddr*)&clientAddr, &addrLen);
        if (bytesReceived < 0) {
            if (isRunning) {
                logger.log("Error: Failed to receive data.");
            }
            continue;  // Skip processing on error
        }

        buffer[bytesReceived] = '\0';  // Null-terminate the received string
        std::string orderStr(buffer.data());

        // Check for shutdown command
        if (orderStr == "shutdown") {
            logger.log("Shutdown command received. Stopping server...");
            isRunning = false;
            break;
        }

        try {
            // Parse and process the order
            auto order = parseOrder(orderStr);
            engine.processOrder(order);

            // Send a success response back to the client
            std::string response = "Order processed successfully.";
            sendto(socket_fd, response.c_str(), response.length(), 0, (struct sockaddr*)&clientAddr, addrLen);
        } catch (const std::exception& e) {
            // Send an error response to the client
            std::string response = "Error processing order: " + std::string(e.what());
            sendto(socket_fd, response.c_str(), response.length(), 0, (struct sockaddr*)&clientAddr, addrLen);
        }
    }

    logger.log("Server has stopped.");
}

// Parses an order string into an Order object
Order NetworkInterface::parseOrder(const std::string& orderStr) {
    Logger& logger = Logger::getInstance();
    std::istringstream ss(orderStr);

    int orderId, quantity, timestamp, traderId;
    char side;
    double price;
    int isMarketOrder;

    // Parse the order string
    if (!(ss >> orderId >> side >> price >> quantity >> timestamp >> traderId >> isMarketOrder)) {
        logger.log("Parsing Error: Malformed order string: " + orderStr);
        throw std::invalid_argument("Malformed order string");
    }

    // Validate the parsed order
    validateOrder(orderId, side, price, quantity, timestamp, traderId, isMarketOrder, logger);

    logger.log("Order parsed successfully: ID=" + std::to_string(orderId) +
               ", Side=" + std::string(1, side) +
               ", Price=" + std::to_string(price) +
               ", Quantity=" + std::to_string(quantity) +
               ", Timestamp=" + std::to_string(timestamp) +
               ", TraderID=" + std::to_string(traderId) +
               ", MarketOrder=" + std::to_string(isMarketOrder));

    return Order(orderId, side, price, quantity, timestamp, traderId, isMarketOrder == 1);
}

// Validates order fields to ensure correctness
void NetworkInterface::validateOrder(int orderId, char side, double price, int quantity, int timestamp, int traderId, int isMarketOrder, Logger& logger) {
    std::vector<std::string> errors;

    (void)orderId;  // Suppress unused parameter warning
    (void)traderId; // Suppress unused parameter warning

    // Validate side
    if (side != 'B' && side != 'S') {
        errors.push_back("Invalid side: must be 'B' or 'S'. Received: '" + std::string(1, side) + "'.");
    }

    // Validate price
    if (price <= 0.0) {
        errors.push_back("Price must be greater than zero. Received: " + std::to_string(price));
    }

    // Validate quantity
    if (quantity <= 0) {
        errors.push_back("Quantity must be greater than zero. Received: " + std::to_string(quantity));
    }

    // Validate isMarketOrder
    if (isMarketOrder != 0 && isMarketOrder != 1) {
        errors.push_back("isMarketOrder must be 0 or 1. Received: " + std::to_string(isMarketOrder));
    }

    // Log timestamp for debugging
    logger.log("Timestamp received: " + std::to_string(timestamp));

    // If there are errors, log and throw an exception
    if (!errors.empty()) {
        std::string errorMsg = "Validation errors: ";
        for (const auto& error : errors) {
            errorMsg += "\n- " + error;
        }
        logger.log(errorMsg); // Log all errors
        throw std::invalid_argument(errorMsg);
    }
}