module;

#include <gtest/gtest.h>
#include <gmock/gmock.h>

#include <utility>

export module DataConnection_test;
import MMO.DataConnection;
import std;

// class DataConnection : public ::testing::Test {
//     void TearDown() override {
//         MMO::Networking::MSQUIC::MSQuicGlobal::get()->get().reset();
//     }
// };

TEST(DataConnection, ClientSettings) {
    MMO::Networking::NetworkSettings settings{0};
    MMO::Networking::NetworkCredentials credConfig{
        .Type = MMO::Networking::Additional::CredentialType::QUIC_CREDENTIAL_TYPE_NONE,
        .Flags = MMO::Networking::Additional::CredentialFlags::QUIC_CREDENTIAL_FLAG_CLIENT | MMO::Networking::Additional::CredentialFlags::QUIC_CREDENTIAL_FLAG_NO_CERTIFICATE_VALIDATION
    };

    MMO::Networking::NetworkingConnection::defaultSettings(settings, credConfig);
    auto res = MMO::Networking::NetworkingConnection::connectTo(settings, credConfig, "127.0.0.1", 2524);
    EXPECT_TRUE(res.has_value());
}

TEST(DataConnection, ServerSettings) {
    MMO::Networking::NetworkSettings settings{0};
    MMO::Networking::NetworkCertificate certFile{
        .PrivateKeyFile = "../key.pem",
        .CertificateFile = "../cert.pem",
    };
    MMO::Networking::NetworkCredentials credConfig{
        .Type = MMO::Networking::Additional::CredentialType::QUIC_CREDENTIAL_TYPE_CERTIFICATE_FILE,
        .CertificateFile = &certFile
    };

    MMO::Networking::NetworkingServer::defaultSettings(settings, credConfig);
    auto res = MMO::Networking::NetworkingServer::hostFrom(settings, credConfig, 2524, "127.0.0.1");
    EXPECT_TRUE(res.has_value());
}

TEST(DataConnection, ConnectToRemote) {
    MMO::Networking::NetworkSettings settings{0};
    MMO::Networking::NetworkCredentials credConfig{
        .Type = MMO::Networking::Additional::CredentialType::QUIC_CREDENTIAL_TYPE_NONE,
        .Flags = MMO::Networking::Additional::CredentialFlags::QUIC_CREDENTIAL_FLAG_CLIENT | MMO::Networking::Additional::CredentialFlags::QUIC_CREDENTIAL_FLAG_NO_CERTIFICATE_VALIDATION
    };
    MMO::Networking::NetworkingConnection::defaultSettings(settings, credConfig);
    auto res = MMO::Networking::NetworkingConnection::connectTo(settings, credConfig, "127.0.0.1", 2524);
    EXPECT_TRUE(res.has_value());

    auto connection = res.value();

    auto result = connection->establishConnection();

    EXPECT_FALSE(result.has_value());
}

TEST(DataConnection, ListenForConnections) {
    MMO::Networking::NetworkSettings settings{0};
    MMO::Networking::NetworkCertificate certFile{
        .PrivateKeyFile = "../key.pem",
        .CertificateFile = "../cert.pem",
    };
    MMO::Networking::NetworkCredentials credConfig{
        .Type = MMO::Networking::Additional::CredentialType::QUIC_CREDENTIAL_TYPE_CERTIFICATE_FILE,
        .CertificateFile = &certFile
    };
    MMO::Networking::NetworkingServer::defaultSettings(settings, credConfig);
    auto res = MMO::Networking::NetworkingServer::hostFrom(settings, credConfig, 2524, "127.0.0.1");
    EXPECT_TRUE(res.has_value());

    auto server = res.value();

    EXPECT_THAT(server->startListening(), testing::Eq(std::nullopt));
}


TEST(DataConnection, EstablishConnection) {
    auto timeout = std::chrono::seconds(5);
    auto start = std::chrono::high_resolution_clock::now();


    MMO::Networking::NetworkSettings serverSettings{0};
    MMO::Networking::NetworkCertificate serverCertFile{
        .PrivateKeyFile = "../key.pem",
        .CertificateFile = "../cert.pem",
    };
    MMO::Networking::NetworkCredentials serverCredConfig{
        .Type = MMO::Networking::Additional::CredentialType::QUIC_CREDENTIAL_TYPE_CERTIFICATE_FILE,
        .CertificateFile = &serverCertFile
    };
    MMO::Networking::NetworkingServer::defaultSettings(serverSettings, serverCredConfig);
    auto serverRes = MMO::Networking::NetworkingServer::hostFrom(serverSettings, serverCredConfig, 2524,
                                                                     "0.0.0.0");
    EXPECT_TRUE(serverRes.has_value());

    auto server = serverRes.value();

    EXPECT_THAT(server->startListening(), testing::Eq(std::nullopt));

    std::println("Binding listener...");
    std::fflush(stdout);

    std::shared_ptr<MMO::Networking::NetworkingConnection> serverConnection;

    auto serverCB = std::make_shared<std::function<void(std::shared_ptr<MMO::Networking::NetworkingConnection>)>>(
        [&serverConnection](auto data) {
            serverConnection = std::move(data);
        });

    server->addReceiveCallback(serverCB);

    std::println("Creating client->..");
    std::fflush(stdout);

    MMO::Networking::NetworkSettings clientSettings{0};
    MMO::Networking::NetworkCredentials clientCredConfig{
        .Type = MMO::Networking::Additional::CredentialType::QUIC_CREDENTIAL_TYPE_NONE,
        .Flags = MMO::Networking::Additional::CredentialFlags::QUIC_CREDENTIAL_FLAG_CLIENT | MMO::Networking::Additional::CredentialFlags::QUIC_CREDENTIAL_FLAG_NO_CERTIFICATE_VALIDATION
    };
    MMO::Networking::NetworkingConnection::defaultSettings(clientSettings, clientCredConfig);
    auto clientRes = MMO::Networking::NetworkingConnection::connectTo(clientSettings, clientCredConfig, "127.0.0.1",
                                                                      2524);
    EXPECT_TRUE(clientRes.has_value());

    auto client = clientRes.value();

    std::println("Connecting to server...");
    std::fflush(stdout);
    EXPECT_FALSE(client->establishConnection().has_value());

    while (!client->isConnected()) {
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
        if (std::chrono::high_resolution_clock::now() - start > timeout) {
            FAIL() << "Connection timed out";
        }
    }

    EXPECT_TRUE(client->isConnected());
    EXPECT_TRUE(serverConnection != nullptr);


    while (!serverConnection->isConnected()) {
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
        if (std::chrono::high_resolution_clock::now() - start > timeout) {
            FAIL() << "Connection timed out";
        }
    }
    EXPECT_TRUE(serverConnection->isConnected());

}


TEST(DataConnection, SendData) {
    auto timeout = std::chrono::seconds(5);
    auto start = std::chrono::high_resolution_clock::now();

    MMO::Networking::NetworkSettings serverSettings{0};
    MMO::Networking::NetworkCertificate serverCertFile{
        .PrivateKeyFile = "../key.pem",
        .CertificateFile = "../cert.pem",
    };
    MMO::Networking::NetworkCredentials serverCredConfig{
        .Type = MMO::Networking::Additional::CredentialType::QUIC_CREDENTIAL_TYPE_CERTIFICATE_FILE,
        .CertificateFile = &serverCertFile
    };
    MMO::Networking::NetworkingServer::defaultSettings(serverSettings, serverCredConfig);
    auto serverRes = MMO::Networking::NetworkingServer::hostFrom(serverSettings, serverCredConfig, 2524,
                                                                     "0.0.0.0");
    EXPECT_TRUE(serverRes.has_value());

    auto server = serverRes.value();

    EXPECT_THAT(server->startListening(), testing::Eq(std::nullopt));

    std::println("Binding listener...");
    std::fflush(stdout);

    std::shared_ptr<MMO::Networking::NetworkingConnection> serverConnection;

    auto serverCB = std::make_shared<std::function<void(std::shared_ptr<MMO::Networking::NetworkingConnection>)>>(
        [&serverConnection](auto data) {
            serverConnection = std::move(data);
        });

    server->addReceiveCallback(serverCB);


    std::println("Creating client->..");
    std::fflush(stdout);

    MMO::Networking::NetworkSettings clientSettings{0};
    MMO::Networking::NetworkCredentials clientCredConfig{
        .Type = MMO::Networking::Additional::CredentialType::QUIC_CREDENTIAL_TYPE_NONE,
        .Flags = MMO::Networking::Additional::CredentialFlags::QUIC_CREDENTIAL_FLAG_CLIENT | MMO::Networking::Additional::CredentialFlags::QUIC_CREDENTIAL_FLAG_NO_CERTIFICATE_VALIDATION
    };
    MMO::Networking::NetworkingConnection::defaultSettings(clientSettings, clientCredConfig);
    auto clientRes = MMO::Networking::NetworkingConnection::connectTo(clientSettings, clientCredConfig, "127.0.0.1",
                                                                      2524);
    EXPECT_TRUE(clientRes.has_value());

    auto client = clientRes.value();

    std::println("Connecting to server...");
    std::fflush(stdout);
    EXPECT_FALSE(client->establishConnection().has_value());

    while (!client->isConnected()) {
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
        if (std::chrono::high_resolution_clock::now() - start > timeout) {
            FAIL() << "Connection timed out";
        }
    }

    EXPECT_TRUE(client->isConnected());
    EXPECT_TRUE(serverConnection != nullptr);


    while (!serverConnection->isConnected()) {
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
        if (std::chrono::high_resolution_clock::now() - start > timeout) {
            FAIL() << "Connection timed out";
        }
    }
    EXPECT_TRUE(serverConnection->isConnected());

    std::println("Sending data...");
    std::fflush(stdout);

    std::shared_ptr<MMO::Networking::NetworkingDataLane> serverStream;

    auto serverStreamCB = std::make_shared<std::function<void(std::shared_ptr<MMO::Networking::NetworkingDataLane>, std::shared_ptr<MMO::Networking::NetworkingConnection>)>>(
        [&serverStream](const auto& dataLane, const auto&) {
            serverStream = dataLane;
        });

    serverConnection->addRemoteStreamCallbacks(serverStreamCB);

    // auto streamRes = client->createStream();
    // EXPECT_TRUE(streamRes.has_value());
    // auto stream = streamRes.value();
    std::vector<uint8_t> testData = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    auto sendResult = client->send(testData);
    EXPECT_FALSE(sendResult.has_value());

    std::println("Waiting for data to be received...");
    std::fflush(stdout);
    while (!serverStream || !serverStream->hasData()) {
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
        if (std::chrono::high_resolution_clock::now() - start > timeout) {
            FAIL() << "No data received";
        }
    }

    EXPECT_TRUE(serverStream->hasData());

    auto receivedData = serverStream->retrieveAndResetData();

    EXPECT_THAT(receivedData, testing::ContainerEq(testData));

}