1 files changed, 250 insertions, 0 deletions
diff --git a/Utilities/LibMatrix.HomeserverEmulator/Services/UserStore.cs b/Utilities/LibMatrix.HomeserverEmulator/Services/UserStore.cs
new file mode 100644
index 0000000..4ce9f92
--- /dev/null
+++ b/Utilities/LibMatrix.HomeserverEmulator/Services/UserStore.cs
@@ -0,0 +1,250 @@
+using System.Collections.Concurrent;
+using System.Collections.ObjectModel;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using ArcaneLibs;
+using ArcaneLibs.Collections;
+using ArcaneLibs.Extensions;
+using LibMatrix.EventTypes.Spec.State;
+using LibMatrix.Filters;
+using LibMatrix.Responses;
+
+namespace LibMatrix.HomeserverEmulator.Services;
+
+public class UserStore {
+    public ConcurrentBag<User> _users = new();
+    private readonly RoomStore _roomStore;
+
+    public UserStore(HSEConfiguration config, RoomStore roomStore) {
+        _roomStore = roomStore;
+        if (config.StoreData) {
+            var dataDir = Path.Combine(HSEConfiguration.Current.DataStoragePath, "users");
+            if (!Directory.Exists(dataDir)) Directory.CreateDirectory(dataDir);
+            foreach (var userId in Directory.GetDirectories(dataDir)) {
+                var tokensDir = Path.Combine(dataDir, userId, "tokens.json");
+                var path = Path.Combine(dataDir, userId, $"user.json");
+
+                var user = JsonSerializer.Deserialize<User>(File.ReadAllText(path));
+                user!.AccessTokens = JsonSerializer.Deserialize<ObservableDictionary<string, User.SessionInfo>>(File.ReadAllText(tokensDir))!;
+                _users.Add(user);
+            }
+
+            Console.WriteLine($"Loaded {_users.Count} users from disk");
+        }
+        else {
+            Console.WriteLine("Data storage is disabled, not loading users from disk");
+        }
+    }
+
+    public async Task<User?> GetUserById(string userId, bool createIfNotExists = false) {
+        if (_users.Any(x => x.UserId == userId))
+            return _users.First(x => x.UserId == userId);
+
+        if (!createIfNotExists)
+            return null;
+
+        return await CreateUser(userId);
+    }
+
+    public async Task<User?> GetUserByTokenOrNull(string token, bool createIfNotExists = false, string? serverName = null) {
+        if (_users.Any(x => x.AccessTokens.ContainsKey(token)))
+            return _users.First(x => x.AccessTokens.ContainsKey(token));
+
+        if (!createIfNotExists)
+            return null;
+        if (string.IsNullOrWhiteSpace(serverName)) throw new NullReferenceException("Server name was not passed");
+        var uid = $"@{Guid.NewGuid().ToString()}:{serverName}";
+        return await CreateUser(uid);
+    }
+
+    public async Task<User> GetUserByToken(string token, bool createIfNotExists = false, string? serverName = null) {
+        return await GetUserByTokenOrNull(token, createIfNotExists, serverName) ?? throw new MatrixException() {
+            ErrorCode = MatrixException.ErrorCodes.M_UNKNOWN_TOKEN,
+            Error = "Invalid token."
+        };
+    }
+
+    public async Task<User> CreateUser(string userId, Dictionary<string, object>? profile = null) {
+        profile ??= new();
+        if (!profile.ContainsKey("displayname")) profile.Add("displayname", userId.Split(":")[0]);
+        if (!profile.ContainsKey("avatar_url")) profile.Add("avatar_url", null);
+        var user = new User() {
+            UserId = userId,
+            AccountData = new() {
+                new StateEventResponse() {
+                    Type = "im.vector.analytics",
+                    RawContent = new JsonObject() {
+                        ["pseudonymousAnalyticsOptIn"] = false
+                    },
+                },
+                new StateEventResponse() {
+                    Type = "im.vector.web.settings",
+                    RawContent = new JsonObject() {
+                        ["developerMode"] = true
+                    }
+                },
+            }
+        };
+        user.Profile.AddRange(profile);
+        _users.Add(user);
+        if (!_roomStore._rooms.IsEmpty)
+            foreach (var item in Random.Shared.GetItems(_roomStore._rooms.ToArray(), Math.Min(_roomStore._rooms.Count, 400))) {
+                item.AddUser(userId);
+            }
+
+        int random = Random.Shared.Next(10);
+        for (int i = 0; i < random; i++) {
+            var room = _roomStore.CreateRoom(new());
+            room.AddUser(userId);
+        }
+
+        return user;
+    }
+
+    public class User : NotifyPropertyChanged {
+        public User() {
+            AccessTokens = new();
+            Filters = new();
+            Profile = new();
+            AccountData = new();
+            RoomKeys = new();
+            AuthorizedSessions = new();
+        }
+
+        private CancellationTokenSource _debounceCts = new();
+        private string _userId;
+        private ObservableDictionary<string, SessionInfo> _accessTokens;
+        private ObservableDictionary<string, SyncFilter> _filters;
+        private ObservableDictionary<string, object> _profile;
+        private ObservableCollection<StateEventResponse> _accountData;
+        private ObservableDictionary<string, RoomKeysResponse> _roomKeys;
+        private ObservableDictionary<string, AuthorizedSession> _authorizedSessions;
+
+        public string UserId {
+            get => _userId;
+            set => SetField(ref _userId, value);
+        }
+
+        public ObservableDictionary<string, SessionInfo> AccessTokens {
+            get => _accessTokens;
+            set {
+                if (value == _accessTokens) return;
+                _accessTokens = new(value);
+                _accessTokens.CollectionChanged += async (sender, args) => await SaveDebounced();
+                OnPropertyChanged();
+            }
+        }
+
+        public ObservableDictionary<string, SyncFilter> Filters {
+            get => _filters;
+            set {
+                if (value == _filters) return;
+                _filters = new(value);
+                _filters.CollectionChanged += async (sender, args) => await SaveDebounced();
+                OnPropertyChanged();
+            }
+        }
+
+        public ObservableDictionary<string, object> Profile {
+            get => _profile;
+            set {
+                if (value == _profile) return;
+                _profile = new(value);
+                _profile.CollectionChanged += async (sender, args) => await SaveDebounced();
+                OnPropertyChanged();
+            }
+        }
+
+        public ObservableCollection<StateEventResponse> AccountData {
+            get => _accountData;
+            set {
+                if (value == _accountData) return;
+                _accountData = new(value);
+                _accountData.CollectionChanged += async (sender, args) => await SaveDebounced();
+                OnPropertyChanged();
+            }
+        }
+
+        public ObservableDictionary<string, RoomKeysResponse> RoomKeys {
+            get => _roomKeys;
+            set {
+                if (value == _roomKeys) return;
+                _roomKeys = new(value);
+                _roomKeys.CollectionChanged += async (sender, args) => await SaveDebounced();
+                OnPropertyChanged();
+            }
+        }
+
+        public ObservableDictionary<string, AuthorizedSession> AuthorizedSessions {
+            get => _authorizedSessions;
+            set {
+                if (value == _authorizedSessions) return;
+                _authorizedSessions = new(value);
+                _authorizedSessions.CollectionChanged += async (sender, args) => await SaveDebounced();
+                OnPropertyChanged();
+            }
+        }
+
+        public async Task SaveDebounced() {
+            if (!HSEConfiguration.Current.StoreData) return;
+            await _debounceCts.CancelAsync();
+            _debounceCts = new CancellationTokenSource();
+            try {
+                await Task.Delay(250, _debounceCts.Token);
+                var dataDir = Path.Combine(HSEConfiguration.Current.DataStoragePath, "users", _userId);
+                if (!Directory.Exists(dataDir)) Directory.CreateDirectory(dataDir);
+                var tokensDir = Path.Combine(dataDir, "tokens.json");
+                var path = Path.Combine(dataDir, $"user.json");
+                Console.WriteLine($"Saving user {_userId} to {path}!");
+                await File.WriteAllTextAsync(path, this.ToJson(ignoreNull: true));
+                await File.WriteAllTextAsync(tokensDir, AccessTokens.ToJson(ignoreNull: true));
+            }
+            catch (TaskCanceledException) { }
+            catch (InvalidOperationException) { } // We don't care about 100% data safety, this usually happens when something is updated while serialising
+        }
+
+        public class SessionInfo {
+            public string DeviceId { get; set; } = Guid.NewGuid().ToString();
+            public Dictionary<string, UserSyncState> SyncStates { get; set; } = new();
+
+            public class UserSyncState {
+                public Dictionary<string, SyncRoomPosition> RoomPositions { get; set; } = new();
+                public string FilterId { get; set; }
+                public DateTime SyncStateCreated { get; set; } = DateTime.Now;
+
+                public class SyncRoomPosition {
+                    public int TimelinePosition { get; set; }
+                    public string LastTimelineEventId { get; set; }
+                    public int AccountDataPosition { get; set; }
+                    public bool Joined { get; set; }
+                }
+
+                public UserSyncState Clone() {
+                    return new() {
+                        FilterId = FilterId,
+                        RoomPositions = RoomPositions.ToDictionary(x => x.Key, x => new SyncRoomPosition() {
+                            TimelinePosition = x.Value.TimelinePosition,
+                            AccountDataPosition = x.Value.AccountDataPosition
+                        })
+                    };
+                }
+            }
+        }
+
+        public LoginResponse Login() {
+            var session = new SessionInfo();
+            AccessTokens.Add(Guid.NewGuid().ToString(), session);
+            SaveDebounced();
+            return new LoginResponse() {
+                AccessToken = AccessTokens.Keys.Last(),
+                DeviceId = session.DeviceId,
+                UserId = UserId
+            };
+        }
+
+        public class AuthorizedSession {
+            public string Homeserver { get; set; }
+            public string AccessToken { get; set; }
+        }
+    }
+}
\ No newline at end of file