#include <deerith/engine.h>
#include <deerith/network/router.h>
#include <deerith/client/world.h>

#include <enet/enet.h>
#include <thread>
#include <memory>

#include <deerith/client/network/network_internals.h>

namespace deerith
{
    ENetHost *client;
    ENetPeer *server_peer;

    std::unique_ptr<client_t> server_client;
}

deerith::client_t *deerith::get_server_client()
{
    return server_client.get();
}

void deerith::connect_to_server(const char *address, int port)
{
    ENetAddress eaddress = {0};
    eaddress.port = port;

    int result = enet_address_set_host(&eaddress, address);
    deerith_assert(result == 0, "connect_to_server invalid address");

    client = enet_host_create(NULL, 1, 2, 0, 0);
    deerith_assert(client, "connect_to_server failed to create host");

    server_peer = enet_host_connect(client, &eaddress, 2, 0);
    deerith_assert(server_peer, "enet_host_connect failed on connect_to_server");

    server_client = std::make_unique<client_t>(server_peer);
}

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

    setup_base_protocols();

    return 0;
}

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

void deerith::flush_network_events()
{
    ENetEvent event;
    while (enet_host_service(client, &event, 0) > 0)
    {
        switch (event.type)
        {
        case ENET_EVENT_TYPE_DISCONNECT:
            event.peer->data = NULL;
            break;

        case ENET_EVENT_TYPE_RECEIVE:
            ENetPacket *packet = event.packet;
            router_process_packet(packet->data, packet->dataLength, server_client.get());
            enet_packet_destroy(event.packet);
            break;
        }
    }
}

bool deerith::wait_till_connected_to_server()
{
    ENetEvent event;
    if (enet_host_service(client, &event, 5000) > 0 && event.type == ENET_EVENT_TYPE_CONNECT)
    {
        deerith_trace("connected to server");
        return true;
    }
    else
    {
        enet_peer_reset(server_peer);
        deerith_error("failed to connect to server");
        return false;
    }
}