SettingsDialog.xaml.cs

using System.ComponentModel;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using ReadFolder.Models;
using ReadFolder.Services;
using ReadFolder.ViewModels;
using WpfCheckBox = System.Windows.Controls.CheckBox;
using WpfMessageBox = System.Windows.MessageBox;

namespace ReadFolder;

public partial class SettingsDialog : Window
{
    private const string RepositoryUrl = "https://github.com/BlackCoder0/ReadFolder";

    private readonly SettingsService _settingsService;
    private readonly IClipboardService _clipboard;
    private readonly IExplorerService _explorer;
    private readonly Action _clearCache;
    private readonly SettingsDialogViewModel _viewModel;
    private bool _saved;

    public SettingsDialog(
        AppSettings settings,
        SettingsService settingsService,
        IClipboardService clipboard,
        IExplorerService explorer,
        Action clearCache,
        Action<ImageCardStyle>? applyImageCardStyle = null,
        Action<AppThemeMode>? applyTheme = null)
    {
        _settingsService = settingsService;
        _clipboard = clipboard;
        _explorer = explorer;
        _clearCache = clearCache;
        _viewModel = new SettingsDialogViewModel(settings, applyImageCardStyle, applyTheme);
        DataContext = _viewModel;
        InitializeComponent();
    }

    private void TitleBar_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
    {
        if (e.LeftButton == MouseButtonState.Pressed)
        {
            DragMove();
        }
    }

    private void Window_PreviewKeyDown(object sender, System.Windows.Input.KeyEventArgs e)
    {
        if (e.Key == Key.Escape)
        {
            Close();
            e.Handled = true;
        }
    }

    private void DeletePreview_Unchecked(object sender, RoutedEventArgs e)
    {
        if (_viewModel.Settings.DeletePreviewWarningAccepted)
        {
            return;
        }

        var result = WpfMessageBox.Show(
            this,
            LocalizationService.Instance["Settings.DeletePreviewWarning"],
            "ReadFolder",
            MessageBoxButton.YesNo,
            MessageBoxImage.Warning);
        if (result == MessageBoxResult.Yes)
        {
            _viewModel.Settings.DeletePreviewWarningAccepted = true;
            return;
        }

        if (sender is WpfCheckBox checkBox)
        {
            checkBox.IsChecked = true;
        }
    }

    private void ResetPreviewSnooze_Click(object sender, RoutedEventArgs e)
    {
        _viewModel.ResetPreviewSnooze();
        WpfMessageBox.Show(
            this,
            LocalizationService.Instance["Settings.ResetPreviewSnoozeDone"],
            "ReadFolder",
            MessageBoxButton.OK,
            MessageBoxImage.Information);
    }

    private void ClearCache_Click(object sender, RoutedEventArgs e)
    {
        _clearCache();
        WpfMessageBox.Show(
            this,
            LocalizationService.Instance["Settings.ClearCacheDone"],
            "ReadFolder",
            MessageBoxButton.OK,
            MessageBoxImage.Information);
    }

    private void OpenSettingsLocation_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            if (File.Exists(_settingsService.SettingsFilePath))
            {
                _explorer.SelectPath(_settingsService.SettingsFilePath);
                return;
            }

            _explorer.Open(_settingsService.SettingsDirectory);
        }
        catch (Exception ex)
        {
            WpfMessageBox.Show(this, ex.Message, "ReadFolder", MessageBoxButton.OK, MessageBoxImage.Warning);
        }
    }

    private void OpenGitHub_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            _explorer.Open(RepositoryUrl);
        }
        catch (Exception ex)
        {
            WpfMessageBox.Show(this, ex.Message, "ReadFolder", MessageBoxButton.OK, MessageBoxImage.Warning);
        }
    }

    private void CopyEmail_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            _clipboard.SetText(BatchPreviewSettingsPolicy.ContactEmail);
            WpfMessageBox.Show(
                this,
                LocalizationService.Instance["Settings.EmailCopied"],
                "ReadFolder",
                MessageBoxButton.OK,
                MessageBoxImage.Information);
        }
        catch (Exception ex)
        {
            WpfMessageBox.Show(
                this,
                LocalizationService.Instance.Format("Settings.EmailCopyFailed", ex.Message),
                "ReadFolder",
                MessageBoxButton.OK,
                MessageBoxImage.Warning);
        }
    }

    private void Close_Click(object sender, RoutedEventArgs e)
    {
        Close();
    }

    protected override void OnClosing(CancelEventArgs e)
    {
        SaveSettings();
        base.OnClosing(e);
    }

    private void SaveSettings()
    {
        if (_saved)
        {
            return;
        }

        _settingsService.Save(_viewModel.Settings);
        _saved = true;
    }
}

public sealed class SettingsDialogViewModel : INotifyPropertyChanged
{
    private string _selectedLanguageCode;
    private readonly Action<ImageCardStyle>? _applyImageCardStyle;
    private readonly Action<AppThemeMode>? _applyTheme;
    private ImageCardStyle _selectedImageCardStyle;
    private AppThemeMode _selectedThemeMode;
    private PostOperationNavigationMode _selectedPasteNavigationMode;
    private PostOperationNavigationMode _selectedMoveNavigationMode;
    private PostOperationNavigationMode _selectedCopyNavigationMode;
    private PostOperationNavigationMode _selectedDeleteNavigationMode;
    private PostOperationNavigationMode _selectedRenameFileNavigationMode;
    private PostOperationNavigationMode _selectedRenameFolderNavigationMode;

    public SettingsDialogViewModel(
        AppSettings settings,
        Action<ImageCardStyle>? applyImageCardStyle = null,
        Action<AppThemeMode>? applyTheme = null)
    {
        Settings = settings;
        _applyImageCardStyle = applyImageCardStyle;
        _applyTheme = applyTheme;
        _selectedLanguageCode = string.IsNullOrWhiteSpace(settings.LanguageCode)
            ? LocalizationService.Instance.CurrentLanguageCode
            : settings.LanguageCode;
        _selectedImageCardStyle = settings.ImageCardStyle;
        _selectedThemeMode = settings.ThemeMode;
        _selectedPasteNavigationMode = settings.PasteNavigationMode;
        _selectedMoveNavigationMode = settings.MoveNavigationMode;
        _selectedCopyNavigationMode = settings.CopyNavigationMode;
        _selectedDeleteNavigationMode = settings.DeleteNavigationMode;
        _selectedRenameFileNavigationMode = settings.RenameFileNavigationMode;
        _selectedRenameFolderNavigationMode = settings.RenameFolderNavigationMode;
    }

    public AppSettings Settings { get; }

    public IReadOnlyList<LanguageChoice> LanguageOptions { get; } = new[]
    {
        new LanguageChoice("zh-CN", "中文"),
        new LanguageChoice("en-US", "English")
    };

    public string SelectedLanguageCode
    {
        get => _selectedLanguageCode;
        set
        {
            if (string.Equals(_selectedLanguageCode, value, StringComparison.OrdinalIgnoreCase))
            {
                return;
            }

            _selectedLanguageCode = value;
            Settings.LanguageCode = value;
            LocalizationService.Instance.SetLanguage(value);
            OnPropertyChanged();
        }
    }

    public IReadOnlyList<LocalizedChoice<ImageCardStyle>> ImageCardStyleOptions { get; } = new[]
    {
        new LocalizedChoice<ImageCardStyle>(ImageCardStyle.Compact, "Settings.ImageCardStyleCompact"),
        new LocalizedChoice<ImageCardStyle>(ImageCardStyle.InitialBorder, "Settings.ImageCardStyleInitialBorder")
    };

    public ImageCardStyle SelectedImageCardStyle
    {
        get => _selectedImageCardStyle;
        set
        {
            if (_selectedImageCardStyle == value)
            {
                return;
            }

            _selectedImageCardStyle = value;
            Settings.ImageCardStyle = value;
            _applyImageCardStyle?.Invoke(value);
            OnPropertyChanged();
        }
    }

    public IReadOnlyList<LocalizedChoice<AppThemeMode>> ThemeOptions { get; } = new[]
    {
        new LocalizedChoice<AppThemeMode>(AppThemeMode.Light, "Settings.ThemeLight"),
        new LocalizedChoice<AppThemeMode>(AppThemeMode.Dark, "Settings.ThemeDark")
    };

    public IReadOnlyList<LocalizedChoice<PostOperationNavigationMode>> PostOperationNavigationOptions { get; } = new[]
    {
        new LocalizedChoice<PostOperationNavigationMode>(PostOperationNavigationMode.FollowTargetFolder, "Settings.NavigationFollowTarget"),
        new LocalizedChoice<PostOperationNavigationMode>(PostOperationNavigationMode.KeepCurrentView, "Settings.NavigationKeepCurrentView"),
        new LocalizedChoice<PostOperationNavigationMode>(PostOperationNavigationMode.ReturnToCurrentFolder, "Settings.NavigationReturnToCurrent")
    };

    public IReadOnlyList<LocalizedChoice<PostOperationNavigationMode>> PostOperationNavigationOptionsWithoutTarget { get; } = new[]
    {
        new LocalizedChoice<PostOperationNavigationMode>(PostOperationNavigationMode.KeepCurrentView, "Settings.NavigationKeepCurrentView"),
        new LocalizedChoice<PostOperationNavigationMode>(PostOperationNavigationMode.ReturnToCurrentFolder, "Settings.NavigationReturnToCurrent")
    };

    public AppThemeMode SelectedThemeMode
    {
        get => _selectedThemeMode;
        set
        {
            if (_selectedThemeMode == value)
            {
                return;
            }

            _selectedThemeMode = value;
            Settings.ThemeMode = value;
            _applyTheme?.Invoke(value);
            OnPropertyChanged();
        }
    }

    public PostOperationNavigationMode SelectedPasteNavigationMode
    {
        get => _selectedPasteNavigationMode;
        set
        {
            if (_selectedPasteNavigationMode == value)
            {
                return;
            }

            _selectedPasteNavigationMode = value;
            Settings.PasteNavigationMode = value;
            OnPropertyChanged();
        }
    }

    public PostOperationNavigationMode SelectedMoveNavigationMode
    {
        get => _selectedMoveNavigationMode;
        set
        {
            if (_selectedMoveNavigationMode == value)
            {
                return;
            }

            _selectedMoveNavigationMode = value;
            Settings.MoveNavigationMode = value;
            OnPropertyChanged();
        }
    }

    public PostOperationNavigationMode SelectedCopyNavigationMode
    {
        get => _selectedCopyNavigationMode;
        set
        {
            if (_selectedCopyNavigationMode == value)
            {
                return;
            }

            _selectedCopyNavigationMode = value;
            Settings.CopyNavigationMode = value;
            OnPropertyChanged();
        }
    }

    public PostOperationNavigationMode SelectedDeleteNavigationMode
    {
        get => _selectedDeleteNavigationMode;
        set
        {
            if (_selectedDeleteNavigationMode == value)
            {
                return;
            }

            _selectedDeleteNavigationMode = value;
            Settings.DeleteNavigationMode = value;
            OnPropertyChanged();
        }
    }

    public PostOperationNavigationMode SelectedRenameFileNavigationMode
    {
        get => _selectedRenameFileNavigationMode;
        set
        {
            if (_selectedRenameFileNavigationMode == value)
            {
                return;
            }

            _selectedRenameFileNavigationMode = value;
            Settings.RenameFileNavigationMode = value;
            OnPropertyChanged();
        }
    }

    public PostOperationNavigationMode SelectedRenameFolderNavigationMode
    {
        get => _selectedRenameFolderNavigationMode;
        set
        {
            if (_selectedRenameFolderNavigationMode == value)
            {
                return;
            }

            _selectedRenameFolderNavigationMode = value;
            Settings.RenameFolderNavigationMode = value;
            OnPropertyChanged();
        }
    }

    public string VersionText => GetVersionText();

    public string EmailDisplay => BatchPreviewSettingsPolicy.ContactEmailDisplay;

    public bool IsPreviewSnoozed => Settings.BatchPreviewSnoozeUntil is { } snoozeUntil && snoozeUntil > DateTime.Now;

    public string PreviewSnoozeStatus => IsPreviewSnoozed
        ? LocalizationService.Instance.Format("Settings.PreviewSnoozeActive", Settings.BatchPreviewSnoozeUntil!.Value.ToString("HH:mm"))
        : LocalizationService.Instance["Settings.PreviewSnoozeInactive"];

    public void ResetPreviewSnooze()
    {
        Settings.BatchPreviewSnoozeUntil = null;
        OnPropertyChanged(nameof(IsPreviewSnoozed));
        OnPropertyChanged(nameof(PreviewSnoozeStatus));
    }

    public event PropertyChangedEventHandler? PropertyChanged;

    private static string GetVersionText()
    {
        var assembly = Assembly.GetExecutingAssembly();
        var version = assembly
            .GetCustomAttribute<AssemblyInformationalVersionAttribute>()
            ?.InformationalVersion;
        return string.IsNullOrWhiteSpace(version)
            ? assembly.GetName().Version?.ToString() ?? "Unknown"
            : version;
    }

    private void OnPropertyChanged([CallerMemberName] string? propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

public sealed record LanguageChoice(string Code, string DisplayName);

public sealed class LocalizedChoice<T> : INotifyPropertyChanged
{
    public LocalizedChoice(T value, string resourceKey)
    {
        Value = value;
        ResourceKey = resourceKey;
        LocalizationService.Instance.LanguageChanged += OnLanguageChanged;
    }

    public T Value { get; }

    public string ResourceKey { get; }

    public string DisplayName => LocalizationService.Instance[ResourceKey];

    public event PropertyChangedEventHandler? PropertyChanged;

    private void OnLanguageChanged(object? sender, EventArgs e)
    {
        OnPropertyChanged(nameof(DisplayName));
    }

    private void OnPropertyChanged([CallerMemberName] string? propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}