#define IMPORT_CORE
#include <core/Logger.h>
#include <core/Utility.h>
#include <string.h>

#include "../Tests.h"
#include "../src/ErrorSimulator.h"
#include "core/Network.h"

#define TEST_READ(Type, type, value)                                           \
    {                                                                          \
        type u;                                                                \
        CORE_TEST_FALSE(coreReadInPacket##Type(&in, &u));                      \
        CORE_TEST_TRUE(u == value);                                            \
    }

static void testWriteRead(void) {
    CoreOutPacket out;
    coreInitOutPacket(&out);
    coreWriteOutPacketU8(&out, 200);
    coreWriteOutPacketU16(&out, 6656);
    coreWriteOutPacketU32(&out, 348923689);
    coreWriteOutPacketI8(&out, 90);
    coreWriteOutPacketI8(&out, -35);
    coreWriteOutPacketI16(&out, 843);
    coreWriteOutPacketI16(&out, -8961);
    coreWriteOutPacketI32(&out, 100430199);
    coreWriteOutPacketI32(&out, -534534);
    coreWriteOutPacketFloat(&out, 64564.5346f);
    const char s[] = "This is Great";
    coreWriteOutPacketString(&out, s);

    CoreInPacket in;
    coreInitInPacket(&in, out.data.buffer, out.data.size);
    TEST_READ(U8, u8, 200)
    TEST_READ(U16, u16, 6656)
    TEST_READ(U32, u32, 348923689)
    TEST_READ(I8, i8, 90)
    TEST_READ(I8, i8, -35)
    TEST_READ(I16, i16, 843)
    TEST_READ(I16, i16, -8961)
    TEST_READ(I32, i32, 100430199)
    TEST_READ(I32, i32, -534534)
    float f;
    CORE_TEST_FALSE(coreReadInPacketFloat(&in, &f));
    CORE_TEST_FLOAT(64564.5346f, f, 0.00001f);
    char buffer[256];
    size_t n = coreReadInPacketString(&in, buffer, sizeof(buffer));
    CORE_TEST_SIZE(14, n);
    CORE_TEST_STRING(s, buffer);

    CORE_TEST_TRUE(coreReadInPacketU8(&in, &(u8){0}));
    CORE_TEST_TRUE(coreReadInPacketU16(&in, &(u16){0}));
    CORE_TEST_TRUE(coreReadInPacketU32(&in, &(u32){0}));
    CORE_TEST_TRUE(coreReadInPacketI8(&in, &(i8){0}));
    CORE_TEST_TRUE(coreReadInPacketI16(&in, &(i16){0}));
    CORE_TEST_TRUE(coreReadInPacketI32(&in, &(i32){0}));
    CORE_TEST_TRUE(coreReadInPacketFloat(&in, &(float){0}));
    CORE_TEST_SIZE(0, coreReadInPacketString(&in, nullptr, 0));
    CORE_TEST_SIZE(0, coreReadInPacketString(&in, buffer, sizeof(buffer)));

    coreDestroyOutPacket(&out);
}

static void testTooShortBuffer(void) {
    CoreOutPacket out;
    coreInitOutPacket(&out);
    coreWriteOutPacketString(&out, "This is Great");
    coreWriteOutPacketString(&out, "Well hoho");

    CoreInPacket in;
    coreInitInPacket(&in, out.data.buffer, out.data.size);
    char buffer[8];
    size_t n = coreReadInPacketString(&in, buffer, sizeof(buffer));
    CORE_TEST_SIZE(14, n);
    CORE_TEST_STRING("This is", buffer);
    char buffer2[6];
    size_t n2 = coreReadInPacketString(&in, buffer2, sizeof(buffer2));
    CORE_TEST_SIZE(10, n2);
    CORE_TEST_STRING("Well ", buffer2);

    coreDestroyOutPacket(&out);
}

typedef struct {
    u8 a;
    u8 b;
} PacketTest;

static void testBinaryData(void) {
    CoreOutPacket out;
    coreInitOutPacket(&out);
    PacketTest data = {56, 3};
    coreWriteOutPacket(&out, &data, sizeof(data));

    CoreInPacket in;
    coreInitInPacket(&in, out.data.buffer, out.data.size);

    PacketTest inData;
    CORE_TEST_FALSE(coreReadInPacket(&in, &inData, sizeof(inData)));
    CORE_TEST_TRUE(memcmp(&inData, &data, sizeof(inData)) == 0);

    coreDestroyOutPacket(&out);
}

static void testShortString(void) {
    CoreOutPacket out;
    coreInitOutPacket(&out);
    coreWriteOutPacketU16(&out, 200);
    coreWriteOutPacketU16(&out, 65535);

    CoreInPacket in;
    coreInitInPacket(&in, out.data.buffer, out.data.size);

    char buffer[256];
    size_t n = coreReadInPacketString(&in, buffer, sizeof(buffer));
    CORE_TEST_SIZE(200, n);
    CORE_TEST_STRING("", buffer);

    coreDestroyOutPacket(&out);
}

static void tickClient(int ticks) {
    for(int i = 0; i < ticks; i++) {
        coreTickClient();
    }
}

static void tick(int ticks) {
    for(int i = 0; i < ticks; i++) {
        coreTickClient();
        coreTickServer();
    }
}

static bool clientConnected = false;
static bool clientDisconnected = false;
static bool clientPackage = false;
static int packageCounter = 0;
static bool serverConnected = false;
static bool serverDisconnect = false;
static u8 data1 = 0;
static u16 data2 = 0;
static u32 data3 = 0;
static i8 data4 = 0;
static i16 data5 = 0;
static i32 data6 = 0;
static i8 data7 = 0;
static i16 data8 = 0;
static i32 data9 = 0;
static char data10[20];
static float data11 = 0.0f;

static void onServerConnect(CoreClient) {
    serverConnected = true;
}

static void onServerDisconnect(CoreClient) {
    serverDisconnect = true;
}

static void onServerPacket(CoreClient client, CoreInPacket* in) {
    CORE_TEST_FALSE(coreReadInPacketU8(in, &data1));
    CORE_TEST_FALSE(coreReadInPacketU16(in, &data2));
    CORE_TEST_FALSE(coreReadInPacketU32(in, &data3));
    CORE_TEST_FALSE(coreReadInPacketI8(in, &data4));
    CORE_TEST_FALSE(coreReadInPacketI16(in, &data5));
    CORE_TEST_FALSE(coreReadInPacketI32(in, &data6));
    CORE_TEST_FALSE(coreReadInPacketI8(in, &data7));
    CORE_TEST_FALSE(coreReadInPacketI16(in, &data8));
    CORE_TEST_FALSE(coreReadInPacketI32(in, &data9));
    CORE_TEST_SIZE(9, coreReadInPacketString(in, data10, sizeof(data10)));
    CORE_TEST_FALSE(coreReadInPacketFloat(in, &data11));

    CoreOutPacket out;
    coreInitOutPacket(&out);
    if(packageCounter == 0) {
        coreSendServerPacket(client, &out, CORE_RELIABLE);
    } else if(packageCounter == 1) {
        coreSendServerPacket(client, &out, CORE_SEQUENCED);
    } else if(packageCounter == 2) {
        coreSendServerPacket(client, &out, CORE_UNSEQUENCED);
    }
    coreDestroyOutPacket(&out);
    packageCounter++;
}

static void onClientConnect() {
    clientConnected = true;
}

static void onClientDisconnect() {
    clientDisconnected = true;
}

static void onClientPacket(CoreInPacket*) {
    clientPackage = true;
}

static void testConnect(CorePacketSendMode mode) {
    clientConnected = false;
    clientDisconnected = false;
    clientPackage = false;
    serverConnected = false;
    serverDisconnect = false;
    data1 = 0;
    data2 = 0;
    data3 = 0;
    data4 = 0;
    data5 = 0;
    data6 = 0;
    data7 = 0;
    data8 = 0;
    data9 = 0;
    *data10 = '\0';
    data11 = 0.0f;

    coreResetServerHandler();
    coreSetServerConnectHandler(onServerConnect);
    coreSetServerDisconnectHandler(onServerDisconnect);
    coreSetServerPacketHandler(onServerPacket);

    coreResetClientHandler();
    coreSetClientConnectHandler(onClientConnect);
    coreSetClientDisconnectHandler(onClientDisconnect);
    coreSetClientPacketHandler(onClientPacket);

    if(!CORE_TEST_FALSE(coreStartServer(54321, 5))) {
        return;
    } else if(!CORE_TEST_FALSE(coreStartClient())) {
        return;
    } else if(!CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 90))) {
        return;
    }
    CORE_TEST_FALSE(coreIsClientConnected());
    CORE_TEST_TRUE(coreIsClientConnecting());
    tick(100);
    CORE_TEST_TRUE(clientConnected);
    CORE_TEST_TRUE(coreIsClientConnected());
    CORE_TEST_FALSE(coreIsClientConnecting());

    CoreOutPacket out;
    coreInitOutPacket(&out);
    coreWriteOutPacketU8(&out, 0xF1);
    coreWriteOutPacketU16(&out, 0xF123);
    coreWriteOutPacketU32(&out, 0xF1234567);
    coreWriteOutPacketI8(&out, -0x71);
    coreWriteOutPacketI16(&out, -0x7123);
    coreWriteOutPacketI32(&out, -0x71234567);
    coreWriteOutPacketI8(&out, 0x71);
    coreWriteOutPacketI16(&out, 0x7123);
    coreWriteOutPacketI32(&out, 0x71234567);
    const char s[] = "Hi there";
    coreWriteOutPacketString(&out, s);
    coreWriteOutPacketFloat(&out, 252345.983f);
    coreSendClientPacket(&out, mode);
    coreDestroyOutPacket(&out);

    tick(100);

    CORE_TEST_TRUE(clientPackage);
    CORE_TEST_TRUE(serverConnected);

    CORE_TEST_U64(0xF1, data1);
    CORE_TEST_U64(0xF123, data2);
    CORE_TEST_U64(0xF1234567, data3);
    CORE_TEST_I64(-0x71, data4);
    CORE_TEST_I64(-0x7123, data5);
    CORE_TEST_I64(-0x71234567, data6);
    CORE_TEST_I64(0x71, data7);
    CORE_TEST_I64(0x7123, data8);
    CORE_TEST_I64(0x71234567, data9);
    CORE_TEST_STRING(s, data10);
    CORE_TEST_FLOAT(252345.983f, data11, 0.01f);

    coreDisconnectClient(90);
    CORE_TEST_FALSE(coreIsClientConnected());
    CORE_TEST_FALSE(coreIsClientConnecting());
    tick(100);
    CORE_TEST_TRUE(clientDisconnected);
    CORE_TEST_TRUE(serverDisconnect);

    coreStopClient();
    coreStopServer();
}

static bool disconnected = false;

static void testStopDisconnect(void) {
    disconnected = true;
}

static void testDisconnect(void) {
    disconnected = false;
    coreResetClientHandler();
    coreSetClientDisconnectHandler(testStopDisconnect);
    if(!CORE_TEST_FALSE(coreStartClient())) {
        return;
    } else if(!CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 90))) {
        return;
    }
    CORE_TEST_FALSE(coreIsClientConnected());
    CORE_TEST_TRUE(coreIsClientConnecting());
    coreDisconnectClient(50);
    tickClient(100);
    CORE_TEST_FALSE(coreIsClientConnected());
    CORE_TEST_FALSE(coreIsClientConnecting());
    CORE_TEST_TRUE(disconnected);
    coreStopClient();
}

static void testStop(void) {
    disconnected = false;
    coreResetClientHandler();
    coreSetClientDisconnectHandler(testStopDisconnect);
    if(!CORE_TEST_FALSE(coreStartClient())) {
        return;
    } else if(!CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 90))) {
        return;
    }
    CORE_TEST_FALSE(coreIsClientConnected());
    CORE_TEST_TRUE(coreIsClientConnecting());
    coreStopClient();
    CORE_TEST_FALSE(coreIsClientConnected());
    CORE_TEST_FALSE(coreIsClientConnecting());
    CORE_TEST_TRUE(disconnected);
}

static void testClientStartFails(void) {
    CORE_TEST_FALSE(coreStartClient());
    logLevel = LOG_NONE;
    CORE_TEST_TRUE(coreStartClient());
    coreStopClient();
#ifdef ERROR_SIMULATOR
    coreFailCounter = 0;
    CORE_TEST_TRUE(coreStartClient());
    coreFailCounter = 1;
    CORE_TEST_TRUE(coreStartClient());
    coreFailCounter = -1;
#endif
    logLevel = LOG_DEBUG;
}

static void testClientConnectionFails(void) {
    coreResetClientHandler();
    logLevel = LOG_NONE;
    CORE_TEST_TRUE(coreConnectClient("", 54321, 100));
    CORE_TEST_FALSE(coreStartClient());
#ifdef ERROR_SIMULATOR
    coreFailCounter = 0;
    CORE_TEST_TRUE(coreConnectClient("", 54321, 100));
    coreFailCounter = -1;
#endif
    CORE_TEST_FALSE(coreConnectClient("", 54321, 100));
    CORE_TEST_TRUE(coreConnectClient("", 54321, 100));
    logLevel = LOG_DEBUG;
    tickClient(100);
    coreStopClient();
}

static void testInvalidClientAccess(void) {
    coreDisconnectClient(0);
    coreSendClientPacket(nullptr, 0);
    coreTickClient();
}

static void testServerStartFails(void) {
    logLevel = LOG_NONE;
    CORE_TEST_TRUE(coreStartServer(54321, 0));
#ifdef ERROR_SIMULATOR
    coreFailCounter = 0;
    CORE_TEST_TRUE(coreStartServer(54321, 5));
    coreFailCounter = 1;
    CORE_TEST_TRUE(coreStartServer(54321, 5));
    coreFailCounter = -1;
#endif
    CORE_TEST_FALSE(coreStartServer(54321, 5));
    CORE_TEST_TRUE(coreStartServer(54321, 5));
    logLevel = LOG_DEBUG;
    coreStopServer();
}

static void testServerClosesOnConnected(void) {
    clientDisconnected = false;
    CORE_TEST_FALSE(coreStartServer(54321, 5));
    CORE_TEST_FALSE(coreStartClient());
    coreSetClientDisconnectHandler(onClientDisconnect);
    CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 50));
    tick(100);
    CORE_TEST_TRUE(coreIsClientConnected());
    coreStopServer();

    coreSetClientTimeout(500, 500, 500);
    for(int i = 0; i < 500 && coreIsClientConnected(); i++) {
        coreTickClient();
        coreSleepNanos(10000000);
    }
    CORE_TEST_FALSE(coreIsClientConnected());
    CORE_TEST_TRUE(clientDisconnected);
    coreStopClient();
}

static CoreClient clientId = 0;

static void onConnectSetClient(CoreClient client) {
    clientId = client;
}

static void testServerDisconnectsClient(void) {
    clientDisconnected = false;
    CORE_TEST_FALSE(coreStartServer(54321, 5));
    CORE_TEST_FALSE(coreStartClient());
    coreSetClientDisconnectHandler(onClientDisconnect);
    coreSetServerConnectHandler(onConnectSetClient);
    CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 50));
    tick(100);
    CORE_TEST_TRUE(coreIsClientConnected());

    coreDisconnectServerClient(clientId);

    for(int i = 0; i < 500 && coreIsClientConnected(); i++) {
        coreTickClient();
        coreTickServer();
        coreSleepNanos(10000000);
    }
    CORE_TEST_FALSE(coreIsClientConnected());
    CORE_TEST_TRUE(clientDisconnected);
    coreStopClient();
    coreStopServer();
}

static void onConnectSetTimeout(CoreClient client) {
    coreServerTimeout(client, 500, 500, 500);
}

static void testClientClosesOnConnected(void) {
    serverDisconnect = false;
    CORE_TEST_FALSE(coreStartServer(54321, 5));
    CORE_TEST_FALSE(coreStartClient());
    coreSetServerDisconnectHandler(onServerDisconnect);
    coreSetServerConnectHandler(onConnectSetTimeout);
    CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 50));
    tick(100);
    CORE_TEST_TRUE(coreIsClientConnected());
#ifdef ERROR_SIMULATOR
    coreFailCounter = 0;
#endif
    coreStopClient();
#ifdef ERROR_SIMULATOR
    coreFailCounter = -1;
#endif
    for(int i = 0; i < 500 && !serverDisconnect; i++) {
        coreTickServer();
        coreSleepNanos(10000000);
    }
    CORE_TEST_TRUE(serverDisconnect);
    coreStopServer();
}

static void testInvalidServerAccess(void) {
    coreTickServer();
    coreSendServerPacket(0, nullptr, 0);
    coreServerTimeout(0, 500, 500, 500);
    coreDisconnectServerClient(0);
}

static void testDummyCallbacks(void) {
    coreResetClientHandler();
    coreResetServerHandler();
    CORE_TEST_FALSE(coreStartServer(54321, 5));
    CORE_TEST_FALSE(coreStartClient());
    CORE_TEST_FALSE(coreConnectClient("127.0.0.1", 54321, 50));
    tick(100);
    CORE_TEST_TRUE(coreIsClientConnected());
    CoreOutPacket out;
    coreInitOutPacket(&out);
    coreSendServerPacketBroadcast(&out, CORE_RELIABLE);
    coreSendClientPacket(&out, CORE_RELIABLE);
    tick(100);
    coreDestroyOutPacket(&out);
    coreStopClient();
    coreStopServer();
}

void coreTestNetwork(void) {
    testWriteRead();
    testTooShortBuffer();
    testBinaryData();
    testShortString();
    testConnect(CORE_UNSEQUENCED);
    testConnect(CORE_SEQUENCED);
    testConnect(CORE_RELIABLE);
    testDisconnect();
    testStop();
    testClientStartFails();
    testClientConnectionFails();
    testInvalidClientAccess();
    testServerStartFails();
    testServerClosesOnConnected();
    testServerDisconnectsClient();
    testClientClosesOnConnected();
    testInvalidServerAccess();
    testDummyCallbacks();
}