StabilityMatrix/StabilityMatrix.Avalonia/ViewModels/Dialogs/SelectDataDirectoryViewModel.cs

using System;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading.Tasks;
using AsyncAwaitBestPractices;
using Avalonia.Platform.Storage;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using NLog;
using StabilityMatrix.Avalonia.ViewModels.Base;
using StabilityMatrix.Avalonia.Views.Dialogs;
using StabilityMatrix.Core.Attributes;
using StabilityMatrix.Core.Helper;
using StabilityMatrix.Core.Models.Progress;
using StabilityMatrix.Core.Models.Settings;
using StabilityMatrix.Core.Services;

namespace StabilityMatrix.Avalonia.ViewModels.Dialogs;

[View(typeof(SelectDataDirectoryDialog))]
public partial class SelectDataDirectoryViewModel : ContentDialogViewModelBase
{
    private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
    public static string DefaultInstallLocation => Compat.AppDataHome;
    
    private readonly ISettingsManager settingsManager;
    
    private const string ValidExistingDirectoryText = "Valid existing data directory found";
    private const string InvalidDirectoryText =
        "Directory must be empty or have a valid settings.json file";
    private const string NotEnoughFreeSpaceText = "Not enough free space on the selected drive";
    private const string FatWarningText =
        "FAT32 / exFAT drives are not supported at this time";

    [ObservableProperty] private string dataDirectory = DefaultInstallLocation;
    [ObservableProperty] private bool isPortableMode;
    
    [ObservableProperty] private string directoryStatusText = string.Empty;
    [ObservableProperty] private bool isStatusBadgeVisible;
    [ObservableProperty] private bool isDirectoryValid;
    [ObservableProperty] private bool showFatWarning;

    public RefreshBadgeViewModel ValidatorRefreshBadge { get; } = new()
    {
        State = ProgressState.Inactive,
        SuccessToolTipText = ValidExistingDirectoryText,
        FailToolTipText = InvalidDirectoryText
    };
    
    public bool HasOldData => settingsManager.GetOldInstalledPackages().Any();
    
    public SelectDataDirectoryViewModel(ISettingsManager settingsManager)
    {
        this.settingsManager = settingsManager;
        ValidatorRefreshBadge.RefreshFunc = ValidateDataDirectory;
    }

    public override void OnLoaded()
    {
        ValidatorRefreshBadge.RefreshCommand.ExecuteAsync(null).SafeFireAndForget();
    }
    
    // Revalidate on data directory change
    partial void OnDataDirectoryChanged(string value)
    {
        ValidatorRefreshBadge.RefreshCommand.ExecuteAsync(null).SafeFireAndForget();
    }
    
    private async Task<bool> ValidateDataDirectory()
    {
        await using var delay = new MinimumDelay(100, 200);
        
        ShowFatWarning = IsDriveFat(DataDirectory);

        // Doesn't exist, this is fine as a new install, hide badge
        if (!Directory.Exists(DataDirectory))
        {
            IsStatusBadgeVisible = false;
            IsDirectoryValid = true;
            return true;
        }
        // Otherwise check that a settings.json exists
        var settingsPath = Path.Combine(DataDirectory, "settings.json");
        
        // settings.json exists: Try deserializing it
        if (File.Exists(settingsPath))
        {
            try
            {
                var jsonText = await File.ReadAllTextAsync(settingsPath);
                JsonSerializer.Deserialize<Settings>(jsonText, new JsonSerializerOptions
                {
                    Converters = { new JsonStringEnumConverter() }
                });
                // If successful, show existing badge
                IsStatusBadgeVisible = true;
                IsDirectoryValid = true;
                DirectoryStatusText = ValidExistingDirectoryText;
                return true;
            }
            catch (Exception e)
            {
                Logger.Info("Failed to deserialize settings.json: {Msg}", e.Message);
                // If not, show error badge, and set directory to invalid to prevent continuing
                IsStatusBadgeVisible = true;
                IsDirectoryValid = false;
                DirectoryStatusText = InvalidDirectoryText;
                return false;
            }
        }
        
        // No settings.json
        
        // Check if the directory is %APPDATA%\StabilityMatrix: hide badge and set directory valid
        if (DataDirectory == DefaultInstallLocation)
        {
            IsStatusBadgeVisible = false;
            IsDirectoryValid = true;
            return true;
        }
        
        // Check if the directory is empty: hide badge and set directory to valid
        var isEmpty = !Directory.EnumerateFileSystemEntries(DataDirectory).Any();
        if (isEmpty)
        {
            IsStatusBadgeVisible = false;
            IsDirectoryValid = true;
            return true;
        }

        // Not empty and not appdata: show error badge, and set directory to invalid
        IsStatusBadgeVisible = true;
        IsDirectoryValid = false;
        DirectoryStatusText = InvalidDirectoryText;
        return false;
    }
    
    private bool CanPickFolder => App.StorageProvider.CanPickFolder;
    
    [RelayCommand(CanExecute = nameof(CanPickFolder))]
    private async Task ShowFolderBrowserDialog()
    {
        var provider = App.StorageProvider;
        var result = await provider.OpenFolderPickerAsync(new FolderPickerOpenOptions
        {
            Title = "Select Data Folder",
            AllowMultiple = false
        });
        
        if (result.Count != 1) return;
        
        DataDirectory = result[0].Path.LocalPath;
    }

    partial void OnIsPortableModeChanged(bool value)
    {
        DataDirectory = value ? Compat.AppCurrentDir + "Data" : DefaultInstallLocation;
    }

    private bool IsDriveFat(string path)
    {
        try
        {
            var drive = new DriveInfo(Path.GetPathRoot(path));
            return drive.DriveFormat.Contains("FAT", StringComparison.OrdinalIgnoreCase);
        }
        catch (Exception e)
        {
            Logger.Warn(e, "Error checking drive FATness");
            return false;
        }
    }
}