Wino-Mail/Wino.Mail/Views/ImapSetup/TestingImapConnectionPage.xaml.cs

using System;
using System.Threading.Tasks;
using CommunityToolkit.Mvvm.Messaging;
using Microsoft.Extensions.DependencyInjection;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Navigation;
using Wino.Core.Domain;
using Wino.Core.Domain.Entities.Shared;
using Wino.Core.Domain.Exceptions;
using Wino.Core.Domain.Interfaces;
using Wino.Core.Domain.Models.AutoDiscovery;
using Wino.Core.Domain.Models.Connectivity;
using Wino.Messaging.Client.Mails;
using Wino.Messaging.Server;


namespace Wino.Views.ImapSetup;

public sealed partial class TestingImapConnectionPage : Page
{
    private IWinoServerConnectionManager _winoServerConnectionManager = App.Current.Services.GetService<IWinoServerConnectionManager>();
    private AutoDiscoverySettings autoDiscoverySettings;
    private CustomServerInformation serverInformationToTest;

    public TestingImapConnectionPage()
    {
        InitializeComponent();
    }

    protected override async void OnNavigatedTo(NavigationEventArgs e)
    {
        base.OnNavigatedTo(e);

        // We can only go back to this page from failed connection page.
        // We must go back once again in that case to actual setup dialog.
        if (e.NavigationMode == NavigationMode.Back)
        {
            WeakReferenceMessenger.Default.Send(new ImapSetupBackNavigationRequested());
        }
        else
        {
            // Test connection

            // Discovery settings are passed.
            // Create server information out of the discovery settings.
            if (e.Parameter is AutoDiscoverySettings parameterAutoDiscoverySettings)
            {
                autoDiscoverySettings = parameterAutoDiscoverySettings;
                serverInformationToTest = autoDiscoverySettings.ToServerInformation();
            }
            else if (e.Parameter is CustomServerInformation customServerInformation)
            {
                // Only server information is passed.
                serverInformationToTest = customServerInformation;
            }

            // Make sure that certificate dialog must be present in case of SSL handshake fails.
            await PerformTestAsync(allowSSLHandshake: false);
        }
    }

    private async Task PerformTestAsync(bool allowSSLHandshake)
    {
        CertificateDialog.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
        TestingConnectionPanel.Visibility = Windows.UI.Xaml.Visibility.Visible;

        await Task.Delay(1000);

        var testResultResponse = await _winoServerConnectionManager
            .GetResponseAsync<ImapConnectivityTestResults, ImapConnectivityTestRequested>(new ImapConnectivityTestRequested(serverInformationToTest, allowSSLHandshake));

        if (!testResultResponse.IsSuccess)
        {
            // Wino Server is connection is failed.
            ReturnWithError(testResultResponse.Message);
        }
        else
        {
            var testResultData = testResultResponse.Data;

            if (testResultData.IsSuccess)
            {
                // All success. Finish setup with validated server information.
                ReturnWithSuccess();
            }
            else
            {
                // Check if certificate UI is required.

                if (testResultData.IsCertificateUIRequired)
                {
                    // Certificate UI is required. Show certificate dialog.

                    CertIssuer.Text = testResultData.CertificateIssuer;
                    CertValidFrom.Text = testResultData.CertificateValidFromDateString;
                    CertValidTo.Text = testResultData.CertificateExpirationDateString;

                    TestingConnectionPanel.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
                    CertificateDialog.Visibility = Windows.UI.Xaml.Visibility.Visible;
                }
                else
                {
                    // Connection test failed. Show error dialog.

                    var protocolLog = testResultData.FailureProtocolLog;

                    ReturnWithError(testResultData.FailedReason, protocolLog);
                }
            }
        }
    }

    private void ReturnWithError(string error, string protocolLog = "")
    {
        var failurePackage = new ImapConnectionFailedPackage(error, protocolLog, autoDiscoverySettings);
        WeakReferenceMessenger.Default.Send(new ImapSetupBackNavigationRequested(typeof(ImapConnectionFailedPage), failurePackage));
    }

    private void ReturnWithSuccess()
        => WeakReferenceMessenger.Default.Send(new ImapSetupDismissRequested(serverInformationToTest));

    private void DenyClicked(object sender, Windows.UI.Xaml.RoutedEventArgs e)
        => ReturnWithError(Translator.IMAPSetupDialog_CertificateDenied, string.Empty);

    private async void AllowClicked(object sender, Windows.UI.Xaml.RoutedEventArgs e)
    {
        // Run the test again, but this time allow SSL handshake.
        // Any authentication error will be shown to the user after this test.

        await PerformTestAsync(allowSSLHandshake: true);
    }
}