#include "packet.h"

struct nn_packet *nn_packet_create(void)
{
    struct nn_packet *packet = al_alloc_object(struct nn_packet);
    nn_buffer_init(&packet->buffer);
    nn_packet_reset(packet);
    return packet;
}

struct nn_packet *nn_packet_clone(struct nn_packet *packet)
{
    al_assert(packet->buffer.alloc >= NNWT_PACKET_HEADER_LENGTH);
    struct nn_packet *c = nn_packet_create();
    u32 size = nn_packet_get_size(packet);
    nn_buffer_ensure_space(&c->buffer, size);
    al_memcpy(nn_buffer_get_ptr(&c->buffer, 0), nn_buffer_get_ptr(&packet->buffer, 0), size);
    c->windex = packet->windex;
    c->rindex = packet->rindex;
    c->opaque = packet->opaque;
    return c;
}

void nn_packet_reset(struct nn_packet *packet)
{
    nn_buffer_ensure_space(&packet->buffer, NNWT_PACKET_HEADER_LENGTH);
    packet->rindex = NNWT_PACKET_HEADER_LENGTH;
    packet->windex = NNWT_PACKET_HEADER_LENGTH;
    packet->opaque = NULL;
}

void nn_packet_write_size(struct nn_packet *packet)
{
    struct nn_buffer *buffer = &packet->buffer;
    al_assert(buffer->alloc >= packet->windex);
    buffer->size = packet->windex;
    if (buffer->size < buffer->alloc / 2) {
        nn_buffer_shrink_to_size(buffer);
    }
    nn_buffer_write(buffer, &packet->windex, 0, sizeof(u32));
}

u32 nn_packet_get_size(struct nn_packet *packet)
{
    return nn_packet_get_u32(packet, 0);
}

#define DEFINE_PACKET_WRITE_FUNC(type) \
    void nn_packet_write_##type(struct nn_packet *packet, type v) \
    { \
        NNWT_PACKET_WRITE_TYPE(packet, type, v); \
    }

DEFINE_PACKET_WRITE_FUNC(u8)
DEFINE_PACKET_WRITE_FUNC(s8)
DEFINE_PACKET_WRITE_FUNC(u16)
DEFINE_PACKET_WRITE_FUNC(s16)
DEFINE_PACKET_WRITE_FUNC(u32)
DEFINE_PACKET_WRITE_FUNC(s32)
DEFINE_PACKET_WRITE_FUNC(u64)
DEFINE_PACKET_WRITE_FUNC(s64)
DEFINE_PACKET_WRITE_FUNC(f32)
DEFINE_PACKET_WRITE_FUNC(f64)

void nn_packet_write_bool(struct nn_packet *packet, bool v)
{
    u8 byte = v ? 1 : 0;
    NNWT_PACKET_WRITE_TYPE(packet, u8, byte);
}

void nn_packet_write_str(struct nn_packet *packet, str *s)
{
    NNWT_PACKET_WRITE_TYPE(packet, u32, s->length);
    NNWT_PACKET_WRITE_DATA(packet, s->data, s->length);
}

void nn_packet_write_buffer(struct nn_packet *packet, struct nn_buffer *buf)
{
    u64 size = (u64)buf->size;
    NNWT_PACKET_WRITE_TYPE(packet, u64, size);
    NNWT_PACKET_WRITE_DATA(packet, nn_buffer_get_ptr(buf, 0), buf->size);
}

#define DEFINE_PACKET_READ_FUNC(type) \
    type nn_packet_read_##type(struct nn_packet *packet) \
    { \
        type r; \
        NNWT_PACKET_READ_TYPE(packet, type, r); \
        return r; \
    }

DEFINE_PACKET_READ_FUNC(u8)
DEFINE_PACKET_READ_FUNC(s8)
DEFINE_PACKET_READ_FUNC(u16)
DEFINE_PACKET_READ_FUNC(s16)
DEFINE_PACKET_READ_FUNC(u32)
DEFINE_PACKET_READ_FUNC(s32)
DEFINE_PACKET_READ_FUNC(u64)
DEFINE_PACKET_READ_FUNC(s64)
DEFINE_PACKET_READ_FUNC(f32)
DEFINE_PACKET_READ_FUNC(f64)

bool nn_packet_read_bool(struct nn_packet *packet)
{
    u8 byte;
    NNWT_PACKET_READ_TYPE(packet, u8, byte);
    return byte == 1;
}

void nn_packet_read_str(struct nn_packet *packet, str *s)
{
    NNWT_PACKET_READ_TYPE(packet, u32, s->length);
    NNWT_PACKET_READ_DATA(packet, s->length, s->data);
    s->alloc = 0;
}

void nn_packet_read_buffer(struct nn_packet *packet, struct nn_buffer *buf)
{
    u64 size;
    NNWT_PACKET_READ_TYPE(packet, u64, size);
    al_assert(sizeof(size_t) > 4 || size <= INT32_MAX);
    buf->size = (size_t)size;
    NNWT_PACKET_READ_DATA(packet, buf->size, buf->data);
    buf->alloc = 0;
}

void nn_packet_write_wstr(struct nn_packet *packet, wstr *w)
{
    NNWT_PACKET_WRITE_TYPE(packet, u32, w->length);
    NNWT_PACKET_WRITE_DATA(packet, w->data, w->length * sizeof(wchar_t));
}

void nn_packet_read_wstr(struct nn_packet *packet, wstr *w)
{
    NNWT_PACKET_READ_TYPE(packet, u32, w->length);
    NNWT_PACKET_READ_DATA(packet, w->length * sizeof(wchar_t), w->data);
    w->alloc = 0;
}

void nn_packet_free(struct nn_packet *packet)
{
    nn_buffer_free(&packet->buffer);
    al_free(packet);
}