Wino-Mail/Wino.Mail.WinUI/Controls/ImagePreviewControl.cs

using System;
using System.IO;
using System.Net.Mail;
using System.Threading;
using System.Threading.Tasks;
using CommunityToolkit.WinUI;
using EmailValidation;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Media.Imaging;
using Wino.Core.Domain.Interfaces;
using Wino.Mail.WinUI;

namespace Wino.Controls;

/// <summary>
/// Contact avatar control built on top of PersonPicture.
/// Priority:
/// 1) AccountContact/Base64 picture
/// 2) Gravatar thumbnail (if enabled)
/// 3) Initials from display name fallback
/// </summary>
public sealed partial class ImagePreviewControl : PersonPicture
{
    private sealed record RefreshSnapshot(string DisplayName, string Address, string Base64Picture);

    private static readonly TimeSpan RefreshDebounceDuration = TimeSpan.FromMilliseconds(40);

    [GeneratedDependencyProperty]
    public partial IMailItemDisplayInformation? MailItemInformation { get; set; }

    [GeneratedDependencyProperty]
    public partial string? FromName { get; set; }

    [GeneratedDependencyProperty]
    public partial string? FromAddress { get; set; }

    [GeneratedDependencyProperty]
    public partial string? SenderContactPicture { get; set; }

    [GeneratedDependencyProperty(DefaultValue = false)]
    public partial bool ThumbnailUpdatedEvent { get; set; }

    private readonly IThumbnailService? _thumbnailService;
    private readonly IPreferencesService? _preferencesService;
    private CancellationTokenSource? _refreshCancellationTokenSource;
    private CancellationTokenSource? _scheduledRefreshCancellationTokenSource;
    private long _refreshVersion;

    public ImagePreviewControl()
    {
        DefaultStyleKey = typeof(PersonPicture);

        try
        {
            _thumbnailService = App.Current.Services.GetService<IThumbnailService>();
            _preferencesService = App.Current.Services.GetService<IPreferencesService>();
        }
        catch
        {
            // Keep control functional in design-time/test contexts without service provider.
        }

        Loaded += OnLoaded;
        Unloaded += OnUnloaded;
    }

    partial void OnMailItemInformationPropertyChanged(DependencyPropertyChangedEventArgs e)
    {
        RequestRefresh();
    }

    partial void OnFromNameChanged(string? newValue) => RequestRefresh();

    partial void OnFromAddressChanged(string? newValue) => RequestRefresh();

    partial void OnSenderContactPictureChanged(string? newValue) => RequestRefresh();

    partial void OnThumbnailUpdatedEventChanged(bool newValue) => RequestRefresh();

    private void OnLoaded(object sender, RoutedEventArgs e)
    {
        RequestRefresh();
    }

    private void OnUnloaded(object sender, RoutedEventArgs e)
    {
        CancelScheduledRefresh();
        CancelActiveRefresh();
    }

    private void RequestRefresh()
    {
        if (DispatcherQueue == null || DispatcherQueue.HasThreadAccess)
        {
            QueueRefresh();
            return;
        }

        DispatcherQueue.TryEnqueue(QueueRefresh);
    }

    private void QueueRefresh()
    {
        if (!IsLoaded)
            return;

        CancelScheduledRefresh();

        var cts = new CancellationTokenSource();
        _scheduledRefreshCancellationTokenSource = cts;

        _ = DebounceAndRefreshAsync(cts.Token);
    }

    private async Task DebounceAndRefreshAsync(CancellationToken cancellationToken)
    {
        try
        {
            await Task.Delay(RefreshDebounceDuration, cancellationToken).ConfigureAwait(false);
        }
        catch (OperationCanceledException)
        {
            return;
        }

        StartRefresh();
    }

    private void StartRefresh()
    {
        CancelActiveRefresh();

        var cts = new CancellationTokenSource();
        _refreshCancellationTokenSource = cts;
        var refreshVersion = Interlocked.Increment(ref _refreshVersion);
        _ = RefreshAsync(refreshVersion, cts.Token);
    }

    private void CancelScheduledRefresh()
    {
        var cts = _scheduledRefreshCancellationTokenSource;
        _scheduledRefreshCancellationTokenSource = null;

        if (cts != null && !cts.IsCancellationRequested)
        {
            cts.Cancel();
        }

        cts?.Dispose();
    }

    private void CancelActiveRefresh()
    {
        var cts = _refreshCancellationTokenSource;
        _refreshCancellationTokenSource = null;

        if (cts != null && !cts.IsCancellationRequested)
        {
            cts.Cancel();
        }

        cts?.Dispose();
    }

    private async Task RefreshAsync(long refreshVersion, CancellationToken cancellationToken)
    {
        try
        {
            var snapshot = await CaptureSnapshotAsync(refreshVersion, cancellationToken).ConfigureAwait(false);
            if (snapshot == null)
                return;

            await ApplyInitialVisualStateAsync(snapshot.DisplayName, refreshVersion, cancellationToken).ConfigureAwait(false);

            // 1) Explicit contact picture.
            if (!string.IsNullOrWhiteSpace(snapshot.Base64Picture))
            {
                var localBitmap = await CreateBitmapFromBase64Async(snapshot.Base64Picture, cancellationToken).ConfigureAwait(false);
                if (localBitmap != null)
                {
                    await ApplyProfilePictureAsync(localBitmap, refreshVersion, cancellationToken).ConfigureAwait(false);
                    return;
                }
            }

            // 2) Gravatar lookup through thumbnail service (if enabled).
            if (_preferencesService?.IsGravatarEnabled == true &&
                _thumbnailService != null &&
                !string.IsNullOrWhiteSpace(snapshot.Address) &&
                EmailValidator.Validate(snapshot.Address))
            {
                var thumbnailBase64 = await _thumbnailService
                    .GetThumbnailAsync(snapshot.Address.Trim().ToLowerInvariant(), awaitLoad: true)
                    .ConfigureAwait(false);

                if (!string.IsNullOrWhiteSpace(thumbnailBase64))
                {
                    var thumbnailBitmap = await CreateBitmapFromBase64Async(thumbnailBase64, cancellationToken).ConfigureAwait(false);
                    if (thumbnailBitmap != null)
                    {
                        await ApplyProfilePictureAsync(thumbnailBitmap, refreshVersion, cancellationToken).ConfigureAwait(false);
                        return;
                    }
                }
            }

            // 3) Initials fallback is already in place via DisplayName + ProfilePicture = null.
        }
        catch (OperationCanceledException)
        {
            // Expected during virtualization/recycling.
        }
        catch
        {
            // Keep fallback initials if decoding/network fails.
        }
    }

    // DependencyProperty-backed values must be read on UI thread once, then used off-thread.
    private async Task<RefreshSnapshot?> CaptureSnapshotAsync(long refreshVersion, CancellationToken cancellationToken)
    {
        return await ExecuteOnUiThreadAsync(() =>
        {
            if (!IsActiveRefresh(refreshVersion, cancellationToken))
                return null;

            var address = ResolveAddress();
            var displayName = ResolveDisplayName(address);
            var base64Picture = ResolveBase64Picture();

            return new RefreshSnapshot(displayName, address, base64Picture);
        }).ConfigureAwait(false);
    }

    private string ResolveAddress()
    {
        var contactAddress = MailItemInformation?.SenderContact?.Address;
        if (!string.IsNullOrWhiteSpace(contactAddress))
            return contactAddress.Trim();

        if (!string.IsNullOrWhiteSpace(MailItemInformation?.FromAddress))
            return MailItemInformation.FromAddress.Trim();

        return FromAddress?.Trim() ?? string.Empty;
    }

    private string ResolveDisplayName(string resolvedAddress)
    {
        var contactName = MailItemInformation?.SenderContact?.Name;
        if (!string.IsNullOrWhiteSpace(contactName))
            return contactName.Trim();

        if (!string.IsNullOrWhiteSpace(MailItemInformation?.FromName))
            return MailItemInformation.FromName.Trim();

        if (!string.IsNullOrWhiteSpace(FromName))
            return FromName.Trim();

        return resolvedAddress.Trim();
    }

    private string ResolveBase64Picture()
    {
        if (!string.IsNullOrWhiteSpace(MailItemInformation?.SenderContact?.Base64ContactPicture))
            return MailItemInformation.SenderContact.Base64ContactPicture;

        if (!string.IsNullOrWhiteSpace(MailItemInformation?.Base64ContactPicture))
            return MailItemInformation.Base64ContactPicture;

        return SenderContactPicture ?? string.Empty;
    }

    private async Task ApplyInitialVisualStateAsync(string displayName, long refreshVersion, CancellationToken cancellationToken)
    {
        await ExecuteOnUiThreadAsync(() =>
        {
            if (!IsActiveRefresh(refreshVersion, cancellationToken))
                return;

            DisplayName = displayName;
            ProfilePicture = null;
        }).ConfigureAwait(false);
    }

    private async Task ApplyProfilePictureAsync(BitmapImage bitmapImage, long refreshVersion, CancellationToken cancellationToken)
    {
        await ExecuteOnUiThreadAsync(() =>
        {
            if (!IsActiveRefresh(refreshVersion, cancellationToken))
                return;

            ProfilePicture = bitmapImage;
        }).ConfigureAwait(false);
    }

    private bool IsActiveRefresh(long refreshVersion, CancellationToken cancellationToken)
        => !cancellationToken.IsCancellationRequested && refreshVersion == _refreshVersion;

    private async Task ExecuteOnUiThreadAsync(Action action)
    {
        if (DispatcherQueue == null || DispatcherQueue.HasThreadAccess)
        {
            action();
            return;
        }

        var completion = new TaskCompletionSource<object?>(TaskCreationOptions.RunContinuationsAsynchronously);

        var enqueued = DispatcherQueue.TryEnqueue(() =>
        {
            try
            {
                action();
                completion.TrySetResult(null);
            }
            catch (Exception ex)
            {
                completion.TrySetException(ex);
            }
        });

        if (!enqueued)
        {
            completion.TrySetException(new InvalidOperationException("Failed to dispatch UI update."));
        }

        await completion.Task.ConfigureAwait(false);
    }

    private async Task<T> ExecuteOnUiThreadAsync<T>(Func<T> func)
    {
        if (DispatcherQueue == null || DispatcherQueue.HasThreadAccess)
        {
            return func();
        }

        var completion = new TaskCompletionSource<T>(TaskCreationOptions.RunContinuationsAsynchronously);

        var enqueued = DispatcherQueue.TryEnqueue(() =>
        {
            try
            {
                completion.TrySetResult(func());
            }
            catch (Exception ex)
            {
                completion.TrySetException(ex);
            }
        });

        if (!enqueued)
        {
            completion.TrySetException(new InvalidOperationException("Failed to dispatch UI update."));
        }

        return await completion.Task.ConfigureAwait(false);
    }

    private async Task<BitmapImage?> CreateBitmapFromBase64Async(string base64, CancellationToken cancellationToken)
    {
        if (string.IsNullOrWhiteSpace(base64))
            return null;

        byte[] bytes;

        try
        {
            bytes = await Task.Run(() => Convert.FromBase64String(base64), cancellationToken).ConfigureAwait(false);
        }
        catch
        {
            return null;
        }

        cancellationToken.ThrowIfCancellationRequested();

        return await ExecuteOnUiThreadAsync(() =>
        {
            cancellationToken.ThrowIfCancellationRequested();

            using var memoryStream = new MemoryStream(bytes);
            var bitmapImage = new BitmapImage();
            bitmapImage.SetSource(memoryStream.AsRandomAccessStream());
            return bitmapImage;
        }).ConfigureAwait(false);
    }

    private static bool IsValidEmail(string email)
    {
        try
        {
            _ = new MailAddress(email);
            return true;
        }
        catch
        {
            return false;
        }
    }
}