Aaru/Aaru.Tui/ViewModels/Windows/ImageWindowViewModel.cs

using System.Collections.ObjectModel;
using System.Windows.Input;
using Aaru.CommonTypes;
using Aaru.CommonTypes.Interfaces;
using Aaru.Tui.Models;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Controls.ApplicationLifetimes;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using Humanizer;
using Humanizer.Bytes;

namespace Aaru.Tui.ViewModels.Windows;

public sealed partial class ImageWindowViewModel : ViewModelBase
{
    readonly IMediaImage _imageFormat;
    readonly Window      _parent;
    readonly Window      _view;
    [ObservableProperty]
    public string _filePath;
    [ObservableProperty]
    bool _isPartitionInformationVisible;
    [ObservableProperty]
    bool _isStatusVisible;
    [ObservableProperty]
    ObservableCollection<FileSystemModelNode> _nodes;
    [ObservableProperty]
    string _partitionDescription;
    [ObservableProperty]
    string _partitionLength;
    [ObservableProperty]
    string _partitionName;
    [ObservableProperty]
    string _partitionOffset;
    [ObservableProperty]
    string _partitionScheme;
    [ObservableProperty]
    string _partitionSequence;
    [ObservableProperty]
    string _partitionSize;
    [ObservableProperty]
    string _partitionStart;
    [ObservableProperty]
    string _partitionType;
    FileSystemModelNode? _selectedNode;
    [ObservableProperty]
    string? _status;

    public ImageWindowViewModel(Window parent, Window view, IMediaImage imageFormat, string filePath)
    {
        _imageFormat = imageFormat;
        FilePath     = filePath;
        _view        = view;
        _parent      = parent;

        ExitCommand = new RelayCommand(Exit);
        BackCommand = new RelayCommand(Back);
    }

    public FileSystemModelNode? SelectedNode
    {
        get => _selectedNode;
        set
        {
            SetProperty(ref _selectedNode, value);

            if(_selectedNode is null) return;

            if(_selectedNode.Partition is not null)
            {
                IsPartitionInformationVisible = true;

                PartitionSequence    = _selectedNode.Partition.Value.Sequence.ToString();
                PartitionName        = _selectedNode.Partition.Value.Name;
                PartitionType        = _selectedNode.Partition.Value.Type;
                PartitionStart       = _selectedNode.Partition.Value.Start.ToString();
                PartitionOffset      = ByteSize.FromBytes(_selectedNode.Partition.Value.Offset).Humanize();
                PartitionLength      = $"{_selectedNode.Partition.Value.Length} sectors";
                PartitionSize        = ByteSize.FromBytes(_selectedNode.Partition.Value.Size).Humanize();
                PartitionScheme      = _selectedNode.Partition.Value.Scheme;
                PartitionDescription = _selectedNode.Partition.Value.Description;

                OnPropertyChanged(nameof(PartitionSequence));
                OnPropertyChanged(nameof(PartitionName));
                OnPropertyChanged(nameof(PartitionType));
                OnPropertyChanged(nameof(PartitionStart));
                OnPropertyChanged(nameof(PartitionOffset));
                OnPropertyChanged(nameof(PartitionLength));
                OnPropertyChanged(nameof(PartitionSize));
                OnPropertyChanged(nameof(PartitionScheme));
                OnPropertyChanged(nameof(PartitionDescription));
            }
            else
                IsPartitionInformationVisible = false;

            OnPropertyChanged(nameof(IsPartitionInformationVisible));
        }
    }

    public ICommand BackCommand { get; }
    public ICommand ExitCommand { get; }

    void Back()
    {
        _parent.Show();
        _view.Close();
    }

    void Exit()
    {
        var lifetime = Application.Current!.ApplicationLifetime as IControlledApplicationLifetime;
        lifetime!.Shutdown();
    }

    public void LoadComplete()
    {
        _ = Task.Run(Worker);
    }

    void Worker()
    {
        IsStatusVisible = true;
        Status          = "Loading partitions...";

        Nodes = [];

        List<Partition>? partitionsList = Core.Partitions.GetAll(_imageFormat);

        if(partitionsList.Count == 0)
        {
            partitionsList.Add(new Partition
            {
                Name   = Localization.Core.Whole_device,
                Length = _imageFormat.Info.Sectors,
                Size   = _imageFormat.Info.Sectors * _imageFormat.Info.SectorSize
            });
        }

        var sequence = 0;

        Status = "Loading filesystems...";

        PluginRegister plugins = PluginRegister.Singleton;

        foreach(Partition partition in partitionsList)
        {
            var node = new FileSystemModelNode(partition.Name ?? $"Partition {sequence}")
            {
                Partition = partition
            };

            Core.Filesystems.Identify(_imageFormat, out List<string>? idPlugins, partition);

            if(idPlugins.Count > 0)
            {
                var subNodes = new ObservableCollection<FileSystemModelNode>();

                foreach(string pluginName in idPlugins)
                {
                    if(!plugins.Filesystems.TryGetValue(pluginName, out IFilesystem? fs)) continue;
                    if(fs is null) continue;

                    var fsNode = new FileSystemModelNode(fs.Name)
                    {
                        Filesystem = fs
                    };

                    subNodes.Add(fsNode);
                }

                node.SubNodes = subNodes;
            }

            Nodes.Add(node);
            sequence++;
        }

        Status          = "Done.";
        IsStatusVisible = false;
    }
}