#include <packer.hpp>
#include <cassert>

void Packer::write_int8(int8_t v) {
    oss_->write((const char *)&v, sizeof(v));
}

void Packer::write_int16(int16_t v) {
    oss_->write((const char *)&v, sizeof(v));
}

void Packer::write_int32(int32_t v) {
    oss_->write((const char *)&v, sizeof(v));
}

void Packer::write_int64(int64_t v) {
    oss_->write((const char *)&v, sizeof(v));
}

void Packer::overwrite_int8(size_t tell_after, int8_t v) {
    oss_->seekp(tell_after - 1);
    write_int8(v);
    oss_->seekp(0, std::ios_base::end);
}

void Packer::overwrite_int16(size_t tell_after, int16_t v) {
    oss_->seekp(tell_after - 2);
    write_int16(v);
    oss_->seekp(0, std::ios_base::end);
}

void Packer::overwrite_int32(size_t tell_after, int32_t v) {
    oss_->seekp(tell_after - 4);
    write_int32(v);
    oss_->seekp(0, std::ios_base::end);
}

void Packer::overwrite_int64(size_t tell_after, int64_t v) {
    oss_->seekp(tell_after - 8);
    write_int64(v);
    oss_->seekp(0, std::ios_base::end);
}

int Packer::lua_writer(lua_State *L, const void *p, size_t sz, void *ud) {
    Packer *pkr = (Packer *)ud;
    pkr->oss_->write((const char *)p, sz);
    return 0;
}

Unpacker::Unpacker(const char *d, size_t s) {
    assert(d != nullptr);
    assert(s >= 0);
    data_ = d;
    size_ = s;
}

int8_t Unpacker::read_int8() {
    assert(size_ >= 1);
    int8_t result;
    memcpy(&result, data_, 1);
    data_ += 1;
    size_ -= 1;
    return result;
}

int16_t Unpacker::read_int16() {
    assert(size_ >= 2);
    int16_t result;
    memcpy(&result, data_, 2);
    data_ += 2;
    size_ -= 2;
    return result;
}

int32_t Unpacker::read_int32() {
    assert(size_ >= 4);
    int32_t result;
    memcpy(&result, data_, 4);
    data_ += 4;
    size_ -= 4;
    return result;
}

int64_t Unpacker::read_int64() {
    assert(size_ >= 8);
    int64_t result;
    memcpy(&result, data_, 8);
    data_ += 8;
    size_ -= 8;
    return result;
}

void Unpacker::skip(size_t n) {
    assert(size_ >= n);
    data_ += n;
    size_ -= n;
}

Unpacker Unpacker::read_section(size_t n) {
    assert(size_ >= n);
    const char *d = data_;
    data_ += n;
    size_ -= n;
    return Unpacker(d, n);
}

const char *Unpacker::lua_reader(lua_State *L, void *ud, size_t *size) {
    Unpacker *unpk = (Unpacker *)ud;
    const char *retval = unpk->data_;
    *size = unpk->size_;
    if (unpk->size_ == 0) retval = nullptr;
    unpk->data_ += unpk->size_;
    unpk->size_ = 0;
    return retval;
}