finishing orders for a restaurant 2 client 1 server

Client.cpp

#define WIN32_LEAN_AND_MEAN

#include <ws2tcpip.h>
#include <windows.h>
#include <iostream>
#include <string>
using namespace std;

#pragma comment(lib, "Ws2_32.lib")

#define DEFAULT_BUFLEN 4096
#define SERVER_IP "127.0.0.1"
#define SERVER_PORT 8888

SOCKET client_socket;
sockaddr_in server_addr;
int server_addr_len = sizeof(server_addr);
string nickname;

DWORD WINAPI Sender(void* param)
{
    while (true) {
        cout << "Enter dish name (from menu): ";
        char query[DEFAULT_BUFLEN];
        cin.getline(query, DEFAULT_BUFLEN);

        string message = "ORDER:" + string(query);
        int send_result = sendto(client_socket, message.c_str(), message.size(), 0, (sockaddr*)&server_addr, server_addr_len);
        if (send_result == SOCKET_ERROR) {
            printf("sendto error: %d\n", WSAGetLastError());
        }
    }
}

DWORD WINAPI Receiver(void* param)
{
    while (true) {
        char response[DEFAULT_BUFLEN];
        sockaddr_in from_addr;
        int from_len = sizeof(from_addr);
        int result = recvfrom(client_socket, response, DEFAULT_BUFLEN, 0, (sockaddr*)&from_addr, &from_len);
        if (result > 0) {
            response[result] = '\0';
            cout << response << "\n";
        }
        else if (result == SOCKET_ERROR) {
            printf("recvfrom error: %d\n", WSAGetLastError());
        }
    }
}

BOOL ExitHandler(DWORD whatHappening)
{
    switch (whatHappening)
    {
    case CTRL_C_EVENT:
    case CTRL_BREAK_EVENT:
    case CTRL_CLOSE_EVENT:
    case CTRL_LOGOFF_EVENT:
    case CTRL_SHUTDOWN_EVENT:
        cout << "Disconnecting...\n";
        Sleep(1000);
        sendto(client_socket, "off", 3, 0, (sockaddr*)&server_addr, server_addr_len);
        closesocket(client_socket);
        WSACleanup();
        exit(0);
        return TRUE;
    default:
        return FALSE;
    }
}

int main()
{
    SetConsoleCtrlHandler((PHANDLER_ROUTINE)ExitHandler, TRUE);

    setlocale(0, "");
    system("title UDP RESTAURANT CLIENT");

    cout << "Enter your nickname: ";
    getline(cin, nickname);

    WSADATA wsaData;
    int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != 0) {
        printf("WSAStartup failed: %d\n", iResult);
        return 1;
    }

    client_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (client_socket == INVALID_SOCKET) {
        printf("Socket creation failed: %ld\n", WSAGetLastError());
        WSACleanup();
        return 2;
    }

    sockaddr_in client_addr;
    client_addr.sin_family = AF_INET;
    client_addr.sin_addr.s_addr = INADDR_ANY;
    client_addr.sin_port = 0;

    if (bind(client_socket, (sockaddr*)&client_addr, sizeof(client_addr)) == SOCKET_ERROR) {
        printf("Bind failed: %d\n", WSAGetLastError());
        closesocket(client_socket);
        WSACleanup();
        return 3;
    }

    int client_addr_len = sizeof(client_addr);
    if (getsockname(client_socket, (sockaddr*)&client_addr, &client_addr_len) == SOCKET_ERROR) {
        printf("getsockname failed: %d\n", WSAGetLastError());
        closesocket(client_socket);
        WSACleanup();
        return 4;
    }

    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVER_PORT);
    inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr);

    printf("UDP client started. Nickname: %s. Bound to port %d. Sending to %s:%d\n",
        nickname.c_str(), ntohs(client_addr.sin_port), SERVER_IP, SERVER_PORT);

    string initial_message = "INFO: " + nickname + " joined the restaurant";
    sendto(client_socket, initial_message.c_str(), initial_message.size(), 0, (sockaddr*)&server_addr, server_addr_len);

    CreateThread(0, 0, Sender, 0, 0, 0);
    CreateThread(0, 0, Receiver, 0, 0, 0);

    Sleep(INFINITE);

    closesocket(client_socket);
    WSACleanup();
    return 0;
}

Server.cpp

#include <winsock2.h>
#include <iostream>
#include <vector>
#include <queue>
#include <thread>
#include <chrono>
#include <string>
#include <ctime>
using namespace std;

#pragma comment(lib, "ws2_32.lib")
#pragma warning(disable:4996)

#define DEFAULT_BUFLEN 4096
#define SERVER_PORT 8888

SOCKET server_socket;

struct Dish {
    string name;
    int prep_time; 

vector<Dish> menu = {
    {"Pizza", 5}, {"Salad", 2}, {"Soup", 3}, {"Burger", 4},
    {"Steak", 6}, {"Pasta", 4}, {"Sushi", 5}, {"Sandwich", 2},
    {"Fries", 1}, {"Dessert", 3}
};

struct Order {
    sockaddr_in client;
    Dish dish;
    chrono::system_clock::time_point time_received;
};

queue<Order> orderQueue;
vector<sockaddr_in> clients;

void logMessage(const string& msg) {
    time_t now = time(0);
    char* dt = ctime(&now);
    dt[strlen(dt) - 1] = '\0';
    cout << "[" << dt << "] " << msg << endl;
}

void processOrders() {
    while (true) {
        if (!orderQueue.empty()) {
            Order o = orderQueue.front();
            orderQueue.pop();

            logMessage("Cooking " + o.dish.name + " for client " + string(inet_ntoa(o.client.sin_addr)) + ":" + to_string(ntohs(o.client.sin_port)));

            this_thread::sleep_for(chrono::seconds(o.dish.prep_time));

            string msg = "READY: Your " + o.dish.name + " is ready, enjoy!";
            sendto(server_socket, msg.c_str(), msg.size(), 0, (sockaddr*)&o.client, sizeof(o.client));

            auto wait_time = chrono::duration_cast<chrono::seconds>(chrono::system_clock::now() - o.time_received).count();
            logMessage("Completed " + o.dish.name + " for client after " + to_string(wait_time) + "s");
        }
        else {
            this_thread::sleep_for(chrono::milliseconds(100));
        }
    }
}

Dish findDish(const string& name) {
    for (auto& d : menu) {
        if (d.name == name) return d;
    }
    return { "Unknown", 0 };
}

int main() {
    setlocale(0, "");
    system("title UDP RESTAURANT SERVER");

    WSADATA wsa;
    if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) {
        printf("WSAStartup failed: %d\n", WSAGetLastError());
        return 1;
    }

    server_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (server_socket == INVALID_SOCKET) {
        printf("Socket creation failed: %d\n", WSAGetLastError());
        return 2;
    }

    sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    server.sin_port = htons(SERVER_PORT);

    if (bind(server_socket, (sockaddr*)&server, sizeof(server)) == SOCKET_ERROR) {
        printf("Bind failed: %d\n", WSAGetLastError());
        closesocket(server_socket);
        WSACleanup();
        return 3;
    }

    logMessage("Restaurant server started. Waiting for orders...");

    thread worker(processOrders);

    char buffer[DEFAULT_BUFLEN];
    sockaddr_in client_addr;
    int addrlen = sizeof(client_addr);

    while (true) {
        int len = recvfrom(server_socket, buffer, DEFAULT_BUFLEN, 0, (sockaddr*)&client_addr, &addrlen);
        if (len > 0) {
            buffer[len] = '\0';
            string msg(buffer);

            logMessage("Received from " + string(inet_ntoa(client_addr.sin_addr)) + ":" + to_string(ntohs(client_addr.sin_port)) + " -> " + msg);

            if (msg.rfind("ORDER:", 0) == 0) {
                string dishName = msg.substr(6);
                Dish d = findDish(dishName);

                if (d.name == "Unknown") {
                    string reply = "ERROR: Dish not on menu.";
                    sendto(server_socket, reply.c_str(), reply.size(), 0, (sockaddr*)&client_addr, addrlen);
                }
                else {
                    Order o{ client_addr, d, chrono::system_clock::now() };
                    orderQueue.push(o);

                    string info = "INFO: Client ordered " + d.name;
                    for (auto& addr : clients) {
                        sendto(server_socket, info.c_str(), info.size(), 0, (sockaddr*)&addr, sizeof(addr));
                    }
                }
            }

            bool exists = false;
            for (auto& addr : clients) {
                if (addr.sin_addr.s_addr == client_addr.sin_addr.s_addr && addr.sin_port == client_addr.sin_port) {
                    exists = true;
                    break;
                }
            }
            if (!exists) clients.push_back(client_addr);
        }
    }

    worker.join();
    closesocket(server_socket);
    WSACleanup();
    return 0;
}