SpecialMenuPageViewModel.cs

using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Windows.Data;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using ContextMenuMgr.Contracts;
using ContextMenuMgr.Frontend.Services;

namespace ContextMenuMgr.Frontend.ViewModels;

/// <summary>
/// Represents a special menu page view model.
/// </summary>
public partial class SpecialMenuPageViewModel : ObservableObject, IDisposable
{
    private readonly IBackendClient _backendClient;
    private readonly FrontendNavigationState? _navigationState;
    private readonly IconPreviewService _iconPreviewService;
    private readonly LocalizationService _localization;
    private readonly ExplorerRestartStateService _explorerRestartState;
    private readonly string _titleKey;
    private readonly string _descriptionKey;
    private readonly Dictionary<string, bool> _winXExpandedStates = new(StringComparer.OrdinalIgnoreCase);
    private readonly object _refreshSync = new();
    private readonly SemaphoreSlim _openWithOperationGate = new(1, 1);
    private readonly CancellationTokenSource _disposeCts = new();
    private readonly DelayedLoadingPresentation _loadingPresentation = new();
    private Task? _refreshTask;
    private Task? _autoRefreshTask;
    private int _refreshGeneration;
    private bool _hasLoaded;
    private bool _hasSnapshot;
    private bool _disposed;
    private bool _suppressShellNewLockSync;
    private int _shellNewStateVersion;
    private bool _shellNewDiscoveryValid;
    private bool _suppressDropEffectSync;
    private bool _suppressDocumentIconProviderSync;
    private bool _hasDocumentIconProviderChanged;

    public SpecialMenuPageViewModel(
        SpecialMenuKind kind,
        string titleKey,
        string descriptionKey,
        IBackendClient backendClient,
        IconPreviewService iconPreviewService,
        LocalizationService localization,
        ExplorerRestartStateService explorerRestartState, FrontendNavigationState? navigationState = null)
    {
        Kind = kind;
        _navigationState = navigationState;
        if (kind == SpecialMenuKind.OpenWith && navigationState is not null)
        {
            navigationState.OpenWithRequested += OnOpenWithRequested;
        }
        _titleKey = titleKey;
        _descriptionKey = descriptionKey;
        _backendClient = backendClient;
        _backendClient.ItemsRemoved += OnItemsRemoved;
        _iconPreviewService = iconPreviewService;
        _localization = localization;
        _explorerRestartState = explorerRestartState;
        _loadingPresentation.PropertyChanged += OnLoadingPresentationChanged;
        ItemsView = new ListCollectionView(Items);
        ((ListCollectionView)ItemsView).IsLiveFiltering = true;
        foreach (var property in new[] { nameof(SpecialMenuItemViewModel.DisplayName), nameof(SpecialMenuItemViewModel.KeyName),
            nameof(SpecialMenuItemViewModel.Subtitle), nameof(SpecialMenuItemViewModel.Detail) }) ((ListCollectionView)ItemsView).LiveFilteringProperties.Add(property);
        ItemsView.Filter = FilterItem;
        if (kind == SpecialMenuKind.OpenWith)
        {
            ((ListCollectionView)ItemsView).LiveFilteringProperties.Add(nameof(SpecialMenuItemViewModel.IsReadOnlyOpenWith));
            ItemsView.SortDescriptions.Add(new SortDescription(nameof(SpecialMenuItemViewModel.DisplayName), ListSortDirection.Ascending));
            ItemsView.SortDescriptions.Add(new SortDescription(nameof(SpecialMenuItemViewModel.Id), ListSortDirection.Ascending));
            ((ListCollectionView)ItemsView).IsLiveSorting = true;
            var protectedItems = new ListCollectionView(Items) { IsLiveFiltering = true, IsLiveSorting = true };
            foreach (var property in new[] { nameof(SpecialMenuItemViewModel.IsReadOnlyOpenWith),
                nameof(SpecialMenuItemViewModel.DisplayName), nameof(SpecialMenuItemViewModel.KeyName),
                nameof(SpecialMenuItemViewModel.Subtitle), nameof(SpecialMenuItemViewModel.Detail) })
                protectedItems.LiveFilteringProperties.Add(property);
            protectedItems.Filter = FilterProtectedOpenWithItem;
            protectedItems.SortDescriptions.Add(new SortDescription(nameof(SpecialMenuItemViewModel.DisplayName), ListSortDirection.Ascending));
            protectedItems.SortDescriptions.Add(new SortDescription(nameof(SpecialMenuItemViewModel.Id), ListSortDirection.Ascending));
            OpenWithProtectedItemsView = protectedItems;
        }
        SearchLabel = _localization.Translate("SearchLabel");
        AddText = _localization.Translate("Add");
        EditText = _localization.Translate("Edit");
        RefreshText = _localization.Translate("Refresh");
        RestoreDefaultsText = _localization.Translate("RestoreDefault");
        LockNewMenuText = _localization.Translate("LockNewMenu");
        LockNewMenuDescription = _localization.Translate("LockNewMenuDescription");
        WinXCompatibilityNoticeText = _localization.Translate("WinXCompatibilityNotice");
        WinXCompatibilityNoticeToolTip = _localization.Translate("WinXCompatibilityNoticeToolTip");
        DeleteText = _localization.Translate("Delete");
        UndoText = _localization.Translate("Undo");
        PermanentDeleteText = _localization.Translate("PermanentDelete");
        CancelText = _localization.Translate("DialogCancel");
        DropEffectLabel = _localization.Translate("DefaultDropEffect");
        DocumentIconProviderLabel = _localization.Translate("DocumentIconProvider");
        DocumentIconProviderDescription = _localization.Translate("DocumentIconProviderDescription");
        DocumentIconProviderChangedHint = _localization.Translate("DocumentIconProviderChangedHint");
        DropEffectOptions =
        [
            DefaultDropEffect.Default,
            DefaultDropEffect.Copy,
            DefaultDropEffect.Move,
            DefaultDropEffect.CreateLink
        ];
        _backendClient.NotificationReceived += OnNotificationReceived;
        _localization.LanguageChanged += OnLanguageChanged;
        Items.CollectionChanged += OnItemsCollectionChanged;
        WinXGroups.CollectionChanged += OnWinXGroupsCollectionChanged;
        if (kind == SpecialMenuKind.OpenWith) SearchText = navigationState?.OpenWithFocusPath ?? string.Empty;
    }

    public SpecialMenuKind Kind { get; }

    public ObservableCollection<SpecialMenuItemViewModel> Items { get; } = [];

    public ObservableCollection<WinXGroupNodeViewModel> WinXGroups { get; } = [];

    public ICollectionView ItemsView { get; }

    public ListCollectionView? OpenWithProtectedItemsView { get; }

    public string Title => _localization.Translate(_titleKey);

    public string Description => _localization.Translate(_descriptionKey);

    public bool ShowOpenWithInspection => Kind == SpecialMenuKind.OpenWith;
    public string OpenWithInspectionLabel => _localization.Translate("OpenWithInspectionLabel");
    public string OpenWithInspectText => _localization.Translate("OpenWithInspect");
    public string OpenWithCancelText => _localization.Translate("DialogCancel");
    public string OpenWithProtectedGroupText => _localization.Format("OpenWithProtectedGroup", OpenWithProtectedItemsView?.Count ?? 0);
    public bool ShowOpenWithProtectedGroup => OpenWithProtectedItemsView?.IsEmpty == false;

    [ObservableProperty]
    public partial bool IsOpenWithProtectedExpanded { get; set; }

    [ObservableProperty]
    public partial string InspectionExtension { get; set; } = ".txt";

    [ObservableProperty]
    public partial string InspectionText { get; set; } = string.Empty;

    [RelayCommand(IncludeCancelCommand = true)]
    private async Task InspectOpenWithAsync(CancellationToken cancellationToken)
    {
        if (!ShowOpenWithInspection) return;
        using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(30));
        using var linked = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeout.Token, _disposeCts.Token);
        InspectionText = _localization.Translate("LoadingItemsText");
        try
        {
            var result = await _backendClient.InspectOpenWithSourcesAsync(InspectionExtension, linked.Token);
            linked.Token.ThrowIfCancellationRequested();
            var lines = new List<string> { result.Extension, _localization.Translate("OpenWithInspectionNotice") };
            foreach (var candidate in result.Candidates)
            {
                lines.Add(string.Empty);
                lines.Add(candidate.Identifier);
                foreach (var source in candidate.Sources)
                {
                    lines.Add(_localization.Translate("OpenWithSource" + source.Kind) + " · "
                        + _localization.Translate("OpenWithResolution" + source.Resolution));
                    lines.Add(source.SourcePath + " [" + source.ValueName + "]");
                    lines.AddRange(source.RegistrationPaths.Select(p => "  → " + p));
                    lines.Add(_localization.Translate(source.ManageableRegistrationIds.Count > 0
                        ? "OpenWithManageableReference" : "OpenWithReadOnlySource"));
                }
            }
            if (result.Candidates.Count == 0) lines.Add(_localization.Translate("EmptyItemsText"));
            lines.AddRange(result.Diagnostics.Select(d => _localization.Translate(d.Code) + " " + d.SourcePath));
            InspectionText = string.Join(Environment.NewLine, lines);
        }
        catch (OperationCanceledException)
        {
            InspectionText = _localization.Translate("OpenWithInspectionCanceled");
        }
        catch (Exception ex) { InspectionText = ex.Message; }
    }

    [ObservableProperty]
    public partial string SearchText { get; set; } = string.Empty;

    [ObservableProperty]
    public partial string SearchLabel { get; set; }

    [ObservableProperty]
    public partial string AddText { get; set; }

    [ObservableProperty]
    public partial string EditText { get; set; }

    [ObservableProperty]
    public partial string RefreshText { get; set; }

    [ObservableProperty]
    public partial string RestoreDefaultsText { get; set; }

    [ObservableProperty]
    public partial string LockNewMenuText { get; set; }

    [ObservableProperty]
    public partial string LockNewMenuDescription { get; set; }

    [ObservableProperty]
    public partial string WinXCompatibilityNoticeText { get; set; }

    [ObservableProperty]
    public partial string WinXCompatibilityNoticeToolTip { get; set; }

    [ObservableProperty]
    public partial string DeleteText { get; set; }

    [ObservableProperty]
    public partial string UndoText { get; set; }

    [ObservableProperty]
    public partial string PermanentDeleteText { get; set; }

    [ObservableProperty]
    public partial string CancelText { get; set; }

    [ObservableProperty]
    public partial string DropEffectLabel { get; set; }

    [ObservableProperty]
    public partial IReadOnlyList<DefaultDropEffect> DropEffectOptions { get; set; } = [];

    [ObservableProperty]
    public partial DefaultDropEffect SelectedDropEffect { get; set; }

    [ObservableProperty]
    public partial string DocumentIconProviderLabel { get; set; }

    [ObservableProperty]
    public partial string DocumentIconProviderDescription { get; set; }

    [ObservableProperty]
    public partial string DocumentIconProviderChangedHint { get; set; }

    public string MicrosoftOfficeLabel => "Microsoft Office";

    public string WpsOfficeLabel => "WPS Office";

    [ObservableProperty]
    public partial DocumentIconProvider SelectedDocumentIconProvider { get; set; }

    [ObservableProperty]
    public partial bool IsDocumentIconProviderBusy { get; private set; }

    public bool IsMicrosoftDocumentIconProviderSelected => SelectedDocumentIconProvider == DocumentIconProvider.MicrosoftOffice;

    public bool IsWpsDocumentIconProviderSelected => SelectedDocumentIconProvider == DocumentIconProvider.WpsOffice;

    public bool CanChangeDocumentIconProvider => ShowDocumentIconProvider && !IsDocumentIconProviderBusy;

    partial void OnIsDocumentIconProviderBusyChanged(bool value) => OnPropertyChanged(nameof(CanChangeDocumentIconProvider));

    [ObservableProperty]
    public partial bool ShowDocumentIconProvider { get; set; }

    public bool ShowDocumentIconProviderChangedHint => ShowDocumentIconProvider && _hasDocumentIconProviderChanged;

    [ObservableProperty]
    public partial bool? IsShellNewOrderLocked { get; set; }

    [ObservableProperty]
    [NotifyPropertyChangedFor(nameof(CanToggleShellNewOrderLock))]
    public partial bool IsShellNewLockBusy { get; private set; }

    public bool CanToggleShellNewOrderLock => !IsShellNewLockBusy && IsShellNewOrderLocked.HasValue
        && (_shellNewDiscoveryValid || IsShellNewOrderLocked == true);

    private void ApplyShellNewLockState(bool? locked)
    {
        _suppressShellNewLockSync = true;
        try { IsShellNewOrderLocked = locked; }
        finally { _suppressShellNewLockSync = false; }
        OnPropertyChanged(nameof(CanToggleShellNewOrderLock));
        UpdateShellNewMoveAvailability();
    }

    [ObservableProperty]
    public partial string StatusText { get; set; } = string.Empty;

    [ObservableProperty]
    public partial bool IsBusy { get; set; }

    [ObservableProperty]
    public partial bool IsLoading { get; private set; }

    public bool ShowShellNewOrderLock => Kind == SpecialMenuKind.ShellNew;

    public bool ShowRestoreDefaults => Kind == SpecialMenuKind.SendTo;

    public bool ShowDropEffectSelector => Kind == SpecialMenuKind.DragDrop;

    public bool ShowWinXTree => Kind == SpecialMenuKind.WinX;

    public bool ShowWinXCompatibilityNotice => Kind == SpecialMenuKind.WinX;

    public string LoadingItemsText => _localization.Translate("LoadingItemsText");

    public string EmptyItemsText => _localization.Translate("EmptyItemsText");

    public bool IsListLoading => !_hasSnapshot && _loadingPresentation.IsVisible;

    public bool ShowListContent => !IsListLoading && !IsListEmpty;

    public bool IsListEmpty
    {
        get
        {
            if (IsListLoading || (!_hasSnapshot && IsLoading))
            {
                return false;
            }

            if (Kind == SpecialMenuKind.WinX)
            {
                return WinXGroups.Count == 0
                       || WinXGroups.All(static group => group.Items.Count == 0);
            }

            return ItemsView.IsEmpty && !ShowOpenWithProtectedGroup;
        }
    }

    public bool ShowListPlaceholder => IsListLoading || IsListEmpty;

    partial void OnSearchTextChanged(string value)
    {
        ItemsView.Refresh();
        OpenWithProtectedItemsView?.Refresh();
        RefreshListPlaceholderState();
    }

    partial void OnIsBusyChanged(bool value)
    {
        RefreshListPlaceholderState();
    }

    partial void OnIsLoadingChanged(bool value) => _loadingPresentation.Update(value);

    private void OnLoadingPresentationChanged(object? sender, PropertyChangedEventArgs e) => RefreshListPlaceholderState();

    partial void OnIsShellNewOrderLockedChanged(bool? oldValue, bool? newValue)
    {
        if (_suppressShellNewLockSync || oldValue == newValue || Kind != SpecialMenuKind.ShellNew) return;
        if (IsShellNewLockBusy || !oldValue.HasValue || newValue is not bool requested || (!_shellNewDiscoveryValid && requested))
        {
            ApplyShellNewLockState(oldValue);
            return;
        }
        ObserveFireAndForget(SetShellNewOrderLockAsync(requested), "SetShellNewOrderLockAsync");
    }

    partial void OnSelectedDropEffectChanged(DefaultDropEffect oldValue, DefaultDropEffect newValue)
    {
        if (_suppressDropEffectSync || oldValue == newValue || Kind != SpecialMenuKind.DragDrop)
        {
            return;
        }

        ObserveFireAndForget(SetDefaultDropEffectAsync(oldValue, newValue), "SetDefaultDropEffectAsync");
    }

    partial void OnSelectedDocumentIconProviderChanged(DocumentIconProvider oldValue, DocumentIconProvider newValue)
    {
        OnPropertyChanged(nameof(IsMicrosoftDocumentIconProviderSelected));
        OnPropertyChanged(nameof(IsWpsDocumentIconProviderSelected));
        if (_suppressDocumentIconProviderSync || oldValue == newValue || !ShowDocumentIconProvider || IsDocumentIconProviderBusy)
        {
            return;
        }

        IsDocumentIconProviderBusy = true;
        ObserveFireAndForget(SetDocumentIconProviderAsync(oldValue, newValue), "SetDocumentIconProviderAsync");
    }

    partial void OnShowDocumentIconProviderChanged(bool value)
    {
        OnPropertyChanged(nameof(ShowDocumentIconProviderChangedHint));
        OnPropertyChanged(nameof(CanChangeDocumentIconProvider));
    }

    [RelayCommand]
    public Task RefreshAsync()
    {
        return StartRefreshAsync(markLoaded: true);
    }

    public Task EnsureLoadedAsync()
    {
        lock (_refreshSync)
        {
            if (_hasLoaded)
            {
                StartAutoRefreshLoop();
                return Task.CompletedTask;
            }
        }

        return StartRefreshAsync(markLoaded: true);
    }

    private Task StartRefreshAsync(bool markLoaded, bool showBusy = true)
    {
        lock (_refreshSync)
        {
            if (Kind == SpecialMenuKind.ShellNew && IsShellNewLockBusy) return Task.CompletedTask;
            if (_refreshTask is { IsCompleted: false })
            {
                return _refreshTask;
            }

            var generation = ++_refreshGeneration;
            _refreshTask = RefreshCoreAsync(generation, markLoaded, showBusy);
            return _refreshTask;
        }
    }

    private async Task RefreshCoreAsync(int generation, bool markLoaded, bool showBusy)
    {
        var shellNewVersion = _shellNewStateVersion;
        var openWithGateHeld = false;
        if (showBusy)
        {
            await SetBusyAsync(true);
            await YieldToUiAsync();
        }

        try
        {
            if (Kind == SpecialMenuKind.OpenWith)
            {
                await _openWithOperationGate.WaitAsync(_disposeCts.Token);
                openWithGateHeld = true;
            }
            using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
            using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(timeoutCts.Token, _disposeCts.Token);
            if (!_hasSnapshot)
            {
                var cached = await _backendClient.ReadCachedListAsync<SpecialMenuEntry>(new PipeRequest {
                    Command = PipeCommand.GetSpecialMenuSnapshot, SpecialKind = Kind }, linkedCts.Token);
                if (cached is not null && IsCurrentRefreshGeneration(generation))
                {
                    await ApplySnapshotAsync(cached, Kind == SpecialMenuKind.ShellNew ? shellNewVersion : null);
                    await System.Windows.Application.Current.Dispatcher.InvokeAsync(() => StatusText = _localization.Translate("MenuListCachedStatus"));
                }
            }
            if (showBusy) await SetLoadingAsync(!_hasSnapshot);
            if (Kind == SpecialMenuKind.ShellNew) await VerifyShellNewLockStateAsync(shellNewVersion);
            var snapshot = await _backendClient.GetSpecialMenuSnapshotAsync(Kind, linkedCts.Token);
            if (!IsCurrentRefreshGeneration(generation) || (Kind == SpecialMenuKind.ShellNew && shellNewVersion != _shellNewStateVersion))
            {
                FrontendDebugLog.Info(
                    "SpecialMenuPageViewModel",
                    $"RefreshAsync stale result ignored. Kind={Kind}, Generation={generation}.");
                return;
            }

            if (Kind == SpecialMenuKind.ShellNew)
                await System.Windows.Application.Current.Dispatcher.InvokeAsync(() =>
                {
                    if (shellNewVersion != _shellNewStateVersion) return;
                    _shellNewDiscoveryValid = true;
                    OnPropertyChanged(nameof(CanToggleShellNewOrderLock));
                });
            await ApplySnapshotAsync(snapshot, Kind == SpecialMenuKind.ShellNew ? shellNewVersion : null, preserveBusy: true);
            await System.Windows.Application.Current.Dispatcher.InvokeAsync(() =>
            {
                if (!IsCurrentRefreshGeneration(generation) || (Kind == SpecialMenuKind.ShellNew && shellNewVersion != _shellNewStateVersion))
                {
                    return;
                }

                if (Kind != SpecialMenuKind.ShellNew || IsShellNewOrderLocked.HasValue)
                    StatusText = snapshot is MenuListSnapshot<SpecialMenuEntry> { IsComplete: false }
                        ? _localization.Translate("MenuListIncompleteStatus") : string.Empty;
                if (markLoaded)
                {
                    _hasLoaded = true;
                    StartAutoRefreshLoop();
                }
            });

            if (showBusy && IsCurrentRefreshGeneration(generation))
            {
                await SetLoadingAsync(false);
            }

            await RefreshOfficeCoexistenceStatusAsync(linkedCts.Token);
        }
        catch (OperationCanceledException ex) when (_disposeCts.IsCancellationRequested || !IsCurrentRefreshGeneration(generation))
        {
            FrontendDebugLog.Info(
                "SpecialMenuPageViewModel",
                $"RefreshAsync canceled benignly. Kind={Kind}, Generation={generation}, Message={ex.Message}");
        }
        catch (ObjectDisposedException ex) when (_disposed)
        {
            FrontendDebugLog.Info(
                "SpecialMenuPageViewModel",
                $"RefreshAsync skipped during disposal. Kind={Kind}, Generation={generation}, Message={ex.Message}");
        }
        catch (OperationCanceledException ex)
        {
            InvalidateShellNewDiscovery(shellNewVersion);
            FrontendDebugLog.Warning(
                "SpecialMenuPageViewModel",
                $"RefreshAsync canceled by timeout or caller. Kind={Kind}, Generation={generation}, Message={ex.Message}");
            if (showBusy)
            {
                StatusText = _localization.Translate("OtherRulesClickRefreshToRetry");
            }
        }
        catch (Exception ex)
        {
            InvalidateShellNewDiscovery(shellNewVersion);
            FrontendDebugLog.Warning(
                "SpecialMenuPageViewModel",
                $"RefreshAsync failed. Kind={Kind}, Generation={generation}, Message={ex.Message}");
            if (showBusy)
            {
                StatusText = _localization.Format("OtherRulesTabLoadFailed", ex.Message);
            }
        }
        finally
        {
            if (openWithGateHeld) _openWithOperationGate.Release();
            if (showBusy && IsCurrentRefreshGeneration(generation))
            {
                await SetLoadingAsync(false);
                await SetBusyAsync(false);
            }
        }
    }

    [RelayCommand]
    private async Task AddAsync()
    {
        var openWithGateHeld = false;
        try
        {
            var operationId = Guid.NewGuid();
            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(15));
            var request = await CreateAddRequestAsync(operationId);
            if (request is null)
            {
                return;
            }

            if (Kind == SpecialMenuKind.OpenWith)
            {
                await _openWithOperationGate.WaitAsync(_disposeCts.Token);
                openWithGateHeld = true;
            }
            var item = await _backendClient.CreateSpecialMenuItemAsync(request, cts.Token);
            if (Kind == SpecialMenuKind.OpenWith && item is null)
                throw new InvalidOperationException("OpenWithOperationUncertain");
            if (item is not null)
            {
                if (Kind == SpecialMenuKind.WinX)
                {
                    _explorerRestartState.MarkRequired();
                    await RefreshAsync();
                }
                else
                {
                    Upsert(item);
                }
            }
        }
        catch (OperationCanceledException) when (Kind == SpecialMenuKind.WinX)
        {
            await FrontendMessageBox.ShowErrorAsync(
                "Win+X create timed out. Check backend logs for WinXCreate stage logs.",
                Title);
        }
        catch (Exception ex)
        {
            if (openWithGateHeld) await ReconcileOpenWithFailureAsync(null);
            await FrontendMessageBox.ShowErrorAsync(LocalizeOpenWithError(ex), Title);
        }
        finally
        {
            if (openWithGateHeld) _openWithOperationGate.Release();
        }
    }

    [RelayCommand]
    private async Task DeleteAsync(SpecialMenuItemViewModel? item)
    {
        if (item is null)
        {
            return;
        }

        var openWithGateHeld = false;
        try
        {
            if (ProtectedMenuItemGuard.IsProtectedOpenItem(item)
                && !await ProtectedMenuItemGuard.ConfirmAsync(_localization))
            {
                return;
            }

            item.IsBusy = true;
            if (Kind == SpecialMenuKind.OpenWith)
            {
                await _openWithOperationGate.WaitAsync(_disposeCts.Token);
                openWithGateHeld = true;
            }
            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
            var updated = await _backendClient.DeleteSpecialMenuItemAsync(item.Entry, Guid.NewGuid(), cts.Token);
            if (updated is not null)
            {
                item.Update(updated);
            }
            else
            {
                Items.Remove(item);
            }

            if (Kind == SpecialMenuKind.WinX)
            {
                _explorerRestartState.MarkRequired();
                await RefreshAsync();
            }
        }
        catch (BackendRequestException ex) when (ex.ErrorCode == PipeErrorCodes.MenuItemRemoved) {  }
        catch (Exception ex)
        {
            if (Kind == SpecialMenuKind.OpenWith && openWithGateHeld)
                await ReconcileOpenWithFailureAsync(item);
            await FrontendMessageBox.ShowErrorAsync(
                LocalizeOpenWithError(ex),
                item.DisplayName);
        }
        finally
        {
            if (openWithGateHeld) _openWithOperationGate.Release();
            item.IsBusy = false;
        }
    }

    [RelayCommand]
    private async Task UndoDeleteAsync(SpecialMenuItemViewModel? item)
    {
        if (item is null)
        {
            return;
        }

        var openWithGateHeld = false;
        try
        {
            item.IsBusy = true;
            if (Kind == SpecialMenuKind.OpenWith)
            {
                await _openWithOperationGate.WaitAsync(_disposeCts.Token);
                openWithGateHeld = true;
            }
            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
            var updated = await _backendClient.UndoDeleteSpecialMenuItemAsync(item.Entry, Guid.NewGuid(), cts.Token);
            if (updated is not null)
            {
                item.Update(updated);
            }
            else
            {
                Items.Remove(item);
            }

            if (Kind == SpecialMenuKind.WinX)
            {
                _explorerRestartState.MarkRequired();
            }
        }
        catch (BackendRequestException ex) when (ex.ErrorCode == PipeErrorCodes.MenuItemRemoved) {  }
        catch (Exception ex)
        {
            if (Kind == SpecialMenuKind.OpenWith && openWithGateHeld)
                await ReconcileOpenWithFailureAsync(item);
            await FrontendMessageBox.ShowErrorAsync(
                LocalizeOpenWithError(ex),
                item.DisplayName);
        }
        finally
        {
            if (openWithGateHeld) _openWithOperationGate.Release();
            item.IsBusy = false;
        }
    }

    [RelayCommand]
    private Task OpenPermanentDeleteFlyoutAsync(SpecialMenuItemViewModel? item)
    {
        if (item is not null)
        {
            item.IsPermanentDeleteFlyoutOpen = true;
        }

        return Task.CompletedTask;
    }

    [RelayCommand]
    private async Task ConfirmPermanentDeleteAsync(SpecialMenuItemViewModel? item)
    {
        if (item is null)
        {
            return;
        }

        item.IsPermanentDeleteFlyoutOpen = false;
        var openWithGateHeld = false;
        try
        {
            item.IsBusy = true;
            if (Kind == SpecialMenuKind.OpenWith)
            {
                await _openWithOperationGate.WaitAsync(_disposeCts.Token);
                openWithGateHeld = true;
            }
            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
            await _backendClient.PurgeDeletedSpecialMenuItemAsync(item.Entry, Guid.NewGuid(), cts.Token);
            Items.Remove(item);
            if (Kind == SpecialMenuKind.WinX)
            {
                _explorerRestartState.MarkRequired();
            }
        }
        catch (BackendRequestException ex) when (ex.ErrorCode == PipeErrorCodes.MenuItemRemoved) {  }
        catch (Exception ex)
        {
            if (Kind == SpecialMenuKind.OpenWith && openWithGateHeld)
                await ReconcileOpenWithFailureAsync(item);
            await FrontendMessageBox.ShowErrorAsync(
                LocalizeOpenWithError(ex),
                item.DisplayName);
        }
        finally
        {
            if (openWithGateHeld) _openWithOperationGate.Release();
            item.IsBusy = false;
        }
    }

    [RelayCommand]
    private async Task EditAsync(SpecialMenuItemViewModel? item)
    {
        if (item is null || !item.CanEdit)
        {
            return;
        }

        var openWithGateHeld = false;
        try
        {
            var operationId = Guid.NewGuid();
            var request = await CreateUpdateRequestAsync(item, operationId);
            if (request is null)
            {
                return;
            }

            item.IsBusy = true;
            if (Kind == SpecialMenuKind.OpenWith)
            {
                await _openWithOperationGate.WaitAsync(_disposeCts.Token);
                openWithGateHeld = true;
            }
            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(15));
            var updated = await _backendClient.UpdateSpecialMenuItemAsync(request, cts.Token);
            if (Kind == SpecialMenuKind.OpenWith && updated is null)
                throw new InvalidOperationException("OpenWithOperationUncertain");
            if (updated is not null)
            {
                if (Kind == SpecialMenuKind.WinX)
                {
                    _explorerRestartState.MarkRequired();
                    await RefreshAsync();
                }
                else
                {
                    item.Update(updated);
                }
            }
        }
        catch (BackendRequestException ex) when (ex.ErrorCode == PipeErrorCodes.MenuItemRemoved) {  }
        catch (Exception ex)
        {
            if (Kind == SpecialMenuKind.OpenWith && openWithGateHeld)
                await ReconcileOpenWithFailureAsync(item);
            await FrontendMessageBox.ShowErrorAsync(
                LocalizeOpenWithError(ex),
                item.DisplayName);
        }
        finally
        {
            if (openWithGateHeld) _openWithOperationGate.Release();
            item.IsBusy = false;
        }
    }

    [RelayCommand]
    private async Task MoveUpAsync(SpecialMenuItemViewModel? item) => await MoveAsync(item, true);

    [RelayCommand]
    private async Task MoveDownAsync(SpecialMenuItemViewModel? item) => await MoveAsync(item, false);

    [RelayCommand]
    private async Task RestoreDefaultsAsync()
    {
        if (Kind != SpecialMenuKind.SendTo)
        {
            return;
        }

        try
        {
            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(20));
            await _backendClient.RestoreSpecialMenuDefaultsAsync(Kind, null, Guid.NewGuid(), cts.Token);
            if (Kind == SpecialMenuKind.WinX)
            {
                _explorerRestartState.MarkRequired();
            }
            await RefreshAsync();
        }
        catch (BackendRequestException ex) when (ex.ErrorCode == PipeErrorCodes.MenuItemRemoved) { }
        catch (Exception ex)
        {
            await FrontendMessageBox.ShowErrorAsync(ex.Message, Title);
        }
    }

    private async Task MoveAsync(SpecialMenuItemViewModel? item, bool moveUp)
    {
        if (item is null)
        {
            return;
        }

        if ((moveUp && !item.CanMoveUp) || (!moveUp && !item.CanMoveDown))
        {
            return;
        }

        try
        {
            StatusText = string.Empty;
            item.IsBusy = true;
            var operationId = Guid.NewGuid();
            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
            var request = Kind == SpecialMenuKind.ShellNew
                ? new PipeRequest
                {
                    SpecialKind = Kind,
                    ShellNewSort = new ShellNewSortRequest(item.Id, moveUp),
                    ClientOperationId = operationId
                }
                : new PipeRequest
                {
                    SpecialKind = Kind,
                    WinXMove = new WinXMoveRequest(item.Id, moveUp),
                    ClientOperationId = operationId
                };
            var updated = await _backendClient.MoveSpecialMenuItemAsync(request, cts.Token);
            if (updated is not null)
            {
                if (Kind == SpecialMenuKind.WinX)
                {
                    _explorerRestartState.MarkRequired();
                }
                await RefreshAsync();
            }
        }
        catch (Exception ex)
        {
            if (Kind == SpecialMenuKind.ShellNew && IsExpectedShellNewMoveFailure(ex))
            {
                StatusText = ex.Message;
                return;
            }

            await FrontendMessageBox.ShowErrorAsync(ex.Message, item.DisplayName);
        }
        finally
        {
            item.IsBusy = false;
        }
    }

    private async Task<bool> SetEnabledAsync(SpecialMenuItemViewModel item, bool enabled)
    {
        var openWithGateHeld = false;
        try
        {
            if (!enabled
                && ProtectedMenuItemGuard.IsProtectedOpenItem(item)
                && !await ProtectedMenuItemGuard.ConfirmAsync(_localization))
            {
                return false;
            }

            if (Kind == SpecialMenuKind.OpenWith)
            {
                await _openWithOperationGate.WaitAsync(_disposeCts.Token);
                openWithGateHeld = true;
            }
            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
            var updated = await _backendClient.SetSpecialMenuItemEnabledAsync(item.Entry, enabled, Guid.NewGuid(), cts.Token);
            if (updated is not null)
            {
                item.Update(updated);
                if (Kind == SpecialMenuKind.WinX)
                {
                    _explorerRestartState.MarkRequired();
                }
            }

            if (Kind == SpecialMenuKind.OpenWith && updated is null)
                throw new InvalidOperationException(_localization.Translate("OpenWithOperationUncertain"));
            return true;
        }
        catch (BackendRequestException ex) when (ex.ErrorCode == PipeErrorCodes.MenuItemRemoved) { return false; }
        catch (Exception ex)
        {
            if (Kind == SpecialMenuKind.OpenWith && openWithGateHeld)
                await ReconcileOpenWithFailureAsync(item);
            await FrontendMessageBox.ShowErrorAsync(
                LocalizeOpenWithError(ex),
                item.DisplayName);
            return false;
        }
        finally
        {
            if (openWithGateHeld) _openWithOperationGate.Release();
        }
    }

    [RelayCommand]
    private Task ProtectOpenWithAsync(SpecialMenuItemViewModel item)
        => ReviewOpenWithAsync(item, !item.HasPersistentProtection);

    [RelayCommand]
    private void OpenWithApprovals(SpecialMenuItemViewModel item)
        => _navigationState?.RequestApprovals(item.Entry.Metadata.GetValueOrDefault("AppRegistryPath"));

    private void OnOpenWithRequested(object? sender, EventArgs e)
        => SearchText = _navigationState?.OpenWithFocusPath ?? string.Empty;

    private async Task ReviewOpenWithAsync(SpecialMenuItemViewModel item, bool protect)
    {
        if (Kind != SpecialMenuKind.OpenWith || !item.CanReviewOpenWith) return;
        item.IsBusy = true;
        var gateHeld = false;
        try
        {
            await _openWithOperationGate.WaitAsync(_disposeCts.Token);
            gateHeld = true;
            using var timeout = CancellationTokenSource.CreateLinkedTokenSource(_disposeCts.Token);
            timeout.CancelAfter(TimeSpan.FromSeconds(20));
            await _backendClient.ReviewOpenWithRegistrationAsync(item.Entry, protect, timeout.Token);
            // Even a successful response may precede a corrective action or another client.
            var snapshot = await _backendClient.GetSpecialMenuSnapshotAsync(Kind, timeout.Token);
            await ApplySnapshotAsync(snapshot);
        }
        catch (BackendRequestException ex) when (ex.ErrorCode == PipeErrorCodes.MenuItemRemoved) {  }
        catch (Exception ex)
        {
            await ReconcileOpenWithFailureAsync(item);
            await FrontendMessageBox.ShowErrorAsync(LocalizeOpenWithError(ex), Title);
        }
        finally { item.IsBusy = false; if (gateHeld) _openWithOperationGate.Release(); }
    }

    private string LocalizeOpenWithError(Exception ex) => ex.Message is
        "OpenWithExternalVisibility" or "OpenWithOperationUncertain" or "OpenWithUnsupportedRegistration"
        or "OpenWithIdentityUnavailable" or "OpenWithPersistenceUnavailable" or "OpenWithUserProtectionOnly"
        or "OpenWithProtectionRequiresDisabled" or "OpenWithStaleReview" or "OpenWithReviewRequired"
            ? _localization.Translate(ex.Message) : ex.Message;

    private async Task ReconcileOpenWithFailureAsync(SpecialMenuItemViewModel? item)
    {
        if (item is not null) item.IsStateUncertain = true;
        try
        {
            // A failed/expired response can follow a completed registry write. Never retry it here.
            using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10));
            using var linked = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, _disposeCts.Token);
            var snapshot = await _backendClient.GetSpecialMenuSnapshotAsync(Kind, linked.Token);
            await ApplySnapshotAsync(snapshot);
            StatusText = string.Empty;
        }
        catch (Exception ex)
        {
            StatusText = _localization.Translate("OpenWithOperationUncertain");
            FrontendDebugLog.Warning("SpecialMenuPageViewModel", $"OpenWith outcome verification failed: {ex.Message}");
        }
    }

    private async Task<PipeRequest?> CreateAddRequestAsync(Guid operationId)
    {
        switch (Kind)
        {
            case SpecialMenuKind.ShellNew:
                var shellNewAddData = await MenuItemFormDialog.ShowAddShellNewAsync(Title, _localization);
                return shellNewAddData is null
                    ? null
                    : new PipeRequest
                    {
                        SpecialKind = Kind,
                        ShellNewCreate = new ShellNewCreateRequest(
                            shellNewAddData.Extension,
                            EmptyToNull(shellNewAddData.DisplayName),
                            EmptyToNull(shellNewAddData.IconPath),
                            EmptyToNull(shellNewAddData.Command),
                            null,
                            shellNewAddData.BeforeSeparator),
                        ClientOperationId = operationId
                    };
            case SpecialMenuKind.SendTo:
                var sendToData = await MenuItemFormDialog.ShowAddSendToAsync(Title, _localization);
                if (sendToData is null)
                {
                    return null;
                }

                if (string.IsNullOrWhiteSpace(sendToData.Name))
                {
                    await FrontendMessageBox.ShowErrorAsync(_localization.Translate("TextCannotBeEmpty"), Title);
                    return null;
                }

                return new PipeRequest { SpecialKind = Kind, SendToCreate = new SendToCreateRequest(sendToData.Name, sendToData.TargetPath, sendToData.Arguments), ClientOperationId = operationId };
            case SpecialMenuKind.WinX:
                var winxData = await MenuItemFormDialog.ShowAddWinXAsync(Title, _localization);
                if (winxData is null)
                {
                    return null;
                }

                if (string.IsNullOrWhiteSpace(winxData.Name))
                {
                    await FrontendMessageBox.ShowErrorAsync(_localization.Translate("TextCannotBeEmpty"), Title);
                    return null;
                }

                if (string.IsNullOrWhiteSpace(winxData.TargetPath))
                {
                    await FrontendMessageBox.ShowErrorAsync(_localization.Translate("TextCannotBeEmpty"), Title);
                    return null;
                }

                if (string.Equals(winxData.GroupName, "Group:", StringComparison.OrdinalIgnoreCase) || winxData.GroupName.StartsWith("Group:", StringComparison.OrdinalIgnoreCase))
                {
                    return new PipeRequest { SpecialKind = Kind, WinXCreateGroup = new WinXCreateGroupRequest(winxData.GroupName.Length > 6 ? winxData.GroupName[6..].Trim() : string.Empty), ClientOperationId = operationId };
                }

                return new PipeRequest
                {
                    SpecialKind = Kind,
                    WinXCreateEntry = new WinXCreateEntryRequest(
                        winxData.Name,
                        winxData.TargetPath,
                        winxData.GroupName,
                        EmptyToNull(winxData.Arguments),
                        EmptyToNull(winxData.WorkingDirectory),
                        EmptyToNull(winxData.IconPath),
                        winxData.RunAsAdmin),
                    ClientOperationId = operationId
                };
            case SpecialMenuKind.OpenWith:
                var openWithData = await MenuItemFormDialog.ShowAddOpenWithAsync(Title, _localization);
                if (openWithData is null)
                {
                    return null;
                }

                if (string.IsNullOrWhiteSpace(openWithData.Name) || string.IsNullOrWhiteSpace(openWithData.TargetPath))
                {
                    await FrontendMessageBox.ShowErrorAsync(_localization.Translate("TextCannotBeEmpty"), Title);
                    return null;
                }

                return new PipeRequest
                {
                    SpecialKind = Kind,
                    OpenWithCreate = new OpenWithCreateRequest(
                        openWithData.Name,
                        openWithData.TargetPath,
                        EmptyToNull(openWithData.Arguments)),
                    ClientOperationId = operationId
                };
            case SpecialMenuKind.DragDrop:
                var dragDrop = await TextInputDialog.ShowAsync(Title, "GUID|Group(Folder/Directory/Drive/AllFilesystemObjects)", "{00000000-0000-0000-0000-000000000000}|Folder");
                var dragDropParts = SplitParts(dragDrop, 2);
                return dragDropParts is null
                    ? null
                    : new PipeRequest { SpecialKind = Kind, DragDropCreate = new DragDropCreateRequest(dragDropParts[0], dragDropParts[1]), ClientOperationId = operationId };
            case SpecialMenuKind.CommandStore:
                var commandStore = await TextInputDialog.ShowAsync(Title, "Key|Name|Command", "my.command|My Command|notepad.exe \"%1\"");
                var commandStoreParts = SplitParts(commandStore, 3);
                return commandStoreParts is null
                    ? null
                    : new PipeRequest
                    {
                        SpecialKind = Kind,
                        SpecialItem = new SpecialMenuEntry { Kind = Kind, KeyName = commandStoreParts[0], DisplayName = commandStoreParts[1], CommandText = commandStoreParts[2] },
                        ClientOperationId = operationId
                    };
            case SpecialMenuKind.GuidBlock:
                var guid = await TextInputDialog.ShowAsync(Title, "GUID", "{00000000-0000-0000-0000-000000000000}");
                return string.IsNullOrWhiteSpace(guid)
                    ? null
                    : new PipeRequest { SpecialKind = Kind, GuidBlockCreate = new GuidBlockCreateRequest(guid), ClientOperationId = operationId };
            case SpecialMenuKind.InternetExplorer:
                var ie = await TextInputDialog.ShowAsync(Title, "Name|Command", "Open with Notepad|notepad.exe");
                var ieParts = SplitParts(ie, 2);
                return ieParts is null
                    ? null
                    : new PipeRequest { SpecialKind = Kind, IeMenuCreate = new IeMenuCreateRequest(ieParts[0], ieParts[1]), ClientOperationId = operationId };
        }

        return null;
    }

    private async Task<PipeRequest?> CreateUpdateRequestAsync(SpecialMenuItemViewModel item, Guid operationId)
    {
        switch (Kind)
        {
            case SpecialMenuKind.ShellNew:
                var shellNewInitialData = new ShellNewFormData
                {
                    Extension = item.Id,
                    DisplayName = item.DisplayName,
                    IconPath = item.Entry.IconPath ?? string.Empty,
                    Command = item.Entry.CommandText ?? string.Empty,
                    BeforeSeparator = false
                };
                var shellNewEditData = await MenuItemFormDialog.ShowEditShellNewAsync(Title, shellNewInitialData, _localization);
                return shellNewEditData is null
                    ? null
                    : new PipeRequest
                    {
                        SpecialKind = Kind,
                        ShellNewUpdate = new ShellNewUpdateRequest(
                            shellNewEditData.Extension,
                            string.IsNullOrWhiteSpace(shellNewEditData.DisplayName) ? null : shellNewEditData.DisplayName,
                            string.IsNullOrWhiteSpace(shellNewEditData.IconPath) ? null : shellNewEditData.IconPath,
                            string.IsNullOrWhiteSpace(shellNewEditData.Command) ? null : shellNewEditData.Command,
                            null,
                            shellNewEditData.BeforeSeparator),
                        ClientOperationId = operationId
                    };
            case SpecialMenuKind.SendTo:
                var sendToInitialData = new MenuItemFormData
                {
                    Name = item.DisplayName,
                    TargetPath = item.Entry.TargetPath ?? string.Empty,
                    Arguments = item.Entry.Arguments ?? string.Empty,
                    WorkingDirectory = item.Entry.WorkingDirectory ?? string.Empty,
                    IconPath = item.Entry.IconPath ?? string.Empty
                };
                var sendToData = await MenuItemFormDialog.ShowEditSendToAsync(Title, sendToInitialData, _localization);
                if (sendToData is null)
                {
                    return null;
                }

                if (string.IsNullOrWhiteSpace(sendToData.Name))
                {
                    await FrontendMessageBox.ShowErrorAsync(_localization.Translate("TextCannotBeEmpty"), Title);
                    return null;
                }

                return new PipeRequest
                {
                    SpecialKind = Kind,
                    SendToUpdate = new SendToUpdateRequest(
                        item.Id,
                        sendToData.Name,
                        sendToData.TargetPath,
                        sendToData.Arguments,
                        sendToData.WorkingDirectory,
                        sendToData.IconPath,
                        sendToData.RunAsAdmin),
                    ClientOperationId = operationId
                };
            case SpecialMenuKind.WinX:
                var winxInitialData = new MenuItemFormData
                {
                    Name = item.DisplayName,
                    TargetPath = item.Entry.TargetPath ?? string.Empty,
                    Arguments = item.Entry.Arguments ?? string.Empty,
                    WorkingDirectory = item.Entry.WorkingDirectory ?? string.Empty,
                    IconPath = item.Entry.IconPath ?? string.Empty,
                    GroupName = item.Entry.GroupName ?? string.Empty
                };
                var winxData = await MenuItemFormDialog.ShowEditWinXAsync(Title, winxInitialData, _localization);
                if (winxData is null)
                {
                    return null;
                }

                if (string.IsNullOrWhiteSpace(winxData.Name))
                {
                    await FrontendMessageBox.ShowErrorAsync(_localization.Translate("TextCannotBeEmpty"), Title);
                    return null;
                }

                if (string.IsNullOrWhiteSpace(winxData.TargetPath))
                {
                    await FrontendMessageBox.ShowErrorAsync(_localization.Translate("TextCannotBeEmpty"), Title);
                    return null;
                }

                // Guard against editing Win+X group headers as normal entries.
                if (item.Entry.Metadata.GetValueOrDefault("EntryType") == "Group")
                {
                    await FrontendMessageBox.ShowErrorAsync(_localization.Translate("CannotEditWinXGroupHeader"), Title);
                    return null;
                }

                return new PipeRequest
                {
                    SpecialKind = Kind,
                    WinXUpdateEntry = new WinXUpdateEntryRequest(
                        item.Id,
                        winxData.Name,
                        winxData.TargetPath,
                        EmptyToNull(winxData.Arguments),
                        EmptyToNull(winxData.WorkingDirectory),
                        winxData.GroupName,
                        EmptyToNull(winxData.IconPath),
                        winxData.RunAsAdmin),
                    ClientOperationId = operationId
                };
            case SpecialMenuKind.OpenWith:
                var expectedEditStamp = item.Entry.Metadata.GetValueOrDefault("EditStamp");
                var openWithInitialData = new MenuItemFormData
                {
                    Name = item.DisplayName,
                    TargetPath = item.Entry.TargetPath ?? string.Empty,
                    Arguments = item.Entry.CommandText ?? string.Empty,
                    IconPath = item.Entry.IconPath ?? string.Empty
                };
                var openWithData = await MenuItemFormDialog.ShowEditOpenWithAsync(Title, openWithInitialData, _localization);
                if (openWithData is null)
                {
                    return null;
                }

                if (string.IsNullOrWhiteSpace(openWithData.Name))
                {
                    await FrontendMessageBox.ShowErrorAsync(_localization.Translate("TextCannotBeEmpty"), Title);
                    return null;
                }

                return new PipeRequest
                {
                    SpecialKind = Kind,
                    OpenWithUpdate = new OpenWithUpdateRequest(
                        item.Id,
                        openWithData.Name,
                        EmptyToNull(openWithData.Arguments),
                        expectedEditStamp),
                    ClientOperationId = operationId
                };
            case SpecialMenuKind.CommandStore:
                var commandStore = await TextInputDialog.ShowAsync(Title, "Name|Command|Icon", $"{item.DisplayName}|{item.Entry.CommandText}|{item.Entry.IconPath}");
                var commandStoreParts = SplitParts(commandStore, 3, allowEmptyMiddleParts: true);
                return commandStoreParts is null
                    ? null
                    : new PipeRequest
                    {
                        SpecialKind = Kind,
                        SpecialItem = item.Entry with
                        {
                            DisplayName = commandStoreParts[0],
                            CommandText = EmptyToNull(commandStoreParts[1]),
                            IconPath = EmptyToNull(commandStoreParts[2])
                        },
                        ClientOperationId = operationId
                    };
            case SpecialMenuKind.InternetExplorer:
                var ie = await TextInputDialog.ShowAsync(Title, "Name|Command", $"{item.DisplayName}|{item.Entry.CommandText}");
                var ieParts = SplitParts(ie, 2, allowEmptyMiddleParts: true);
                return ieParts is null
                    ? null
                    : new PipeRequest
                    {
                        SpecialKind = Kind,
                        IeMenuUpdate = new IeMenuUpdateRequest(item.Id, EmptyToNull(ieParts[0]), EmptyToNull(ieParts[1])),
                        ClientOperationId = operationId
                    };
        }

        return null;
    }

    private async Task ApplySnapshotAsync(IEnumerable<SpecialMenuEntry> snapshot, int? shellNewVersion = null, bool preserveBusy = false)
    {
        var entries = snapshot as IReadOnlyList<SpecialMenuEntry> ?? snapshot.ToArray();
        var dispatcher = System.Windows.Application.Current.Dispatcher;
        if (!dispatcher.CheckAccess())
        {
            await dispatcher.InvokeAsync(() => shellNewVersion is int version && version != _shellNewStateVersion
                ? Task.CompletedTask : ApplySnapshotCoreAsync(entries, preserveBusy)).Task.Unwrap();
            return;
        }

        if (shellNewVersion is int version && version != _shellNewStateVersion) return;
        await ApplySnapshotCoreAsync(entries, preserveBusy);
    }

    private async Task ApplySnapshotCoreAsync(IReadOnlyList<SpecialMenuEntry> entries, bool preserveBusy)
    {
        entries = MenuListData.Current(entries);
        _hasSnapshot = true;
        if (Kind == SpecialMenuKind.WinX)
        {
            ApplyWinXSnapshotIncrementally(entries, preserveBusy);
            return;
        }

        var isInitialLoad = Items.Count == 0;
        if (isInitialLoad)
        {
            await AddInitialItemsAsync(entries);
        }
        else
        {
            ReconcileItemsIncrementally(entries, preserveBusy);
        }

        if (entries is not MenuListSnapshot<SpecialMenuEntry> { IsFromCache: true }) UpdatePageStateFromSnapshot(entries);
        foreach (var row in Items) row.IsBackendAvailable = entries is not MenuListSnapshot<SpecialMenuEntry> { IsFromCache: true } || _backendClient.IsConnected;
        UpdateShellNewMoveAvailability();

        RefreshListPlaceholderState();
    }

    private async Task AddInitialItemsAsync(IReadOnlyList<SpecialMenuEntry> entries)
    {
        for (var index = 0; index < entries.Count; index++)
        {
            Items.Add(new SpecialMenuItemViewModel(
                entries[index],
                _iconPreviewService,
                _localization,
                SetEnabledAsync));

            if ((index + 1) % 32 == 0)
            {
                await YieldToUiAsync();
            }
        }
    }

    private static async Task YieldToUiAsync()
    {
        await System.Windows.Application.Current.Dispatcher.InvokeAsync(
            static () => { },
            System.Windows.Threading.DispatcherPriority.Background);
    }

    private async Task SetBusyAsync(bool value)
    {
        var dispatcher = System.Windows.Application.Current.Dispatcher;
        if (dispatcher.CheckAccess())
        {
            IsBusy = value;
            return;
        }

        await dispatcher.InvokeAsync(() => IsBusy = value);
    }

    private async Task SetLoadingAsync(bool value)
    {
        var dispatcher = System.Windows.Application.Current.Dispatcher;
        if (dispatcher.CheckAccess()) IsLoading = value;
        else await dispatcher.InvokeAsync(() => IsLoading = value);
    }

    private void ApplyWinXSnapshotIncrementally(IReadOnlyList<SpecialMenuEntry> entries, bool preserveBusy)
    {
        ReconcileItemsIncrementally(entries, preserveBusy);
        foreach (var row in Items) row.IsBackendAvailable = entries is not MenuListSnapshot<SpecialMenuEntry> { IsFromCache: true } || _backendClient.IsConnected;
        if (entries is not MenuListSnapshot<SpecialMenuEntry> { IsFromCache: true }) UpdatePageStateFromSnapshot(entries);
        ReconcileWinXGroupsIncrementally();

        RefreshListPlaceholderState();
    }

    private void ReconcileItemsIncrementally(IReadOnlyList<SpecialMenuEntry> entries, bool preserveBusy)
    {
        var existingById = new Dictionary<string, SpecialMenuItemViewModel>(StringComparer.OrdinalIgnoreCase);
        foreach (var item in Items)
        {
            existingById[item.Id] = item;
        }

        var newIds = entries
            .Select(static entry => entry.Id)
            .ToHashSet(StringComparer.OrdinalIgnoreCase);
        for (var index = Items.Count - 1; index >= 0; index--)
        {
            if ((!preserveBusy || !Items[index].IsBusy) && MenuListData.AllowsRemoval(entries, Items[index].Entry) && !newIds.Contains(Items[index].Id))
            {
                Items.RemoveAt(index);
            }
        }

        for (var targetIndex = 0; targetIndex < entries.Count; targetIndex++)
        {
            var entry = entries[targetIndex];
            if (existingById.TryGetValue(entry.Id, out var item))
            {
                if (!preserveBusy || !item.IsBusy) item.Update(entry);
            }
            else
            {
                item = new SpecialMenuItemViewModel(entry, _iconPreviewService, _localization, SetEnabledAsync);
            }

            var currentIndex = Items.IndexOf(item);
            if (currentIndex < 0)
            {
                Items.Insert(targetIndex, item);
            }
            else if (currentIndex != targetIndex)
            {
                Items.Move(currentIndex, targetIndex);
            }
        }
    }

    private void OnItemsRemoved(object? sender, MenuItemsRemovedEventArgs e)
    {
        if (e.Request.SpecialItem?.Kind != Kind) return;
        var dispatcher = System.Windows.Application.Current.Dispatcher;
        _ = dispatcher.InvokeAsync(() =>
        {
            if (_disposed) return;
            foreach (var item in Items.Where(item => e.ItemIds.Contains(item.Id, StringComparer.OrdinalIgnoreCase)).ToArray()) Items.Remove(item);
            if (Kind == SpecialMenuKind.WinX) ReconcileWinXGroupsIncrementally();
            RefreshListPlaceholderState();
        });
    }

    private void Upsert(SpecialMenuEntry entry)
    {
        if (Kind == SpecialMenuKind.WinX)
        {
            ObserveFireAndForget(RefreshAsync(), "WinXUpsertRefreshAsync");
            return;
        }

        var current = Items.FirstOrDefault(item => string.Equals(item.Id, entry.Id, StringComparison.OrdinalIgnoreCase));
        if (current is null)
        {
            Items.Add(new SpecialMenuItemViewModel(entry, _iconPreviewService, _localization, SetEnabledAsync));
        }
        else
        {
            current.Update(entry);
        }

        UpdateShellNewMoveAvailability();
        RefreshListPlaceholderState();
    }

    private bool FilterItem(object obj)
    {
        return obj is SpecialMenuItemViewModel item
            && (Kind != SpecialMenuKind.OpenWith || !item.IsReadOnlyOpenWith)
            && MatchesSearch(item);
    }

    private bool FilterProtectedOpenWithItem(object obj)
        => obj is SpecialMenuItemViewModel item && item.IsReadOnlyOpenWith && MatchesSearch(item);

    private bool MatchesSearch(SpecialMenuItemViewModel item)
    {
        if (string.IsNullOrWhiteSpace(SearchText))
        {
            return true;
        }

        var search = SearchText.Trim();
        return Contains(item.DisplayName, search)
               || Contains(item.KeyName, search)
               || Contains(item.Subtitle, search)
               || Contains(item.Detail, search)
               || (Kind == SpecialMenuKind.OpenWith && Contains(item.Entry.RegistryPath, search));
    }

    private void OnNotificationReceived(object? sender, BackendNotification notification)
    {
        if (notification.SpecialKind != Kind || notification.SpecialItem is null && notification.Kind != PipeNotificationKind.OpenWithChanged)
        {
            return;
        }

        System.Windows.Application.Current.Dispatcher.Invoke(() =>
        {
            if (Kind == SpecialMenuKind.OpenWith)
            {
                // Notifications can arrive late or out of order. Read the physical source.
                ObserveFireAndForget(RefreshAsync(), "OpenWithNotificationRefreshAsync");
                return;
            }
            if (Kind == SpecialMenuKind.WinX)
            {
                ObserveFireAndForget(RefreshAsync(), "WinXNotificationRefreshAsync");
                return;
            }

            if (notification.SpecialItem is { } specialItem)
                ObserveFireAndForget(VerifyNotificationItemAsync(specialItem), "SpecialMenuNotificationVerification");
        });
    }

    private async Task VerifyNotificationItemAsync(SpecialMenuEntry entry)
    {
        var current = Items.FirstOrDefault(item => item.Id.Equals(entry.Id, StringComparison.OrdinalIgnoreCase));
        var original = current?.Entry;
        try
        {
            using var timeout = CancellationTokenSource.CreateLinkedTokenSource(_disposeCts.Token);
            timeout.CancelAfter(TimeSpan.FromSeconds(10));
            var verified = await _backendClient.GetSpecialMenuItemStateAsync(entry, timeout.Token);
            if (!_disposed && verified is not null && (current is null || !current.IsBusy && ReferenceEquals(current.Entry, original))) Upsert(verified);
        }
        catch (BackendRequestException ex) when (ex.ErrorCode == PipeErrorCodes.MenuItemRemoved) { }
    }

    private void OnLanguageChanged(object? sender, EventArgs e)
    {
        SearchLabel = _localization.Translate("SearchLabel");
        AddText = _localization.Translate("Add");
        EditText = _localization.Translate("Edit");
        RefreshText = _localization.Translate("Refresh");
        RestoreDefaultsText = _localization.Translate("RestoreDefault");
        LockNewMenuText = _localization.Translate("LockNewMenu");
        LockNewMenuDescription = _localization.Translate("LockNewMenuDescription");
        WinXCompatibilityNoticeText = _localization.Translate("WinXCompatibilityNotice");
        WinXCompatibilityNoticeToolTip = _localization.Translate("WinXCompatibilityNoticeToolTip");
        DeleteText = _localization.Translate("Delete");
        UndoText = _localization.Translate("Undo");
        PermanentDeleteText = _localization.Translate("PermanentDelete");
        CancelText = _localization.Translate("DialogCancel");
        DropEffectLabel = _localization.Translate("DefaultDropEffect");
        DocumentIconProviderLabel = _localization.Translate("DocumentIconProvider");
        DocumentIconProviderDescription = _localization.Translate("DocumentIconProviderDescription");
        DocumentIconProviderChangedHint = _localization.Translate("DocumentIconProviderChangedHint");
        OnPropertyChanged(nameof(MicrosoftOfficeLabel));
        OnPropertyChanged(nameof(WpsOfficeLabel));
        foreach (var item in Items)
        {
            item.RefreshLocalization();
        }

        OnPropertyChanged(nameof(Title));
        OnPropertyChanged(nameof(Description));
        OnPropertyChanged(nameof(OpenWithInspectionLabel));
        OnPropertyChanged(nameof(OpenWithInspectText));
        OnPropertyChanged(nameof(OpenWithCancelText));
        OnPropertyChanged(nameof(LoadingItemsText));
        OnPropertyChanged(nameof(EmptyItemsText));
        RefreshListPlaceholderState();
    }

    private void OnItemsCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
    {
        RefreshListPlaceholderState();
    }

    private void OnWinXGroupsCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
    {
        RefreshListPlaceholderState();
    }

    private void InvalidateShellNewDiscovery(int version)
    {
        if (Kind != SpecialMenuKind.ShellNew) return;
        System.Windows.Application.Current.Dispatcher.Invoke(() =>
        {
            if (version != _shellNewStateVersion) return;
            _shellNewDiscoveryValid = false;
            OnPropertyChanged(nameof(CanToggleShellNewOrderLock));
            UpdateShellNewMoveAvailability();
        });
    }

    private async Task<bool> VerifyShellNewLockStateAsync(int version)
    {
        try
        {
            using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10));
            using var linked = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, _disposeCts.Token);
            var locked = await _backendClient.GetShellNewOrderLockAsync(linked.Token);
            await System.Windows.Application.Current.Dispatcher.InvokeAsync(() =>
            {
                if (version == _shellNewStateVersion) ApplyShellNewLockState(locked);
            });
            return true;
        }
        catch (Exception ex) when (!_disposeCts.IsCancellationRequested)
        {
            FrontendDebugLog.Warning("SpecialMenuPageViewModel", $"ShellNewLockStateUncertain: {ex}");
            await System.Windows.Application.Current.Dispatcher.InvokeAsync(() =>
            {
                if (version != _shellNewStateVersion) return;
                ApplyShellNewLockState(null);
                StatusText = _localization.Translate("ShellNewLockStateUnknown");
            });
            return false;
        }
    }

    private async Task SetShellNewOrderLockAsync(bool requested)
    {
        IsShellNewLockBusy = true;
        var version = ++_shellNewStateVersion;
        _shellNewDiscoveryValid = false;
        UpdateShellNewMoveAvailability();
        Exception? failure = null;
        try
        {
            try
            {
                using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10));
                using var linked = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, _disposeCts.Token);
                await _backendClient.SetShellNewOrderLockAsync(requested, Guid.NewGuid(), linked.Token);
            }
            catch (Exception ex) when (!_disposeCts.IsCancellationRequested)
            {
                failure = ex;
                FrontendDebugLog.Warning("SpecialMenuPageViewModel", $"ShellNewLockRequestOutcomePending: {ex}");
            }
            // The query waits behind the backend mutation, but never behind expensive
            // packaged discovery. A timed-out response says nothing about physical state.
            if (!await VerifyShellNewLockStateAsync(version)) return;
            await WaitForCurrentRefreshAsync();
        }
        finally
        {
            IsShellNewLockBusy = false;
            UpdateShellNewMoveAvailability();
        }
        await RefreshAsync();
        if (version == _shellNewStateVersion && (failure is BackendRequestException || (IsShellNewOrderLocked.HasValue && IsShellNewOrderLocked != requested)))
            StatusText = failure?.Message ?? _localization.Translate("ShellNewLockStateMismatch");
    }

    private async Task WaitForCurrentRefreshAsync()
    {
        Task? refreshTask;
        lock (_refreshSync)
        {
            refreshTask = _refreshTask is { IsCompleted: false } task ? task : null;
        }

        if (refreshTask is not null)
        {
            await refreshTask;
        }
    }

    private async Task SetDefaultDropEffectAsync(DefaultDropEffect oldValue, DefaultDropEffect newValue)
    {
        try
        {
            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
            await _backendClient.UpdateSpecialMenuItemAsync(
                new PipeRequest
                {
                    SpecialKind = Kind,
                    DefaultDropEffect = newValue,
                    ClientOperationId = Guid.NewGuid()
                },
                cts.Token);
            await RefreshAsync();
        }
        catch (Exception ex)
        {
            _suppressDropEffectSync = true;
            try
            {
                SelectedDropEffect = oldValue;
            }
            finally
            {
                _suppressDropEffectSync = false;
            }

            await FrontendMessageBox.ShowErrorAsync(ex.Message, Title);
        }
    }

    private async Task RefreshOfficeCoexistenceStatusAsync(CancellationToken cancellationToken)
    {
        if (Kind != SpecialMenuKind.ShellNew)
        {
            ShowDocumentIconProvider = false;
            return;
        }

        try
        {
            var status = await _backendClient.GetOfficeSuiteCoexistenceStatusAsync(cancellationToken);
            await System.Windows.Application.Current.Dispatcher.InvokeAsync(() =>
            {
                ShowDocumentIconProvider = status?.IsCoexistenceActive == true;
                if (status?.CurrentDocumentIconProvider is not { } provider)
                {
                    return;
                }

                _suppressDocumentIconProviderSync = true;
                try
                {
                    SelectedDocumentIconProvider = provider;
                    // The detected value can equal the enum's default, in which
                    // case the setter does not notify the one-way radio bindings.
                    OnPropertyChanged(nameof(IsMicrosoftDocumentIconProviderSelected));
                    OnPropertyChanged(nameof(IsWpsDocumentIconProviderSelected));
                }
                finally
                {
                    _suppressDocumentIconProviderSync = false;
                }
            });
        }
        catch (Exception ex)
        {
            FrontendDebugLog.Warning(
                "SpecialMenuPageViewModel",
                $"RefreshOfficeCoexistenceStatusAsync failed. Kind={Kind}, Message={ex.Message}");
            await System.Windows.Application.Current.Dispatcher.InvokeAsync(() => ShowDocumentIconProvider = false);
        }
    }

    private async Task SetDocumentIconProviderAsync(DocumentIconProvider oldValue, DocumentIconProvider newValue)
    {
        try
        {
            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
            var status = await _backendClient.SetDocumentIconProviderAsync(newValue, cts.Token);
            _suppressDocumentIconProviderSync = true;
            try
            {
                SelectedDocumentIconProvider = status?.CurrentDocumentIconProvider ?? newValue;
            }
            finally
            {
                _suppressDocumentIconProviderSync = false;
            }

            await RefreshAsync();
            _hasDocumentIconProviderChanged = true;
            _explorerRestartState.MarkIconCacheRefreshRequired();
            OnPropertyChanged(nameof(ShowDocumentIconProviderChangedHint));
        }
        catch (Exception ex)
        {
            _suppressDocumentIconProviderSync = true;
            try
            {
                SelectedDocumentIconProvider = oldValue;
            }
            finally
            {
                _suppressDocumentIconProviderSync = false;
            }

            await FrontendMessageBox.ShowErrorAsync(ex.Message, Title);
        }
        finally
        {
            IsDocumentIconProviderBusy = false;
        }
    }

    private void UpdatePageStateFromSnapshot(IEnumerable<SpecialMenuEntry> snapshot)
    {
        if (Kind == SpecialMenuKind.DragDrop)
        {
            var effectText = snapshot.FirstOrDefault(static item => item.Metadata.GetValueOrDefault("EntryType") == "DefaultDropEffect")?.Notes;
            _suppressDropEffectSync = true;
            try
            {
                SelectedDropEffect = Enum.TryParse<DefaultDropEffect>(effectText, out var effect) ? effect : DefaultDropEffect.Default;
            }
            finally
            {
                _suppressDropEffectSync = false;
            }
        }
    }

    private void ReconcileWinXGroupsIncrementally()
    {
        foreach (var group in WinXGroups)
        {
            _winXExpandedStates[group.Group.KeyName] = group.IsExpanded;
        }

        var existingGroupsByKey = new Dictionary<string, WinXGroupNodeViewModel>(StringComparer.OrdinalIgnoreCase);
        foreach (var group in WinXGroups)
        {
            existingGroupsByKey.TryAdd(group.Group.KeyName, group);
        }
        var groupSpecs = BuildWinXGroupSpecs();
        var targetGroupKeys = groupSpecs
            .Select(static spec => spec.Group.KeyName)
            .ToHashSet(StringComparer.OrdinalIgnoreCase);

        for (var index = WinXGroups.Count - 1; index >= 0; index--)
        {
            if (!targetGroupKeys.Contains(WinXGroups[index].Group.KeyName))
            {
                WinXGroups.RemoveAt(index);
            }
        }

        for (var targetIndex = 0; targetIndex < groupSpecs.Count; targetIndex++)
        {
            var spec = groupSpecs[targetIndex];
            if (!existingGroupsByKey.TryGetValue(spec.Group.KeyName, out var group))
            {
                group = CreateWinXGroupNode(spec.Group);
            }
            else
            {
                group.UpdateGroup(spec.Group);
            }

            if (_winXExpandedStates.TryGetValue(spec.Group.KeyName, out var expanded))
            {
                group.IsExpanded = expanded;
            }

            var currentIndex = WinXGroups.IndexOf(group);
            if (currentIndex < 0)
            {
                WinXGroups.Insert(targetIndex, group);
            }
            else if (currentIndex != targetIndex)
            {
                WinXGroups.Move(currentIndex, targetIndex);
            }

            ReconcileWinXGroupItems(group.Items, spec.Items);
        }

        UpdateWinXMoveAvailability();
        RefreshListPlaceholderState();
    }

    private void RefreshListPlaceholderState()
    {
        OnPropertyChanged(nameof(IsListLoading));
        OnPropertyChanged(nameof(ShowListContent));
        OnPropertyChanged(nameof(IsListEmpty));
        OnPropertyChanged(nameof(ShowListPlaceholder));
        if (Kind == SpecialMenuKind.OpenWith)
        {
            OnPropertyChanged(nameof(OpenWithProtectedGroupText));
            OnPropertyChanged(nameof(ShowOpenWithProtectedGroup));
        }
    }

    private List<(SpecialMenuItemViewModel Group, List<SpecialMenuItemViewModel> Items)> BuildWinXGroupSpecs()
    {
        var specs = new List<(SpecialMenuItemViewModel Group, List<SpecialMenuItemViewModel> Items)>();
        SpecialMenuItemViewModel? currentGroup = null;
        foreach (var item in Items)
        {
            if (item.Entry.Metadata.GetValueOrDefault("EntryType") == "Group")
            {
                currentGroup = item;
                specs.Add((currentGroup, []));
                continue;
            }

            if (currentGroup is null || !string.Equals(currentGroup.KeyName, item.Entry.GroupName, StringComparison.OrdinalIgnoreCase))
            {
                var existingSpecIndex = FindWinXGroupSpecIndex(specs, item.Entry.GroupName);
                currentGroup = existingSpecIndex >= 0 ? specs[existingSpecIndex].Group : null;
                if (currentGroup is null)
                {
                    currentGroup = new SpecialMenuItemViewModel(
                        new SpecialMenuEntry
                        {
                            Id = $"{SpecialMenuKind.WinX}:Synthetic:{item.Entry.GroupName}",
                            Kind = SpecialMenuKind.WinX,
                            DisplayName = item.Entry.GroupName ?? string.Empty,
                            KeyName = item.Entry.GroupName ?? string.Empty,
                            IsEnabled = true,
                            CanEdit = false,
                            CanDelete = false,
                            Metadata = new Dictionary<string, string> { ["EntryType"] = "Group" }
                        },
                        _iconPreviewService,
                        _localization,
                        SetEnabledAsync);
                    specs.Add((currentGroup, []));
                }
            }

            var specIndex = FindWinXGroupSpecIndex(specs, currentGroup.KeyName);
            if (specIndex >= 0)
            {
                specs[specIndex].Items.Add(item);
            }
        }

        return specs;
    }

    private static int FindWinXGroupSpecIndex(
        IReadOnlyList<(SpecialMenuItemViewModel Group, List<SpecialMenuItemViewModel> Items)> specs,
        string? keyName)
    {
        for (var index = 0; index < specs.Count; index++)
        {
            if (string.Equals(specs[index].Group.KeyName, keyName, StringComparison.OrdinalIgnoreCase))
            {
                return index;
            }
        }

        return -1;
    }

    private static void ReconcileWinXGroupItems(
        ObservableCollection<SpecialMenuItemViewModel> currentItems,
        IReadOnlyList<SpecialMenuItemViewModel> targetItems)
    {
        var targetIds = targetItems
            .Select(static item => item.Id)
            .ToHashSet(StringComparer.OrdinalIgnoreCase);
        for (var index = currentItems.Count - 1; index >= 0; index--)
        {
            if (!targetIds.Contains(currentItems[index].Id))
            {
                currentItems.RemoveAt(index);
            }
        }

        for (var targetIndex = 0; targetIndex < targetItems.Count; targetIndex++)
        {
            var item = targetItems[targetIndex];
            var currentIndex = currentItems.IndexOf(item);
            if (currentIndex < 0)
            {
                currentItems.Insert(targetIndex, item);
            }
            else if (currentIndex != targetIndex)
            {
                currentItems.Move(currentIndex, targetIndex);
            }
        }
    }

    private void UpdateShellNewMoveAvailability()
    {
        if (Kind != SpecialMenuKind.ShellNew)
        {
            return;
        }

        var movableItems = Items
            .Where(static item => item.Entry.CanMove)
            .ToArray();

        for (var index = 0; index < movableItems.Length; index++)
        {
            movableItems[index].SetMoveAvailability(
                IsShellNewOrderLocked == true && _shellNewDiscoveryValid && !IsShellNewLockBusy && index > 0,
                IsShellNewOrderLocked == true && _shellNewDiscoveryValid && !IsShellNewLockBusy && index < movableItems.Length - 1);
        }

        foreach (var item in Items.Where(static item => !item.Entry.CanMove))
        {
            item.SetMoveAvailability(false, false);
        }
    }

    private static bool IsExpectedShellNewMoveFailure(Exception exception)
    {
        var message = exception.Message;
        return message.Contains("ShellNew ordering", StringComparison.OrdinalIgnoreCase)
            || message.Contains(@"Discardable\PostSetup\ShellNew", StringComparison.OrdinalIgnoreCase)
            || message.Contains("Access to the registry key", StringComparison.OrdinalIgnoreCase)
            || message.Contains("registry key is denied", StringComparison.OrdinalIgnoreCase);
    }

    private void UpdateWinXMoveAvailability()
    {
        for (var groupIndex = 0; groupIndex < WinXGroups.Count; groupIndex++)
        {
            var group = WinXGroups[groupIndex];
            var entries = group.Items
                .Where(static item => item.Entry.Metadata.GetValueOrDefault("EntryType") == "Entry")
                .ToArray();

            for (var itemIndex = 0; itemIndex < entries.Length; itemIndex++)
            {
                var hasItemAboveInGroup = itemIndex > 0;
                var hasItemBelowInGroup = itemIndex < entries.Length - 1;
                var hasGroupAbove = HasAdjacentWinXGroup(groupIndex, moveUp: true);
                var hasGroupBelow = HasAdjacentWinXGroup(groupIndex, moveUp: false);

                entries[itemIndex].SetMoveAvailability(
                    hasItemAboveInGroup || hasGroupAbove,
                    hasItemBelowInGroup || hasGroupBelow);
            }
        }
    }

    private bool HasAdjacentWinXGroup(int groupIndex, bool moveUp)
    {
        var nextIndex = moveUp ? groupIndex - 1 : groupIndex + 1;
        return nextIndex >= 0 && nextIndex < WinXGroups.Count;
    }

    private WinXGroupNodeViewModel CreateWinXGroupNode(SpecialMenuItemViewModel group)
    {
        var node = new WinXGroupNodeViewModel(group)
        {
            IsExpanded = !_winXExpandedStates.TryGetValue(group.KeyName, out var expanded) || expanded
        };
        return node;
    }

    private static string[]? SplitParts(string? value, int count, bool allowEmptyMiddleParts = false)
    {
        if (string.IsNullOrWhiteSpace(value))
        {
            return null;
        }

        var parts = value.Split('|');
        if (parts.Length < count || (!allowEmptyMiddleParts && parts.Take(count - 1).Any(string.IsNullOrWhiteSpace)))
        {
            return null;
        }

        return parts.Concat(Enumerable.Repeat(string.Empty, count)).Take(count).Select(static part => part.Trim()).ToArray();
    }

    private static string? EmptyToNull(string? value) => string.IsNullOrWhiteSpace(value) ? null : value;

    private static bool Contains(string? value, string search) =>
        !string.IsNullOrWhiteSpace(value) && value.Contains(search, StringComparison.OrdinalIgnoreCase);

    public void Dispose()
    {
        if (_disposed)
        {
            return;
        }

        _disposed = true;
        if (_navigationState is not null) _navigationState.OpenWithRequested -= OnOpenWithRequested;
        _backendClient.ItemsRemoved -= OnItemsRemoved;
        _loadingPresentation.PropertyChanged -= OnLoadingPresentationChanged;
        _loadingPresentation.Dispose();
        _disposeCts.Cancel();
        _backendClient.NotificationReceived -= OnNotificationReceived;
        _localization.LanguageChanged -= OnLanguageChanged;
        Items.CollectionChanged -= OnItemsCollectionChanged;
        WinXGroups.CollectionChanged -= OnWinXGroupsCollectionChanged;
    }

    private void StartAutoRefreshLoop()
    {
        if (Kind == SpecialMenuKind.CommandStore)
        {
            return;
        }

        if (_autoRefreshTask is { IsCompleted: false })
        {
            return;
        }

        var token = _disposeCts.Token;
        _autoRefreshTask = Task.Run(() => AutoRefreshLoopAsync(token), token);
    }

    private async Task AutoRefreshLoopAsync(CancellationToken cancellationToken)
    {
        while (!cancellationToken.IsCancellationRequested)
        {
            try
            {
                await Task.Delay(TimeSpan.FromSeconds(Kind == SpecialMenuKind.ShellNew ? 30 : 5), cancellationToken);
                await StartRefreshAsync(markLoaded: false, showBusy: false);
            }
            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
            {
                break;
            }
            catch (Exception ex)
            {
                FrontendDebugLog.Warning(
                    "SpecialMenuPageViewModel",
                    $"AutoRefreshLoopAsync failed. Kind={Kind}, Message={ex.Message}");
            }
        }
    }

    private bool IsCurrentRefreshGeneration(int generation)
    {
        lock (_refreshSync)
        {
            return generation == _refreshGeneration && !_disposed;
        }
    }

    private void ObserveFireAndForget(Task task, string operationName)
    {
        if (task.IsCompletedSuccessfully)
        {
            return;
        }

        _ = ObserveFireAndForgetAsync(task, operationName);
    }

    private async Task ObserveFireAndForgetAsync(Task task, string operationName)
    {
        try
        {
            await task;
        }
        catch (OperationCanceledException ex)
        {
            FrontendDebugLog.Info(
                "SpecialMenuPageViewModel",
                $"{operationName} canceled. Kind={Kind}, Message={ex.Message}");
        }
        catch (ObjectDisposedException ex)
        {
            FrontendDebugLog.Info(
                "SpecialMenuPageViewModel",
                $"{operationName} skipped during disposal. Kind={Kind}, Message={ex.Message}");
        }
        catch (Exception ex)
        {
            FrontendDebugLog.Warning(
                "SpecialMenuPageViewModel",
                $"{operationName} failed. Kind={Kind}, Message={ex.Message}");
        }
    }
}

public sealed class ShellNewPageViewModel : SpecialMenuPageViewModel
{
    public ShellNewPageViewModel(IBackendClient backendClient, IconPreviewService iconPreviewService, LocalizationService localization, ExplorerRestartStateService explorerRestartState)
        : base(SpecialMenuKind.ShellNew, "ShellNewPageTitle", "ShellNewPageDescription", backendClient, iconPreviewService, localization, explorerRestartState)
    {
    }
}

public sealed class SendToPageViewModel : SpecialMenuPageViewModel
{
    public SendToPageViewModel(IBackendClient backendClient, IconPreviewService iconPreviewService, LocalizationService localization, ExplorerRestartStateService explorerRestartState)
        : base(SpecialMenuKind.SendTo, "SendToPageTitle", "SendToPageDescription", backendClient, iconPreviewService, localization, explorerRestartState)
    {
    }
}

public sealed class WinXPageViewModel : SpecialMenuPageViewModel
{
    public WinXPageViewModel(IBackendClient backendClient, IconPreviewService iconPreviewService, LocalizationService localization, ExplorerRestartStateService explorerRestartState)
        : base(SpecialMenuKind.WinX, "WinXPageTitle", "WinXPageDescription", backendClient, iconPreviewService, localization, explorerRestartState)
    {
    }
}

public sealed class OpenWithPageViewModel : SpecialMenuPageViewModel
{
    public OpenWithPageViewModel(IBackendClient backendClient, IconPreviewService iconPreviewService, LocalizationService localization,
        ExplorerRestartStateService explorerRestartState, FrontendNavigationState navigationState)
        : base(SpecialMenuKind.OpenWith, "OpenWithPageTitle", "OpenWithPageDescription", backendClient, iconPreviewService, localization, explorerRestartState, navigationState)
    {
    }
}

public sealed partial class WinXGroupNodeViewModel : ObservableObject
{
    public WinXGroupNodeViewModel(SpecialMenuItemViewModel group)
    {
        Group = group;
    }

    public SpecialMenuItemViewModel Group { get; private set; }

    public ObservableCollection<SpecialMenuItemViewModel> Items { get; } = [];

    [ObservableProperty]
    public partial bool IsExpanded { get; set; } = true;

    public void UpdateGroup(SpecialMenuItemViewModel group)
    {
        if (ReferenceEquals(Group, group))
        {
            return;
        }

        if (string.Equals(Group.Id, group.Id, StringComparison.OrdinalIgnoreCase))
        {
            Group.Update(group.Entry);
            return;
        }

        Group = group;
        OnPropertyChanged(nameof(Group));
    }
}