#include <gtest/gtest.h>

// STL includes
#include <cstring>
#include <thread>

// Project includes
#include "tcp_client.hpp"
#include "tcp_server.hpp"


TEST(BlockingTcpServer, Accept) {
    tcp::BlockingServer server;
    tcp::BlockingClient client;

    auto lisRes = server.start_listening(1234);

    std::thread clientThread([&client]() {
        auto conRes = client.connect({"localhost"}, 1234);
        EXPECT_TRUE(conRes.has_value());
    });

    std::thread serverThread([&server]() {
        auto accRes = server.accept();
        EXPECT_TRUE(accRes.has_value());
    });

    serverThread.join();
    clientThread.join();
}

TEST(BlockingTcpServer, RestartListening) {
    tcp::BlockingServer server;
    tcp::BlockingClient client;

    auto lisRes = server.start_listening(1234);

    std::thread clientThread([&client]() {
        auto conRes = client.connect({"localhost"}, 1234);
        EXPECT_TRUE(conRes.has_value());
    });

    clientThread.join();

    auto lisRes2 = server.start_listening(2345);

    std::thread clientThread2([&client]() {
        auto conRes = client.connect({"localhost"}, 1234);
        EXPECT_FALSE(conRes.has_value());
    });

    clientThread2.join();

    std::thread clientThread3([&client]() {
        auto conRes2 = client.connect({"localhost"}, 2345);
        EXPECT_TRUE(conRes2.has_value());
    });

    clientThread3.join();
}

TEST(BlockingTcpServer, StopListening) {
    tcp::BlockingServer server;
    tcp::BlockingClient client;

    auto lisRes = server.start_listening(1234);

    std::thread clientThread([&client]() {
        auto conRes = client.connect({"localhost"}, 1234);
        EXPECT_TRUE(conRes.has_value());
    });

    clientThread.join();

    server.stop_listening();

    std::thread clientThread2([&client]() {
        auto conRes2 = client.connect({"localhost"}, 1234);
        EXPECT_FALSE(conRes2.has_value());
    });

    clientThread2.join();
}

TEST(BlockingTcpServer, MultipleAccept) {
    tcp::BlockingServer server;
    tcp::BlockingClient client1;
    tcp::BlockingClient client2;

    auto lisRes1 = server.start_listening(1234);

    std::thread clientThread1([&client1]() {
        auto conRes1 = client1.connect({"localhost"}, 1234);
        EXPECT_TRUE(conRes1.has_value());
    });

    std::thread clientThread2([&client2]() {
        auto conRes2 = client2.connect({"localhost"}, 1234);
        EXPECT_TRUE(conRes2.has_value());
    });

    std::thread serverThread([&server]() {
        auto accRes1 = server.accept();
        EXPECT_TRUE(accRes1.has_value());

        auto accRes2 = server.accept();
        EXPECT_TRUE(accRes2.has_value());
    });

    clientThread1.join();
    clientThread2.join();
    serverThread.join();
}

TEST(BlockingTcpServer, GetClientIPAsString) {
    tcp::BlockingServer server;
    tcp::BlockingClient client;

    auto lisRes = server.start_listening(1234);
    auto conRes = client.connect({"localhost"}, 1234);
    auto accRes = server.accept();

    auto ipRes = server.get_client_ip_as_string();
    if (!ipRes) return;

    EXPECT_STREQ(ipRes.value().data(), "127.0.0.1");
}

TEST(BlockingTcpClient, Connect) {
    tcp::BlockingServer server;
    tcp::BlockingClient client;

    auto lisRes = server.start_listening(1234);

    std::thread clientThread([&client]() {
        auto conRes = client.connect({"localhost"}, 1234);
        EXPECT_TRUE(conRes.has_value());
    });

    clientThread.join();
}

TEST(BlockingClient, Reconnect) {
    tcp::BlockingServer server1;
    tcp::BlockingServer server2;
    tcp::BlockingClient client;

    auto lisRes1 = server1.start_listening(1234);
    auto lisRes2 = server2.start_listening(2345);

    std::thread clientThread([&client]() {
        auto conRes = client.connect({"localhost"}, 1234);
        EXPECT_TRUE(conRes.has_value());
    });

    clientThread.join();

    std::thread clientThread2([&client]() {
        auto conRes2 = client.connect({"localhost"}, 2345);
        EXPECT_TRUE(conRes2.has_value());
    });

    clientThread2.join();
}

TEST(BlockingTcpClientServer, ClientSendServerReceive) {
    tcp::BlockingServer server;
    tcp::BlockingClient client;

    auto lisRes = server.start_listening(1234);
    auto conRes = client.connect({"localhost"}, 1234);
    auto accRes = server.accept();

    std::array<char, 14> txMsg   = {"Hello, World!"};
    auto                 sendRes = client.send(std::as_bytes(std::span(txMsg)));

    EXPECT_EQ(sendRes.value(), txMsg.size());

    std::array<char, 1024> rxBuffer;
    auto recvRes = server.recv(std::as_writable_bytes(std::span(rxBuffer)));
    EXPECT_EQ(recvRes.value(), txMsg.size());
    EXPECT_EQ(std::strcmp(txMsg.data(), rxBuffer.data()), 0);
}

TEST(BlockingTcpClientServer, ClientReceiveServerSend) {
    tcp::BlockingServer server;
    tcp::BlockingClient client;

    auto lisRes = server.start_listening(1234);
    auto conRes = client.connect({"localhost"}, 1234);
    auto accRes = server.accept();

    std::array<char, 14> txMsg   = {"Hello, World!"};
    auto                 sendRes = server.send(std::as_bytes(std::span(txMsg)));

    EXPECT_EQ(sendRes.value(), txMsg.size());

    std::array<char, 1024> rxBuffer;
    auto recvRes = client.recv(std::as_writable_bytes(std::span(rxBuffer)));
    EXPECT_EQ(recvRes.value(), txMsg.size());
    EXPECT_EQ(std::strcmp(txMsg.data(), rxBuffer.data()), 0);
}