#include <wchar.h>
#include <nn/fs.h>
#include <cstdlib>
#include "configLoader.h"

namespace common
{

Result ConfigFileLoader::Initialize(const wchar_t* fileName, void* buffer, const size_t bufferSize)
{
    s64 fileSize;
    FileInputStream fi;
    NN_UTIL_RETURN_IF_FAILED(fi.TryInitialize(fileName));
    NN_UTIL_RETURN_IF_FAILED(fi.TryGetSize(&fileSize));

    if (fileSize > bufferSize)
    {
        NN_TLOG_("Too Large File\n");
        return Result(nn::Result::LEVEL_FATAL, nn::Result::SUMMARY_OUT_OF_RESOURCE, nn::Result::MODULE_COMMON, nn::Result::DESCRIPTION_TOO_LARGE);
    }

    m_Buffer = static_cast<wchar_t*>(buffer);
    NN_UTIL_RETURN_IF_FAILED(fi.TryRead(&m_UsedBufferSize, m_Buffer, fileSize));

    return ParseData();
}

void ConfigFileLoader::Finalize()
{
    m_Buffer = 0;
    m_ParamNum = 0;
}

Result ConfigFileLoader::ParseData()
{
    if (!m_Buffer)
    {
        return Result(nn::Result::LEVEL_FATAL, nn::Result::SUMMARY_INVALID_STATE, nn::Result::MODULE_COMMON, nn::Result::DESCRIPTION_NOT_INITIALIZED);
    }

    int pos = 0;

    // ビッグエンディアンでないことを確認
    NN_ASSERTMSG(m_Buffer[0] != 0xfffe, "Invalid Config File's Endian\n");

    if (m_Buffer[0] == 0xfeff)
    {
        // UTF-16 BOMの調整
        pos++;
    }

    m_ParamNum = 0;
    m_ParamName[m_ParamNum] = &(m_Buffer[pos]);
    m_ParamValue[m_ParamNum] = L'\0';

    // ダブルクウォート中なら : も文字として読み取る
    bool inEscape = false;
    // # で行末までコメント
    bool inComment = false;

    while (pos < m_UsedBufferSize / sizeof(m_Buffer[0]))
    {
        switch (m_Buffer[pos])
        {
        case L'"':
        {
            inEscape = !inEscape;
        }
        break;

        case L'#':
        {
            inComment = true;
        }
        break;

        case L':':
        {
            if(inEscape || inComment)
            {
                break;
            }
            m_Buffer[pos] = L'\0';
            m_ParamValue[m_ParamNum++] = &(m_Buffer[pos + 1]);
        }

        break;
        case L'\r':
        case L'\n':
        {
            if(inComment)
            {
                inComment = false;
            }
            m_Buffer[pos] = L'\0';
            m_ParamName[m_ParamNum] = &(m_Buffer[pos + 1]);
            m_ParamValue[m_ParamNum] = L'\0';
        }
        break;

        }
        pos++;
    }

    return ResultSuccess();
}

s32 ConfigFileLoader::SearchParamName(const wchar_t *paramName)
{
    if (!m_Buffer)
    {
        NN_TLOG_("ConfigFileLoader not initialized.\n");
        return -1;
    }

    for (s32 i = 0; i < m_ParamNum; i++)
    {
        if (wcscmp(m_ParamName[i], paramName) == 0)
        {
            return i;
        }
    }
    return -1;
}

const wchar_t *ConfigFileLoader::ReadAsWChar(const wchar_t *paramName)
{
    s32 idx = SearchParamName(paramName);
    if (idx < 0)
    {
        NN_LOG("Unknown Parameter Name %ls\n", paramName);
    }
    return (idx < 0) ? L'\0' : m_ParamValue[idx];
}

const char *ConfigFileLoader::ReadAsChar(const wchar_t *paramName)
{
    memset(m_ReadCharBuffer, 0, sizeof(m_ReadCharBuffer));
    const wchar_t *value = ReadAsWChar(paramName);
    if(value == L'\0')
    {
        return NULL;
    }
    wcstombs(m_ReadCharBuffer, value, wcslen(value));
    return m_ReadCharBuffer;
}

int ConfigFileLoader::ReadAsInteger(const wchar_t *paramName)
{
    return atoi(ReadAsChar(paramName));
}

}