Languages.h

// Wykonane przez Piotra Chudzińskiego w dniu 14.05.2025
#pragma once
 
#include <foundation/Common.h>
#include <nlohmann/json.hpp>
#include <unordered_map>
#include "vfspp/IFileSystem.h"
 
#define _TW(key) Phosphorus::Languages::TranslateWide(key)
#define _T(key) Phosphorus::Languages::Translate(key)
 
namespace Phosphorus
{
    class Languages
    {
    private:
        struct Language
        {
            String Code;
            nlohmann::json Dictionary;
        };
 
        inline static int32 m_CurrentLanguage = 0;

        inline static std::unordered_map<int32, Language> m_Dictionaries;
 
    public:
        template<typename TELang>
        static void SetLanguage(TELang lang)
        {
            m_CurrentLanguage = static_cast<int32>(lang);
        }

        template<typename TELang>
        static void LoadDictionary(vfspp::IFileSystemPtr system, const String &path, TELang lang)
        {
            const vfspp::IFilePtr ptr = system->OpenFile(vfspp::FileInfo(path.Get()), vfspp::IFile::FileMode::Read);
 
            std::vector<uint8> fileData;
            fileData.resize(ptr->Size());
            ptr->Read(fileData.data(), ptr->Size());
 
            std::string s = std::string{reinterpret_cast<int8 *>(fileData.data()), fileData.size()};
 
            const auto &json = nlohmann::json::parse(s);
 
            Language language;
            language.Dictionary = json;
            language.Code = json["generic.code"].get<std::string>();
 
            m_Dictionaries.emplace(static_cast<int32>(lang), language);
            INFO("[Languages] Loaded '{}' language ('{}')", json["generic.name"].get<std::string>(),
                 json["generic.name"].get<std::string>());
        }
 
        static String Translate(const String &key);
        static WideString TranslateWide(const String &key);
    };
} // namespace Phosphorus