// Copyright 2022, FOSS-VG Developers and Contributers
//
// This program is free software: you can redistribute it and/or modify it
// under the terms of the GNU Affero General Public License as published
// by the Free Software Foundation, version 3.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// version 3 along with this program.
// If not, see https://www.gnu.org/licenses/agpl-3.0.en.html

#include <bit>
#include <cstdint>
#include <vector>
#include <tinyutf8/tinyutf8.h>
#include <iostream>

#include "nbt.hpp"
#include "error.hpp"
#include "javacompat.hpp"


#include "../../.endianness"
#ifdef FOSSVG_ENDIAN_BIG_WORD
    #error "Honeywell-316-style endianness is not supported. If you feel like it should, feel free to participate in the project to maintain it."
#endif
#ifdef FOSSVG_ENDIAN_LITTLE_WORD
    #error "PDP-11-style endianness is not supported. If you feel like it should, feel free to participate in the project to maintain it."
#endif
#ifdef FOSSVG_ENDIAN_UNKNOWN
    #error "The endianness of your system could not be determined. Please set it manually. FOSS-VG is currently implemented using some endian-specific functions."
#endif

namespace NBT {
    namespace helper {
        ErrorOr<int8_t> readInt8(uint8_t data[], uint64_t dataSize, uint64_t currentPosition) {
            if (dataSize<currentPosition+1) return ErrorOr<int8_t>(true, ErrorCodes::OUT_OF_RANGE);
            return ErrorOr<int8_t>((int8_t) data[currentPosition]);
        }

        ErrorOr<int16_t> readInt16(uint8_t data[], uint64_t dataSize, uint64_t currentPosition) {
            if (dataSize<currentPosition+2) return ErrorOr<int16_t>(true, ErrorCodes::OUT_OF_RANGE);
            return ErrorOr<int16_t>((int16_t) ((static_cast<int16_t>(data[currentPosition]) << 8) | static_cast<int16_t>(data[currentPosition+1])));
        }

        ErrorOr<int32_t> readInt32(uint8_t data[], uint64_t dataSize, uint64_t currentPosition) {
            if (dataSize<currentPosition+4) return ErrorOr<int32_t>(true, ErrorCodes::OUT_OF_RANGE);
            return ErrorOr<int32_t>((int32_t) (
                (static_cast<int32_t>(data[currentPosition  ]) << 24) |
                (static_cast<int32_t>(data[currentPosition+1]) << 16) |
                (static_cast<int32_t>(data[currentPosition+2]) <<  8) |
                 static_cast<int32_t>(data[currentPosition+3])
            ));
        }

        ErrorOr<int64_t> readInt64(uint8_t data[], uint64_t dataSize, uint64_t currentPosition) {
            if (dataSize<currentPosition+8) return ErrorOr<int64_t>(true, ErrorCodes::OUT_OF_RANGE);
            return ErrorOr<int64_t>((int64_t) (
                (static_cast<int64_t>(data[currentPosition  ]) << 56) |
                (static_cast<int64_t>(data[currentPosition+1]) << 48) |
                (static_cast<int64_t>(data[currentPosition+2]) << 40) |
                (static_cast<int64_t>(data[currentPosition+3]) << 32) |
                (static_cast<int64_t>(data[currentPosition+4]) << 24) |
                (static_cast<int64_t>(data[currentPosition+5]) << 16) |
                (static_cast<int64_t>(data[currentPosition+6]) <<  8) |
                 static_cast<int64_t>(data[currentPosition+7])
            ));
        }

        //FIXME: endian-dependent implementations
        ErrorOr<float> readFloat(uint8_t data[], uint64_t dataSize, uint64_t currentPosition) {
            float* value = new float;
            uint8_t* valueAsBytes = reinterpret_cast<uint8_t*>(value);
            if (dataSize<=currentPosition) return ErrorOr<float>(true, ErrorCodes::OUT_OF_RANGE);
            if (dataSize<currentPosition+4) return ErrorOr<float>(true, ErrorCodes::OVERRUN);
            #ifdef FOSSVG_BIG_ENDIAN
                *valueAsBytes   =   data[currentPosition];
                *(valueAsBytes+1) = data[currentPosition+1];
                *(valueAsBytes+2) = data[currentPosition+2];
                *(valueAsBytes+3) = data[currentPosition+3];
            #else
                #ifdef FOSSVG_LITTLE_ENDIAN
                    *valueAsBytes   =   data[currentPosition+3];
                    *(valueAsBytes+1) = data[currentPosition+2];
                    *(valueAsBytes+2) = data[currentPosition+1];
                    *(valueAsBytes+3) = data[currentPosition];
                #else
                    #error "NBT::helper::readFloat: An implementation for your endianness is unavailable."
                #endif
            #endif
            float dereferencedValue = *value;
            delete value;
            return ErrorOr<float>(dereferencedValue);
        }

        //FIXME: endian-dependent implementations
        ErrorOr<double> readDouble(uint8_t data[], uint64_t dataSize, uint64_t currentPosition) {
            double* value = new double;
            uint8_t* valueAsBytes = reinterpret_cast<uint8_t*>(value);
            if (dataSize<=currentPosition) return ErrorOr<double>(true, ErrorCodes::OUT_OF_RANGE);
            if (dataSize<currentPosition+8) return ErrorOr<double>(true, ErrorCodes::OVERRUN);
            #ifdef FOSSVG_BIG_ENDIAN
                *valueAsBytes   =   data[currentPosition];
                *(valueAsBytes+1) = data[currentPosition+1];
                *(valueAsBytes+2) = data[currentPosition+2];
                *(valueAsBytes+3) = data[currentPosition+3];
                *(valueAsBytes+4) = data[currentPosition+4];
                *(valueAsBytes+5) = data[currentPosition+5];
                *(valueAsBytes+6) = data[currentPosition+6];
                *(valueAsBytes+7) = data[currentPosition+7];
            #else
                #ifdef FOSSVG_LITTLE_ENDIAN
                    *valueAsBytes   =   data[currentPosition+7];
                    *(valueAsBytes+1) = data[currentPosition+6];
                    *(valueAsBytes+2) = data[currentPosition+5];
                    *(valueAsBytes+3) = data[currentPosition+4];
                    *(valueAsBytes+4) = data[currentPosition+3];
                    *(valueAsBytes+5) = data[currentPosition+2];
                    *(valueAsBytes+6) = data[currentPosition+1];
                    *(valueAsBytes+7) = data[currentPosition];
                #else
                    #error "NBT::helper::readDouble: An implementation for your endianness is unavailable."
                #endif
            #endif
            double dereferencedValue = *value;
            delete value;
            return ErrorOr<double>(dereferencedValue);
        }

        ErrorOr<std::vector<int8_t>> readInt8Array(uint8_t data[], uint64_t dataSize, uint64_t currentPosition) {
            // get size prefix
            ErrorOr<int32_t> size = readInt32(data, dataSize, currentPosition);
            if (size.isError) return ErrorOr<std::vector<int8_t>>(true, size.errorCode);

            // get content
            if (currentPosition+4+size.value > dataSize) return ErrorOr<std::vector<int8_t>>(true, ErrorCodes::OVERRUN);
            std::vector<int8_t> result = std::vector<int8_t>();
            for (int i=0; i<size.value; i++) {
                result.push_back(data[currentPosition+4+i]);
            }
            return ErrorOr<std::vector<int8_t>>(result);
        }

        ErrorOr<tiny_utf8::string> readString(uint8_t data[], uint64_t dataSize, uint64_t currentPosition) {
            if(dataSize > 0xFFFF){
                return ErrorOr<tiny_utf8::string>(true, ErrorCodes::OVERRUN);
            }

            ErrorOr<tiny_utf8::string> output = JavaCompat::importJavaString(data+currentPosition, (uint16_t) dataSize);
            if(output.isError){
                return ErrorOr<tiny_utf8::string>(true, output.errorCode);
            }
            return output;
        }

        ErrorOr<std::vector<int32_t>> readInt32Array(uint8_t data[], uint64_t dataSize, uint64_t currentPosition) {
            // get size prefix
            ErrorOr<int32_t> size = readInt32(data, dataSize, currentPosition);
            if (size.isError) return ErrorOr<std::vector<int32_t>>(true, size.errorCode);

            // get content
            if (currentPosition+4+(size.value*4) > dataSize) return ErrorOr<std::vector<int32_t>>(true, ErrorCodes::OVERRUN);
            std::vector<int32_t> result = std::vector<int32_t>();
            for (int i=0; i<size.value; i++) {
                ErrorOr<int32_t> nextInt32 = readInt32(data, dataSize, currentPosition+4+(i*4));
                if (nextInt32.isError) return ErrorOr<std::vector<int32_t>>(true, nextInt32.errorCode);
                result.push_back(nextInt32.value);
            }
            return ErrorOr<std::vector<int32_t>>(result);
        }

        ErrorOr<std::vector<int64_t>> readInt64Array(uint8_t data[], uint64_t dataSize, uint64_t currentPosition) {
            // get size prefix
            ErrorOr<int32_t> size = readInt32(data, dataSize, currentPosition);
            if (size.isError) return ErrorOr<std::vector<int64_t>>(true, size.errorCode);

            // get content
            if (currentPosition+4+(size.value*8) > dataSize) return ErrorOr<std::vector<int64_t>>(true, ErrorCodes::OVERRUN);
            std::vector<int64_t> result = std::vector<int64_t>();
            for (int i=0; i<size.value; i++) {
                ErrorOr<int64_t> nextInt64 = readInt64(data, dataSize, currentPosition+4+(i*8));
                if (nextInt64.isError) return ErrorOr<std::vector<int64_t>>(true, nextInt64.errorCode);
                result.push_back(nextInt64.value);
            }
            return ErrorOr<std::vector<int64_t>>(result);
        }

        void writeInt8(std::vector<uint8_t>* destination, int8_t data) {
            destination->push_back((uint8_t) data);
        }

        //FIXME: endian dependent implementation
        void writeInt16(std::vector<uint8_t>* destination, int16_t data) {
            int16_t* value = new int16_t;
            uint8_t* valueAsBytes = reinterpret_cast<uint8_t*>(value);
            *value = data;
            #ifdef FOSSVG_BIG_ENDIAN
                destination->push_back(*valueAsBytes);
                destination->push_back(*(valueAsBytes+1));
            #else
                #ifdef FOSSVG_LITTLE_ENDIAN
                    destination->push_back(*(valueAsBytes+1));
                    destination->push_back(*valueAsBytes);
                #else
                    #error "NBT::helper::writeInt16: An implementation for your endianness is unavailable."
                #endif
            #endif
            delete value;
        }

        //FIXME: endian dependent implementation
        void writeInt32(std::vector<uint8_t>* destination, int32_t data) {
            int32_t* value = new int32_t;
            uint8_t* valueAsBytes = reinterpret_cast<uint8_t*>(value);
            *value = data;
            #ifdef FOSSVG_BIG_ENDIAN
                destination->push_back(*valueAsBytes);
                destination->push_back(*(valueAsBytes+1));
                destination->push_back(*(valueAsBytes+2));
                destination->push_back(*(valueAsBytes+3));
            #else
                #ifdef FOSSVG_LITTLE_ENDIAN
                    destination->push_back(*(valueAsBytes+3));
                    destination->push_back(*(valueAsBytes+2));
                    destination->push_back(*(valueAsBytes+1));
                    destination->push_back(*valueAsBytes);
                #else
                    #error "NBT::helper::writeInt16: An implementation for your endianness is unavailable."
                #endif
            #endif
            delete value;
        }

        //FIXME: endian dependent implementation
        void writeInt64(std::vector<uint8_t>* destination, int64_t data) {
            int64_t* value = new int64_t;
            uint8_t* valueAsBytes = reinterpret_cast<uint8_t*>(value);
            *value = data;
            #ifdef FOSSVG_BIG_ENDIAN
                destination->push_back(*valueAsBytes);
                destination->push_back(*(valueAsBytes+1));
                destination->push_back(*(valueAsBytes+2));
                destination->push_back(*(valueAsBytes+3));
                destination->push_back(*(valueAsBytes+4));
                destination->push_back(*(valueAsBytes+5));
                destination->push_back(*(valueAsBytes+6));
                destination->push_back(*(valueAsBytes+7));
            #else
                #ifdef FOSSVG_LITTLE_ENDIAN
                    destination->push_back(*(valueAsBytes+7));
                    destination->push_back(*(valueAsBytes+6));
                    destination->push_back(*(valueAsBytes+5));
                    destination->push_back(*(valueAsBytes+4));
                    destination->push_back(*(valueAsBytes+3));
                    destination->push_back(*(valueAsBytes+2));
                    destination->push_back(*(valueAsBytes+1));
                    destination->push_back(*valueAsBytes);
                #else
                    #error "NBT::helper::writeInt16: An implementation for your endianness is unavailable."
                #endif
            #endif
            delete value;
        }

        //FIXME: endian-specific implementations
        void writeFloat(std::vector<uint8_t>* destination, float data) {
            float* value = new float;
            uint8_t* valueAsBytes = reinterpret_cast<uint8_t*>(value);
            *value = data;
            #ifdef FOSSVG_BIG_ENDIAN
                destination->push_back(*valueAsBytes);
                destination->push_back(*(valueAsBytes+1));
                destination->push_back(*(valueAsBytes+2));
                destination->push_back(*(valueAsBytes+3));
            #else
                #ifdef FOSSVG_LITTLE_ENDIAN
                    destination->push_back(*(valueAsBytes+3));
                    destination->push_back(*(valueAsBytes+2));
                    destination->push_back(*(valueAsBytes+1));
                    destination->push_back(*valueAsBytes);
                #else
                    #error "NBT::helper::writeInt16: An implementation for your endianness is unavailable."
                #endif
            #endif
            delete value;
        }

        //FIXME: endian-specific implementations
        void writeDouble(std::vector<uint8_t>* destination, double data) {
            double* value = new double;
            uint8_t* valueAsBytes = reinterpret_cast<uint8_t*>(value);
            *value = data;
            #ifdef FOSSVG_BIG_ENDIAN
                destination->push_back(*valueAsBytes);
                destination->push_back(*(valueAsBytes+1));
                destination->push_back(*(valueAsBytes+2));
                destination->push_back(*(valueAsBytes+3));
                destination->push_back(*(valueAsBytes+4));
                destination->push_back(*(valueAsBytes+5));
                destination->push_back(*(valueAsBytes+6));
                destination->push_back(*(valueAsBytes+7));
            #else
                #ifdef FOSSVG_LITTLE_ENDIAN
                    destination->push_back(*(valueAsBytes+7));
                    destination->push_back(*(valueAsBytes+6));
                    destination->push_back(*(valueAsBytes+5));
                    destination->push_back(*(valueAsBytes+4));
                    destination->push_back(*(valueAsBytes+3));
                    destination->push_back(*(valueAsBytes+2));
                    destination->push_back(*(valueAsBytes+1));
                    destination->push_back(*valueAsBytes);
                #else
                    #error "NBT::helper::writeInt16: An implementation for your endianness is unavailable."
                #endif
            #endif
            delete value;
        }

        void writeInt8Array(std::vector<uint8_t>* destination, std::vector<int8_t> data) {
            writeInt32(destination, data.size());
            for(int8_t datum: data){
                destination->push_back(datum);
            }
        }

        void writeInt8Array(std::vector<uint8_t>* destination, int8_t data[], uint32_t dataSize) {
            writeInt32(destination, dataSize);
            for(uint32_t i=0; i < dataSize; i++){
                destination->push_back(data[i]);
            }
        }

        void writeString(std::vector<uint8_t>* destination, tiny_utf8::string data) {
            ErrorOr<std::vector<uint8_t>> exportedString = JavaCompat::exportJavaString(data);
            if(exportedString.isError){
                std::cerr << "NBT::helpers::writeString encountered an error: " << (int) exportedString.errorCode << std::endl;
                std::abort();
            }
            *destination = exportedString.value;
        }

        void writeInt32Array(std::vector<uint8_t>* destination, std::vector<int32_t> data) {
            writeInt32(destination, data.size());
            for(int32_t element: data){
                writeInt32(destination, element);
            }
        }

        void writeInt32Array(std::vector<uint8_t>* destination, int32_t data[], uint32_t dataSize) {
            writeInt32(destination, dataSize);
            for(uint32_t i = 0; i<dataSize; i++){
                writeInt32(destination, data[i]);
            }
        }

        void writeInt64Array(std::vector<uint8_t>* destination, std::vector<int64_t> data) {
            writeInt32(destination, data.size());
            for(int64_t element: data){
                writeInt64(destination, element);
            }
        }

        void writeInt64Array(std::vector<uint8_t>* destination, int64_t data[], uint32_t dataSize) {
            writeInt32(destination, dataSize);
            for(uint32_t i = 0; i<dataSize; i++){
                writeInt64(destination, data[i]);
            }
        }
    }

    //Tag constructors

    template <typename T>
    Tag<T>::Tag(uint8_t tagType, tiny_utf8::string name, uint16_t nameSize, T content, uint32_t size)
        : tagType(tagType), name(name), nameSize(nameSize), content(content) ,size(size)
    {}

    End::End() : Tag::Tag(0, "", 0, 0, 0) {}

    Byte::Byte(tiny_utf8::string name, uint16_t nameSize, int8_t content)
        : Tag::Tag(1, name, nameSize, content, 1)
    {}

    Byte::Byte(uint8_t data[]){
        if(validate(data)){
            this->tagType = 1;

            uint8_t nameSizeSlice[] = {data[1], data[2]};

            ErrorOr<int16_t> readIntResult = helper::readInt16(nameSizeSlice, 2, 0);
            if(!readIntResult.isError){
                this->nameSize = readIntResult.value;
            }else{
                throw readIntResult.errorCode;
            }

            uint8_t nameSlice[this->nameSize+2];
            for(int i=0; i<this->nameSize+2; i++){
                nameSlice[i] = data[i+1];
            }

            ErrorOr<tiny_utf8::string> readStringResult = helper::readString(nameSlice, this->nameSize, 0);
            if(!readStringResult.isError){
                this->name = readStringResult.value;
            }else{
                throw readStringResult.errorCode;
            }

            //int8 needs only one byte
            this->content = data[this->nameSize+4];
        }
    }

    //more conditions will be added
    bool Byte::validate(uint8_t data[]){
        if(data[0] == 0x01){
            return true;
        }else{
            return false;
        }
    }


    //FIXME: instead of blindly passing the error code upwards, choose one that
    // is applicable to the situation (for example replace OUT_OF_RANGE with
    // OVERRUN where appropriate)
    ErrorOr<uint64_t> nextTagTotalSize(uint8_t data[], uint64_t dataSize, uint64_t currentPosition) {
        uint8_t nextTag;
        if (dataSize <= currentPosition) {
            return ErrorOr<uint64_t>(true, ErrorCodes::OVERRUN);
        } else {
            nextTag = data[currentPosition];
        }
        // deal with compound tags separately
        if (nextTag == TagType::COMPOUND) return ErrorOr<uint64_t>(false, ErrorCodes::NOT_YET_KNOWN);
        // deal with end tag before trying to access the name
        if (nextTag == TagType::END) return ErrorOr<uint64_t>(1);
        // get name size
        ErrorOr<int16_t> nameSize = helper::readInt16(data, dataSize, currentPosition+1);
        if (nameSize.isError) {
            return ErrorOr<uint64_t>(true, nameSize.errorCode);
        }
        switch (nextTag) {
            case TagType::INT8:
                // type byte + name size + data byte -> 4 bytes
                return ErrorOr<uint64_t>((uint64_t) nameSize.value+4);
            case TagType::INT16:
                // type byte + name size + 2 data bytes -> 5 bytes
                return ErrorOr<uint64_t>((uint64_t) nameSize.value+5);
            case TagType::INT32:
                // type byte + name size + 4 data bytes -> 7 bytes
                return ErrorOr<uint64_t>((uint64_t) nameSize.value+7);
            case TagType::INT64:
                // type byte + name size + 8 data bytes -> 11 bytes
                return ErrorOr<uint64_t>((uint64_t) nameSize.value+11);
            case TagType::FLOAT:
                // type byte + name size + 4 data bytes -> 7 bytes
                return ErrorOr<uint64_t>((uint64_t) nameSize.value+7);
            case TagType::DOUBLE:
                // type byte + name size + 8 data bytes -> 11 bytes
                return ErrorOr<uint64_t>((uint64_t) nameSize.value+11);
            case TagType::INT8_ARRAY:
                // type byte + name size + 4 size bytes -> 7 bytes
                uint64_t totalSize = (uint64_t) nameSize.value+7;

                // add size of actual data (1 byte per entry)
                ErrorOr<int32_t> arraySize = helper::readInt32(data, dataSize, currentPosition+totalSize);
                if (arraySize.isError) {
                    return ErrorOr<uint64_t>(true, arraySize.errorCode);
                }
                totalSize += (uint64_t) arraySize.value;

                return ErrorOr<uint64_t>(totalSize);
            case TagType::STRING:
                // type byte + name size + 2 size bytes -> 5 bytes
                uint64_t totalSize = (uint64_t) nameSize.value+5;

                // add size of actual data
                ErrorOr<int16_t> stringSize = helper::readInt16(data, dataSize, currentPosition+totalSize);
                if (stringSize.isError) {
                    return ErrorOr<uint64_t>(true, stringSize.errorCode);
                }
                totalSize += (uint64_t) stringSize.value;

                return ErrorOr<uint64_t>(totalSize);
            case TagType::LIST:
                // type byte + name size + type prefix + 4 size bytes -> 8 bytes
                uint64_t totalSize = (uint64_t) nameSize.value+8;

                // determine size of actual data
                ErrorOr<uint8_t> containedType = nextTagType(data, dataSize, currentPosition+totalSize-1);
                if (containedType.isError) {
                    return ErrorOr<uint64_t>(true, containedType.errorCode);
                }
                ErrorOr<int16_t> listSize = helper::readInt16(data, dataSize, currentPosition+totalSize);
                if (listSize.isError) {
                    return ErrorOr<uint64_t>(true, listSize.errorCode);
                }
                // Can we just multiply list size with data type size?
                if (containedType.value == TagType::END || containedType.value == TagType::INT8 || containedType.value == TagType::INT16 || containedType.value == TagType::INT32 || containedType.value == TagType::INT64 || containedType.value == TagType::FLOAT || containedType.value == TagType::DOUBLE) {
                    uint8_t factor;
                    switch (containedType.value) {
                        case TagType::END:
                            factor = 1;
                        case TagType::INT8:
                            factor = 1;
                        case TagType::INT16:
                            factor = 2;
                        case TagType::INT32:
                            factor = 4;
                        case TagType::INT64:
                            factor = 8;
                        case TagType::FLOAT:
                            factor = 4;
                        case TagType::DOUBLE:
                            factor = 8;
                        default:
                            // How would you even get here?
                            return ErrorOr<uint64_t>(true, ErrorCodes::UNKNOWN);
                    }
                    totalSize += listSize*factor;
                    return ErrorOr<uint64_t>(totalSize);
                } else {
                    if (containedType.value == TagType::COMPOUND || containedType.value == TagType::LIST) return ErrorOr<uint64_t>(false, ErrorCodes::NOT_YET_KNOWN);
                    //TODO: INT8_ARRAY, STRING, INT32_ARRAY, INT64_ARRAY
                }

                return ErrorOr<uint64_t>(true, ErrorCodes::UNKNOWN);
            case TagType::INT32_ARRAY:
                // type byte + name size + 4 size bytes -> 7 bytes
                uint64_t totalSize = (uint64_t) nameSize.value+7;

                // add size of actual data (4 bytes per entry)
                ErrorOr<int16_t> arraySize = helper::readInt16(data, dataSize, currentPosition+totalSize);
                if (arraySize.isError) {
                    return ErrorOr<uint64_t>(true, arraySize.errorCode);
                }
                totalSize += (uint64_t) arraySize.value*4;

                return ErrorOr<uint64_t>(totalSize);
            case TagType::INT64_ARRAY:
                // type byte + name size + 4 size bytes -> 7 bytes
                uint64_t totalSize = (uint64_t) nameSize.value+7;

                // add size of actual data (8 bytes per entry)
                ErrorOr<int16_t> arraySize = helper::readInt16(data, dataSize, currentPosition+totalSize);
                if (arraySize.isError) {
                    return ErrorOr<uint64_t>(true, arraySize.errorCode);
                }
                totalSize += (uint64_t) arraySize.value*8;

                return ErrorOr<uint64_t>(totalSize);
            // fall-through in case of unknown tag or parsing error
            default:
                return ErrorOr<uint64_t>(true, ErrorCodes::UNKNOWN);
        }
    }

    ErrorOr<uint32_t> nextTagDataSize(uint8_t data[], uint64_t dataSize, uint64_t currentPosition){

        uint8_t nextTag;
        if (dataSize <= currentPosition) {
            return ErrorOr<uint32_t>(true, ErrorCodes::OVERRUN);
        } else {
            nextTag = data[currentPosition];
        }

        // deal with compound tags separately
        if (nextTag == TagType::COMPOUND) return ErrorOr<uint32_t>(true, ErrorCodes::NOT_YET_KNOWN);
        // deal with end tag before trying to access the name
        if (nextTag == TagType::END) return 0;
        //TODO: implement for all the remaining types
        // fall-through in case of unknown tag or parsing error
        return ErrorOr<uint32_t>(true, ErrorCodes::UNKNOWN);
    }

    bool validateRawNBTData(uint8_t data[], uint64_t dataSize, uint64_t initialPosition){
        //TODO: find out the size of the next tag
        //TODO: consume tag
        //TODO: recurse if tag compound and return if tag end
        return false;
    }
}