#pragma once
#include <cstdint>
#include <string>
#include <vector>
#include <memory>

#include "CAngle.h"
#include "U_Types.h"

class IBinaryStream //TODO missing const
{
public:
    virtual void RawWrite(const void* data, size_t size) = 0;
    virtual void RawRead(void* data, size_t size) = 0;
    virtual bool is_eof();
    
    virtual ~IBinaryStream() = default;

    void ReadData(void* data, size_t size);
    std::unique_ptr<std::uint8_t[]> ReadData(size_t size);
    std::vector<std::uint8_t> ReadDataVec(size_t size);

    void WriteData(const void* data, size_t size);
    void WriteData(std::unique_ptr<std::uint8_t[]> data, size_t size);

    template<typename T>
    void Write(const T& val)
    {
        if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, std::wstring>)
        {
            WriteString<T>(val);
        }
        else if constexpr (std::is_same_v<T, CAngle>)
        {
            typename T::value_type degr = val.asRadians();
            RawWrite(&degr, sizeof(typename T::value_type));
        }
        else if constexpr (is_glm_vec_v<T> || is_glm_quat_v<T> || std::is_same_v<T, CAngles>)
        {
            for(size_t i = 0; i < T::length(); i++)
            {
                Write<typename T::value_type>(val[i]);
            }
        }
        else if constexpr (is_glm_mat_v<T>)
        {
            for(size_t y = 0; y < T::col_type::length(); y++)
            {
                for(size_t x = 0; x < T::length(); x++)
                {
                    typename T::value_type value = val[x][y];
                    RawWrite(&value, sizeof(float));
                }
            }
        }
        else
        {
            RawWrite(&val, sizeof(T));
        }
    }

    template<typename T>
    T Read()
    {
        T ret{};
        if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, std::wstring>)
        {
            ret = ReadString<T>();
        }
        else if constexpr (std::is_same_v<T, CAngle>)
        {
            typename T::value_type degr{};
            RawRead(&degr, sizeof(typename T::value_type));

            ret = T::radians(degr);
        }
        else if constexpr (is_glm_vec_v<T> || is_glm_quat_v<T> || std::is_same_v<T, CAngles>) //TODO why not reading the raw data
        {
            for(size_t i = 0; i < T::length(); i++)
            {
                typename T::value_type item{};
                RawRead(&item, sizeof(typename T::value_type));

                ret[i] = item;
            }
        }
        else if constexpr (is_glm_mat_v<T>) //TODO why not reading the raw data
        {
            for(size_t y = 0; y < T::col_type::length(); y++)
            {
                for(size_t x = 0; x < T::length(); x++)
                {
                    typename T::value_type value{};
                    RawRead(&value, sizeof(float));

                    ret[x][y] = value;
                }
            }
        }
        else
        {
            RawRead(&ret, sizeof(T));
        }
        return ret;
    }

    template<typename String = std::string>
    String ReadString(size_t fixedSize = 0)
    {
        constexpr typename String::value_type charnull = 0; //std::is_same_v<typename String::value_type, char> ? '\0' : L'\0';

        typename String::value_type reat = 1;
        String ret;

        if(fixedSize)
        {
            ret.resize(fixedSize);
            ReadData(static_cast<void*>(ret.data()), fixedSize * sizeof(typename String::value_type));
        }
        else
        {
            ret.reserve(260);

            for(;;)
            {
                reat = Read<typename String::value_type>();
                if (reat == charnull)
                {
                    break;
                }
                else
                {
                    ret += reat;
                }
            }
        }
        return ret;
    }

    template<typename String = std::string>
    void WriteString(const String& str, bool null_terminated = true)
    {
        constexpr typename String::value_type charnull = 0; //std::is_same_v<typename String::value_type, char> ? '\0' : L'\0';

        WriteData(str.data(), str.size());
        if (null_terminated) { Write(charnull); }
    }

    template<typename L = std::uint16_t, typename T = std::string>
    void WriteLenString(const T& str, bool writelen = true, L forcelen = 0U)
    {
        constexpr typename T::value_type charnull = 0; //std::is_same_v<C, char> ? '\0' : L'\0';

        if (writelen)
        {
            Write<L>((forcelen ? forcelen : L(str.size())));
        }

        if (forcelen)
        {
            L lenToWrite = std::min<L>(str.size(), forcelen);

            if (lenToWrite > 0)
            {
                WriteData(static_cast<void*>(const_cast<typename T::value_type*>(str.data())), lenToWrite * sizeof(typename T::value_type));
            }

            if (forcelen > lenToWrite)
            {
                std::vector<typename T::value_type> padding(forcelen - lenToWrite, charnull);
                WriteData(static_cast<void*>(padding.data()), padding.size() * sizeof(typename T::value_type));
            }
        }
        else
        {
            WriteData(static_cast<void*>(const_cast<typename T::value_type*>(str.data())), str.size() * sizeof(typename T::value_type));
        }
    }

    template<typename L = std::uint16_t, typename T = std::string>
    T ReadLenString(bool readlen = true, L forcelen = 0U, bool removenulls = true)
    {
        constexpr typename T::value_type charnull = 0; //std::is_same_v<C, char> ? '\0' : L'\0';

        T ret;
        typename T::value_type reat;
        L len = forcelen;

        if (readlen)
        {
            len = Read<L>();
        }

        ret.resize(len);
        ReadData(static_cast<void*>(ret.data()), len * sizeof(typename T::value_type));

        if (removenulls)
        {
            size_t pos = ret.find_last_not_of(charnull);
            if (pos != T::npos)
            {
                ret.resize(pos + 1);
            }
            else
            {
                ret.clear();
            }
        }
        return ret;
    }

    template<typename T>
    void Read(T& var)
    {
        var = Read<T>();
    }

    template<typename String = std::string>
    void ReadString(String& var, size_t fixedSize = 0)
    {
        var = ReadString<String>(fixedSize);
    }

    template<typename L = std::uint16_t, typename T = std::string>
    void ReadLenString(T& var, bool readlen = true, L forcelen = 0U, bool removenulls = true)
    {
        var = ReadLenString<L, T>(readlen, forcelen, removenulls);
    }
};