#include "MetaCoreFoundation/MetaCoreArchive.h"

#include <cstring>

namespace MetaCore {

void MetaCoreArchiveWriter::WriteBytes(const void* data, std::size_t size) {
    if (data == nullptr || size == 0) {
        return;
    }

    const auto* bytes = static_cast<const std::byte*>(data);
    Buffer_.insert(Buffer_.end(), bytes, bytes + size);
}

void MetaCoreArchiveWriter::WriteSpan(std::span<const std::byte> data) {
    Buffer_.insert(Buffer_.end(), data.begin(), data.end());
}

const std::vector<std::byte>& MetaCoreArchiveWriter::GetBuffer() const {
    return Buffer_;
}

std::size_t MetaCoreArchiveWriter::GetSize() const {
    return Buffer_.size();
}

MetaCoreArchiveReader::MetaCoreArchiveReader(std::span<const std::byte> buffer)
    : Buffer_(buffer) {
}

bool MetaCoreArchiveReader::ReadBytes(void* destination, std::size_t size) {
    if (size == 0) {
        return true;
    }
    if (destination == nullptr || Offset_ + size > Buffer_.size()) {
        return false;
    }

    std::memcpy(destination, Buffer_.data() + Offset_, size);
    Offset_ += size;
    return true;
}

std::optional<std::span<const std::byte>> MetaCoreArchiveReader::ReadSpan(std::size_t size) {
    if (Offset_ + size > Buffer_.size()) {
        return std::nullopt;
    }

    const std::span<const std::byte> result = Buffer_.subspan(Offset_, size);
    Offset_ += size;
    return result;
}

std::optional<std::span<const std::byte>> MetaCoreArchiveReader::PeekSpan(std::size_t size) const {
    if (Offset_ + size > Buffer_.size()) {
        return std::nullopt;
    }
    return Buffer_.subspan(Offset_, size);
}

bool MetaCoreArchiveReader::Skip(std::size_t size) {
    if (Offset_ + size > Buffer_.size()) {
        return false;
    }
    Offset_ += size;
    return true;
}

bool MetaCoreArchiveReader::IsEof() const {
    return Offset_ >= Buffer_.size();
}

std::size_t MetaCoreArchiveReader::GetOffset() const {
    return Offset_;
}

std::size_t MetaCoreArchiveReader::GetRemainingSize() const {
    return Buffer_.size() - Offset_;
}

std::span<const std::byte> MetaCoreArchiveReader::GetBuffer() const {
    return Buffer_;
}

}  // namespace MetaCore