#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(coreInPacketRead##Type(&in, &u));                      \
        CORE_TEST_TRUE(u == value);                                            \
    }

static void testWriteRead(void) {
    CoreOutPacket out;
    coreInitOutPacket(&out);
    coreOutPacketWriteU8(&out, 200);
    coreOutPacketWriteU16(&out, 6656);
    coreOutPacketWriteU32(&out, 348923689);
    coreOutPacketWriteI8(&out, 90);
    coreOutPacketWriteI8(&out, -35);
    coreOutPacketWriteI16(&out, 843);
    coreOutPacketWriteI16(&out, -8961);
    coreOutPacketWriteI32(&out, 100430199);
    coreOutPacketWriteI32(&out, -534534);
    coreOutPacketWriteFloat(&out, 64564.5346f);
    const char s[] = "This is Great";
    coreOutPacketWriteString(&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(coreInPacketReadFloat(&in, &f));
    CORE_TEST_FLOAT(64564.5346f, f, 0.00001f);
    char buffer[256];
    size_t n = coreInPacketReadString(&in, buffer, sizeof(buffer));
    CORE_TEST_SIZE(14, n);
    CORE_TEST_STRING(s, buffer);

    CORE_TEST_TRUE(coreInPacketReadU8(&in, &(u8){0}));
    CORE_TEST_TRUE(coreInPacketReadU16(&in, &(u16){0}));
    CORE_TEST_TRUE(coreInPacketReadU32(&in, &(u32){0}));
    CORE_TEST_TRUE(coreInPacketReadI8(&in, &(i8){0}));
    CORE_TEST_TRUE(coreInPacketReadI16(&in, &(i16){0}));
    CORE_TEST_TRUE(coreInPacketReadI32(&in, &(i32){0}));
    CORE_TEST_TRUE(coreInPacketReadFloat(&in, &(float){0}));
    CORE_TEST_SIZE(0, coreInPacketReadString(&in, nullptr, 0));
    CORE_TEST_SIZE(0, coreInPacketReadString(&in, buffer, sizeof(buffer)));

    coreDestroyOutPacket(&out);
}

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

    CoreInPacket in;
    coreInitInPacket(&in, out.data.buffer, out.data.size);
    char buffer[8];
    size_t n = coreInPacketReadString(&in, buffer, sizeof(buffer));
    CORE_TEST_SIZE(14, n);
    CORE_TEST_STRING("This is", buffer);
    char buffer2[6];
    size_t n2 = coreInPacketReadString(&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};
    coreOutPacketWrite(&out, &data, sizeof(data));

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

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

    coreDestroyOutPacket(&out);
}

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

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

    char buffer[256];
    size_t n = coreInPacketReadString(&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++) {
        coreClientTick();
    }
}

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

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(coreInPacketReadU8(in, &data1));
    CORE_TEST_FALSE(coreInPacketReadU16(in, &data2));
    CORE_TEST_FALSE(coreInPacketReadU32(in, &data3));
    CORE_TEST_FALSE(coreInPacketReadI8(in, &data4));
    CORE_TEST_FALSE(coreInPacketReadI16(in, &data5));
    CORE_TEST_FALSE(coreInPacketReadI32(in, &data6));
    CORE_TEST_FALSE(coreInPacketReadI8(in, &data7));
    CORE_TEST_FALSE(coreInPacketReadI16(in, &data8));
    CORE_TEST_FALSE(coreInPacketReadI32(in, &data9));
    CORE_TEST_SIZE(9, coreInPacketReadString(in, data10, sizeof(data10)));
    CORE_TEST_FALSE(coreInPacketReadFloat(in, &data11));

    CoreOutPacket out;
    coreInitOutPacket(&out);
    if(packageCounter == 0) {
        coreServerSend(client, &out, CORE_RELIABLE);
    } else if(packageCounter == 1) {
        coreServerSend(client, &out, CORE_SEQUENCED);
    } else if(packageCounter == 2) {
        coreServerSend(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;

    coreServerResetHandler();
    coreServerSetConnectHandler(onServerConnect);
    coreServerSetDisconnectHandler(onServerDisconnect);
    coreServerSetPacketHandler(onServerPacket);

    coreClientResetHandler();
    coreClientSetConnectHandler(onClientConnect);
    coreClientSetDisconnectHandler(onClientDisconnect);
    coreClientSetPacketHandler(onClientPacket);

    if(!CORE_TEST_FALSE(coreServerStart(54321, 5))) {
        return;
    } else if(!CORE_TEST_FALSE(coreClientStart())) {
        return;
    } else if(!CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 90))) {
        return;
    }
    CORE_TEST_FALSE(coreClientIsConnected());
    CORE_TEST_TRUE(coreClientIsConnecting());
    tick(100);
    CORE_TEST_TRUE(clientConnected);
    CORE_TEST_TRUE(coreClientIsConnected());
    CORE_TEST_FALSE(coreClientIsConnecting());

    CoreOutPacket out;
    coreInitOutPacket(&out);
    coreOutPacketWriteU8(&out, 0xF1);
    coreOutPacketWriteU16(&out, 0xF123);
    coreOutPacketWriteU32(&out, 0xF1234567);
    coreOutPacketWriteI8(&out, -0x71);
    coreOutPacketWriteI16(&out, -0x7123);
    coreOutPacketWriteI32(&out, -0x71234567);
    coreOutPacketWriteI8(&out, 0x71);
    coreOutPacketWriteI16(&out, 0x7123);
    coreOutPacketWriteI32(&out, 0x71234567);
    const char s[] = "Hi there";
    coreOutPacketWriteString(&out, s);
    coreOutPacketWriteFloat(&out, 252345.983f);
    coreClientSend(&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);

    coreClientDisconnect(90);
    CORE_TEST_FALSE(coreClientIsConnected());
    CORE_TEST_FALSE(coreClientIsConnecting());
    tick(100);
    CORE_TEST_TRUE(clientDisconnected);
    CORE_TEST_TRUE(serverDisconnect);

    coreClientStop();
    coreServerStop();
}

static bool disconnected = false;

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

static void testDisconnect(void) {
    disconnected = false;
    coreClientResetHandler();
    coreClientSetDisconnectHandler(testStopDisconnect);
    if(!CORE_TEST_FALSE(coreClientStart())) {
        return;
    } else if(!CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 90))) {
        return;
    }
    CORE_TEST_FALSE(coreClientIsConnected());
    CORE_TEST_TRUE(coreClientIsConnecting());
    coreClientDisconnect(50);
    tickClient(100);
    CORE_TEST_FALSE(coreClientIsConnected());
    CORE_TEST_FALSE(coreClientIsConnecting());
    CORE_TEST_TRUE(disconnected);
    coreClientStop();
}

static void testStop(void) {
    disconnected = false;
    coreClientResetHandler();
    coreClientSetDisconnectHandler(testStopDisconnect);
    if(!CORE_TEST_FALSE(coreClientStart())) {
        return;
    } else if(!CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 90))) {
        return;
    }
    CORE_TEST_FALSE(coreClientIsConnected());
    CORE_TEST_TRUE(coreClientIsConnecting());
    coreClientStop();
    CORE_TEST_FALSE(coreClientIsConnected());
    CORE_TEST_FALSE(coreClientIsConnecting());
    CORE_TEST_TRUE(disconnected);
}

static void testClientStartFails(void) {
    CORE_TEST_FALSE(coreClientStart());
    CORE_TEST_TRUE(coreClientStart());
    coreClientStop();
#ifdef ERROR_SIMULATOR
    coreFailCounter = 0;
    CORE_TEST_TRUE(coreClientStart());
    coreFailCounter = 1;
    CORE_TEST_TRUE(coreClientStart());
    coreFailCounter = -1;
#endif
}

static void testClientConnectionFails(void) {
    coreClientResetHandler();
    CORE_TEST_TRUE(coreClientConnect("", 54321, 100));
    CORE_TEST_FALSE(coreClientStart());
#ifdef ERROR_SIMULATOR
    coreFailCounter = 0;
    CORE_TEST_TRUE(coreClientConnect("", 54321, 100));
    coreFailCounter = -1;
#endif
    CORE_TEST_FALSE(coreClientConnect("", 54321, 100));
    CORE_TEST_TRUE(coreClientConnect("", 54321, 100));
    tickClient(100);
    coreClientStop();
}

static void testInvalidClientAccess(void) {
    coreClientDisconnect(0);
    coreClientSend(nullptr, 0);
    coreClientTick();
}

static void testServerStartFails(void) {
    CORE_TEST_TRUE(coreServerStart(54321, 0));
#ifdef ERROR_SIMULATOR
    coreFailCounter = 0;
    CORE_TEST_TRUE(coreServerStart(54321, 5));
    coreFailCounter = 1;
    CORE_TEST_TRUE(coreServerStart(54321, 5));
    coreFailCounter = -1;
#endif
    CORE_TEST_FALSE(coreServerStart(54321, 5));
    CORE_TEST_TRUE(coreServerStart(54321, 5));
    coreServerStop();
}

static void testServerClosesOnConnected(void) {
    clientDisconnected = false;
    CORE_TEST_FALSE(coreServerStart(54321, 5));
    CORE_TEST_FALSE(coreClientStart());
    coreClientSetDisconnectHandler(onClientDisconnect);
    CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 50));
    tick(100);
    CORE_TEST_TRUE(coreClientIsConnected());
    coreServerStop();

    coreClientTimeout(500, 500, 500);
    for(int i = 0; i < 500 && coreClientIsConnected(); i++) {
        coreClientTick();
        coreSleep(10000000);
    }
    CORE_TEST_FALSE(coreClientIsConnected());
    CORE_TEST_TRUE(clientDisconnected);
    coreClientStop();
}

static CoreClient clientId = 0;

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

static void testServerDisconnectsClient(void) {
    clientDisconnected = false;
    CORE_TEST_FALSE(coreServerStart(54321, 5));
    CORE_TEST_FALSE(coreClientStart());
    coreClientSetDisconnectHandler(onClientDisconnect);
    coreServerSetConnectHandler(onConnectSetClient);
    CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 50));
    tick(100);
    CORE_TEST_TRUE(coreClientIsConnected());

    coreServerDisconnect(clientId);

    for(int i = 0; i < 500 && coreClientIsConnected(); i++) {
        coreClientTick();
        coreServerTick();
        coreSleep(10000000);
    }
    CORE_TEST_FALSE(coreClientIsConnected());
    CORE_TEST_TRUE(clientDisconnected);
    coreClientStop();
    coreServerStop();
}

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

static void testClientClosesOnConnected(void) {
    serverDisconnect = false;
    CORE_TEST_FALSE(coreServerStart(54321, 5));
    CORE_TEST_FALSE(coreClientStart());
    coreServerSetDisconnectHandler(onServerDisconnect);
    coreServerSetConnectHandler(onConnectSetTimeout);
    CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 50));
    tick(100);
    CORE_TEST_TRUE(coreClientIsConnected());
#ifdef ERROR_SIMULATOR
    coreFailCounter = 0;
#endif
    coreClientStop();
#ifdef ERROR_SIMULATOR
    coreFailCounter = -1;
#endif
    for(int i = 0; i < 500 && !serverDisconnect; i++) {
        coreServerTick();
        coreSleep(10000000);
    }
    CORE_TEST_TRUE(serverDisconnect);
    coreServerStop();
}

static void testInvalidServerAccess(void) {
    coreServerTick();
    coreServerSend(0, nullptr, 0);
    coreServerTimeout(0, 500, 500, 500);
    coreServerDisconnect(0);
}

static void testDummyCallbacks(void) {
    coreClientResetHandler();
    coreServerResetHandler();
    CORE_TEST_FALSE(coreServerStart(54321, 5));
    CORE_TEST_FALSE(coreClientStart());
    CORE_TEST_FALSE(coreClientConnect("127.0.0.1", 54321, 50));
    tick(100);
    CORE_TEST_TRUE(coreClientIsConnected());
    CoreOutPacket out;
    coreInitOutPacket(&out);
    coreServerSendAll(&out, CORE_RELIABLE);
    coreClientSend(&out, CORE_RELIABLE);
    tick(100);
    coreDestroyOutPacket(&out);
    coreClientStop();
    coreServerStop();
}

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();
}