#include <atomic>
#include <thread>

#include "network/Client.h"
#include "network/Server.h"
#include "tests/NetworkTests.h"
#include "tests/Test.h"

static void sleep(int millis) {
    std::this_thread::sleep_for(std::chrono::milliseconds(millis));
}

struct ServerConsumer {
    bool connected = false;
    bool disconnect = false;

    void onConnection(Server::Client& client) {
        (void)client;
        connected = true;
    }

    void onDisconnect(Server::Client& client) {
        (void)client;
        disconnect = true;
    }

    void onPackage(Server::Client& client, InPacket& in) {
        (void)client;
        (void)in;
    }
};

struct ClientConsumer {};

static void testConnect(Test& test) {
    Server server(54321, 5);
    if(server.hasError()) {
        test.checkEqual(false, true, "server can initialize");
        return;
    }
    Client client;
    if(client.hasError()) {
        test.checkEqual(false, true, "client can initialize");
        return;
    }

    std::atomic_bool running(true);
    ServerConsumer serverConsumer;
    std::thread listen([&running, &server, &serverConsumer]() {
        while(running) {
            server.consumeEvents(serverConsumer);
        }
    });

    test.checkEqual(false, client.connect("127.0.0.1", 54321, 5),
                    "connection failed");

    ClientConsumer clientConsumer;
    for(int i = 0; i < 100; i++) {
        client.consumeEvents(clientConsumer);
    }

    test.checkEqual(true, serverConsumer.connected, "server has connection");

    client.disconnect();
    sleep(100);

    test.checkEqual(true, serverConsumer.disconnect, "client has disconnected");

    running = false;
    listen.join();
}

void NetworkTests::test() {
    Test test("Network");
    ENet enet;
    if(enet.init()) {
        test.checkEqual(false, true, "enet init failed");
    } else {
        testConnect(test);
    }
    test.finalize();
}