MainWindow.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading;
using System.Windows;
using System.Windows.Interop;
using System.Windows.Threading;
using Microsoft.Win32;
using Forms = System.Windows.Forms;

namespace DesktopNest
{
    /// <summary>
    /// Coordinates the small desktop-level organizer windows. It deliberately
    /// owns no large dashboard window and performs no filesystem polling or AI
    /// work while the desktop icon set is idle.
    /// </summary>
    internal sealed class DesktopHostController : IDisposable
    {
        private sealed class LayoutGeometrySnapshot
        {
            public BoxLayoutSetting Layout;
            public double Left;
            public double Top;
            public double Width;
            public double Height;
            public double ExpandedHeight;

            public void Restore()
            {
                Layout.Left = Left;
                Layout.Top = Top;
                Layout.Width = Width;
                Layout.Height = Height;
                Layout.ExpandedHeight = ExpandedHeight;
            }
        }

        private static readonly string[] BoxOrder =
            OrganizerCategories.GetIds();

        private const double LayoutGap = 14.0;
        private const double SnapThreshold = 12.0;

        private readonly string _desktopPath;
        private readonly bool _noStartupWrite;
        private readonly bool _qaMode;
        private readonly AppSettings _settings;
        private readonly DesktopIndexService _desktopIndex;
        private readonly DesktopIndexService _publicDesktopIndex;
        private readonly ClassificationCatalog _catalog;
        private readonly AiClassificationService _aiService;
        private readonly Dictionary<string, OrganizerBoxWindow> _boxes =
            new Dictionary<string, OrganizerBoxWindow>(StringComparer.OrdinalIgnoreCase);
        private readonly Dictionary<string, DesktopItem> _snapshot =
            new Dictionary<string, DesktopItem>(StringComparer.OrdinalIgnoreCase);
        private readonly Dictionary<string, DesktopItem> _pendingAi =
            new Dictionary<string, DesktopItem>(StringComparer.OrdinalIgnoreCase);
        private readonly object _aiSync = new object();
        private readonly DispatcherTimer _layoutSaveTimer;
        private readonly DispatcherTimer _displayChangeTimer;
        private readonly DispatcherTimer _desktopWindowRecoveryTimer;
        private readonly HashSet<string> _pendingOrganizerRecovery =
            new HashSet<string>(StringComparer.OrdinalIgnoreCase);

        private UtilityBoxWindow _utilityBox;
        private Forms.NotifyIcon _trayIcon;
        private Forms.ToolStripMenuItem _takeoverMenuItem;
        private Forms.ToolStripMenuItem _startupMenuItem;
        private Forms.ToolStripMenuItem _visibilityMenuItem;
        private Icon _trayDrawingIcon;
        private DesktopLayerCoordinator _desktopLayerCoordinator;
        private bool _started;
        private bool _disposed;
        private bool _exiting;
        private bool _boxesVisible = true;
        private bool _aiWorkerRunning;
        private bool _initialSnapshotPending = true;
        private bool _desktopIconsWereVisible;
        private bool _desktopIconsVisibilityKnown;
        private bool _desktopIconsHiddenByUs;
        private bool _utilityWindowPendingRecovery;
        private bool _desktopActivationGuard;
        private bool _systemEventsSubscribed;
        private bool _layoutBatchInProgress;
        private bool _displayRepairPending;
        private bool _displayRepairChanged;
        private bool _saveSettingsAfterDisplayRepair;
        private int _displayChangeRepairPass;
        private int _desktopWindowRecoveryAttempts;
        private DateTime _lastAiFailureNoticeUtc = DateTime.MinValue;
        private string _lastDisplaySignature = String.Empty;

        public DesktopHostController(string desktopPath, bool noStartupWrite, bool qaMode)
        {
            _desktopPath = desktopPath;
            _noStartupWrite = noStartupWrite;
            _qaMode = qaMode;
            _settings = qaMode ? AppSettings.CreateQaSettings() : AppSettings.Load();
            _desktopIndex = new DesktopIndexService(desktopPath);
            _publicDesktopIndex = CreatePublicDesktopIndex(desktopPath);
            _catalog = qaMode ? ClassificationCatalog.CreateEmpty() : ClassificationCatalog.Load();
            _aiService = new AiClassificationService();
            _layoutSaveTimer = new DispatcherTimer
            {
                Interval = TimeSpan.FromMilliseconds(450)
            };
            _layoutSaveTimer.Tick += delegate
            {
                _layoutSaveTimer.Stop();
                SaveSettings();
            };
            _displayChangeTimer = new DispatcherTimer(DispatcherPriority.Background)
            {
                Interval = TimeSpan.FromMilliseconds(650)
            };
            _displayChangeTimer.Tick += OnDisplayChangeSettled;
            _desktopWindowRecoveryTimer = new DispatcherTimer(DispatcherPriority.Background)
            {
                Interval = TimeSpan.FromMilliseconds(250)
            };
            _desktopWindowRecoveryTimer.Tick += RecoverDestroyedDesktopWindows;
        }

        public void Start()
        {
            if (_started)
            {
                return;
            }
            _started = true;

            _lastDisplaySignature = CaptureDisplaySignature();
            if (!_qaMode)
            {
                try
                {
                    SystemEvents.DisplaySettingsChanged += OnDisplaySettingsChanged;
                    _systemEventsSubscribed = true;
                }
                catch
                {
                    _systemEventsSubscribed = false;
                }
            }

            if (!_qaMode)
            {
                RecoverStaleTakeoverLease();
            }
            ApplyDefaultLayout();
            if (!_qaMode)
            {
                _desktopLayerCoordinator = new DesktopLayerCoordinator(
                    Application.Current.Dispatcher,
                    SendAllWindowsToDesktop,
                    IsDesktopLayerSettled,
                    DesktopWindowBehavior.MoveForegroundToDesktopIfOrganizer,
                    SetDesktopActivationGuard);
            }
            CreateOrganizerWindows();
            CreateTrayIcon();
            ImportProjectApiKeys();
            RefreshDesktop(false);

            _desktopIndex.ItemsChanged += OnDesktopItemsChanged;
            _desktopIndex.StartWatching();
            if (_publicDesktopIndex != null)
            {
                _publicDesktopIndex.ItemsChanged += OnDesktopItemsChanged;
                _publicDesktopIndex.StartWatching();
            }

            if (!_noStartupWrite && _settings.StartWithWindows)
            {
                StartupService.TryEnable();
            }

            if (!_qaMode && _settings.TakeOverDesktopIcons)
            {
                SetDesktopIconTakeover(true);
            }

            Application.Current.Dispatcher.BeginInvoke(
                DispatcherPriority.ApplicationIdle,
                new Action(delegate
                {
                    ReflowOrganizerWindows(false, false, true);
                    SendAllWindowsToDesktop();
                    ShowFirstRunTakeoverChoice();
                    if (_desktopLayerCoordinator != null)
                    {
                        _desktopLayerCoordinator.RequestRepair();
                    }
                }));
        }

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

            if (_desktopLayerCoordinator != null)
            {
                _desktopLayerCoordinator.Dispose();
                _desktopLayerCoordinator = null;
            }
            DesktopWindowBehavior.ReleaseZOrderMarker();

            _layoutSaveTimer.Stop();
            _displayChangeTimer.Stop();
            _desktopWindowRecoveryTimer.Stop();
            if (_systemEventsSubscribed)
            {
                try
                {
                    SystemEvents.DisplaySettingsChanged -= OnDisplaySettingsChanged;
                }
                catch
                {
                }
                _systemEventsSubscribed = false;
            }
            _pendingOrganizerRecovery.Clear();
            _utilityWindowPendingRecovery = false;
            RestoreDesktopIconsIfNeeded();
            SaveCatalog();
            SaveSettings();

            _desktopIndex.ItemsChanged -= OnDesktopItemsChanged;
            _desktopIndex.Dispose();
            if (_publicDesktopIndex != null)
            {
                _publicDesktopIndex.ItemsChanged -= OnDesktopItemsChanged;
                _publicDesktopIndex.Dispose();
            }

            foreach (OrganizerBoxWindow window in _boxes.Values)
            {
                window.SetControllerClosing();
                window.Close();
            }
            _boxes.Clear();
            if (_utilityBox != null)
            {
                _utilityBox.SetControllerClosing();
                _utilityBox.Close();
                _utilityBox = null;
            }
            if (_trayIcon != null)
            {
                _trayIcon.Visible = false;
                _trayIcon.Dispose();
                _trayIcon = null;
            }
            if (_trayDrawingIcon != null)
            {
                _trayDrawingIcon.Dispose();
                _trayDrawingIcon = null;
            }
        }

        private void CreateOrganizerWindows()
        {
            CreateUtilityWindow();
        }

        private void CreateUtilityWindow()
        {
            if (_utilityBox != null)
            {
                return;
            }

            UtilityBoxWindow window = new UtilityBoxWindow(
                _settings.UtilityBox,
                _settings.BoxOpacity);
            window.DesktopPinEnabled = !_qaMode;
            window.Loaded += OnDesktopWindowLoaded;
            window.LayoutChanged += OnLayoutChanged;
            window.MoveCompleted += OnWindowMoveCompleted;
            window.SettingsRequested += delegate { ShowSettings(); };
            window.Closed += delegate
            {
                if (_qaMode && !_disposed && !_exiting)
                {
                    ExitApplication();
                    return;
                }
                if (!_disposed && !_exiting && ReferenceEquals(_utilityBox, window))
                {
                    _utilityBox = null;
                    _utilityWindowPendingRecovery = true;
                    RequestDesktopWindowRecovery();
                }
            };
            _utilityBox = window;
            if (_boxesVisible && _settings.UtilityBox.Visible)
            {
                window.Show();
            }
        }

        private void ImportProjectApiKeys()
        {
            if (_qaMode)
            {
                return;
            }

            ApiKeyImportResult result = SecretStore.ImportProjectKeys();
            if (!String.IsNullOrWhiteSpace(result.Warning))
            {
                ShowTrayMessage("API 密钥导入提示", result.Warning, Forms.ToolTipIcon.Warning);
            }
            else if (result.ImportedCount > 0 && result.PlaintextCleared)
            {
                ShowTrayMessage(
                    "API 密钥导入完成",
                    "密钥已保存到 Windows 凭据管理器，导入文件中对应等号后的内容已清空。",
                    Forms.ToolTipIcon.Info);
            }
        }

        private OrganizerBoxWindow EnsureOrganizerWindow(string boxId)
        {
            OrganizerBoxWindow existing;
            if (_boxes.TryGetValue(boxId, out existing))
            {
                return existing;
            }

            BoxLayoutSetting layout = _settings.FindBox(boxId);
            bool assignedDefaultPosition = false;
            if (Double.IsNaN(layout.Left) || Double.IsNaN(layout.Top))
            {
                System.Windows.Point position = FindAvailableBoxPosition(layout);
                layout.Left = position.X;
                layout.Top = position.Y;
                assignedDefaultPosition = true;
            }
            OrganizerBoxWindow window = new OrganizerBoxWindow(layout, _settings.BoxOpacity);
            window.DesktopPinEnabled = !_qaMode;
            window.Loaded += OnDesktopWindowLoaded;
            window.LayoutChanged += OnLayoutChanged;
            window.RenameRequested += OnLayoutChanged;
            window.OrganizeRequested += delegate { RefreshDesktop(true); };
            window.RearrangeRequested += delegate
            {
                ReflowOrganizerWindows(true, true, true);
            };
            window.SettingsRequested += delegate { ShowSettings(); };
            window.ExitRequested += delegate { ExitApplication(); };
            window.ItemMoveRequested += OnItemMoveRequested;
            window.MoveCompleted += OnWindowMoveCompleted;
            string windowBoxId = layout.Id;
            window.Closed += delegate
            {
                if (_qaMode && !_disposed && !_exiting)
                {
                    ExitApplication();
                    return;
                }
                OrganizerBoxWindow current;
                if (!_disposed &&
                    !_exiting &&
                    _boxes.TryGetValue(windowBoxId, out current) &&
                    ReferenceEquals(current, window))
                {
                    _boxes.Remove(windowBoxId);
                    _pendingOrganizerRecovery.Add(windowBoxId);
                    RequestDesktopWindowRecovery();
                }
            };
            _boxes[layout.Id] = window;
            if (_boxesVisible && layout.Visible)
            {
                window.Show();
                if (_desktopLayerCoordinator != null)
                {
                    _desktopLayerCoordinator.RequestRepair();
                }
            }
            if (assignedDefaultPosition)
            {
                OnLayoutChanged(window, EventArgs.Empty);
            }
            return window;
        }

        private void CreateTrayIcon()
        {
            _trayIcon = new Forms.NotifyIcon();
            try
            {
                _trayDrawingIcon = Icon.ExtractAssociatedIcon(StartupService.GetExecutablePath());
                _trayIcon.Icon = _trayDrawingIcon;
            }
            catch
            {
                _trayIcon.Icon = SystemIcons.Application;
            }
            _trayIcon.Text = "拾光桌面 · 桌面收纳盒";

            Forms.ContextMenuStrip menu = new Forms.ContextMenuStrip();
            Forms.ToolStripMenuItem organize = new Forms.ToolStripMenuItem("立即整理桌面");
            organize.Click += delegate { RefreshDesktop(true); };
            menu.Items.Add(organize);

            Forms.ToolStripMenuItem rearrange = new Forms.ToolStripMenuItem("自动排列收纳盒");
            rearrange.Click += delegate
            {
                ReflowOrganizerWindows(true, true, true);
            };
            menu.Items.Add(rearrange);

            _visibilityMenuItem = new Forms.ToolStripMenuItem("隐藏收纳盒");
            _visibilityMenuItem.Click += delegate { ToggleOrganizerVisibility(); };
            menu.Items.Add(_visibilityMenuItem);
            menu.Items.Add(new Forms.ToolStripSeparator());

            _takeoverMenuItem = new Forms.ToolStripMenuItem("接管系统桌面图标");
            _takeoverMenuItem.Checked = _settings.TakeOverDesktopIcons;
            _takeoverMenuItem.CheckOnClick = true;
            _takeoverMenuItem.Click += delegate
            {
                SetDesktopIconTakeover(_takeoverMenuItem.Checked);
            };
            menu.Items.Add(_takeoverMenuItem);

            _startupMenuItem = new Forms.ToolStripMenuItem("开机自动启动");
            _startupMenuItem.Checked = _settings.StartWithWindows;
            _startupMenuItem.CheckOnClick = true;
            _startupMenuItem.Click += delegate
            {
                _settings.StartWithWindows = _startupMenuItem.Checked;
                if (!_noStartupWrite)
                {
                    StartupService.SetEnabled(_settings.StartWithWindows);
                }
                SaveSettings();
            };
            menu.Items.Add(_startupMenuItem);

            Forms.ToolStripMenuItem settings = new Forms.ToolStripMenuItem("设置…");
            settings.Click += delegate { ShowSettings(); };
            menu.Items.Add(settings);

            Forms.ToolStripMenuItem restore = new Forms.ToolStripMenuItem("恢复系统桌面图标");
            restore.Click += delegate
            {
                if (DesktopIconVisibilityService.TrySetVisible(true))
                {
                    DeleteTakeoverLease();
                    _desktopIconsHiddenByUs = false;
                    _desktopIconsVisibilityKnown = false;
                    _settings.TakeOverDesktopIcons = false;
                    _takeoverMenuItem.Checked = false;
                    SaveSettings();
                    RefreshDesktop(false);
                }
                else
                {
                    ShowTrayMessage("恢复失败", "Explorer 当前没有响应；恢复记录已保留，请稍后重试。", Forms.ToolTipIcon.Warning);
                }
            };
            menu.Items.Add(restore);
            menu.Items.Add(new Forms.ToolStripSeparator());

            Forms.ToolStripMenuItem exit = new Forms.ToolStripMenuItem("退出拾光桌面");
            exit.Click += delegate { ExitApplication(); };
            menu.Items.Add(exit);

            _trayIcon.ContextMenuStrip = menu;
            _trayIcon.DoubleClick += delegate { ToggleOrganizerVisibility(); };
            _trayIcon.Visible = !_qaMode;
        }

        private void RefreshDesktop(bool allowAiForAllUncertain)
        {
            if (_disposed)
            {
                return;
            }

            bool isInitialSnapshot = _initialSnapshotPending;
            _initialSnapshotPending = false;
            IList<DesktopItem> items = ScanAllDesktopItems();
            List<DesktopItem> added = new List<DesktopItem>();
            int index;
            for (index = 0; index < items.Count; index++)
            {
                DesktopItem item = items[index];
                if (!_snapshot.ContainsKey(item.FullPath))
                {
                    added.Add(item);
                }
            }

            _snapshot.Clear();
            for (index = 0; index < items.Count; index++)
            {
                _snapshot[items[index].FullPath] = items[index];
            }
            _catalog.RemoveMissing(items);
            RenderBoxes(items);

            // On the first snapshot, queue only uncached uncertain items. The
            // catalog check inside QueueAiClassification makes this a one-time
            // upgrade/startup analysis rather than a cost on every boot.
            IList<DesktopItem> aiCandidates =
                isInitialSnapshot || allowAiForAllUncertain ? items : added;
            QueueAiClassification(aiCandidates);
            UpdateTrayStatus(items.Count);
        }

        private IList<DesktopItem> ScanAllDesktopItems()
        {
            List<DesktopItem> items = new List<DesktopItem>();
            HashSet<string> seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            IList<DesktopItem> privateItems = _desktopIndex.Scan(String.Empty);
            int index;
            for (index = 0; index < privateItems.Count; index++)
            {
                if (seen.Add(privateItems[index].FullPath))
                {
                    items.Add(privateItems[index]);
                }
            }
            if (_publicDesktopIndex != null)
            {
                IList<DesktopItem> publicItems = _publicDesktopIndex.Scan(String.Empty);
                for (index = 0; index < publicItems.Count; index++)
                {
                    if (seen.Add(publicItems[index].FullPath))
                    {
                        items.Add(publicItems[index]);
                    }
                }
            }
            if (_settings.TakeOverDesktopIcons && UsesPhysicalDesktop())
            {
                items.Add(new DesktopItem(
                    "此电脑",
                    "shell:MyComputerFolder",
                    String.Empty,
                    true,
                    DesktopCategory.Folders,
                    DateTime.MinValue,
                    true));
                items.Add(new DesktopItem(
                    "回收站",
                    "shell:RecycleBinFolder",
                    String.Empty,
                    true,
                    DesktopCategory.Folders,
                    DateTime.MinValue,
                    true));
            }
            return items;
        }

        private void RenderBoxes(IList<DesktopItem> items)
        {
            Dictionary<string, List<DesktopItem>> grouped = new Dictionary<string, List<DesktopItem>>(StringComparer.OrdinalIgnoreCase);
            int index;
            for (index = 0; index < BoxOrder.Length; index++)
            {
                grouped[BoxOrder[index]] = new List<DesktopItem>();
            }

            for (index = 0; index < items.Count; index++)
            {
                DesktopItem item = items[index];
                string boxId;
                if (!_catalog.TryGet(item, out boxId))
                {
                    boxId = ClassificationCatalog.GetRuleBox(item);
                }
                List<DesktopItem> target;
                if (!grouped.TryGetValue(boxId, out target))
                {
                    target = grouped["other"];
                }
                target.Add(item);
            }

            for (index = 0; index < BoxOrder.Length; index++)
            {
                string boxId = BoxOrder[index];
                grouped[boxId].Sort(delegate(DesktopItem first, DesktopItem second)
                {
                    return StringComparer.CurrentCultureIgnoreCase.Compare(first.Name, second.Name);
                });
                OrganizerBoxWindow window;
                if (grouped[boxId].Count > 0)
                {
                    window = EnsureOrganizerWindow(boxId);
                    window.SetItems(grouped[boxId]);
                    if (_boxesVisible && window.LayoutSetting.Visible && !window.IsVisible)
                    {
                        window.Show();
                    }
                }
                else if (_boxes.TryGetValue(boxId, out window))
                {
                    window.SetItems(grouped[boxId]);
                    window.Hide();
                }
            }
        }

        private void QueueAiClassification(IList<DesktopItem> candidates)
        {
            if (!_settings.AiEnabled || !_aiService.HasKey(_settings.AiProvider))
            {
                return;
            }

            lock (_aiSync)
            {
                int index;
                for (index = 0; index < candidates.Count; index++)
                {
                    DesktopItem item = candidates[index];
                    string cached;
                    if (ClassificationCatalog.NeedsAi(item) && !_catalog.TryGet(item, out cached))
                    {
                        _pendingAi[item.FullPath] = item;
                    }
                }
                if (_pendingAi.Count == 0 || _aiWorkerRunning)
                {
                    return;
                }
                _aiWorkerRunning = true;
            }

            ThreadPool.QueueUserWorkItem(delegate
            {
                List<DesktopItem> batch;
                lock (_aiSync)
                {
                    batch = new List<DesktopItem>(_pendingAi.Values.Take(30));
                    int index;
                    for (index = 0; index < batch.Count; index++)
                    {
                        _pendingAi.Remove(batch[index].FullPath);
                    }
                }

                Dictionary<string, string> result = null;
                try
                {
                    result = _aiService.Classify(_settings.AiProvider, _settings.AiModel, batch);
                }
                catch
                {
                    result = null;
                }

                Application.Current.Dispatcher.BeginInvoke(new Action(delegate
                {
                    if (result == null)
                    {
                        NotifyAiFailure();
                    }
                    ApplyAiResult(batch, result);
                    bool hasMore;
                    lock (_aiSync)
                    {
                        _aiWorkerRunning = false;
                        hasMore = _pendingAi.Count > 0;
                    }
                    if (hasMore)
                    {
                        QueueAiClassification(new List<DesktopItem>());
                    }
                }));
            });
        }

        private void NotifyAiFailure()
        {
            DateTime now = DateTime.UtcNow;
            if (now - _lastAiFailureNoticeUtc < TimeSpan.FromMinutes(5))
            {
                return;
            }
            _lastAiFailureNoticeUtc = now;
            ShowTrayMessage(
                "AI 分类暂时不可用",
                "请检查网络、API 密钥和模型设置；本地规则仍会继续工作。",
                Forms.ToolTipIcon.Warning);
        }

        private void ApplyAiResult(IList<DesktopItem> batch, Dictionary<string, string> result)
        {
            if (_disposed || result == null || result.Count == 0)
            {
                return;
            }
            int changed = 0;
            int index;
            for (index = 0; index < batch.Count; index++)
            {
                DesktopItem item = batch[index];
                DesktopItem current;
                string boxId;
                string existingBoxId;
                if (_snapshot.TryGetValue(item.FullPath, out current) &&
                    IsSameClassificationTarget(item, current) &&
                    !_catalog.TryGet(current, out existingBoxId) &&
                    result.TryGetValue(item.FullPath, out boxId))
                {
                    _catalog.Set(current, boxId, "ai");
                    changed++;
                }
            }
            if (changed > 0)
            {
                SaveCatalog();
                RenderBoxes(new List<DesktopItem>(_snapshot.Values));
                ShowTrayMessage("AI 整理完成", "已为新增的低置信度图标完成归类。", Forms.ToolTipIcon.Info);
            }
        }

        private static bool IsSameClassificationTarget(DesktopItem requested, DesktopItem current)
        {
            return requested != null && current != null &&
                   String.Equals(requested.FullPath, current.FullPath, StringComparison.OrdinalIgnoreCase) &&
                   String.Equals(requested.Name, current.Name, StringComparison.Ordinal) &&
                   String.Equals(requested.Extension, current.Extension, StringComparison.OrdinalIgnoreCase) &&
                   requested.IsDirectory == current.IsDirectory &&
                   requested.IsShellItem == current.IsShellItem;
        }

        private void OnDesktopItemsChanged(object sender, EventArgs e)
        {
            // DesktopIndexService already batches Create/Delete/Rename. Comparing
            // snapshots here ensures deletions only update layout and never call AI.
            RefreshDesktop(false);
        }

        private void OnItemMoveRequested(object sender, DesktopItemMoveRequestedEventArgs e)
        {
            DesktopItem item;
            if (e != null && _snapshot.TryGetValue(e.Path, out item))
            {
                _catalog.Set(item, e.TargetBoxId, "manual");
                SaveCatalog();
                RenderBoxes(new List<DesktopItem>(_snapshot.Values));
            }
        }

        private void OnLayoutChanged(object sender, EventArgs e)
        {
            if (_qaMode)
            {
                return;
            }
            if (_layoutBatchInProgress || _displayRepairPending)
            {
                return;
            }
            _layoutSaveTimer.Stop();
            _layoutSaveTimer.Start();
        }

        private void OnDisplaySettingsChanged(object sender, EventArgs e)
        {
            if (_disposed || _exiting || Application.Current == null)
            {
                return;
            }

            Dispatcher dispatcher = Application.Current.Dispatcher;
            try
            {
                if (dispatcher.CheckAccess())
                {
                    QueueDisplayChangeRepair();
                }
                else
                {
                    dispatcher.BeginInvoke(
                        DispatcherPriority.Background,
                        new Action(QueueDisplayChangeRepair));
                }
            }
            catch (InvalidOperationException)
            {
            }
        }

        private void QueueDisplayChangeRepair()
        {
            if (_disposed || _exiting)
            {
                return;
            }

            // WPF can publish transient LocationChanged/SizeChanged events
            // before the new monitor DPI has settled. Do not let the shorter
            // layout-save debounce persist those intermediate coordinates.
            _layoutSaveTimer.Stop();
            if (!_displayRepairPending)
            {
                _displayRepairChanged = false;
            }
            _displayRepairPending = true;
            _displayChangeRepairPass = 0;
            _displayChangeTimer.Stop();
            _displayChangeTimer.Interval = TimeSpan.FromMilliseconds(650);
            _displayChangeTimer.Start();
        }

        private void OnDisplayChangeSettled(object sender, EventArgs e)
        {
            _displayChangeTimer.Stop();
            if (_disposed || _exiting)
            {
                return;
            }

            // A display event can represent a primary-monitor or DPI switch
            // even when the logical WPF WorkArea has identical numbers. Both
            // finite passes are unconditional: the second pass must repair
            // late DPI size changes even when they remain on-screen and do
            // not overlap but no longer share aligned row/column edges.
            string displaySignature = CaptureDisplaySignature();
            _lastDisplaySignature = displaySignature;
            _displayRepairChanged =
                ReflowOrganizerWindows(true, false, false) ||
                _displayRepairChanged;

            // Per-monitor DPI changes can arrive just after the display topology
            // notification. One finite verification pass catches that last move
            // without adding an idle polling loop.
            if (_displayChangeRepairPass == 0)
            {
                _displayChangeRepairPass = 1;
                _displayChangeTimer.Interval = TimeSpan.FromMilliseconds(450);
                _displayChangeTimer.Start();
            }
            else
            {
                _displayChangeRepairPass = 0;
                _displayChangeTimer.Interval = TimeSpan.FromMilliseconds(650);
                _lastDisplaySignature = CaptureDisplaySignature();
                _displayRepairPending = false;
                if (_displayRepairChanged || _saveSettingsAfterDisplayRepair)
                {
                    SaveSettings();
                }
                _displayRepairChanged = false;
                _saveSettingsAfterDisplayRepair = false;
            }
        }

        private bool ReflowOrganizerWindows(
            bool force,
            bool showConfirmation,
            bool saveImmediately)
        {
            if (_disposed || _exiting)
            {
                return false;
            }

            List<DesktopLayoutSlot> slots = new List<DesktopLayoutSlot>();
            List<Window> placementWindows = new List<Window>();
            bool includeUtility = _utilityBox != null &&
                _settings.UtilityBox.Visible;
            if (includeUtility)
            {
                slots.Add(new DesktopLayoutSlot(
                    _settings.UtilityBox,
                    240.0,
                    150.0,
                    42.0));
                placementWindows.Add(_utilityBox);
            }

            List<OrganizerBoxWindow> activeBoxes = new List<OrganizerBoxWindow>();
            int index;
            for (index = 0; index < BoxOrder.Length; index++)
            {
                OrganizerBoxWindow window;
                if (!_boxes.TryGetValue(BoxOrder[index], out window) ||
                    !window.LayoutSetting.Visible ||
                    window.Items.Count == 0)
                {
                    continue;
                }

                activeBoxes.Add(window);
                slots.Add(new DesktopLayoutSlot(
                    window.LayoutSetting,
                    190.0,
                    112.0,
                    36.0));
                placementWindows.Add(window);
            }

            Rect workArea = SystemParameters.WorkArea;
            _layoutBatchInProgress = true;
            try
            {
                if (slots.Count == 0)
                {
                    return false;
                }

                bool physicalNeedsReflow =
                    DesktopWindowPlacementService.NeedsReflow(placementWindows);
                if (!force && !physicalNeedsReflow)
                {
                    return false;
                }

                List<LayoutGeometrySnapshot> snapshots =
                    CaptureLayoutGeometry(slots);
                List<Rect> verifiedLayoutRectangles;
                bool physicallyArranged =
                    DesktopWindowPlacementService.Arrange(
                        placementWindows,
                        out verifiedLayoutRectangles);
                if (!physicallyArranged)
                {
                    if (!DesktopLayoutService.Arrange(slots, workArea))
                    {
                        RestoreLayoutGeometry(snapshots);
                        ApplyPlannedWindowGeometry(
                            includeUtility,
                            activeBoxes);
                        return false;
                    }

                    ApplyPlannedWindowGeometry(includeUtility, activeBoxes);
                    physicallyArranged =
                        DesktopWindowPlacementService.Arrange(
                            placementWindows,
                            out verifiedLayoutRectangles);
                    if (!physicallyArranged)
                    {
                        RestoreLayoutGeometry(snapshots);
                        ApplyPlannedWindowGeometry(includeUtility, activeBoxes);
                        return false;
                    }
                }

                CaptureVerifiedWindowGeometry(
                    slots,
                    verifiedLayoutRectangles);
            }
            finally
            {
                _layoutBatchInProgress = false;
            }

            _layoutSaveTimer.Stop();
            if (saveImmediately)
            {
                SaveSettings();
            }
            if (!_qaMode && _boxesVisible)
            {
                SendAllWindowsToDesktop();
                if (_desktopLayerCoordinator != null)
                {
                    _desktopLayerCoordinator.RequestRepair();
                }
            }
            if (showConfirmation)
            {
                ShowTrayMessage(
                    "收纳盒已排列",
                    "已按当前屏幕的可用空间重新排列。",
                    Forms.ToolTipIcon.Info);
            }
            return true;
        }

        private static List<LayoutGeometrySnapshot> CaptureLayoutGeometry(
            IList<DesktopLayoutSlot> slots)
        {
            List<LayoutGeometrySnapshot> snapshots =
                new List<LayoutGeometrySnapshot>();
            int index;
            for (index = 0; index < slots.Count; index++)
            {
                BoxLayoutSetting layout = slots[index].Layout;
                snapshots.Add(new LayoutGeometrySnapshot
                {
                    Layout = layout,
                    Left = layout.Left,
                    Top = layout.Top,
                    Width = layout.Width,
                    Height = layout.Height,
                    ExpandedHeight = layout.ExpandedHeight
                });
            }
            return snapshots;
        }

        private static void RestoreLayoutGeometry(
            IList<LayoutGeometrySnapshot> snapshots)
        {
            int index;
            for (index = 0; index < snapshots.Count; index++)
            {
                snapshots[index].Restore();
            }
        }

        private void ApplyPlannedWindowGeometry(
            bool includeUtility,
            IList<OrganizerBoxWindow> activeBoxes)
        {
            if (includeUtility && _utilityBox != null)
            {
                _utilityBox.RefreshFromLayout();
                _utilityBox.UpdateLayout();
            }
            int index;
            for (index = 0; index < activeBoxes.Count; index++)
            {
                activeBoxes[index].RefreshFromLayout();
                activeBoxes[index].UpdateLayout();
            }
        }

        private static void CaptureVerifiedWindowGeometry(
            IList<DesktopLayoutSlot> slots,
            IList<Rect> verifiedRectangles)
        {
            if (slots == null || verifiedRectangles == null ||
                slots.Count != verifiedRectangles.Count)
            {
                return;
            }

            int index;
            for (index = 0; index < slots.Count; index++)
            {
                BoxLayoutSetting layout = slots[index].Layout;
                Rect rectangle = verifiedRectangles[index];
                layout.Left = rectangle.Left;
                layout.Top = rectangle.Top;
                layout.Width = rectangle.Width;
                layout.Height = rectangle.Height;
                if (!layout.Collapsed)
                {
                    layout.ExpandedHeight = rectangle.Height;
                }
            }
        }

        private string CaptureDisplaySignature()
        {
            Window target = _utilityBox;
            if (target == null)
            {
                foreach (OrganizerBoxWindow box in _boxes.Values)
                {
                    target = box;
                    break;
                }
            }

            IntPtr handle = target == null
                ? IntPtr.Zero
                : new WindowInteropHelper(target).Handle;
            Forms.Screen screen = handle == IntPtr.Zero
                ? Forms.Screen.PrimaryScreen
                : Forms.Screen.FromHandle(handle);
            double dpiScaleX = 0.0;
            double dpiScaleY = 0.0;
            if (target != null)
            {
                PresentationSource source = PresentationSource.FromVisual(target);
                if (source != null && source.CompositionTarget != null)
                {
                    dpiScaleX = source.CompositionTarget.TransformToDevice.M11;
                    dpiScaleY = source.CompositionTarget.TransformToDevice.M22;
                }
            }

            Rect logical = SystemParameters.WorkArea;
            System.Drawing.Rectangle pixels = screen == null
                ? System.Drawing.Rectangle.Empty
                : screen.WorkingArea;
            string deviceName = screen == null ? String.Empty : screen.DeviceName;
            return String.Format(
                CultureInfo.InvariantCulture,
                "{0}|{1},{2},{3},{4}|{5:R},{6:R},{7:R},{8:R}|{9:R},{10:R}",
                deviceName,
                pixels.Left,
                pixels.Top,
                pixels.Width,
                pixels.Height,
                logical.Left,
                logical.Top,
                logical.Width,
                logical.Height,
                dpiScaleX,
                dpiScaleY);
        }

        private void OnDesktopWindowLoaded(object sender, RoutedEventArgs e)
        {
            if (_desktopLayerCoordinator != null)
            {
                _desktopLayerCoordinator.RequestRepair();
            }
        }

        private void RequestDesktopWindowRecovery()
        {
            if (_disposed || _exiting || _qaMode)
            {
                return;
            }

            _desktopWindowRecoveryAttempts = 0;
            _desktopWindowRecoveryTimer.Stop();
            _desktopWindowRecoveryTimer.Interval = TimeSpan.FromMilliseconds(250);
            _desktopWindowRecoveryTimer.Start();
        }

        private void RecoverDestroyedDesktopWindows(object sender, EventArgs e)
        {
            if (_disposed || _exiting)
            {
                _desktopWindowRecoveryTimer.Stop();
                return;
            }

            if (!DesktopWindowBehavior.IsDesktopHostAvailable())
            {
                _desktopWindowRecoveryAttempts++;
                if (_desktopWindowRecoveryAttempts >= 20)
                {
                    _desktopWindowRecoveryTimer.Interval = TimeSpan.FromSeconds(1);
                }
                return;
            }

            _desktopWindowRecoveryTimer.Stop();
            try
            {
                if (_utilityWindowPendingRecovery && _utilityBox == null)
                {
                    CreateUtilityWindow();
                    _utilityWindowPendingRecovery = false;
                }

                string[] organizerIds = _pendingOrganizerRecovery.ToArray();
                int index;
                for (index = 0; index < organizerIds.Length; index++)
                {
                    string boxId = organizerIds[index];
                    EnsureOrganizerWindow(boxId);
                    _pendingOrganizerRecovery.Remove(boxId);
                }

                RenderBoxes(new List<DesktopItem>(_snapshot.Values));
                if (_desktopLayerCoordinator != null)
                {
                    _desktopLayerCoordinator.RequestRepair();
                }
            }
            catch (InvalidOperationException)
            {
                // Explorer can publish the replacement desktop HWND shortly
                // before it is ready to own windows. Retry only while recovery
                // is pending; normal idle operation has no polling loop.
            }

            if (_utilityWindowPendingRecovery || _pendingOrganizerRecovery.Count > 0)
            {
                _desktopWindowRecoveryTimer.Start();
            }
        }

        private void OnWindowMoveCompleted(object sender, EventArgs e)
        {
            Window moved = sender as Window;
            if (moved == null || !moved.IsVisible)
            {
                return;
            }

            List<Rect> targets = new List<Rect>();
            foreach (OrganizerBoxWindow box in _boxes.Values)
            {
                if (!ReferenceEquals(box, moved) && box.IsVisible)
                {
                    targets.Add(GetWindowRect(box));
                }
            }
            if (_utilityBox != null &&
                !ReferenceEquals(_utilityBox, moved) &&
                _utilityBox.IsVisible)
            {
                targets.Add(GetWindowRect(_utilityBox));
            }

            Rect movingRect = GetWindowRect(moved);
            System.Windows.Point snapped = WindowSnapService.CalculatePosition(
                movingRect,
                targets,
                WindowSnapService.GetWorkArea(moved),
                SnapThreshold,
                LayoutGap);
            if (Math.Abs(moved.Left - snapped.X) > 0.01)
            {
                moved.Left = snapped.X;
            }
            if (Math.Abs(moved.Top - snapped.Y) > 0.01)
            {
                moved.Top = snapped.Y;
            }
            OnLayoutChanged(moved, EventArgs.Empty);
            if (!_qaMode)
            {
                DesktopWindowBehavior.SendToDesktop(moved);
            }
        }

        private void ShowSettings()
        {
            if (_disposed || _qaMode)
            {
                return;
            }
            SettingsWindow window = new SettingsWindow(_settings);
            bool? accepted = window.ShowDialog();
            if (accepted != true)
            {
                return;
            }

            _settings.EnsureDefaults();
            foreach (OrganizerBoxWindow box in _boxes.Values)
            {
                box.SetBoxOpacity(_settings.BoxOpacity);
            }
            if (_utilityBox != null)
            {
                _utilityBox.SetBoxOpacity(_settings.BoxOpacity);
            }

            if (!_noStartupWrite)
            {
                StartupService.SetEnabled(_settings.StartWithWindows);
            }
            SetDesktopIconTakeover(_settings.TakeOverDesktopIcons);
            SaveSettings();
            UpdateTrayChecks();
            RefreshDesktop(true);
        }

        private void ToggleOrganizerVisibility()
        {
            _boxesVisible = !_boxesVisible;
            foreach (OrganizerBoxWindow window in _boxes.Values)
            {
                if (_boxesVisible && window.LayoutSetting.Visible)
                {
                    window.Show();
                }
                else
                {
                    window.Hide();
                }
            }
            if (_utilityBox == null)
            {
                if (!_qaMode)
                {
                    _utilityWindowPendingRecovery = true;
                    RequestDesktopWindowRecovery();
                }
            }
            else if (_boxesVisible && _settings.UtilityBox.Visible)
            {
                _utilityBox.Show();
            }
            else if (_utilityBox != null)
            {
                _utilityBox.Hide();
            }
            _visibilityMenuItem.Text = _boxesVisible ? "隐藏收纳盒" : "显示收纳盒";
            if (_boxesVisible)
            {
                SendAllWindowsToDesktop();
                if (_desktopLayerCoordinator != null)
                {
                    _desktopLayerCoordinator.RequestRepair();
                }
            }
        }

        private void ShowFirstRunTakeoverChoice()
        {
            if (_qaMode || !_settings.ShowTakeoverPrompt)
            {
                return;
            }

            MessageBoxResult choice = MessageBox.Show(
                "拾光桌面已经改为桌面收纳盒形态。\n\n" +
                "启用“桌面图标接管”可以避免系统原图标与收纳盒图标重复。" +
                "它不会移动、重命名或删除任何文件；退出程序时会恢复系统图标。\n\n" +
                "现在启用吗？",
                "启用桌面收纳盒",
                MessageBoxButton.YesNo,
                MessageBoxImage.Question);

            _settings.ShowTakeoverPrompt = false;
            _settings.FirstRun = false;
            SetDesktopIconTakeover(choice == MessageBoxResult.Yes);
            SaveSettings();
        }

        private void SetDesktopIconTakeover(bool enabled)
        {
            if (_qaMode)
            {
                _settings.TakeOverDesktopIcons = false;
                return;
            }
            if (enabled)
            {
                _settings.TakeOverDesktopIcons = EnableDesktopIconTakeover();
            }
            else
            {
                RestoreDesktopIconsIfNeeded();
                _settings.TakeOverDesktopIcons = false;
            }
            UpdateTrayChecks();
            if (_started && !_disposed)
            {
                RefreshDesktop(false);
            }
        }

        private bool EnableDesktopIconTakeover()
        {
            bool visible;
            if (!_desktopIconsVisibilityKnown)
            {
                _desktopIconsVisibilityKnown = DesktopIconVisibilityService.TryGetVisible(out visible);
                if (!_desktopIconsVisibilityKnown)
                {
                    ShowTrayMessage("未能安全接管系统图标", "Explorer 当前不可用，未更改桌面图标状态。", Forms.ToolTipIcon.Warning);
                    return false;
                }
                _desktopIconsWereVisible = visible;
            }
            if (_desktopIconsVisibilityKnown && !_desktopIconsWereVisible)
            {
                return true;
            }
            if (!WriteTakeoverLease())
            {
                ShowTrayMessage("未能安全接管系统图标", "无法创建恢复记录，因此已取消接管。", Forms.ToolTipIcon.Warning);
                return false;
            }
            if (DesktopIconVisibilityService.TrySetVisible(false))
            {
                _desktopIconsHiddenByUs = true;
                return true;
            }

            // The shell command can succeed even when Explorer does not report
            // the updated state promptly. Always attempt a safe restore before
            // declaring takeover unavailable.
            if (DesktopIconVisibilityService.TrySetVisible(true))
            {
                DeleteTakeoverLease();
            }
            ShowTrayMessage("未能接管系统图标", "收纳盒仍可使用；可在设置中稍后重试。", Forms.ToolTipIcon.Warning);
            return false;
        }

        private void RestoreDesktopIconsIfNeeded()
        {
            if (_desktopIconsHiddenByUs && _desktopIconsWereVisible)
            {
                if (DesktopIconVisibilityService.TrySetVisible(true))
                {
                    DeleteTakeoverLease();
                }
            }
            _desktopIconsHiddenByUs = false;
            _desktopIconsVisibilityKnown = false;
        }

        private static void RecoverStaleTakeoverLease()
        {
            string leasePath = AppSettings.GetTakeoverLeasePath();
            if (!File.Exists(leasePath))
            {
                return;
            }
            if (DesktopIconVisibilityService.TrySetVisible(true))
            {
                DeleteTakeoverLease();
            }
        }

        private static bool WriteTakeoverLease()
        {
            try
            {
                string leasePath = AppSettings.GetTakeoverLeasePath();
                Directory.CreateDirectory(Path.GetDirectoryName(leasePath));
                File.WriteAllText(
                    leasePath,
                    Process.GetCurrentProcess().Id.ToString() + "|" + DateTime.UtcNow.ToString("o"));
                return true;
            }
            catch
            {
                return false;
            }
        }

        private static void DeleteTakeoverLease()
        {
            try
            {
                string leasePath = AppSettings.GetTakeoverLeasePath();
                if (File.Exists(leasePath))
                {
                    File.Delete(leasePath);
                }
            }
            catch
            {
            }
        }

        private bool SendAllWindowsToDesktop()
        {
            if (_disposed || _qaMode || !_boxesVisible)
            {
                return true;
            }
            List<Window> visibleWindows = new List<Window>();
            foreach (OrganizerBoxWindow window in _boxes.Values)
            {
                if (window.IsVisible)
                {
                    visibleWindows.Add(window);
                }
            }
            if (_utilityBox != null)
            {
                if (_utilityBox.IsVisible)
                {
                    visibleWindows.Add(_utilityBox);
                }
            }

            bool settled = false;
            bool showDesktopActive = false;
            int statePass;
            for (statePass = 0; statePass < 3; statePass++)
            {
                showDesktopActive = DesktopWindowBehavior.IsShowDesktopActive();
                settled = true;
                foreach (OrganizerBoxWindow window in _boxes.Values)
                {
                    settled = DesktopWindowBehavior.SendToDesktop(
                        window,
                        showDesktopActive,
                        _desktopActivationGuard) && settled;
                }
                if (_utilityBox != null)
                {
                    settled = DesktopWindowBehavior.SendToDesktop(
                        _utilityBox,
                        showDesktopActive,
                        _desktopActivationGuard) && settled;
                }

                // The Shell can reverse state while this batch is being
                // positioned. Never accept a stale "show desktop" snapshot
                // that could leave boxes above an application just restored.
                if (DesktopWindowBehavior.IsShowDesktopActive() == showDesktopActive)
                {
                    break;
                }
                settled = false;
            }
            return settled && DesktopWindowBehavior.AreDesktopPresentationsSettled(
                visibleWindows,
                showDesktopActive,
                _desktopActivationGuard);
        }

        private bool IsDesktopLayerSettled()
        {
            if (_disposed || _qaMode || !_boxesVisible)
            {
                return true;
            }

            List<Window> visibleWindows = new List<Window>();
            foreach (OrganizerBoxWindow window in _boxes.Values)
            {
                if (window.IsVisible)
                {
                    visibleWindows.Add(window);
                }
            }
            if (_utilityBox != null && _utilityBox.IsVisible)
            {
                visibleWindows.Add(_utilityBox);
            }
            return DesktopWindowBehavior.AreDesktopPresentationsSettled(
                visibleWindows,
                DesktopWindowBehavior.IsShowDesktopActive(),
                _desktopActivationGuard);
        }

        private void SetDesktopActivationGuard(bool enabled)
        {
            if (_disposed || _qaMode)
            {
                return;
            }

            if (_desktopActivationGuard != enabled)
            {
                _desktopActivationGuard = enabled;
                foreach (OrganizerBoxWindow window in _boxes.Values)
                {
                    DesktopWindowBehavior.SetActivationGuard(window, enabled);
                }
                if (_utilityBox != null)
                {
                    DesktopWindowBehavior.SetActivationGuard(_utilityBox, enabled);
                }
            }
            if (enabled)
            {
                DesktopWindowBehavior.MoveForegroundToDesktopIfOrganizer();
            }
        }

        private void ExitApplication()
        {
            if (_exiting)
            {
                return;
            }
            _exiting = true;
            Dispose();
            Application.Current.Shutdown();
        }

        private void UpdateTrayChecks()
        {
            if (_takeoverMenuItem != null)
            {
                _takeoverMenuItem.Checked = _settings.TakeOverDesktopIcons;
            }
            if (_startupMenuItem != null)
            {
                _startupMenuItem.Checked = _settings.StartWithWindows;
            }
        }

        private void UpdateTrayStatus(int count)
        {
            if (_trayIcon == null)
            {
                return;
            }
            string ai = _settings.AiEnabled && _aiService.HasKey(_settings.AiProvider) ? "AI按需" : "本地规则";
            string text = "拾光桌面 · " + count + " 个图标 · " + ai;
            _trayIcon.Text = text.Length > 63 ? text.Substring(0, 63) : text;
        }

        private void SaveSettings()
        {
            if (_qaMode)
            {
                return;
            }
            if (_layoutBatchInProgress || _displayRepairPending)
            {
                _saveSettingsAfterDisplayRepair = true;
                return;
            }
            _settings.Save();
        }

        private void SaveCatalog()
        {
            if (!_qaMode)
            {
                _catalog.Save();
            }
        }

        private void ShowTrayMessage(string title, string message, Forms.ToolTipIcon icon)
        {
            if (_trayIcon == null || !_trayIcon.Visible)
            {
                return;
            }
            _trayIcon.BalloonTipTitle = title;
            _trayIcon.BalloonTipText = message;
            _trayIcon.BalloonTipIcon = icon;
            _trayIcon.ShowBalloonTip(2400);
        }

        private void ApplyDefaultLayout()
        {
            Rect area = SystemParameters.WorkArea;
            double gap = 14;
            double margin = 22;
            BoxLayoutSetting utility = _settings.UtilityBox;
            if (Double.IsNaN(utility.Left))
            {
                utility.Left = area.Right - utility.Width - margin;
                utility.Top = area.Top + margin;
            }

            BoxLayoutSetting applications = _settings.FindBox("applications");
            SetDefaultPosition(applications, area.Right - applications.Width - margin,
                utility.Top + utility.Height + gap);
            BoxLayoutSetting folders = _settings.FindBox("folders");
            SetDefaultPosition(folders, area.Right - folders.Width - margin,
                applications.Top + applications.Height + gap);

            BoxLayoutSetting documents = _settings.FindBox("documents");
            SetDefaultPosition(documents, area.Right - documents.Width - applications.Width - margin - gap,
                area.Top + margin);
            BoxLayoutSetting media = _settings.FindBox("media");
            SetDefaultPosition(media, documents.Left, documents.Top + documents.Height + gap);
            BoxLayoutSetting archives = _settings.FindBox("archives");
            SetDefaultPosition(archives, documents.Left, media.Top + media.Height + gap);

            BoxLayoutSetting other = _settings.FindBox("other");
            SetDefaultPosition(other, documents.Left - other.Width - gap, area.Top + margin);
            SaveSettings();
        }

        private System.Windows.Point FindAvailableBoxPosition(BoxLayoutSetting layout)
        {
            Rect area = SystemParameters.WorkArea;
            double margin = 22.0;
            double width = Math.Max(190.0, layout.Width);
            double height = layout.Collapsed
                ? 36.0
                : Math.Max(112.0, layout.Height);
            List<Rect> occupied = new List<Rect>();

            if (_utilityBox != null && _utilityBox.IsVisible)
            {
                occupied.Add(GetWindowRect(_utilityBox));
            }
            foreach (OrganizerBoxWindow box in _boxes.Values)
            {
                if (box.IsVisible)
                {
                    occupied.Add(GetWindowRect(box));
                }
            }

            double columnStride = Math.Max(320.0, width + LayoutGap);
            int column;
            for (column = 0; column < 12; column++)
            {
                double left = area.Right - margin - width - column * columnStride;
                if (left < area.Left + 8.0)
                {
                    break;
                }

                double top = area.Top + margin;
                while (top + height <= area.Bottom - 8.0)
                {
                    Rect candidate = new Rect(left, top, width, height);
                    Rect collision;
                    if (!TryFindCollision(candidate, occupied, out collision))
                    {
                        return new System.Windows.Point(left, top);
                    }
                    top = Math.Max(top + LayoutGap, collision.Bottom + LayoutGap);
                }
            }

            return new System.Windows.Point(
                Math.Max(area.Left + 8.0, area.Right - margin - width),
                Math.Max(area.Top + 8.0, area.Bottom - height - 8.0));
        }

        private static bool TryFindCollision(
            Rect candidate,
            IList<Rect> occupied,
            out Rect collision)
        {
            int index;
            for (index = 0; index < occupied.Count; index++)
            {
                Rect expanded = occupied[index];
                expanded.Inflate(LayoutGap, LayoutGap);
                if (expanded.IntersectsWith(candidate))
                {
                    collision = occupied[index];
                    return true;
                }
            }
            collision = Rect.Empty;
            return false;
        }

        private static Rect GetWindowRect(Window window)
        {
            double width = window.ActualWidth > 0 ? window.ActualWidth : window.Width;
            double height = window.ActualHeight > 0 ? window.ActualHeight : window.Height;
            return new Rect(window.Left, window.Top, width, height);
        }

        private static void SetDefaultPosition(BoxLayoutSetting layout, double left, double top)
        {
            if (Double.IsNaN(layout.Left) || Double.IsNaN(layout.Top))
            {
                layout.Left = left;
                layout.Top = top;
            }
        }

        private static DesktopIndexService CreatePublicDesktopIndex(string selectedDesktopPath)
        {
            try
            {
                string privateDesktop = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
                if (!String.Equals(Path.GetFullPath(privateDesktop), Path.GetFullPath(selectedDesktopPath), StringComparison.OrdinalIgnoreCase))
                {
                    return null;
                }
                string publicDesktop = Environment.GetFolderPath(Environment.SpecialFolder.CommonDesktopDirectory);
                if (String.IsNullOrWhiteSpace(publicDesktop) || !Directory.Exists(publicDesktop) ||
                    String.Equals(Path.GetFullPath(publicDesktop), Path.GetFullPath(selectedDesktopPath), StringComparison.OrdinalIgnoreCase))
                {
                    return null;
                }
                return new DesktopIndexService(publicDesktop);
            }
            catch
            {
                return null;
            }
        }

        private bool UsesPhysicalDesktop()
        {
            try
            {
                return String.Equals(
                    Path.GetFullPath(_desktopPath),
                    Path.GetFullPath(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory)),
                    StringComparison.OrdinalIgnoreCase);
            }
            catch
            {
                return false;
            }
        }
    }
}