2 files changed, 120 insertions, 23 deletions

diff --git a/src/core/system.cpp b/src/core/system.cpp
index a5f763805..fa8bd0317 100644
--- a/src/core/system.cpp
+++ b/src/core/system.cpp
@@ -13,33 +13,30 @@
 #include "core/system.h"
 #include "video_core/video_core.h"
 
-namespace System {
+namespace Core {
 
-static bool is_powered_on{false};
+/*static*/ System System::s_instance;
 
-Result Init(EmuWindow* emu_window, u32 system_mode) {
+System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
     Core::Init();
     CoreTiming::Init();
     Memory::Init();
     HW::Init();
     Kernel::Init(system_mode);
     HLE::Init();
-    if (!VideoCore::Init(emu_window)) {
-        return Result::ErrorInitVideoCore;
-    }
     AudioCore::Init();
     GDBStub::Init();
 
-    is_powered_on = true;
+    if (!VideoCore::Init(emu_window)) {
+        return ResultStatus::ErrorVideoCore;
+    }
 
-    return Result::Success;
-}
+    is_powered_on = true;
 
-bool IsPoweredOn() {
-    return is_powered_on;
+    return ResultStatus::Success;
 }
 
-void Shutdown() {
+void System::Shutdown() {
     GDBStub::Shutdown();
     AudioCore::Shutdown();
     VideoCore::Shutdown();
@@ -52,4 +49,42 @@ void Shutdown() {
     is_powered_on = false;
 }
 
-} // namespace
+System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& filepath) {
+    state.app_loader = Loader::GetLoader(filepath);
+
+    if (!state.app_loader) {
+        LOG_CRITICAL(Frontend, "Failed to obtain loader for %s!", filepath.c_str());
+        return ResultStatus::ErrorGetLoader;
+    }
+
+    boost::optional<u32> system_mode{ state.app_loader->LoadKernelSystemMode() };
+    if (!system_mode) {
+        LOG_CRITICAL(Frontend, "Failed to determine system mode!");
+        return ResultStatus::ErrorSystemMode;
+    }
+
+    ResultStatus init_result{ Init(emu_window, system_mode.get()) };
+    if (init_result != ResultStatus::Success) {
+        LOG_CRITICAL(Frontend, "Failed to initialize system (Error %i)!", init_result);
+        System::Shutdown();
+        return init_result;
+    }
+
+    const Loader::ResultStatus load_result{ state.app_loader->Load() };
+    if (Loader::ResultStatus::Success != load_result) {
+        LOG_CRITICAL(Frontend, "Failed to load ROM (Error %i)!", load_result);
+        System::Shutdown();
+
+        switch (load_result) {
+        case Loader::ResultStatus::ErrorEncrypted:
+            return ResultStatus::ErrorLoader_ErrorEncrypted;
+        case Loader::ResultStatus::ErrorInvalidFormat:
+            return ResultStatus::ErrorLoader_ErrorInvalidFormat;
+        default:
+            return ResultStatus::ErrorLoader;
+        }
+    }
+    return ResultStatus::Success;
+}
+
+} // namespace Core
diff --git a/src/core/system.h b/src/core/system.h
index b41fc088a..192a9c447 100644
--- a/src/core/system.h
+++ b/src/core/system.h
@@ -4,18 +4,80 @@
 
 #pragma once
 
+#include <string>
+
+#include "core/loader/loader.h"
+
 class EmuWindow;
 
-namespace System {
+namespace Core {
+
+class System {
+public:
+    struct State {
+        std::unique_ptr<Loader::AppLoader> app_loader;
+    };
+
+    /**
+     * Gets the instance of the System singleton class.
+     * @returns Reference to the instance of the System singleton class.
+     */
+    static System& GetInstance() {
+        return s_instance;
+    }
+
+    /// Enumeration representing the return values of the System Initialize and Load process.
+    enum class ResultStatus : u32 {
+        Success, ///< Succeeded
+        ErrorGetLoader, ///< Error finding the correct application loader
+        ErrorSystemMode, ///< Error determining the system mode
+        ErrorLoader, ///< Error loading the specified application
+        ErrorLoader_ErrorEncrypted, ///< Error loading the specified application due to encryption
+        ErrorLoader_ErrorInvalidFormat, ///< Error loading the specified application due to an invalid format
+        ErrorVideoCore, ///< Error in the video core
+    };
+
+    /**
+     * Initialize the emulated system.
+     * @param emu_window Pointer to the host-system window used for video output and keyboard input.
+     * @param system_mode The system mode.
+     * @returns ResultStatus code, indicating if the operation succeeded.
+     */
+    ResultStatus Init(EmuWindow* emu_window, u32 system_mode);
+
+    /// Shutdown the emulated system.
+    void Shutdown();
+
+    /**
+     * Load an executable application.
+     * @param emu_window Pointer to the host-system window used for video output and keyboard input.
+     * @param filepath String path to the executable application to load on the host file system.
+     * @returns ResultStatus code, indicating if the operation succeeded.
+     */
+    ResultStatus Load(EmuWindow* emu_window, const std::string& filepath);
+
+    /**
+     * Indicates if the emulated system is powered on (all subsystems initialized and able to run an
+     * application).
+     * @returns True if the emulated system is powered on, otherwise false.
+     */
+    bool IsPoweredOn() const {
+        return is_powered_on;
+    }
+
+    /**
+     * Gets the internal state of the emulated system.
+     * @returns The internal state of the emulated system
+     */
+    State& GetState() {
+        return state;
+    }
+
+private:
+    bool is_powered_on{};
+    State state;
 
-enum class Result {
-    Success,            ///< Everything is fine
-    Error,              ///< Something went wrong (no module specified)
-    ErrorInitCore,      ///< Something went wrong during core init
-    ErrorInitVideoCore, ///< Something went wrong during video core init
+    static System s_instance;
 };
 
-Result Init(EmuWindow* emu_window, u32 system_mode);
-bool IsPoweredOn();
-void Shutdown();
-}
+} // namespace Core