1 files changed, 162 insertions, 0 deletions
diff --git a/source/application/discord/core.cpp b/source/application/discord/core.cpp
new file mode 100644
index 0000000..69a10a1
--- /dev/null
+++ b/source/application/discord/core.cpp
@@ -0,0 +1,162 @@
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "core.h"
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+Result Core::Create(ClientId clientId, std::uint64_t flags, Core** instance)
+{
+    if (!instance) {
+        return Result::InternalError;
+    }
+
+    (*instance) = new Core();
+    DiscordCreateParams params{};
+    DiscordCreateParamsSetDefault(&params);
+    params.client_id = clientId;
+    params.flags = flags;
+    params.events = nullptr;
+    params.event_data = *instance;
+    params.user_events = &UserManager::events_;
+    params.activity_events = &ActivityManager::events_;
+    params.relationship_events = &RelationshipManager::events_;
+    params.lobby_events = &LobbyManager::events_;
+    params.network_events = &NetworkManager::events_;
+    params.overlay_events = &OverlayManager::events_;
+    params.store_events = &StoreManager::events_;
+    auto result = DiscordCreate(DISCORD_VERSION, &params, &((*instance)->internal_));
+    if (result != DiscordResult_Ok || !(*instance)->internal_) {
+        delete (*instance);
+        (*instance) = nullptr;
+    }
+
+    return static_cast<Result>(result);
+}
+
+Core::~Core()
+{
+    if (internal_) {
+        internal_->destroy(internal_);
+        internal_ = nullptr;
+    }
+}
+
+Result Core::RunCallbacks()
+{
+    auto result = internal_->run_callbacks(internal_);
+    return static_cast<Result>(result);
+}
+
+void Core::SetLogHook(LogLevel minLevel, std::function<void(LogLevel, char const*)> hook)
+{
+    setLogHook_.DisconnectAll();
+    setLogHook_.Connect(std::move(hook));
+    static auto wrapper =
+      [](void* callbackData, EDiscordLogLevel level, char const* message) -> void {
+        auto cb(reinterpret_cast<decltype(setLogHook_)*>(callbackData));
+        if (!cb) {
+            return;
+        }
+        (*cb)(static_cast<LogLevel>(level), static_cast<const char*>(message));
+    };
+
+    internal_->set_log_hook(
+      internal_, static_cast<EDiscordLogLevel>(minLevel), &setLogHook_, wrapper);
+}
+
+discord::ApplicationManager& Core::ApplicationManager()
+{
+    if (!applicationManager_.internal_) {
+        applicationManager_.internal_ = internal_->get_application_manager(internal_);
+    }
+
+    return applicationManager_;
+}
+
+discord::UserManager& Core::UserManager()
+{
+    if (!userManager_.internal_) {
+        userManager_.internal_ = internal_->get_user_manager(internal_);
+    }
+
+    return userManager_;
+}
+
+discord::ImageManager& Core::ImageManager()
+{
+    if (!imageManager_.internal_) {
+        imageManager_.internal_ = internal_->get_image_manager(internal_);
+    }
+
+    return imageManager_;
+}
+
+discord::ActivityManager& Core::ActivityManager()
+{
+    if (!activityManager_.internal_) {
+        activityManager_.internal_ = internal_->get_activity_manager(internal_);
+    }
+
+    return activityManager_;
+}
+
+discord::RelationshipManager& Core::RelationshipManager()
+{
+    if (!relationshipManager_.internal_) {
+        relationshipManager_.internal_ = internal_->get_relationship_manager(internal_);
+    }
+
+    return relationshipManager_;
+}
+
+discord::LobbyManager& Core::LobbyManager()
+{
+    if (!lobbyManager_.internal_) {
+        lobbyManager_.internal_ = internal_->get_lobby_manager(internal_);
+    }
+
+    return lobbyManager_;
+}
+
+discord::NetworkManager& Core::NetworkManager()
+{
+    if (!networkManager_.internal_) {
+        networkManager_.internal_ = internal_->get_network_manager(internal_);
+    }
+
+    return networkManager_;
+}
+
+discord::OverlayManager& Core::OverlayManager()
+{
+    if (!overlayManager_.internal_) {
+        overlayManager_.internal_ = internal_->get_overlay_manager(internal_);
+    }
+
+    return overlayManager_;
+}
+
+discord::StorageManager& Core::StorageManager()
+{
+    if (!storageManager_.internal_) {
+        storageManager_.internal_ = internal_->get_storage_manager(internal_);
+    }
+
+    return storageManager_;
+}
+
+discord::StoreManager& Core::StoreManager()
+{
+    if (!storeManager_.internal_) {
+        storeManager_.internal_ = internal_->get_store_manager(internal_);
+    }
+
+    return storeManager_;
+}
+
+} // namespace discord