new approach 00.

src/Nocr.TelegramListener.AppServices/UpdateListeners/UpdateListenerBackgroundService.cs

@@ -1,12 +1,9 @@
-using System.Collections.Concurrent;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
+
 using Nocr.TelegramListener.AppServices.UpdateListeners.Handlers;
-using Prometheus;
 using TL;
-using TL.Methods;
 using WTelegram;
 
 namespace Nocr.TelegramListener.AppServices.UpdateListeners;
@@ -16,85 +13,67 @@ public sealed class UpdateListenerBackgroundService : BackgroundService
     private readonly ILogger<UpdateListenerBackgroundService> _logger;
     private readonly IServiceProvider _serviceProvider;
     private readonly ITelegramClientContainer _telegramClientContainer;
+    private readonly TelegramRegistry _telegramRegistry;
 
-    private UpdateManager? _updateManager;
-
-    private readonly INewMessageHandler _newMessageHandler;
+    private DateTimeOffset _activityStartTime = DateTimeOffset.UtcNow;
 
     public UpdateListenerBackgroundService(
         ILogger<UpdateListenerBackgroundService> logger,
         IServiceProvider serviceProvider,
         ITelegramClientContainer telegramClientContainer,
-        INewMessageHandler newMessageHandler)
+        TelegramRegistry telegramRegistry)
     {
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         _serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
         _telegramClientContainer =
             telegramClientContainer ?? throw new ArgumentNullException(nameof(telegramClientContainer));
-
-        _newMessageHandler = newMessageHandler ?? throw new ArgumentNullException(nameof(newMessageHandler));
+        _telegramRegistry = telegramRegistry ?? throw new ArgumentNullException(nameof(telegramRegistry));
     }
 
 
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
     {
         Helpers.Log = (l, s) => System.Diagnostics.Debug.WriteLine(s);
-
+        Client? client = null;
         while (!stoppingToken.IsCancellationRequested)
         {
-            try
+            if (DateTimeOffset.UtcNow - TimeSpan.FromHours(2) < _activityStartTime)
             {
-                if (_telegramClientContainer.Client != null)
-                {
-                    _logger.LogWarning($"Liveness timeout exceed. Resetting WTelegram client..");
-                    _telegramClientContainer.Reset();
+                _logger.LogInformation("Timeout exceed.");
+                _activityStartTime = DateTimeOffset.UtcNow;
 
-                }
+                client = null;
+            }
 
+            if (client == null)
+            {
+                _telegramRegistry.Clear();
+                _telegramClientContainer.Reset();
                 _telegramClientContainer.Initialize();
-                _updateManager = _telegramClientContainer.Client.WithUpdateManager(HandleUpdates);
 
-                var my = await _telegramClientContainer.Client.LoginUserIfNeeded();
+                client = _telegramClientContainer.Client;
+                client.OnUpdates += HandleUpdates;
+                var my = await client.LoginUserIfNeeded();
+                _telegramRegistry.SetMy(my);
 
                 _logger.LogInformation("Telegram client is logged-in as {Username} (id {Id})",
-                    my.username ??
-                    my.first_name + " " + my.last_name,
-                    my.id);
-
-                var dialogs = await _telegramClientContainer.Client.Messages_GetAllDialogs();
-                dialogs.CollectUsersChats(_updateManager.Users, _updateManager.Chats);
-
-                await Task.Delay(TimeSpan.FromHours(2), stoppingToken);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error in main loop. Restarting...");
-                _telegramClientContainer.Reset();
-                await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
-                continue;
+                    _telegramRegistry.My.username ??
+                    _telegramRegistry.My.first_name + " " + _telegramRegistry.My.last_name,
+                    _telegramRegistry.My.id);
             }
+            
+            await _telegramRegistry.Update(client);
+            await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
         }
     }
 
-    private async Task HandleUpdates(Update update)
+    private async Task HandleUpdates(UpdatesBase updates)
     {
-        _logger.LogInformation($"Update of type: {update.GetType().Name} received.");
-
-        switch (update)
+        using var scope = _serviceProvider.CreateScope();
+        var updateHandler = scope.ServiceProvider.GetRequiredService<IUpdateHandler>();
+        foreach (var update in updates.UpdateList)
         {
-            case UpdateNewMessage unm: await HandleMessage(unm.message); break;
-            case UpdateEditMessage uem: await HandleMessage(uem.message, true); break;
-            default: break;
+            await updateHandler.HandleUpdate(update);
         }
     }
-
-    private Task HandleMessage(MessageBase messageBase, bool edit = false)
-    {
-        switch (messageBase)
-        {
-            case Message m: _newMessageHandler.Handle(m); break;
-        }
-        return Task.CompletedTask;
-    }
-
 }