#include <fstream>
#include <vector>
#include <stdint.h>

int main(int argc, char **argv)
{
    auto filename = argv[1];

    std::ifstream ifs{ filename, std::ios::binary | std::ios::ate };
    std::ifstream::pos_type pos = ifs.tellg();

    auto size = (size_t)pos;
    std::vector<char> file_bytes;

    file_bytes.resize(size);

    ifs.seekg(0, std::ios::beg);
    ifs.read(file_bytes.data(), size);
    ifs.close();

    auto krName = std::string(filename).substr(0, strlen(filename) - 4) + ".kr";

#pragma pack(push, 1)
    struct GrscHeader
    {
        char magic[4];
        struct
        {
            uint8_t major;
            uint8_t minor;
        } version;
        uint32_t num_subs;
        uint32_t unknown_2;
    };

    struct GrscSubHeader
    {
        char resource_name[80];
        int32_t unknown_1;
        int32_t unknown_2;
        char actor_name[80];
        uint32_t num_commands;
    };

    struct GrscCmdHeader
    {
        int32_t priority;
        int32_t unknown_1;
        uint32_t command_length;
    };
#pragma pack(pop)

    struct GrscCmd
    {
        const GrscCmdHeader *header;
        std::string command;
    };

    struct GrscSub
    {
        const GrscSubHeader *header;
        std::vector<GrscCmd> commands;
    };

    const char *cur_ptr = file_bytes.data();

    auto header = reinterpret_cast<const GrscHeader *>(cur_ptr);

    cur_ptr += sizeof(*header);

    std::vector<GrscSub> subs;

    for (int i = 0; i < (int)header->num_subs; i++)
    {
        GrscSub sub;

        sub.header = reinterpret_cast<const GrscSubHeader *>(cur_ptr);

        cur_ptr += sizeof(GrscSubHeader);

        for (int j = 0; j < sub.header->num_commands; j++)
        {
            GrscCmd cmd;

            cmd.header = reinterpret_cast<const GrscCmdHeader *>(cur_ptr);

            cur_ptr += sizeof(GrscCmdHeader);

            cmd.command = std::string(cur_ptr, cur_ptr + cmd.header->command_length);

            cur_ptr += cmd.header->command_length;

            sub.commands.emplace_back(cmd);
        }

        subs.emplace_back(sub);
    }

    std::vector<std::string> strings{};

    for (const auto &sub : subs)
    {
        for (const auto &cmd : sub.commands)
        {
            const auto &str = cmd.command;

            int cur_offset = 0;
            bool in_str = false;
            bool is_next_escaped = false;
            int offset_begin = 0;

            while (cur_offset < str.length())
            {
                if (in_str && is_next_escaped)
                {
                    is_next_escaped = false;
                }
                if (in_str && str[cur_offset] == '\\')
                {
                    is_next_escaped = true;
                }
                else if (str[cur_offset] == '"')
                {
                    if (in_str)
                    {
                        strings.emplace_back(std::string(str.substr(offset_begin, cur_offset - offset_begin)));
                    }
                    else
                    {
                        offset_begin = cur_offset + 1;
                    }

                    in_str = !in_str;
                }

                cur_offset++;
            }

            if (in_str)
            {
                printf("Warning: something might have gone wrong!");
            }
        }
    }

    printf("Bytes read %d / %d", (int)(cur_ptr - file_bytes.data()), file_bytes.size());

    std::ofstream ofs{ krName, std::ios::binary | std::ios::beg };

    for (auto &str : strings)
    {
        ofs.write(str.c_str(), str.length());
        ofs.write("\x0D\x0A", 2);
    }

    ofs.close();

    return 0;
}