packet_buf.cpp

//
// Created by Micael Cossa on 25/07/2025.
//
#include "packet_buf.h"
#include <algorithm>
#include <chrono>
#include <iostream>

#define MAXIMUM_VARINT_BITS 5
#define COMPLETION_BIT_MASK 0x80
#define SEGMENT_BITS 0x7F


constexpr int UUID_SIZE = 16;

int ReadPacketBuffer::readVarInt() {
    int final_result = 0, shifts = 0;

    while(shifts < MAXIMUM_VARINT_BITS && position < size) {

        unsigned char currentByte = buffer[position];

        final_result |= (currentByte & SEGMENT_BITS) << (shifts * 7);
        position++;

        if ((currentByte & COMPLETION_BIT_MASK) == 0) break;
        shifts++;
    }

    return final_result;
}


char *ReadPacketBuffer::getBuffer() {
    return buffer;
}

int ReadPacketBuffer::getSize() {
    return size;
}

long long int ReadPacketBuffer::readLong() {

    int length = sizeof(long long int);



    if(position + length > size) {
        printf("Unable to readLong, buffer size not big enough position: %d , bufferSize: %d \n", (position + length), size);
        return 0;
    }
    long long value;
    for (int i = 0; i < length; i++) {
        reinterpret_cast<unsigned char*>(&value)[i] =
                static_cast<unsigned char>(buffer[position + (7 - i)]);
    }

    position+=length;

    return value;
}

std::string ReadPacketBuffer::readString() {

    int stringLength = readVarInt();

    if(position + stringLength > size) {
        printf("String length bigger than buffer size , Position: %d String Length: %d Buffer Size: %d", position, stringLength, size);
        return "";
    }

    std::string result;
    result.reserve(stringLength);  // Pre-allocate to avoid reallocations
    result.assign(buffer + position, buffer + position + stringLength);
    position += stringLength;

    return result;
}

short ReadPacketBuffer::readShort() {
    int length = sizeof(short);



    if(position + length > size) {
        printf("Unable to readShort, buffer size not big enough position: %d , bufferSize: %d \n", (position + length), size);
        return 0;
    }
    short value;
    for (int i = 0; i < length; i++) {
        reinterpret_cast<unsigned char*>(&value)[i] =
                static_cast<unsigned char>(buffer[position + (1 - i)]);
    }

    position+=length;
    return value;
}

std::string ReadPacketBuffer::readUUID() {
    if(position + UUID_SIZE > size) {
        printf("UUID Length bigger than buffer size , Position: %d Buffer Size: %d", position, size);
        return "";
    }

    std::string result;
    result.reserve(UUID_SIZE);  // Pre-allocate to avoid reallocations
    result.assign(buffer + position, buffer + position + UUID_SIZE);
    return result;
}

// Pre-allocate a buffer of at least 'n' bytes
void WritePacketBuffer::reserve(size_t n) {
    if (capacity < n) {
        char* newBuffer = new char[n];
        if (buffer != nullptr) {
            memcpy(newBuffer, buffer, currPos); // preserve existing data
            delete[] buffer;
        }
        buffer = newBuffer;
        capacity = n;
    }
}


size_t WritePacketBuffer::getSize() {
    return currPos;
}

void WritePacketBuffer::writeByte(const char& byte) {
    if (currPos >= capacity) {
        // grow buffer exponentially if needed
        reserve(capacity > 0 ? capacity * 2 : 512);
    }
    buffer[currPos++] = byte;
}

void WritePacketBuffer::writeVarIntAtTheFront(int value) {
    // Determine the number of bytes needed for the VarInt
    size_t varIntSize = 0;
    int temp = value;
    do {
        temp >>= 7;
        varIntSize++;
    } while (temp != 0);

    // Make sure there’s enough space
    if (currPos + varIntSize > capacity) {
        reserve(currPos + varIntSize);
    }

    // Shift existing data forward to make room for the VarInt
    memmove(buffer + varIntSize, buffer, currPos);

    // Write VarInt bytes at the beginning
    size_t pos = 0;
    do {
        int transfer_bits = value & SEGMENT_BITS;
        value >>= 7;
        if (value != 0)
            transfer_bits |= COMPLETION_BIT_MASK;
        buffer[pos++] = static_cast<char>(transfer_bits);
    } while (value != 0);

    // Update current position
    currPos += varIntSize;
}

void WritePacketBuffer::writeString(const std::string &value) {


    // Write Size
    writeVarInt(static_cast<int>(value.length()));

    // Write UTF-8 Characters
    std::for_each(value.begin(), value.end(), [this](const char& c) {
        this->writeByte(c);
    });
}

void WritePacketBuffer::writeVarInt(int value) {

    do {
        int transfer_bits = (value & SEGMENT_BITS);

        value >>= 7;

        if(value != 0)
            transfer_bits |= COMPLETION_BIT_MASK;

        writeByte(static_cast<char>(transfer_bits));

    } while(value != 0);
}

void WritePacketBuffer::writeLong(const long long int value) {


    reserve(currPos + sizeof(value));
    memcpy(buffer + currPos, &value, sizeof(value));
    currPos += sizeof(value);

}