CPP File

LanguageHandler::LanguageHandler(std::wstring languageFile)
{
    m_LanguageFile = languageFile;

    std::wstring parse = ParseLanguageFile();

    if (parse != L"ParseOK")
    {
        wxMessageBox(parse, L"Parse error", wxICON_ERROR);

        throw L"Parse error";
    }
}

// Simple parser for a *.lang file
std::wstring LanguageHandler::ParseLanguageFile()
{
    bool inLanguage = false;
    bool inSection = false;
    int currentLine = 0;
    std::wstring currentLanguage = L"";
    std::wstring currentSection = L"";

    std::map<std::wstring, // Section
        std::map<std::wstring, // Key
        std::wstring>> oneLanguage;

    // Open file
    std::wifstream langFile(m_LanguageFile);
    if (!langFile.is_open())
        return L"Can not open file";

    for (std::wstring line; getline(langFile, line); currentLine++)
    {
        if (line.size() < 1)
            continue;

        // Remove all spaces
        line.erase(std::remove_if(line.begin(), line.end(), isspace), line.end());

        if (line[0] == L';') // Comment (ignore)
        {
            continue;
        }
        else if (line[0] == L'{') // Language name
        {
            inSection = false;

            if (inLanguage) // Syntax error (missing closing })
                return std::to_wstring(currentLine + 1) + L": Syntax error: missing closing }";

            inLanguage = true;
            currentLanguage = std::wstring(line.begin() + 1, line.end());
            continue;
        }
        else if (line[0] == L'}') // Language end
        {
            inSection = false;
            inLanguage = false;

            m_KnownLanguages.push_back(currentLanguage);

            m_Languages[currentLanguage] = oneLanguage;
            oneLanguage.clear();
        }
        else if (line[0] == L'[') // Section
        {
            if (!inLanguage)
                return std::to_wstring(currentLine + 1) + L": Syntax error: unexpected token \"[\"";

            inSection = true;
            currentSection = std::wstring(line.begin() + 1, line.end() - 1);

            if (*(line.end() - 1) != L']') // Syntax error (missing closing ])
                return std::to_wstring(currentLine + 1) + L": Syntax error: missing closing ]";
        }
        else
        {
            if (!inLanguage || !inSection || line.find('=', 0) == std::wstring::npos) // Unknown expression
                return std::to_wstring(currentLine + 1) + L": Unknown expression";

            // Key/value pair
            std::wstring key_value[2] = { L"", L"" };
            bool value = false;

            for (auto i : line)
            {
                if (i == '=')
                {
                    value = true;
                    continue;
                }

                key_value[static_cast<int>(value)] += i;
            }

            key_value[1] = AddSpacesToValue(key_value[1]);
            oneLanguage[currentSection][key_value[0]] = key_value[1];
        }
    }

    langFile.close();

    return L"ParseOK";
}

bool LanguageHandler::SetLanguage(std::wstring language)
{
    if (m_Languages.find(language) == m_Languages.end())
        return false;

    m_Language = language;

    return true;
}

std::wstring LanguageHandler::Translate(std::wstring frame, std::wstring element)
{
    if (m_Language == L"")
        return L"ERR_NO_LANG";

    if (m_Languages[m_Language].find(frame) == m_Languages[m_Language].end() ||
        m_Languages[m_Language][frame].find(element) == m_Languages[m_Language][frame].end())
    {
        return L"REPLACE ME";
    }

    return m_Languages[m_Language][frame][element];
}