#include <string.h>

#include "../Tests.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, sizeof(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);
    const char s[] = "This is Great";
    coreOutPacketWriteString(&out, s, sizeof(s));
    const char s2[] = "Well hoho";
    coreOutPacketWriteString(&out, s2, sizeof(s2));

    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 bool checkError(Test& test, const Error e, const char* msg) {
    if(e.has()) {
        test.checkFalse(true, msg);
        return true;
    }
    return false;
}

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

static void tick(int ticks) {
    for(int i = 0; i < ticks; i++) {
        Client::tick();
        Server::tick();
    }
}

static void testConnect(Test& test, PacketSendMode mode) {
    static bool clientConnected = false;
    static bool clientDisconnected = false;
    static bool clientPackage = false;
    clientConnected = false;
    clientDisconnected = false;
    clientPackage = false;

    static int packageCounter = 0;
    static bool serverConnected = false;
    static bool serverDisconnect = false;
    static uint8 data1 = 0;
    static uint16 data2 = 0;
    static uint32 data3 = 0;
    static int8 data4 = 0;
    static int16 data5 = 0;
    static int32 data6 = 0;
    static int8 data7 = 0;
    static int16 data8 = 0;
    static int32 data9 = 0;
    static StringBuffer<20> data10;
    static float data11 = 0.0f;
    static IntVector3 data12;
    static Vector3 data13;

    serverConnected = false;
    serverDisconnect = false;
    data1 = 0;
    data2 = 0;
    data3 = 0;
    data4 = 0;
    data5 = 0;
    data6 = 0;
    data7 = 0;
    data8 = 0;
    data9 = 0;
    data10.clear();
    data11 = 0.0f;
    data12 = IntVector3();
    data13 = Vector3();

    Server::resetHandler();
    Server::setConnectHandler([](Server::Client) { serverConnected = true; });
    Server::setDisconnectHandler(
        [](Server::Client) { serverDisconnect = true; });
    Server::setPacketHandler([](Server::Client client, InPacket& in) {
        in.read(data1);
        in.read(data2);
        in.read(data3);
        in.read(data4);
        in.read(data5);
        in.read(data6);
        in.read(data7);
        in.read(data8);
        in.read(data9);
        in.read(data10);
        in.read(data11);
        in.read(data12);
        in.read(data13);

        if(packageCounter == 0) {
            OutPacket out(0);
            Server::send(client, out, PacketSendMode::RELIABLE);
        } else if(packageCounter == 1) {
            OutPacket out(0);
            Server::send(client, out, PacketSendMode::SEQUENCED);
        } else if(packageCounter == 2) {
            OutPacket out(0);
            Server::send(client, out, PacketSendMode::UNSEQUENCED);
        }
        packageCounter++;
    });

    Client::resetHandler();
    Client::setConnectHandler([]() { clientConnected = true; });
    Client::setDisconnectHandler([]() { clientDisconnected = true; });
    Client::setPacketHandler([](InPacket&) { clientPackage = true; });

    if(checkError(test, Server::start(54321, 5), "server can initialize")) {
        return;
    } else if(checkError(test, Client::start(), "client can initialize")) {
        return;
    } else if(checkError(test, Client::connect("127.0.0.1", 54321, 90),
                         "start connection failed")) {
        return;
    }
    test.checkFalse(Client::isConnected(), "client not connected yet");
    test.checkTrue(Client::isConnecting(), "client is connecting");

    tick(100);

    test.checkTrue(clientConnected, "client called connect callback");
    test.checkTrue(Client::isConnected(), "client is connected");
    test.checkFalse(Client::isConnecting(), "client is no more connecting");

    OutPacket out(50);
    out.writeU8(0xF1).writeU16(0xF123).writeU32(0xF1234567);
    out.writeS8(-0x71).writeS16(-0x7123).writeS32(-0x71234567);
    out.writeS8(0x71).writeS16(0x7123).writeS32(0x71234567);
    StringBuffer<20> s("Hi there");
    out.writeString(s);
    out.writeFloat(252345.983f);
    out.writeVector(IntVector3(1, 2, 3));
    out.writeVector(Vector3(1.5f, 2.5f, 3.5f));
    Client::send(out, mode);

    tick(100);

    test.checkTrue(clientPackage, "client has received data");
    test.checkTrue(serverConnected, "server has connection");

    test.checkUnsigned8(0xF1, data1, "correct value is sent 1");
    test.checkUnsigned16(0xF123, data2, "correct value is sent 2");
    test.checkEqual(0xF1234567u, data3, "correct value is sent 3");
    test.checkSigned8(-0x71, data4, "correct value is sent 4");
    test.checkSigned16(-0x7123, data5, "correct value is sent 5");
    test.checkEqual(-0x71234567, data6, "correct value is sent 6");
    test.checkSigned8(0x71, data7, "correct value is sent 7");
    test.checkSigned16(0x7123, data8, "correct value is sent 8");
    test.checkEqual(0x71234567, data9, "correct value is sent 9");
    test.checkEqual(s, data10, "correct value is sent 10");
    test.checkFloat(252345.983f, data11, 0.01f, "correct value is sent 11");
    test.checkEqual(1, data12[0], "correct value is sent 12|1");
    test.checkEqual(2, data12[1], "correct value is sent 12|2");
    test.checkEqual(3, data12[2], "correct value is sent 12|3");
    test.checkFloat(1.5f, data13[0], 0.01f, "correct value is sent 13|1");
    test.checkFloat(2.5f, data13[1], 0.01f, "correct value is sent 13|2");
    test.checkFloat(3.5f, data13[2], 0.01f, "correct value is sent 13|3");

    Client::disconnect(90);
    test.checkFalse(Client::isConnected(), "client was disconnected");
    test.checkFalse(Client::isConnecting(), "client is not connecting");
    tick(100);
    test.checkTrue(clientDisconnected, "client has disconnected");
    test.checkTrue(serverDisconnect, "client has disconnected on server");

    Client::stop();
    Server::stop();
}

static void testDisconnect(Test& test) {
    static bool disconnected = false;
    disconnected = false;
    Client::resetHandler();
    Client::setDisconnectHandler([]() { disconnected = true; });
    if(checkError(test, Client::start(), "client can initialize")) {
        return;
    } else if(checkError(test, Client::connect("127.0.0.1", 54321, 90),
                         "start connection failed")) {
        return;
    }
    test.checkFalse(Client::isConnected(), "client not connected yet");
    test.checkTrue(Client::isConnecting(), "client is connecting");
    Client::disconnect(50);
    tickClient(100);
    test.checkFalse(Client::isConnected(), "client was disconnected");
    test.checkFalse(Client::isConnecting(), "client is not connecting");
    test.checkTrue(disconnected, "client has disconnected");
    Client::stop();
}

static void testStop(Test& test) {
    static bool disconnected = false;
    disconnected = false;
    Client::resetHandler();
    Client::setDisconnectHandler([]() { disconnected = true; });
    if(checkError(test, Client::start(), "client can initialize")) {
        return;
    } else if(checkError(test, Client::connect("127.0.0.1", 54321, 90),
                         "start connection failed")) {
        return;
    }
    test.checkFalse(Client::isConnected(), "client not connected yet");
    test.checkTrue(Client::isConnecting(), "client is connecting");
    Client::stop();
    test.checkFalse(Client::isConnected(), "client was disconnected");
    test.checkFalse(Client::isConnecting(), "client is not connecting");
    test.checkTrue(disconnected, "client has disconnected");
}*/

void coreTestNetwork() {
    testWriteRead();
    testTooShortBuffer();
    testBinaryData();
    testShortString();
    // testConnect(test, PacketSendMode::UNSEQUENCED);
    // testConnect(test, PacketSendMode::RELIABLE);
    // testConnect(test, PacketSendMode::SEQUENCED);
    // testDisconnect(test);
    // testStop(test);
}