#include <cassert>
#include <cstring>

#include "Packet.hh"

// XXX: assumes that sizeof(float32) == sizeof(int32);

/*
 * NetworkPacketInput
 */
template <typename T> T NetworkPacketInput::read_val (void) {
    T val;

    // read
    read(&val, sizeof(T));

    // return
    return val;
}

uint32_t NetworkPacketInput::read_uint32 (void) {
    return ntohl(read_val<uint32_t>());
}

uint16_t NetworkPacketInput::read_uint16 (void) {
    return ntohs(read_val<uint16_t>());
}

uint8_t NetworkPacketInput::read_uint8 (void) {
    return read_val<uint8_t>();
}

int32_t NetworkPacketInput::read_int32 (void) {
    return ntohl(read_val<int32_t>());
}

int16_t NetworkPacketInput::read_int16 (void) {
    return ntohs(read_val<int16_t>());
}

int8_t NetworkPacketInput::read_int8 (void) {
    return read_val<int8_t>();
}
        
float NetworkPacketInput::read_float32 (void) {
    int32_t ival = read_int32();
    float fval;
    
    assert(sizeof(ival) == sizeof(fval));

    memcpy(&fval, &ival, sizeof(float));

    return fval;
}

Vector NetworkPacketInput::read_vector (void) {
    float fx = read_float32();
    float fy = read_float32();

    return Vector(fx, fy);
}

/*
 * NetworkPacketOutput
 */
template <typename T> void NetworkPacketOutput::write_val (const T &val) {
    // write
    write(&val, sizeof(T));
}


void NetworkPacketOutput::write_uint32 (uint32_t val) {
    write_val<uint32_t>(htonl(val));
}

void NetworkPacketOutput::write_uint16 (uint16_t val) {
    write_val<uint16_t>(htons(val));
}

void NetworkPacketOutput::write_uint8 (uint8_t val) {
    write_val<uint8_t>(val);
}

void NetworkPacketOutput::write_int32 (int32_t val) {
    write_val<int32_t>(htonl(val));
}

void NetworkPacketOutput::write_int16 (int16_t val) {
    write_val<int16_t>(htons(val));
}

void NetworkPacketOutput::write_int8 (int8_t val) {
    write_val<int8_t>(val);
}
        
void NetworkPacketOutput::write_float32 (float fval) {
    int32_t ival;

    assert(sizeof(ival) == sizeof(fval));

    memcpy(&ival, &fval, sizeof(int32_t));

    write_int32(ival);
}

void NetworkPacketOutput::write_vector (const Vector &vec) {
    write_float32(vec.x);
    write_float32(vec.y);
}

void NetworkPacketOutput::write_packet (const NetworkPacketBuffer &pkt) {
    // just write() it
    write(pkt.get_buf(), pkt.get_data_size());
}

/*
 * NetworkPacketBuffer
 */
NetworkPacketBuffer::NetworkPacketBuffer (char *buf_ptr, size_t buf_size, size_t data_size) :
    buf_ptr(buf_ptr), buf_size(buf_size), data_size(data_size), offset(0) {
    
    // nothing
    if (buf_ptr == NULL)
        throw NetworkPacketError("buf_ptr may not be NULL");
}

void NetworkPacketBuffer::check_write_size (size_t item_size) {
     if (offset + item_size > buf_size)
        throw NetworkPacketError("not enough space to write");

}
        
void NetworkPacketBuffer::check_read_size (size_t item_size) {
    if (offset + item_size > data_size)
        throw NetworkPacketError("not enough data to read");
}

void NetworkPacketBuffer::write (const void *ptr, size_t len) {
    // check buffer overflow
    check_write_size(len);

    // set value
    memcpy(buf_ptr + offset, ptr, len);

    // update offset and size
    offset += len;
    data_size += len;
}

void NetworkPacketBuffer::read (void *ptr, size_t len) {
    // check buffer underflow
    check_read_size(len);

    // set value
    memcpy(ptr, buf_ptr + offset, len);

    // update offset
    offset += len;
}

/*
 * NetworkPacket
 */
NetworkPacket::NetworkPacket (void) : 
    NetworkPacketBuffer(_buf, NETWORK_PACKET_SIZE, 0) 
{ 
    
}

/*
 * BigNetworkPacket
 */
BigNetworkPacket::BigNetworkPacket (size_t size) :
    NetworkPacketBuffer((char *) malloc(size), size, 0)
{

}

BigNetworkPacket::~BigNetworkPacket (void) {
    free(buf_ptr);
}