#include "Bucket.hh"

#include "../common/Crc.hpp"

#include <cstring>

const uint32_t logging::Bucket::magic_key = 0xCAFEDEACul;
const std::size_t logging::Bucket::buffer_capacity = logging::Bucket::buffer_size * sizeof(uint16_t);
const std::size_t logging::Bucket::offset_of___crc = logging::Bucket::buffer_size * sizeof(uint16_t) - sizeof(uint32_t);
const std::size_t logging::Bucket::data_capacity = logging::Bucket::buffer_size * sizeof(uint16_t) - sizeof(uint32_t) - offset_of___data;

logging::Bucket::Bucket() {

    reset();

}

uint32_t logging::Bucket::calc_crc() const {

    return common::crc::crcCalc<common::crc::Crc32_ZLIB>( reinterpret_cast<const char *>(buffer), buffer_capacity - sizeof(uint32_t) );

}

void logging::Bucket::update_crc() {

    uint32_t crc = calc_crc();

    std::memcpy(buffer + offset_of___crc,       &crc,           sizeof(uint32_t));

}

void logging::Bucket::fill( const char * data, std::size_t size ) {

    uint16_t data_pointer = get_data_pointer();

    std::memcpy(buffer + offset_of___data + data_pointer, data, size);

    set_data_pointer( data_pointer + size );

}

void logging::Bucket::reset() {

    uint16_t data_pointer = 0;
    uint32_t crc = 0;

    std::memcpy(buffer + offset_of___magic_key, &magic_key,     sizeof(uint32_t));
    std::memcpy(buffer + offset_of___load,      &data_pointer,  sizeof(uint16_t));
    std::memcpy(buffer + offset_of___crc,       &crc,           sizeof(uint32_t));

}

std::size_t logging::Bucket::size() const {

    return buffer_capacity;

}

std::size_t logging::Bucket::allowed_space() const {

    return data_capacity;

}

std::size_t logging::Bucket::free_space() const {

    return data_capacity - get_data_pointer();

}

uint32_t logging::Bucket::get_magic() const {

    uint32_t magic_key;

    std::memcpy(&magic_key, buffer + offset_of___magic_key, sizeof(uint32_t));

    return magic_key;

}

std::pair<const char *, std::size_t> logging::Bucket::serialize() const {

    return { reinterpret_cast< const char *>(buffer), buffer_capacity };

}

uint16_t logging::Bucket::get_data_pointer() const {

    uint16_t data_pointer_in_8bit_bytes;

    std::memcpy(&data_pointer_in_8bit_bytes, buffer + offset_of___load, sizeof(uint16_t));

    uint16_t data_pointer = data_pointer_in_8bit_bytes * 8 / CHAR_BIT;

    return data_pointer;

}

void logging::Bucket::set_data_pointer( uint16_t data_pointer ) {

    uint16_t data_pointer_in_8bit_bytes = data_pointer * CHAR_BIT / 8;

    std::memcpy(buffer + offset_of___load,      &data_pointer_in_8bit_bytes,  sizeof(uint16_t));

}

bool logging::Bucket::check() const {

    return calc_crc() == get_crc()
            and magic_key == get_magic()
            and get_data_pointer() <= data_capacity;

}

uint32_t logging::Bucket::get_crc() const {

    uint32_t crc;

    std::memcpy(&crc, buffer + offset_of___crc, sizeof(uint32_t));

    return crc;

}

std::pair<const char*, size_t> logging::Bucket::data() const {

    std::size_t data_load = get_data_pointer();

    return { reinterpret_cast<const char *>(buffer + offset_of___data), data_load };

}