App.axaml.cs

using Aniki.Services.Anime;
using Aniki.Services.Interfaces;
using Aniki.Views;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Controls.ApplicationLifetimes;
using Avalonia.Data.Core.Plugins;
using Avalonia.Markup.Xaml;
using Avalonia.Threading;
using Velopack;
using Velopack.Sources;

namespace Aniki;

internal sealed class App : Application
{
    public override void Initialize()
    {
        DependencyInjection.Instance.BuildServiceProvider();
        AvaloniaXamlLoader.Load(this);
    }
    
    public void Reset()
    {
        if (ApplicationLifetime is not IClassicDesktopStyleApplicationLifetime desktop) return;
        
        Window? oldWindow = desktop.MainWindow;

        AnimeService.IsLoggedIn = false;
        DependencyInjection.Instance.Logout();
        
        desktop.MainWindow = new LoginWindow();
        desktop.MainWindow.Show();
        
        oldWindow?.Close();
        
    }

    public override void OnFrameworkInitializationCompleted()
    {
        Dispatcher.UIThread.UnhandledException += OnUnhandledException;

        _ = PostInitialization();
    }

    private async Task PostInitialization()
    {
        BindingPlugins.DataValidators.RemoveAt(0);
        
        if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
        {
            desktop.ShutdownRequested += OnShutdownRequested;
            
            desktop.MainWindow = new LoginWindow();

            await CheckForUpdates().ConfigureAwait(true);
        }
        
        DependencyInjection.Instance.ServiceProvider!.GetService<ITokenService>()?.Init();

        AppDomain.CurrentDomain.UnhandledException += (sender, e) => 
            OnUnhandledException(sender, (DispatcherUnhandledExceptionEventArgs)e.ExceptionObject );
        
        base.OnFrameworkInitializationCompleted();
    }

    private static async Task CheckForUpdates()
    {
        try
        {
            UpdateManager mgr = new(new GithubSource("https://github.com/TrueTheos/Aniki", null, false));

            if (!mgr.IsInstalled)
                return;

            UpdateInfo? update = await mgr.CheckForUpdatesAsync().ConfigureAwait(true);
            if (update == null)
                return;

            var target = update.TargetFullRelease.Version;
            if (mgr.CurrentVersion is { } current && target <= current)
                return;

            await mgr.DownloadUpdatesAsync(update).ConfigureAwait(true);

            mgr.ApplyUpdatesAndRestart(update.TargetFullRelease);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Update check failed: {ex.Message}");
        }
    }
    
    private async void OnShutdownRequested(object? sender, ShutdownRequestedEventArgs e)
    {
        e.Cancel = true;
        
        try
        {
            await DependencyInjection.Instance.ServiceProvider!.GetRequiredService<ISaveService>().SaveAllCaches().ConfigureAwait(true);

            if (sender is not IClassicDesktopStyleApplicationLifetime lifetime) return;
            lifetime.ShutdownRequested -= OnShutdownRequested;
            lifetime.Shutdown();
        }
        catch
        {
            // ignored
        }
    }
    
    private void OnUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
    {
        Console.WriteLine(e.Exception);

        e.Handled = true;
    }
}