ServiceProviderViewModel.cs

using CommunityToolkit.Mvvm.Input;
using NeuroAccessMaui.Services;
using IServiceProvider = Waher.Networking.XMPP.Contracts.IServiceProvider;
 
namespace NeuroAccessMaui.UI.Pages.Wallet.ServiceProviders
{
    public partial class ServiceProviderViewModel(IServiceProvider ServiceProvider, int IconHeight, ServiceProvidersViewModel Parent)
        : XmppViewModel
    {
        private readonly IServiceProvider serviceProvider = ServiceProvider;
        private readonly ServiceProvidersViewModel parent = Parent;
        private ImageSource? iconSource;
 
        private const double WideAspectThreshold = 2; 
 
        public IServiceProvider ServiceProvider => this.serviceProvider;
 
        public string Id => this.serviceProvider.Id;
 
        public string Name => this.serviceProvider.Name;
 
        public bool HasIcon => !string.IsNullOrEmpty(this.serviceProvider.IconUrl);
 
        public string IconUrl => this.serviceProvider.IconUrl;
 
        private bool HasValidIconDimensions => this.serviceProvider.IconWidth > 0 && this.serviceProvider.IconHeight > 0;
 
        private double IconAspectRatio
        {
            get
            {
                if (!this.HasValidIconDimensions)
                    return 1.0;
 
                return (double)this.serviceProvider.IconWidth / this.serviceProvider.IconHeight;
            }
        }
 
        public bool IsWideHero => this.HasIcon && this.HasValidIconDimensions && this.IconAspectRatio >= WideAspectThreshold;
 
        public bool ShowImage => this.HasIcon;
 
        public bool ShowText =>
            !this.HasIcon ||
            !this.IsWideHero ||
            this.serviceProvider.GetType().Assembly == typeof(App).Assembly;
 
        public int IconHeight { get; } = IconHeight;
 
        public int IconWidth
        {
            get
            {
                if (!this.HasIcon || this.serviceProvider.IconHeight == 0)
                    return 0;
 
                double s = ((double)this.IconHeight) / this.serviceProvider.IconHeight;
 
                return (int)(this.serviceProvider.IconWidth * s + 0.5);
            }
        }
 
        public int DisplayIconHeight
        {
            get
            {
                if (!this.ShowImage)
                    return 0;
 
                // With text -> uniform square (height == width == IconHeight)
                // Image-only -> use the requested height (width is proportional)
                return this.IconHeight;
            }
        }
 
        public int DisplayIconWidth
        {
            get
            {
                if (!this.ShowImage)
                    return 0;
 
                // If text is visible, we present the icon as a square for uniformity.
                if (this.ShowText)
                    return this.IconHeight;
 
                // Image-only (wide hero) preserves proportional width.
                return this.IconWidth;
            }
        }
 
        private bool hasRun = false;
 
        public ImageSource? IconUrlSource
        {
            get
            {
                if (this.iconSource is null && !this.hasRun)
                {
                    //Load the icon
                    Task.Run(this.UpdateIconUrlSourceAsync);
                    this.hasRun = true;
                }
                return this.iconSource;
            }
        }
 
        public async Task UpdateIconUrlSourceAsync()
        {
            if (this.iconSource is not null) return; // Already loaded or loading
 
            try
            {
                //Check if URI is SVG
                bool isSvg = this.IconUrl.EndsWith(".svg", StringComparison.OrdinalIgnoreCase);
 
                if (this.IconUrl.StartsWith("resource://", StringComparison.Ordinal))
                    this.iconSource = ImageSource.FromResource(this.IconUrl[11..]);
                else if (this.IconUrl.StartsWith("file://", StringComparison.Ordinal))
                {
                    if (isSvg)
                        this.iconSource = this.IconUrl[7..^4];
                    else
                        this.iconSource = this.IconUrl[7..];
                }
                else if (Uri.TryCreate(this.IconUrl, UriKind.Absolute, out Uri? ParsedUri))
                {
                    if (isSvg)
                        this.iconSource = await ServiceRef.UiService.ConvertSvgUriToImageSource(this.IconUrl);
                    else
                        this.iconSource = ImageSource.FromUri(ParsedUri);
                }
                else
                {
                    //if it is an SVG, remove the extension
                    //Maui does not inheritly support SVGs, but can implicitly convert them to png
                    if (isSvg)
                        this.iconSource = ImageSource.FromFile(this.IconUrl[..^4]);
                    else
                        this.iconSource = ImageSource.FromFile(this.IconUrl);
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
 
            MainThread.BeginInvokeOnMainThread(() => this.OnPropertyChanged(nameof(this.IconUrlSource)));
        }
 
        [RelayCommand]
        private Task SelectServiceProvider()
        {
            return this.parent.SelectServiceProvider(this);
        }
    }
}