1 files changed, 138 insertions, 9 deletions

diff --git a/src/core/hle/service/acc/profile_manager.cpp b/src/core/hle/service/acc/profile_manager.cpp
index bcb3475db..06f7d1b15 100644
--- a/src/core/hle/service/acc/profile_manager.cpp
+++ b/src/core/hle/service/acc/profile_manager.cpp
@@ -4,32 +4,57 @@
 
 #include <random>
 #include <boost/optional.hpp>
+#include "common/file_util.h"
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"
 
 namespace Service::Account {
+
+struct UserRaw {
+    UUID uuid;
+    UUID uuid2;
+    u64 timestamp;
+    ProfileUsername username;
+    INSERT_PADDING_BYTES(0x80);
+};
+static_assert(sizeof(UserRaw) == 0xC8, "UserRaw has incorrect size.");
+
+struct ProfileDataRaw {
+    INSERT_PADDING_BYTES(0x10);
+    std::array<UserRaw, MAX_USERS> users;
+};
+static_assert(sizeof(ProfileDataRaw) == 0x650, "ProfileDataRaw has incorrect size.");
+
 // TODO(ogniK): Get actual error codes
 constexpr ResultCode ERROR_TOO_MANY_USERS(ErrorModule::Account, -1);
 constexpr ResultCode ERROR_USER_ALREADY_EXISTS(ErrorModule::Account, -2);
 constexpr ResultCode ERROR_ARGUMENT_IS_NULL(ErrorModule::Account, 20);
 
-const UUID& UUID::Generate() {
+constexpr char ACC_SAVE_AVATORS_BASE_PATH[] = "/system/save/8000000000000010/su/avators/";
+
+UUID UUID::Generate() {
     std::random_device device;
     std::mt19937 gen(device());
     std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
-    uuid[0] = distribution(gen);
-    uuid[1] = distribution(gen);
-    return *this;
+    return UUID{distribution(gen), distribution(gen)};
 }
 
 ProfileManager::ProfileManager() {
-    // TODO(ogniK): Create the default user we have for now until loading/saving users is added
-    auto user_uuid = UUID{1, 0};
-    ASSERT(CreateNewUser(user_uuid, Settings::values.username).IsSuccess());
-    OpenUser(user_uuid);
+    ParseUserSaveFile();
+
+    if (user_count == 0)
+        CreateNewUser(UUID::Generate(), "yuzu");
+
+    auto current = std::clamp<int>(Settings::values.current_user, 0, MAX_USERS - 1);
+    if (UserExistsIndex(current))
+        current = 0;
+
+    OpenUser(*GetUser(current));
 }
 
-ProfileManager::~ProfileManager() = default;
+ProfileManager::~ProfileManager() {
+    WriteUserSaveFile();
+}
 
 /// After a users creation it needs to be "registered" to the system. AddToProfiles handles the
 /// internal management of the users profiles
@@ -101,6 +126,12 @@ ResultCode ProfileManager::CreateNewUser(UUID uuid, const std::string& username)
     return CreateNewUser(uuid, username_output);
 }
 
+boost::optional<UUID> ProfileManager::GetUser(std::size_t index) const {
+    if (index >= MAX_USERS)
+        return boost::none;
+    return profiles[index].user_uuid;
+}
+
 /// Returns a users profile index based on their user id.
 boost::optional<std::size_t> ProfileManager::GetUserIndex(const UUID& uuid) const {
     if (!uuid) {
@@ -164,6 +195,12 @@ bool ProfileManager::UserExists(UUID uuid) const {
     return (GetUserIndex(uuid) != boost::none);
 }
 
+bool ProfileManager::UserExistsIndex(std::size_t index) const {
+    if (index >= MAX_USERS)
+        return false;
+    return profiles[index].user_uuid.uuid != INVALID_UUID;
+}
+
 /// Opens a specific user
 void ProfileManager::OpenUser(UUID uuid) {
     auto idx = GetUserIndex(uuid);
@@ -239,4 +276,96 @@ bool ProfileManager::CanSystemRegisterUser() const {
     // emulate qlaunch. Update this to dynamically change.
 }
 
+bool ProfileManager::RemoveUser(UUID uuid) {
+    auto index = GetUserIndex(uuid);
+    if (index == boost::none) {
+        return false;
+    }
+
+    profiles[*index] = ProfileInfo{};
+    std::stable_partition(profiles.begin(), profiles.end(),
+                          [](const ProfileInfo& profile) { return profile.user_uuid; });
+    return true;
+}
+
+bool ProfileManager::SetProfileBase(UUID uuid, const ProfileBase& profile_new) {
+    auto index = GetUserIndex(uuid);
+    if (profile_new.user_uuid == UUID(INVALID_UUID) || index == boost::none) {
+        return false;
+    }
+
+    auto& profile = profiles[*index];
+    profile.user_uuid = profile_new.user_uuid;
+    profile.username = profile_new.username;
+    profile.creation_time = profile_new.timestamp;
+
+    return true;
+}
+
+void ProfileManager::ParseUserSaveFile() {
+    FileUtil::IOFile save(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
+                              ACC_SAVE_AVATORS_BASE_PATH + "profiles.dat",
+                          "rb");
+
+    if (!save.IsOpen()) {
+        LOG_WARNING(Service_ACC, "Failed to load profile data from save data... Generating new "
+                                 "user 'yuzu' with random UUID.");
+        return;
+    }
+
+    ProfileDataRaw data;
+    if (save.ReadBytes(&data, sizeof(ProfileDataRaw)) != sizeof(ProfileDataRaw)) {
+        LOG_WARNING(Service_ACC, "profiles.dat is smaller than expected... Generating new user "
+                                 "'yuzu' with random UUID.");
+        return;
+    }
+
+    for (std::size_t i = 0; i < MAX_USERS; ++i) {
+        const auto& user = data.users[i];
+
+        if (user.uuid != UUID(INVALID_UUID))
+            AddUser({user.uuid, user.username, user.timestamp, {}, false});
+    }
+
+    std::stable_partition(profiles.begin(), profiles.end(),
+                          [](const ProfileInfo& profile) { return profile.user_uuid; });
+}
+
+void ProfileManager::WriteUserSaveFile() {
+    ProfileDataRaw raw{};
+
+    for (std::size_t i = 0; i < MAX_USERS; ++i) {
+        raw.users[i].username = profiles[i].username;
+        raw.users[i].uuid2 = profiles[i].user_uuid;
+        raw.users[i].uuid = profiles[i].user_uuid;
+        raw.users[i].timestamp = profiles[i].creation_time;
+    }
+
+    const auto raw_path =
+        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) + "/system/save/8000000000000010";
+    if (FileUtil::Exists(raw_path) && !FileUtil::IsDirectory(raw_path))
+        FileUtil::Delete(raw_path);
+
+    const auto path = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
+                      ACC_SAVE_AVATORS_BASE_PATH + "profiles.dat";
+
+    if (!FileUtil::CreateFullPath(path)) {
+        LOG_WARNING(Service_ACC, "Failed to create full path of profiles.dat. Create the directory "
+                                 "nand/system/save/8000000000000010/su/avators to mitigate this "
+                                 "issue.");
+        return;
+    }
+
+    FileUtil::IOFile save(path, "wb");
+
+    if (!save.IsOpen()) {
+        LOG_WARNING(Service_ACC, "Failed to write save data to file... No changes to user data "
+                                 "made in current session will be saved.");
+        return;
+    }
+
+    save.Resize(sizeof(ProfileDataRaw));
+    save.WriteBytes(&raw, sizeof(ProfileDataRaw));
+}
+
 }; // namespace Service::Account