Add list of GPUs.

Marechai.App/Presentation/ViewModels/GpusListViewModel.cs

@@ -0,0 +1,204 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Threading.Tasks;
+using Marechai.App.Services;
+using Uno.Extensions.Navigation;
+
+namespace Marechai.App.Presentation.ViewModels;
+
+/// <summary>
+///     ViewModel for displaying a list of GPUs
+/// </summary>
+public partial class GpusListViewModel : ObservableObject
+{
+    private readonly GpusService                _gpusService;
+    private readonly IStringLocalizer           _localizer;
+    private readonly ILogger<GpusListViewModel> _logger;
+    private readonly INavigator                 _navigator;
+
+    [ObservableProperty]
+    private string _errorMessage = string.Empty;
+
+    [ObservableProperty]
+    private ObservableCollection<GpuListItem> _gpusList = [];
+
+    [ObservableProperty]
+    private bool _hasError;
+
+    [ObservableProperty]
+    private bool _isDataLoaded;
+
+    [ObservableProperty]
+    private bool _isLoading;
+
+    [ObservableProperty]
+    private string _pageTitle = string.Empty;
+
+    public GpusListViewModel(GpusService gpusService, IStringLocalizer localizer, ILogger<GpusListViewModel> logger,
+                             INavigator  navigator)
+    {
+        _gpusService         = gpusService;
+        _localizer           = localizer;
+        _logger              = logger;
+        _navigator           = navigator;
+        LoadData             = new AsyncRelayCommand(LoadDataAsync);
+        NavigateToGpuCommand = new AsyncRelayCommand<GpuListItem>(NavigateToGpuAsync);
+    }
+
+    public IAsyncRelayCommand              LoadData             { get; }
+    public IAsyncRelayCommand<GpuListItem> NavigateToGpuCommand { get; }
+
+    /// <summary>
+    ///     Loads all GPUs and sorts them with special handling for Framebuffer and Software
+    /// </summary>
+    private async Task LoadDataAsync()
+    {
+        try
+        {
+            IsLoading    = true;
+            ErrorMessage = string.Empty;
+            HasError     = false;
+            IsDataLoaded = false;
+            GpusList.Clear();
+
+            _logger.LogInformation("LoadDataAsync called for GPUs");
+
+            PageTitle = _localizer["GraphicalProcessingUnits"];
+
+            // Load GPUs from the API
+            await LoadGpusFromApiAsync();
+
+            _logger.LogInformation("LoadGpusFromApiAsync completed. GpusList.Count={Count}", GpusList.Count);
+
+            if(GpusList.Count == 0)
+            {
+                ErrorMessage = _localizer["No graphics processing units found"].Value;
+                HasError     = true;
+
+                _logger.LogWarning("No GPUs found");
+            }
+            else
+                IsDataLoaded = true;
+        }
+        catch(Exception ex)
+        {
+            _logger.LogError(ex, "Error loading GPUs: {Exception}", ex.Message);
+            ErrorMessage = _localizer["Failed to load graphics processing units. Please try again later."].Value;
+            HasError     = true;
+        }
+        finally
+        {
+            IsLoading = false;
+        }
+    }
+
+    /// <summary>
+    ///     Loads GPUs from the API and sorts them with special handling for Framebuffer and Software
+    /// </summary>
+    private async Task LoadGpusFromApiAsync()
+    {
+        try
+        {
+            List<GpuDto> gpus = await _gpusService.GetAllGpusAsync();
+
+            if(gpus == null || gpus.Count == 0)
+            {
+                _logger.LogInformation("No GPUs returned from API");
+
+                return;
+            }
+
+            // Separate special GPUs from regular ones
+            var specialGpus = new List<GpuListItem>();
+            var regularGpus = new List<GpuListItem>();
+
+            foreach(GpuDto gpu in gpus)
+            {
+                string displayName = gpu.Name ?? string.Empty;
+
+                // Replace special database names
+                if(displayName == "DB_FRAMEBUFFER")
+                    displayName = "Framebuffer";
+                else if(displayName == "DB_SOFTWARE")
+                    displayName                               = "Software";
+                else if(displayName == "DB_NONE") displayName = "None";
+
+                var gpuItem = new GpuListItem
+                {
+                    Id        = gpu.Id ?? 0,
+                    Name      = displayName,
+                    Company   = gpu.Company ?? string.Empty,
+                    IsSpecial = gpu.Name is "DB_FRAMEBUFFER" or "DB_SOFTWARE" or "DB_NONE"
+                };
+
+                if(gpuItem.IsSpecial)
+                    specialGpus.Add(gpuItem);
+                else
+                    regularGpus.Add(gpuItem);
+
+                _logger.LogInformation("GPU: {Name}, Company: {Company}, ID: {Id}, IsSpecial: {IsSpecial}",
+                                       displayName,
+                                       gpu.Company,
+                                       gpu.Id,
+                                       gpuItem.IsSpecial);
+            }
+
+            // Sort special GPUs: Framebuffer first, then Software, then None
+            specialGpus.Sort((a, b) =>
+            {
+                int orderA = a.Name == "Framebuffer"
+                                 ? 0
+                                 : a.Name == "Software"
+                                     ? 1
+                                     : 2;
+
+                int orderB = b.Name == "Framebuffer"
+                                 ? 0
+                                 : b.Name == "Software"
+                                     ? 1
+                                     : 2;
+
+                return orderA.CompareTo(orderB);
+            });
+
+            // Sort regular GPUs alphabetically
+            regularGpus.Sort((a, b) => string.Compare(a.Name, b.Name, StringComparison.OrdinalIgnoreCase));
+
+            // Add special GPUs first, then regular GPUs
+            foreach(GpuListItem gpu in specialGpus) GpusList.Add(gpu);
+
+            foreach(GpuListItem gpu in regularGpus) GpusList.Add(gpu);
+        }
+        catch(Exception ex)
+        {
+            _logger.LogError(ex, "Error loading GPUs from API");
+        }
+    }
+
+    /// <summary>
+    ///     Navigates to the GPU detail view
+    /// </summary>
+    private async Task NavigateToGpuAsync(GpuListItem? gpu)
+    {
+        if(gpu is null) return;
+
+        _logger.LogInformation("Navigating to GPU detail: {GpuName} (ID: {GpuId})", gpu.Name, gpu.Id);
+
+        // For now, we'll just log it. Implement detail page navigation when ready.
+        // await _navigator.NavigateViewModelAsync<GpuDetailViewModel>(this, data: gpu);
+    }
+}
+
+/// <summary>
+///     Data model for a GPU in the list
+/// </summary>
+public class GpuListItem
+{
+    public int    Id        { get; set; }
+    public string Name      { get; set; } = string.Empty;
+    public string Company   { get; set; } = string.Empty;
+    public bool   IsSpecial { get; set; }
+}