#include <deerith/core/log.h>
#include <enet/enet.h>

#include <deerith/core/log.h>

#include <thread>
#include <vector>

#include "network_internals.h"

namespace deerith
{
    ENetHost *server;

    std::vector<ENetPeer *> new_clients;
}

bool deerith::init_server(int port)
{
    ENetAddress address = {0};

    address.host = ENET_HOST_ANY;
    address.port = port;

    server = enet_host_create(&address, 32, 2, 0, 0);

    if (server == nullptr)
    {
        deerith_error("init_server failed");
        return false;
    }
    return true;
}

int deerith::init_network()
{
    if (enet_initialize() != 0)
    {
        deerith_error("An error occurred while initializing ENet.\n");
        return 1;
    }

    return 0;
}

void deerith::shutdown_network()
{
    enet_deinitialize();
}

std::vector<ENetPeer *> &deerith::get_new_clients()
{
    return new_clients;
}

void deerith::flush_network_events()
{
    ENetEvent event;
    new_clients.clear();

    int result = 1;
    while ((result = enet_host_service(server, &event, 0)) > 0)
    {
        switch (event.type)
        {
        case ENET_EVENT_TYPE_CONNECT:
            new_clients.push_back(event.peer);
            break;

        case ENET_EVENT_TYPE_DISCONNECT:
            event.peer->data = NULL;
            break;

        case ENET_EVENT_TYPE_RECEIVE:
            printf("A packet of length %lu containing %s was received from %s on channel %u.\n",
                   event.packet->dataLength,
                   event.packet->data,
                   event.peer->data,
                   event.channelID);

            enet_packet_destroy(event.packet);
            break;

        case ENET_EVENT_TYPE_NONE:
            break;
        }
    }
}