#include "CBinaryFile.h"

#include "CEngine.h"
#include "U_Log.h"
#include "CCommandProcessor.h"
#include <iostream>

CBinaryFile::CBinaryFile(const std::filesystem::path& filename, bool isread)
{
    isread ? OpenRead(filename) : OpenWrite(filename);
}

CBinaryFile::~CBinaryFile()
{
    Close();
}

bool CBinaryFile::OpenWrite(const std::filesystem::path& filename)
{
    Close();
    m_stream.open(filename, std::ios::binary | std::ios::out);

    m_isWrite = true;
    return IsOpen();
}

bool CBinaryFile::OpenRead(const std::filesystem::path& filename)
{
    Close();
    m_stream.open(filename, std::ios::binary | std::ios::in);

    m_isWrite = false;
    return IsOpen();
}

void CBinaryFile::Close()
{
    if(!IsOpen()) { return; }
    m_stream.close();
}

bool CBinaryFile::IsOpen() const
{
    return m_stream.is_open();
}

void CBinaryFile::SetSeek(size_t seek)
{
    if (!IsOpen()) { return; }
    m_stream.seekp(seek, std::ios_base::beg);
}

size_t CBinaryFile::GetSeek()
{
    if(!IsOpen()) { return 0; }
    return m_stream.tellp();
}

size_t CBinaryFile::GetSize()
{
    if (!IsOpen()) { return 0; }

    size_t oldseek = GetSeek();
    size_t ret = 0;

    m_stream.seekp(0, std::ios_base::end);
    ret = m_stream.tellp();

    SetSeek(oldseek);
    return ret;
}

void CBinaryFile::RawWrite(const void* data, size_t size)
{
    if(!IsOpen() || IsRead()) { return; }
    m_stream.write((char*)data, size);
}

void CBinaryFile::RawRead(void* data, size_t size)
{
    if(!IsOpen() || IsWrite() || GetSeek() + size > GetSize()) { return; }
    m_stream.read((char*)data, size);
}

bool CBinaryFile::IsRead() const
{
    return !m_isWrite;
}

bool CBinaryFile::IsWrite() const
{
    return m_isWrite;
}

bool CBinaryFile::is_eof()
{
    return IsOpen() && GetSeek() <= GetSize();
}

void CBinaryFile::Open(const std::filesystem::path& filename, bool isread)
{
    isread ? OpenRead(filename) : OpenWrite(filename);
}

CFileGuard::CFileGuard(CBinaryFile& file) : m_File(file) {}
CFileGuard::CFileGuard(CBinaryFile& file, const std::filesystem::path& filename, bool isread) : m_File(file) { m_File.Open(filename, isread); }
CFileGuard::~CFileGuard()
{
    if(m_File.IsOpen())
    {
        m_File.Close();
    }
}

class CBinaryFileTester : public CCustomCommandProcessor
{
public:
    CBinaryFileTester()
    {
        Log::Instance() << "Welcome to the binary file tester\n";
    }

    CBinaryFile File;

    template<typename T>
    void Write(const std::wstring& val)
    {
        File.Write<T>(StringUtils::FromStr<T>(val));
    }

    template<typename T>
    std::wstring Read()
    {
        return StringUtils::ToStr<std::wstring, T>(File.Read<T>());
    }

    void WriteByType(const CCommandArgsWrapper& args, size_t curindex)
    {
        std::wstring type = args[curindex];
        std::wstring val = args[curindex + 1];

        if(type == L"int8") { Write<std::int8_t>(val); }
        else if(type == L"uint8") { Write<std::uint8_t>(val); }
        else if(type == L"int16") { Write<std::int16_t>(val); }
        else if(type == L"uint16") { Write<std::uint16_t>(val); }
        else if(type == L"int32") { Write<std::int32_t>(val); }
        else if(type == L"uint32") { Write<std::uint32_t>(val); }
        else if(type == L"int64") { Write<std::int64_t>(val); }
        else if(type == L"uint64") { Write<std::uint64_t>(val); }
        else if(type == L"float") { Write<float>(val); }
        else if(type == L"double") { Write<double>(val); }
        else if(type == L"bool") { Write<bool>(val); }
        else if(type == L"angle") { Write<CAngle>(val); }
        else if(type == L"angles") { Write<CAngles>(val); }
        else if(type == L"vec1") { Write<glm::vec1>(val); }
        else if(type == L"vec2") { Write<glm::vec2>(val); }
        else if(type == L"vec3") { Write<glm::vec3>(val); }
        else if(type == L"vec4") { Write<glm::vec4>(val); }
        else if(type == L"quat") { Write<glm::quat>(val); }
        else if(type == L"str" || type == L"string") { File.WriteString<std::string>(StringUtils::WstrToStr(val)); }
        else if(type == L"wstr" || type == L"wstring") { File.WriteString<std::wstring>(val); }
        else if(type == L"lenstr8") { File.WriteLenString<std::uint8_t, std::string>(StringUtils::WstrToStr(val)); }
        else if(type == L"lenstr16") { File.WriteLenString<std::uint16_t, std::string>(StringUtils::WstrToStr(val)); }
        else if(type == L"lenstr32") { File.WriteLenString<std::uint32_t, std::string>(StringUtils::WstrToStr(val)); }
        else if(type == L"lenstr64") { File.WriteLenString<std::uint64_t, std::string>(StringUtils::WstrToStr(val)); }
        else if(type == L"lenstr8force") { File.WriteLenString<std::uint8_t, std::string>(StringUtils::WstrToStr(val), true, StringUtils::FromStr<size_t>(args[curindex + 2])); }
        else if(type == L"lenstr16force") { File.WriteLenString<std::uint16_t, std::string>(StringUtils::WstrToStr(val), true, StringUtils::FromStr<size_t>(args[curindex + 2])); }
        else if(type == L"lenstr32force") { File.WriteLenString<std::uint32_t, std::string>(StringUtils::WstrToStr(val), true, StringUtils::FromStr<size_t>(args[curindex + 2])); }
        else if(type == L"lenstr64force") { File.WriteLenString<std::uint64_t, std::string>(StringUtils::WstrToStr(val), true, StringUtils::FromStr<size_t>(args[curindex + 2])); }
        else if(type == L"lenwstr8") { File.WriteLenString<std::uint8_t, std::wstring>(val); }
        else if(type == L"lenwstr16") { File.WriteLenString<std::uint16_t, std::wstring>(val); }
        else if(type == L"lenwstr32") { File.WriteLenString<std::uint32_t, std::wstring>(val); }
        else if(type == L"lenwstr64") { File.WriteLenString<std::uint64_t, std::wstring>(val); }
        else if(type == L"lenwstr8force") { File.WriteLenString<std::uint8_t, std::wstring>(val, true, StringUtils::FromStr<size_t>(args[curindex + 2])); }
        else if(type == L"lenwstr16force") { File.WriteLenString<std::uint16_t, std::wstring>(val, true, StringUtils::FromStr<size_t>(args[curindex + 2])); }
        else if(type == L"lenwstr32force") { File.WriteLenString<std::uint32_t, std::wstring>(val, true, StringUtils::FromStr<size_t>(args[curindex + 2])); }
        else if(type == L"lenwstr64force") { File.WriteLenString<std::uint64_t, std::wstring>(val, true, StringUtils::FromStr<size_t>(args[curindex + 2])); }
        else { Log::Instance() << "Invalid type\n"; }
    }

    std::wstring ReadByType(const CCommandArgsWrapper& args, size_t curindex)
    {
        std::wstring type = args[curindex];
        std::wstring val = args[curindex + 1];
        std::wstring ret;

        if(type == L"int8") { ret = StringUtils::ToStr<std::wstring>(Read<std::int8_t>()); }
        else if(type == L"uint8") { ret = StringUtils::ToStr<std::wstring>(Read<std::uint8_t>()); }
        else if(type == L"int16") { ret = StringUtils::ToStr<std::wstring>(Read<std::int16_t>()); }
        else if(type == L"uint16") { ret = StringUtils::ToStr<std::wstring>(Read<std::uint16_t>()); }
        else if(type == L"int32") { ret = StringUtils::ToStr<std::wstring>(Read<std::int32_t>()); }
        else if(type == L"uint32") { ret = StringUtils::ToStr<std::wstring>(Read<std::uint32_t>()); }
        else if(type == L"int64") { ret = StringUtils::ToStr<std::wstring>(Read<std::int64_t>()); }
        else if(type == L"uint64") { ret = StringUtils::ToStr<std::wstring>(Read<std::uint64_t>()); }
        else if(type == L"float") { ret = StringUtils::ToStr<std::wstring>(Read<float>()); }
        else if(type == L"double") { ret = StringUtils::ToStr<std::wstring>(Read<double>()); }
        else if(type == L"bool") { ret = StringUtils::ToStr<std::wstring>(Read<bool>()); }
        else if(type == L"angle") { ret = StringUtils::ToStr<std::wstring>(Read<CAngle>()); }
        else if(type == L"angles") { ret = StringUtils::ToStr<std::wstring>(Read<CAngles>()); }
        else if(type == L"vec1") { ret = StringUtils::ToStr<std::wstring>(Read<glm::vec1>()); }
        else if(type == L"vec2") { ret = StringUtils::ToStr<std::wstring>(Read<glm::vec2>()); }
        else if(type == L"vec3") { ret = StringUtils::ToStr<std::wstring>(Read<glm::vec3>()); }
        else if(type == L"vec4") { ret = StringUtils::ToStr<std::wstring>(Read<glm::vec4>()); }
        else if(type == L"quat") { ret = StringUtils::ToStr<std::wstring>(Read<glm::quat>()); }
        else if(type == L"str" || type == L"string") { ret = StringUtils::ToStr<std::wstring>(File.ReadString<std::string>()); }
        else if(type == L"wstr" || type == L"wstring") { ret = File.ReadString<std::wstring>(); }
        else if(type == L"lenstr8") { ret = StringUtils::ToStr<std::wstring>(File.ReadLenString<std::uint8_t, std::string>()); }
        else if(type == L"lenstr16") { ret = StringUtils::ToStr<std::wstring>(File.ReadLenString<std::uint16_t, std::string>()); }
        else if(type == L"lenstr32") { ret = StringUtils::ToStr<std::wstring>(File.ReadLenString<std::uint32_t, std::string>()); }
        else if(type == L"lenstr64") { ret = StringUtils::ToStr<std::wstring>(File.ReadLenString<std::uint64_t, std::string>()); }
        else if(type == L"lenwstr8") { ret = File.ReadLenString<std::uint8_t, std::wstring>(); }
        else if(type == L"lenwstr16") { ret = File.ReadLenString<std::uint16_t, std::wstring>(); }
        else if(type == L"lenwstr32") { ret = File.ReadLenString<std::uint32_t, std::wstring>(); }
        else if(type == L"lenwstr64") { ret = File.ReadLenString<std::uint64_t, std::wstring>(); }
        else { Log::Instance() << "Invalid type\n"; }

        return ret;
    }

    void m_process(const std::string& cmd, const CCommandArgsWrapper& args, const CCommandSender& sender) override
    {
        if(cmd == "open")
        {
            if(args[0] == L"write")
            {
                File.OpenWrite(args.WrapArgument<std::string>(1));
            }
            else if(args[0] == L"read")
            {
                File.OpenRead(args.WrapArgument<std::string>(1));
            }
            Log::Instance() << (File.IsOpen() ? "Opened file\n" : "Not opened file\n");
        }
        else if(cmd == "close")
        {
            File.Close();
            Log::Instance() << (File.IsOpen() ? "File wasn't closed\n" : "File isn't opened now\n");
        }
        else if(cmd == "size")
        {
            Log::Instance() << "Size is " << File.GetSize() << "\n";
        }
        else if(cmd == "seek")
        {
            bool isnum = !args[0].empty() && StringUtils::isNumber(args[0]);
            if(!isnum)
            {
                Log::Instance() << "Seek is " << File.GetSeek() << "\n";
            }
            else
            {
                File.SetSeek(StringUtils::FromStr<size_t>(args[0]));
                Log::Instance() << "Set seek to " << File.GetSeek() << "\n";
            }
        }
        else if(cmd == "mode")
        {
            if(!File.IsOpen()) { Log::Instance() << "Not opened\n"; }
            else
            {
                Log::Instance() << (File.IsWrite() ? "Write mode\n" : "Read mode\n");
            }
        }
        else if(cmd == "eof")
        {
            Log::Instance() << (File.is_eof() ? "Eof is true\n" : "NOT eof\n");
        }
        else if(cmd == "write")
        {
            WriteByType(args, 0);
            Log::Instance() << "Written\n";
        }
        else if(cmd == "read")
        {
            std::wstring ret = ReadByType(args, 0);
            Log::Instance() << "Read result: \"" << ret << "\"\n";
        }
    }
};

void TestBinaryFile()
{
    COMPONENT_CALL(CCommandProcessor, AddCustomProcessor(std::make_unique<CBinaryFileTester>()));
}