#include "NetworkPacket.hh"


NetworkPacket::NetworkPacket (void) :
    buf_size(NETWORK_PACKET_SIZE), data_size(0), offset(0) {
    
    // nothing
}

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

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

template <typename T> T NetworkPacket::read_val (void) {
    T val;

    // check size
    check_read_size(sizeof(T));
    
    // set value
    val = *((T*) (buf + offset));

    // update offset
    offset += sizeof(T);

    // return
    return val;
}

template <typename T> void NetworkPacket::write_val (const T &val) {
    // check max size
    check_write_size(sizeof(T));
    
    // set value
    *((T*) (buf + offset)) = val;

    // update offset and size
    offset += sizeof(T);
    data_size += sizeof(T);
}

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

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

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

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

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

int8_t NetworkPacket::read_int8 (void) {
    return read_val<int8_t>();
}
        
float NetworkPacket::read_float32 (void) {
    /* XXX */
}

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

    return Vector(fx, fy);
}

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

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

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

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

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

void NetworkPacket::write_int8 (int8_t val) {
    write_val<int8_t>(val);
}
        
void write_float32 (float val) {
    /* XXX: */
}

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

void NetworkPacket::write_packet (const NetworkPacket &pkt) {
    // check buffer size
    check_write_size(pkt.get_data_size());

    // copy
    memcpy(buf + offset, pkt.get_buf(), pkt.get_data_size());

    // update offset/data_size
    offset += pkt.get_data_size();
    data_size += pkt.get_data_size();
}