NotesPanelWindow.xaml.cs

using NoteIt.Models;
using NoteIt.Native;
using NoteIt.Services;
using NoteIt.UI;
using Microsoft.UI;
using Microsoft.UI.Windowing;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Controls.Primitives;
using Microsoft.UI.Xaml.Media;
using Microsoft.UI.Xaml.Media.Animation;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Windows.ApplicationModel.DataTransfer;
using Windows.Graphics;
using WinRT.Interop;

namespace NoteIt;

/// <summary>
/// The sliding panel. Positioning/animation are ported from WorldClockTray's
/// ClockPanel (by way of the ClipboardTray app this project itself was
/// adapted from): the panel docks against whichever screen edge the anchor
/// point (tray icon click / cursor) is actually closest to, instead of
/// always assuming the taskbar is at the bottom. Both the window itself
/// (native SetWindowPos+DwmFlush tween, see WindowAnimator) and its content
/// (a separate XAML slide+fade, see TriggerContentAnimation) enter from that
/// same resolved edge.
///
/// Unlike a clipboard history panel, notes are user-authored and editable
/// in place: each row is a live TextBox rather than a read-only, click-to-
/// copy button, and nothing is ever silently trimmed off the bottom of the
/// list -- see OnNoteTextChanged and the absence of any Trim()/MaxItems
/// logic that a transient-capture history would have.
/// </summary>
public sealed partial class NotesPanelWindow : Window
{
    private const double PanelWidthDip = 340;

    // Height is no longer fixed: the panel grows to fit its content (down to
    // this floor, so it never looks cramped when empty/near-empty) and up to
    // this fraction of the current monitor's work area, beyond which it holds
    // at that cap and the ListView's own built-in ScrollViewer takes over.
    private const double MinPanelHeightDip = 220;
    private const double MaxPanelHeightFraction = 0.75;
    private const double ExtraFitHeightDip = 10;

    private const double EdgeMarginDip = 10;
    private const int SlideDurationMs = 280;
    private const double ContentSlideOffsetDip = 14;
    private const int ContentSlideDurationMs = 320;
    private const int ContentFadeDurationMs = 150;
    private const double ReopenDebounceSeconds = 0.25;
    private const int HeightResizeDurationMs = 200;

    // How long to wait after the last keystroke in a note before writing it
    // to disk -- saving on every single character would mean a save-to-disk
    // call per keypress while someone's mid-sentence. Coalesced the same way
    // ScheduleWindowHeightUpdate coalesces a burst of layout changes, just on
    // a longer, restartable timer instead of a one-shot dispatcher post.
    private static readonly TimeSpan SaveDebounceDelay = TimeSpan.FromMilliseconds(600);

    private DateTime _lastCloseTimeUtc = DateTime.MinValue;

    public ObservableCollection<NoteItem> Items { get; } = new();

    /// <summary>What PinnedList binds to: the subset of Items where
    /// IsPinned is true, further narrowed by whatever the search box/
    /// content filter currently restrict to. Kept in sync by ApplyFilter,
    /// same as UnpinnedItems below -- splitting the old combined
    /// FilteredItems into these two is what lets PinnedList sit in its own
    /// sticky section (see the XAML) instead of scrolling away with the
    /// rest of the notes, while still sharing all the same filter/search
    /// logic.</summary>
    public ObservableCollection<NoteItem> PinnedItems { get; } = new();

    /// <summary>What HistoryList (the scrollable list) binds to: the
    /// subset of Items where IsPinned is false, same filter/search
    /// treatment as PinnedItems. Kept as separate collections, rather than
    /// filtering Items in place, so pinning/persistence logic elsewhere
    /// never has to know or care that a search is active -- TogglePin just
    /// flips IsPinned and calls ApplyFilter, which moves the note from one
    /// collection to the other for free.</summary>
    public ObservableCollection<NoteItem> UnpinnedItems { get; } = new();

    public bool IsPanelVisible { get; private set; }

    /// <summary>Panel-level pin (distinct from NoteItem.IsPinned, which
    /// pins individual notes to the top of the list). While true:
    /// MouseHookWatcher's click-away check skips SlideOut entirely, so the
    /// panel can be left open on screen like a sticky-note board while you
    /// work.</summary>
    public bool IsPanelPinned { get; private set; }

    public IntPtr Hwnd => _hwnd;

    public Visibility EmptyStateVisibility(int pinnedCount, int unpinnedCount) =>
        pinnedCount == 0 && unpinnedCount == 0 ? Visibility.Visible : Visibility.Collapsed;

    public string EmptyStateText(int pinnedCount, int unpinnedCount, int itemCount) =>
        itemCount == 0 ? "No notes yet -- click + to add one" : "No matching notes";

    /// <summary>Bound to the divider Border between PinnedList and
    /// HistoryList: visible only once there's actually a pinned note above
    /// it AND something unpinned below to separate it from.</summary>
    public Visibility PinnedDividerVisibility(int pinnedCount, int unpinnedCount) =>
        pinnedCount > 0 && unpinnedCount > 0 ? Visibility.Visible : Visibility.Collapsed;

    public ThemeMode Theme { get; private set; }
    public CornerStyle CornerStyle { get; private set; }
    public bool IsDarkMode { get; private set; }

    /// <summary>Fires whenever the panel's *resolved* light/dark state
    /// changes -- used by App to swap the tray icon between its white/black
    /// monochrome variants so it stays visible against either taskbar.</summary>
    public event Action<bool>? EffectiveThemeChanged;

    private readonly SettingsStore _settingsStore;
    private readonly NotesStore _notesStore;

    private readonly AppWindow _appWindow;
    private readonly IntPtr _hwnd;
    private readonly double _scale;
    private string _lastEffectiveEdge = "right";

    private PointInt32 _lastAnchor;
    private bool _sizingInProgress;

    private bool _heightUpdateQueued;

    private readonly TranslateTransform _contentTransform = new();
    private Storyboard? _contentStoryboard;
    private CancellationTokenSource? _animCts;

    private CancellationTokenSource? _resizeAnimCts;
    private bool _slideInProgress;

    private static readonly TimeSpan ScrollBarHideDelay = TimeSpan.FromSeconds(2);
    private ScrollBar? _historyScrollBar;
    private DispatcherTimer? _scrollBarHideTimer;
    private Storyboard? _scrollBarFadeStoryboard;

    private const double ScrollToTopThreshold = 80;
    private ScrollViewer? _historyScrollViewer;
    private Storyboard? _scrollToTopFadeStoryboard;

    private DispatcherTimer? _saveDebounceTimer;

    /// <summary>Open "edit in window" editors, keyed by NoteItem.Id, so
    /// clicking the button again for a note that's already open activates
    /// the existing window instead of stacking a second one on top of it.
    /// Entries are removed on Closed. See OnOpenEditorClicked.</summary>
    private readonly Dictionary<string, NoteEditorWindow> _openEditors = new();

    /// <summary>Open pop-out mini windows, keyed by NoteItem.Id -- same
    /// reuse-if-already-open convention as _openEditors (see
    /// OnPopOutClicked / UI/StickyPopoutWindow).</summary>
    private readonly Dictionary<string, UI.StickyPopoutWindow> _openPopouts = new();

    /// <summary>Advances by one every time a pop-out is created, purely to
    /// stagger each new window's spawn position a little from the last so
    /// popping out several notes in a row doesn't stack them in an
    /// identical spot directly on top of one another.</summary>
    private int _popoutCascadeCount;

    /// <summary>Standing restriction applied on top of the search text --
    /// never resets automatically, same as the search text, until the user
    /// picks a different option from FilterButton's menu.</summary>
    private enum ContentFilterMode { All, Pinned }
    private ContentFilterMode _contentFilter = ContentFilterMode.All;

    public NotesPanelWindow(SettingsStore settingsStore, NotesStore notesStore)
    {
        this.InitializeComponent();
        Container.RenderTransform = _contentTransform;

        Items.CollectionChanged += (_, _) => ApplyFilter();
        PinnedItems.CollectionChanged += (_, _) => ScheduleWindowHeightUpdate();
        UnpinnedItems.CollectionChanged += (_, _) => ScheduleWindowHeightUpdate();

        _settingsStore = settingsStore;
        _notesStore = notesStore;
        Theme = settingsStore.LoadThemeMode();
        CornerStyle = settingsStore.LoadCornerStyle();

        _hwnd = WindowNative.GetWindowHandle(this);
        var windowId = global::Microsoft.UI.Win32Interop.GetWindowIdFromWindow(_hwnd);
        _appWindow = AppWindow.GetFromWindowId(windowId);
        _scale = WindowEffects.ScaleFactor(_hwnd);

        _lastAnchor = new PointInt32(_appWindow.Position.X, _appWindow.Position.Y);

        var widthPx = (int)Math.Round(PanelWidthDip * _scale);
        var heightPx = (int)Math.Round(MinPanelHeightDip * _scale);
        _appWindow.Resize(new SizeInt32(widthPx, heightPx));
        _appWindow.IsShownInSwitchers = false;

        ExtendsContentIntoTitleBar = true;
        _appWindow.TitleBar.PreferredHeightOption = TitleBarHeightOption.Collapsed;
        _appWindow.TitleBar.ExtendsContentIntoTitleBar = true;

        if (_appWindow.Presenter is OverlappedPresenter presenter)
        {
            presenter.IsResizable = false;
            presenter.IsMaximizable = false;
            presenter.IsMinimizable = false;
            presenter.SetBorderAndTitleBar(true, true);
        }

        WindowEffects.HideFromTaskbar(_hwnd);
        WindowEffects.ApplyShadow(_hwnd);
        WindowEffects.ApplyCornerStyle(_hwnd, CornerStyle);

        var isDark = ApplyThemeCore(Theme);

        NoiseOverlay.RenderTransformOrigin = new Windows.Foundation.Point(0, 0);
        NoiseOverlay.RenderTransform = new ScaleTransform { ScaleX = 1.0 / _scale, ScaleY = 1.0 / _scale };

        WindowEffects.ApplyAcrylicBackdrop(this, isDark, thin: false);
        WindowEffects.RegenerateNoise(NoiseOverlay, widthPx, heightPx);

        // Warm-up: one real Show/Activate cycle, far off-screen, before the
        // panel is ever meant to be visible -- see the ClipboardTray-era
        // comment this was ported from for why WinUI3's virtualizing
        // ListView needs this.
        var warmUpPos = new PointInt32(_appWindow.Position.X - 30000, _appWindow.Position.Y - 30000);
        _appWindow.Move(warmUpPos);
        _appWindow.Show();
        this.Activate();
        Container.UpdateLayout();
        _appWindow.Hide();

        SystemThemeService.Changed += OnSystemThemeChanged;

        _saveDebounceTimer = new DispatcherTimer { Interval = SaveDebounceDelay };
        _saveDebounceTimer.Tick += (_, _) =>
        {
            _saveDebounceTimer!.Stop();
            SaveNotes();
        };

        // Fire-and-forget: repopulates Items from disk once loaded.
        _ = LoadNotesAsync();
    }

    /// <summary>Restores persisted notes from NotesStore.</summary>
    private Task LoadNotesAsync()
    {
        foreach (var record in _notesStore.Load())
        {
            Items.Add(new NoteItem
            {
                Id = record.Id,
                Text = record.Text,
                CreatedAt = record.CreatedAt,
                ModifiedAt = record.ModifiedAt,
                IsPinned = record.IsPinned,
                PaperColorKey = record.PaperColorKey,
            });
        }
        return Task.CompletedTask;
    }

    /// <summary>Snapshots the current Items into NotesStore's manifest
    /// format and saves it. Called (debounced) on every edit, and
    /// immediately after every add/remove/pin/clear-all.</summary>
    private void SaveNotes()
    {
        var records = Items.Select(item => new NotesStore.Record
        {
            Id = item.Id,
            Text = item.Text,
            CreatedAt = item.CreatedAt,
            ModifiedAt = item.ModifiedAt,
            IsPinned = item.IsPinned,
            PaperColorKey = item.PaperColorKey,
        }).ToList();

        _notesStore.Save(records);
    }

    /// <summary>Restarts the debounce timer -- called on every keystroke in
    /// a note. A burst of keystrokes collapses into one save, ~600ms after
    /// the user stops typing.</summary>
    private void ScheduleSave()
    {
        if (_saveDebounceTimer == null) return;
        _saveDebounceTimer.Stop();
        _saveDebounceTimer.Start();
    }

    private void OnSystemThemeChanged()
    {
        if (Theme != ThemeMode.System) return;
        DispatcherQueue.TryEnqueue(() =>
        {
            ApplyTheme(Theme);
            NotifyEditorsOfTheme();
        });
    }

    public void ApplyAndPersistTheme(ThemeMode mode)
    {
        ApplyTheme(mode);
        _settingsStore.SaveThemeMode(mode);
        NotifyEditorsOfTheme();
    }

    public void ApplyAndPersistCornerStyle(CornerStyle style)
    {
        CornerStyle = style;
        WindowEffects.ApplyCornerStyle(_hwnd, style);
        _settingsStore.SaveCornerStyle(style);
        NotifyEditorsOfTheme();
    }

    /// <summary>Re-themes every currently-open note editor window to match
    /// the panel's own theme/corner style -- called any time either changes
    /// live (Settings, or Windows' own Light/Dark switch under "System"),
    /// so an editor left open doesn't visually diverge from the app around
    /// it.</summary>
    private void NotifyEditorsOfTheme()
    {
        foreach (var editor in _openEditors.Values)
            editor.ApplyTheme(Theme, CornerStyle);

        foreach (var popout in _openPopouts.Values)
            popout.ApplyTheme(Theme, CornerStyle);
    }

    public void ApplyTheme(ThemeMode mode)
    {
        Theme = mode;
        var isDark = ApplyThemeCore(mode);
        WindowEffects.ApplyAcrylicBackdrop(this, isDark, thin: false);
    }

    private bool ApplyThemeCore(ThemeMode mode)
    {
        var effectiveMode = SystemThemeService.Resolve(mode, taskbarSurface: true);
        var isDark = effectiveMode == ThemeMode.Dark;
        if (Content is FrameworkElement root)
            root.RequestedTheme = isDark ? ElementTheme.Dark : ElementTheme.Light;
        WindowEffects.SetDarkMode(_hwnd, isDark);
        IsDarkMode = isDark;
        EffectiveThemeChanged?.Invoke(isDark);
        return isDark;
    }

    /// <summary>Panel bounds in physical screen pixels, for the mouse hook's
    /// click-away hit test.</summary>
    public PixelRect CurrentScreenRectPx()
    {
        var pos = _appWindow.Position;
        var size = _appWindow.Size;
        return new PixelRect(pos.X, pos.Y, size.Width, size.Height);
    }

    // --- note mutation ---------------------------------------------------

    /// <summary>Adds a fresh blank note just below the pinned block (so a
    /// new note never pushes a pin down) and focuses it for immediate
    /// typing. Called from the header's "+" button.</summary>
    private void OnAddNoteClicked(object sender, RoutedEventArgs e) => AddNoteAndFocus();

    private void AddNoteAndFocus()
    {
        var insertAt = Items.TakeWhile(i => i.IsPinned).Count();
        var note = new NoteItem();
        Items.Insert(insertAt, note);
        SaveNotes();

        // If a search/filter is currently hiding new (empty, unpinned)
        // notes, clear it so the note the user is about to type into is
        // actually visible -- otherwise it would be created invisibly.
        if (_contentFilter != ContentFilterMode.All)
        {
            _contentFilter = ContentFilterMode.All;
            FilterGlyph.ClearValue(Microsoft.UI.Xaml.Controls.FontIcon.ForegroundProperty);
        }
        if (!string.IsNullOrEmpty(SearchBox.Text))
            SearchBox.Text = string.Empty;
        else
            ApplyFilter();

        // Container realization for a just-inserted item happens on the
        // next layout pass, so focusing has to wait a beat -- mirrors the
        // ScheduleWindowHeightUpdate pattern elsewhere in this file.
        DispatcherQueue.TryEnqueue(Microsoft.UI.Dispatching.DispatcherQueuePriority.Low, () =>
        {
            // A freshly-added note is always unpinned (see the insertAt
            // computation above), so it always lands in HistoryList, never
            // PinnedList.
            HistoryList.UpdateLayout();
            if (HistoryList.ContainerFromItem(note) is ListViewItem container)
            {
                var textBox = FindDescendant<TextBox>(container);
                textBox?.Focus(FocusState.Programmatic);
            }
        });
    }

    /// <summary>Pushes a note's TextBox content back into the model as the
    /// user types, bumps ModifiedAt, and schedules both a persisted save
    /// and a fit-to-content height recalc (a growing/shrinking note changes
    /// the panel's natural height same as adding/removing a whole note
    /// does).</summary>
    private void OnNoteTextChanged(object sender, TextChangedEventArgs e)
    {
        if (sender is not TextBox { Tag: NoteItem item } textBox) return;

        // Runs even when the guard below bails out early, since that guard
        // only covers user-edit side effects (save/resize) -- a recycled
        // container re-firing TextChanged for a *different* note (whose
        // overflow state has nothing to do with the previous occupant's)
        // still needs its indicator re-checked.
        UpdateMoreIndicator(textBox);

        if (item.Text == textBox.Text) return; // recycled container re-firing with the same text

        item.Text = textBox.Text;
        item.ModifiedAt = DateTime.Now;

        ScheduleSave();
        ScheduleWindowHeightUpdate();

        // A note's pinned/all-notes membership never changes just from
        // editing its text, but a search query might now include/exclude
        // it.
        if (!string.IsNullOrEmpty(SearchBox.Text))
            ApplyFilter();
    }

    /// <summary>Shows the small chevron under a note's TextBox once its
    /// content actually overflows the 10-line preview cap (the TextBox's
    /// MaxHeight in the item template), by checking the TextBox's own
    /// internal ScrollViewer -- the same technique OnNotesListLoaded uses
    /// to reach HistoryList's ScrollViewer. Deferred to a low-priority
    /// dispatcher pass because the ScrollViewer's extent isn't updated
    /// until the layout pass after Text changes lands, same reasoning as
    /// the focus-after-insert dispatch in OnAddNoteClicked.</summary>
    private void UpdateMoreIndicator(TextBox textBox)
    {
        DispatcherQueue.TryEnqueue(Microsoft.UI.Dispatching.DispatcherQueuePriority.Low, () =>
        {
            if (VisualTreeHelper.GetParent(textBox) is not FrameworkElement wrapper) return;
            if (FindDescendant<FontIcon>(wrapper, f => f.Name == "MoreIndicator") is not { } indicator) return;

            var scrollViewer = FindDescendant<ScrollViewer>(textBox);
            indicator.Visibility = scrollViewer is { ScrollableHeight: > 0.5 }
                ? Visibility.Visible
                : Visibility.Collapsed;
        });
    }

    private void OnCopyNoteClicked(object sender, RoutedEventArgs e)
    {
        if (sender is not FrameworkElement { Tag: NoteItem item }) return;

        var package = new DataPackage();
        package.SetText(item.Text ?? string.Empty);
        Clipboard.SetContent(package);
    }

    /// <summary>Opens (or, if one's already open for this note, just
    /// activates) a full editor window for the note -- the panel's row
    /// stays live underneath since both views edit the same NoteItem
    /// instance. See UI/NoteEditorWindow.xaml.cs.</summary>
    private void OnOpenEditorClicked(object sender, RoutedEventArgs e)
    {
        if (sender is not FrameworkElement { Tag: NoteItem item }) return;

        if (_openEditors.TryGetValue(item.Id, out var existing))
        {
            existing.Activate();
            return;
        }

        var editor = new NoteEditorWindow(item, Theme, CornerStyle, PersistNow);
        _openEditors[item.Id] = editor;
        editor.Closed += (_, _) => _openEditors.Remove(item.Id);
        editor.Activate();
    }

    /// <summary>Opens (or, if one's already open for this note, just
    /// activates) a small movable, always-on-top "sticky note" style
    /// window for the note -- unlike OnOpenEditorClicked's full editor,
    /// this is meant to be left floating on top of other apps while you
    /// work elsewhere. Both windows edit the very same NoteItem instance,
    /// same as the panel row and the full editor do, so all three views
    /// (row, editor, pop-out) stay in sync live. See
    /// UI/StickyPopoutWindow.</summary>
    private void OnPopOutClicked(object sender, RoutedEventArgs e)
    {
        if (sender is not FrameworkElement { Tag: NoteItem item }) return;

        if (_openPopouts.TryGetValue(item.Id, out var existing))
        {
            existing.Activate();
            return;
        }

        // Spawns a little down-and-right of the panel itself, cascading
        // further with each additional pop-out (wrapping every 6 so a long
        // run of clicks doesn't walk the window off-screen).
        var stepPx = (int)Math.Round(28 * _scale);
        var basePx = (int)Math.Round(24 * _scale);
        var step = stepPx * (_popoutCascadeCount % 6);
        _popoutCascadeCount++;

        var anchor = new PointInt32(_appWindow.Position.X + basePx + step, _appWindow.Position.Y + basePx + step);

        var popout = new UI.StickyPopoutWindow(item, Theme, CornerStyle, anchor, PersistNow);
        _openPopouts[item.Id] = popout;
        popout.Closed += (_, _) => _openPopouts.Remove(item.Id);
        popout.Activate();
    }

    /// <summary>Persist-now callback handed to editor windows: writes the
    /// full current Items snapshot the same way every other mutation here
    /// does (SaveNotes has no notion of "just one note"), so an editor
    /// window's Save button/autosave shares the exact same write path as
    /// the panel's own inline editing.</summary>
    private void PersistNow() => SaveNotes();

    // --- fit-to-content height -------------------------------------------------

    private void ScheduleWindowHeightUpdate()
    {
        if (_heightUpdateQueued) return;
        _heightUpdateQueued = true;
        DispatcherQueue.TryEnqueue(Microsoft.UI.Dispatching.DispatcherQueuePriority.Low, () =>
        {
            _heightUpdateQueued = false;
            UpdateWindowHeight();
        });
    }

    private void UpdateWindowHeight()
    {
        if (_sizingInProgress) return;
        _sizingInProgress = true;
        try
        {
            Container.UpdateLayout();

            var availableSize = new Windows.Foundation.Size(PanelWidthDip, double.PositiveInfinity);
            Container.Measure(availableSize);
            var naturalHeightDip = Container.DesiredSize.Height;

            var wa = WorkAreaPx(_lastAnchor);
            var maxHeightDip = (wa.Height * MaxPanelHeightFraction) / _scale;

            // +ExtraFitHeightDip: a small cushion on top of the exact fit,
            // since the exact-fit height sometimes clips the last visible
            // pixels of a row right at the panel edge.
            var targetHeightDip = Math.Clamp(naturalHeightDip, MinPanelHeightDip, Math.Max(MinPanelHeightDip, maxHeightDip)) + ExtraFitHeightDip;
            var newHeightPx = (int)Math.Round(targetHeightDip * _scale);

            if (newHeightPx == _appWindow.Size.Height) return;

            WindowEffects.RegenerateNoise(NoiseOverlay, _appWindow.Size.Width, newHeightPx);

            if (IsPanelVisible && !_slideInProgress)
            {
                AnimateHeightTo(newHeightPx);
                return;
            }

            _appWindow.Resize(new SizeInt32(_appWindow.Size.Width, newHeightPx));

            if (IsPanelVisible)
                _appWindow.Move(TargetPosPx(_lastAnchor));
        }
        finally
        {
            _sizingInProgress = false;
        }
    }

    private void AnimateHeightTo(int newHeightPx)
    {
        _resizeAnimCts?.Cancel();
        _resizeAnimCts = new CancellationTokenSource();

        var currentPos = _appWindow.Position;
        var currentSize = _appWindow.Size;
        var targetPos = TargetPosPxForSize(_lastAnchor, currentSize.Width, newHeightPx);

        WindowAnimator.ResizeAndMove(
            _hwnd,
            new RectInt32(currentPos.X, currentPos.Y, currentSize.Width, currentSize.Height),
            new RectInt32(targetPos.X, targetPos.Y, currentSize.Width, newHeightPx),
            HeightResizeDurationMs,
            WindowAnimator.ExponentialEaseOut,
            DispatcherQueue,
            cancellationToken: _resizeAnimCts.Token);
    }

    // --- positioning ---------------------------------------------------------

    private RectInt32 WorkAreaPx(PointInt32 anchor)
    {
        var area = DisplayArea.GetFromPoint(anchor, DisplayAreaFallback.Nearest);
        return area.WorkArea;
    }

    private static string ResolveEdge(PointInt32 anchor, RectInt32 wa)
    {
        var left = anchor.X - wa.X;
        var right = (wa.X + wa.Width) - anchor.X;
        var top = anchor.Y - wa.Y;
        var bottom = (wa.Y + wa.Height) - anchor.Y;

        var min = Math.Min(Math.Min(left, right), Math.Min(top, bottom));
        if (min == left) return "left";
        if (min == right) return "right";
        if (min == top) return "top";
        return "bottom";
    }

    private PointInt32 TargetPosPx(PointInt32 anchor) =>
        TargetPosPxForSize(anchor, _appWindow.Size.Width, _appWindow.Size.Height);

    private PointInt32 TargetPosPxForSize(PointInt32 anchor, int width, int height)
    {
        var wa = WorkAreaPx(anchor);
        var edge = ResolveEdge(anchor, wa);
        _lastEffectiveEdge = edge;

        var edgeMargin = (int)Math.Round(EdgeMarginDip * _scale);
        var contentWidth = width;
        var contentHeight = height;

        int x, y;
        if (edge is "left" or "right")
        {
            y = anchor.Y - contentHeight / 2;
            y = Math.Max(wa.Y + edgeMargin, Math.Min(y, wa.Y + wa.Height - contentHeight - edgeMargin));
            x = edge == "left" ? wa.X + edgeMargin : wa.X + wa.Width - contentWidth - edgeMargin;
        }
        else
        {
            x = anchor.X - contentWidth / 2;
            x = Math.Max(wa.X + edgeMargin, Math.Min(x, wa.X + wa.Width - contentWidth - edgeMargin));
            y = edge == "top" ? wa.Y + edgeMargin : wa.Y + wa.Height - contentHeight - edgeMargin;
        }

        return new PointInt32(x, y);
    }

    private PointInt32 HiddenPosPx(PointInt32 target)
    {
        var contentWidth = _appWindow.Size.Width;
        var contentHeight = _appWindow.Size.Height;
        var offset = (int)Math.Round(30 * _scale);
        return _lastEffectiveEdge switch
        {
            "left" => new PointInt32(target.X - contentWidth - offset, target.Y),
            "right" => new PointInt32(target.X + contentWidth + offset, target.Y),
            "top" => new PointInt32(target.X, target.Y - contentHeight - offset),
            _ => new PointInt32(target.X, target.Y + contentHeight + offset), // "bottom"
        };
    }

    // --- show/hide with slide --------------------------------------------------

    public void ShowNearPoint(int x, int y) => SlideIn(new PointInt32(x, y));

    /// <summary>Used when a second .exe launch wakes the already-running
    /// instance: if the panel is hidden, slide it in like a normal open;
    /// if it's already open, just re-foreground it instead of re-running
    /// the slide-in animation from the hidden position.</summary>
    public void ShowOrForegroundNearPoint(int x, int y)
    {
        if (IsPanelVisible)
        {
            WindowEffects.ApplyTopmostBelowTaskbar(_hwnd);
            this.Activate();
            NativeMethods.SetForegroundWindow(_hwnd);
        }
        else
        {
            SlideIn(new PointInt32(x, y));
        }
    }

    public void SlideIn(PointInt32 anchor)
    {
        _lastAnchor = anchor;
        UpdateWindowHeight();

        var target = TargetPosPx(anchor);
        var hidden = HiddenPosPx(target);

        PrepareContentEntrance();

        _appWindow.Move(hidden);
        _appWindow.Show();
        WindowEffects.ApplyTopmostBelowTaskbar(_hwnd);
        this.Activate();

        NativeMethods.SetForegroundWindow(_hwnd);

        SearchBox.Focus(FocusState.Programmatic);

        AnimateTo(target, isOpening: true, onNearComplete: TriggerContentAnimation);
        IsPanelVisible = true;
    }

    public void HidePanel() => SlideOut();

    public void SlideOut()
    {
        // Reset the search on close, same as Windows 11's own flyouts do.
        SearchBox.Text = string.Empty;

        // Flush any pending debounced edit immediately -- the panel is
        // about to disappear, so there's no "later" to save on.
        if (_saveDebounceTimer?.IsEnabled == true)
        {
            _saveDebounceTimer.Stop();
            SaveNotes();
        }

        StopContentStoryboard();
        var current = new PointInt32(_appWindow.Position.X, _appWindow.Position.Y);
        var hidden = HiddenPosPx(current);
        AnimateTo(hidden, isOpening: false, onFinished: () => _appWindow.Hide());
        IsPanelVisible = false;
        _lastCloseTimeUtc = DateTime.UtcNow;
    }

    public void Toggle(PointInt32 anchor)
    {
        if (!IsPanelVisible && (DateTime.UtcNow - _lastCloseTimeUtc).TotalSeconds < ReopenDebounceSeconds)
            return;

        if (IsPanelVisible) SlideOut();
        else SlideIn(anchor);
    }

    private void PrepareContentEntrance()
    {
        StopContentStoryboard();

        var offset = ContentSlideOffsetDip * _scale;
        double x = 0, y = 0;
        switch (_lastEffectiveEdge)
        {
            case "left": x = -offset; break;
            case "right": x = offset; break;
            case "top": y = -offset; break;
            default: y = offset; break; // "bottom"
        }

        _contentTransform.X = x;
        _contentTransform.Y = y;
        Container.Opacity = 0;
    }

    private void TriggerContentAnimation()
    {
        var axis = _lastEffectiveEdge is "left" or "right" ? "X" : "Y";
        var from = axis == "X" ? _contentTransform.X : _contentTransform.Y;

        var sb = new Storyboard();

        var slideAnim = new DoubleAnimation
        {
            From = from,
            To = 0,
            Duration = new Duration(TimeSpan.FromMilliseconds(ContentSlideDurationMs)),
            EasingFunction = new CircleEase { EasingMode = EasingMode.EaseOut }
        };
        Storyboard.SetTarget(slideAnim, _contentTransform);
        Storyboard.SetTargetProperty(slideAnim, axis);

        var fadeAnim = new DoubleAnimation
        {
            From = 0,
            To = 1,
            Duration = new Duration(TimeSpan.FromMilliseconds(ContentFadeDurationMs))
        };
        Storyboard.SetTarget(fadeAnim, Container);
        Storyboard.SetTargetProperty(fadeAnim, "Opacity");

        sb.Children.Add(slideAnim);
        sb.Children.Add(fadeAnim);
        _contentStoryboard = sb;
        sb.Begin();
    }

    private void StopContentStoryboard()
    {
        if (_contentStoryboard != null)
        {
            try { _contentStoryboard.Stop(); } catch { /* best effort */ }
            _contentStoryboard = null;
        }
        Container.Opacity = 1;
        _contentTransform.X = 0;
        _contentTransform.Y = 0;
    }

    private void AnimateTo(PointInt32 target, bool isOpening, Action? onFinished = null, Action? onNearComplete = null)
    {
        _animCts?.Cancel();
        _animCts = new CancellationTokenSource();

        _resizeAnimCts?.Cancel();
        _slideInProgress = true;

        var start = _appWindow.Position;
        var easing = isOpening
            ? (Func<double, double>)WindowAnimator.ExponentialEaseOut
            : WindowAnimator.CircularEaseIn;

        WindowAnimator.Slide(
            _hwnd, start, target, SlideDurationMs, easing, DispatcherQueue,
            nearCompleteFraction: isOpening ? 0.1 : 0.0,
            onNearComplete: onNearComplete,
            onComplete: () =>
            {
                _slideInProgress = false;
                onFinished?.Invoke();
            },
            cancellationToken: _animCts.Token);
    }

    private void OnSearchTextChanged(object sender, TextChangedEventArgs e) => ApplyFilter();

    private void OnFilterFlyoutOpening(object sender, object e)
    {
        SetFilterChecked(FilterAllItem, _contentFilter == ContentFilterMode.All);
        SetFilterChecked(FilterPinnedItem, _contentFilter == ContentFilterMode.Pinned);
    }

    private static void SetFilterChecked(MenuFlyoutItem item, bool isChecked) =>
        item.Icon = isChecked ? new FontIcon { Glyph = "\uE73E", FontSize = 12 } : null;

    private void OnFilterModeClicked(object sender, RoutedEventArgs e)
    {
        if (sender is not MenuFlyoutItem { Tag: string tag }) return;

        _contentFilter = tag switch
        {
            "Pinned" => ContentFilterMode.Pinned,
            _ => ContentFilterMode.All
        };

        if (_contentFilter == ContentFilterMode.All)
            FilterGlyph.ClearValue(FontIcon.ForegroundProperty);
        else if (Application.Current.Resources.TryGetValue("AccentTextFillColorPrimaryBrush", out var accentBrush))
            FilterGlyph.Foreground = (Microsoft.UI.Xaml.Media.Brush)accentBrush;

        ApplyFilter();
    }

    /// <summary>Recomputes PinnedItems and UnpinnedItems from Items + the
    /// search box's current text + FilterButton's current restriction.
    /// Matches are split by IsPinned and each half is synced into its own
    /// collection (see SyncCollection) -- diffing against each collection's
    /// existing contents rather than clearing and rebuilding, so neither
    /// ListView flickers, drops scroll position, or -- crucially for an
    /// editable list -- steals focus out of whichever note the user is
    /// actively typing into, and a pin/unpin toggle reads as the row
    /// cleanly leaving one list and landing in the other instead of both
    /// lists doing a full refresh.</summary>
    private void ApplyFilter()
    {
        var query = SearchBox.Text?.Trim() ?? string.Empty;

        IEnumerable<NoteItem> matches = Items;

        if (_contentFilter == ContentFilterMode.Pinned)
            matches = matches.Where(item => item.IsPinned);

        if (query.Length > 0)
        {
            matches = matches.Where(item =>
                item.Text != null && item.Text.Contains(query, StringComparison.OrdinalIgnoreCase));
        }

        var matchList = matches.ToList();

        // Items already keeps pinned notes contiguous at the top (see
        // IsPinned/TogglePin/AddNoteAndFocus), so both halves come out of
        // this split still in their existing relative order.
        var pinnedTarget = matchList.Where(item => item.IsPinned).ToList();
        var unpinnedTarget = matchList.Where(item => !item.IsPinned).ToList();

        SyncCollection(PinnedItems, pinnedTarget);
        SyncCollection(UnpinnedItems, unpinnedTarget);
    }

    /// <summary>Diffs collection against target -- moving/inserting/
    /// removing individual entries -- instead of clearing and rebuilding it
    /// outright, so the ListView bound to it doesn't flicker, lose scroll
    /// position, or steal focus out from under an actively-edited note, and
    /// only the entries that actually changed play an add/remove/move
    /// animation. Shared by both PinnedItems and UnpinnedItems in
    /// ApplyFilter above.</summary>
    private static void SyncCollection(ObservableCollection<NoteItem> collection, List<NoteItem> target)
    {
        for (var i = collection.Count - 1; i >= 0; i--)
        {
            if (!target.Contains(collection[i]))
                collection.RemoveAt(i);
        }

        for (var i = 0; i < target.Count; i++)
        {
            if (i < collection.Count && collection[i] == target[i])
                continue;

            var existingIndex = collection.IndexOf(target[i]);
            if (existingIndex >= 0)
                collection.Move(existingIndex, i);
            else
                collection.Insert(i, target[i]);
        }
    }

    private async void OnClearAllClicked(object sender, RoutedEventArgs e)
    {
        // Deleting every note is a lot more destructive than clearing a
        // transient clipboard history -- always confirm, not just when
        // pinned items are involved.
        var unpinnedCount = Items.Count(i => !i.IsPinned);
        if (unpinnedCount == 0) return;

        var dialog = new ContentDialog
        {
            Title = "Delete all notes?",
            Content = unpinnedCount == Items.Count
                ? $"This will permanently delete all {unpinnedCount} notes."
                : $"This will permanently delete {unpinnedCount} unpinned notes. Pinned notes are kept.",
            PrimaryButtonText = "Delete",
            CloseButtonText = "Cancel",
            DefaultButton = ContentDialogButton.Close,
            XamlRoot = Content.XamlRoot,
        };

        var result = await dialog.ShowAsync();
        if (result != ContentDialogResult.Primary) return;

        for (var i = Items.Count - 1; i >= 0; i--)
        {
            if (!Items[i].IsPinned)
                Items.RemoveAt(i);
        }
        SaveNotes();
    }

    private void OnPinPanelClicked(object sender, RoutedEventArgs e)
    {
        IsPanelPinned = !IsPanelPinned;
        PinPanelButton.Content = IsPanelPinned ? "\uE77A" : "\uE718";
        ToolTipService.SetToolTip(PinPanelButton, IsPanelPinned ? "Unpin panel" : "Keep panel open");

        if (IsPanelPinned)
            WindowEffects.ApplyTopmostBelowTaskbar(_hwnd);
    }

    private void OnPinItemClicked(object sender, RoutedEventArgs e)
    {
        if (sender is FrameworkElement { Tag: NoteItem item })
        {
            TogglePin(item);
        }
    }

    /// <summary>Flips IsPinned and moves the note to preserve the list's
    /// invariant that every pinned note sits contiguously above every
    /// unpinned one: a newly pinned note jumps straight to index 0 (the
    /// very top, above any other already-pinned notes); an unpinned note
    /// drops back into the unpinned section in its existing relative order
    /// rather than always landing at the very top of that section.</summary>
    private void TogglePin(NoteItem item)
    {
        var currentIndex = Items.IndexOf(item);
        if (currentIndex < 0) return;

        item.IsPinned = !item.IsPinned;

        var targetIndex = item.IsPinned
            ? 0
            : Items.TakeWhile(i => i.IsPinned).Count();

        if (targetIndex != currentIndex)
            Items.Move(currentIndex, targetIndex);

        // Move already triggers ApplyFilter via the CollectionChanged
        // subscription in the constructor, but only when it actually
        // fires -- pinning a note that's already at index 0 skips the Move
        // entirely, which would otherwise leave PinnedItems/UnpinnedItems
        // stale while filtered to Pinned.
        ApplyFilter();
        SaveNotes();
    }

    /// <summary>Fires once PinnedList's built-in CanReorderItems/AllowDrop
    /// drag settles -- args.DropResult is Move for a completed reorder, or
    /// None/Copy for a canceled drag (e.g. dropped outside the list), which
    /// is why this bails out early rather than persisting a no-op order. By
    /// this point the ListView has already run the Move directly against
    /// PinnedItems (it's an IList), so PinnedItems itself needs no further
    /// work here -- only Items, the source of truth ApplyFilter rebuilds
    /// PinnedItems/UnpinnedItems from on every future change, which would
    /// otherwise snap PinnedItems right back to its old order next time
    /// ApplyFilter runs. Re-derives Items' full order as the new pinned
    /// order (still contiguous at the top, the same invariant TogglePin
    /// maintains) followed by the unpinned notes in their existing order,
    /// and diffs Items onto that with the same SyncCollection helper
    /// ApplyFilter itself uses.</summary>
    private void OnPinnedListDragItemsCompleted(ListViewBase sender, DragItemsCompletedEventArgs args)
    {
        if (args.DropResult != DataPackageOperation.Move) return;

        var target = PinnedItems.Concat(Items.Where(i => !i.IsPinned)).ToList();
        SyncCollection(Items, target);
        SaveNotes();
    }

    private async void OnRemoveItemClicked(object sender, RoutedEventArgs e)
    {
        if (sender is not FrameworkElement { Tag: NoteItem item }) return;

        // Only prompt for a note that actually has content, or is pinned --
        // deleting a blank, never-pinned note (e.g. right after clicking
        // "+" by mistake) shouldn't need a confirmation dialog.
        if (item.IsPinned || !item.IsEmpty)
        {
            var dialog = new ContentDialog
            {
                Title = item.IsPinned ? "Delete pinned note?" : "Delete note?",
                Content = item.IsPinned
                    ? "This note is pinned. Are you sure you want to delete it?"
                    : "This will permanently delete this note.",
                PrimaryButtonText = "Delete",
                CloseButtonText = "Cancel",
                DefaultButton = ContentDialogButton.Close,
                XamlRoot = Content.XamlRoot,
            };

            var result = await dialog.ShowAsync();
            if (result != ContentDialogResult.Primary)
                return; // user cancelled -- leave the note in place
        }

        Items.Remove(item);
        SaveNotes();
    }

    private void OnItemPointerEntered(object sender, Microsoft.UI.Xaml.Input.PointerRoutedEventArgs e)
    {
        if (sender is Grid grid)
        {
            if (grid.FindName("EditButton") is Button editButton)
            {
                editButton.Opacity = 1;
                editButton.IsHitTestVisible = true;
            }

            if (grid.FindName("PopOutButton") is Button popOutButton)
            {
                popOutButton.Opacity = 1;
                popOutButton.IsHitTestVisible = true;
            }

            if (grid.FindName("CopyButton") is Button copyButton)
            {
                copyButton.Opacity = 1;
                copyButton.IsHitTestVisible = true;
            }

            if (grid.FindName("RemoveButton") is Button removeButton)
            {
                removeButton.Opacity = 1;
                removeButton.IsHitTestVisible = true;
            }

            if (grid.FindName("PinButton") is Button pinButton)
            {
                pinButton.Opacity = 1;
                pinButton.IsHitTestVisible = true;
            }

            if (grid.FindName("RowHighlight") is Border highlight)
                highlight.Opacity = 1;
        }
    }

    private void OnItemPointerExited(object sender, Microsoft.UI.Xaml.Input.PointerRoutedEventArgs e)
    {
        if (sender is Grid { Tag: NoteItem item } grid)
        {
            if (grid.FindName("EditButton") is Button editButton)
            {
                editButton.Opacity = 0;
                editButton.IsHitTestVisible = false;
            }

            if (grid.FindName("PopOutButton") is Button popOutButton)
            {
                popOutButton.Opacity = 0;
                popOutButton.IsHitTestVisible = false;
            }

            if (grid.FindName("CopyButton") is Button copyButton)
            {
                copyButton.Opacity = 0;
                copyButton.IsHitTestVisible = false;
            }

            if (grid.FindName("RemoveButton") is Button removeButton)
            {
                removeButton.Opacity = 0;
                removeButton.IsHitTestVisible = false;
            }

            if (grid.FindName("PinButton") is Button pinButton)
            {
                pinButton.Opacity = item.IsPinned ? 1 : 0;
                pinButton.IsHitTestVisible = item.IsPinned;
            }

            if (grid.FindName("RowHighlight") is Border highlight)
                highlight.Opacity = 0;
        }
    }

    private void OnHistoryListLoaded(object sender, RoutedEventArgs e)
    {
        if (_historyScrollBar != null) return; // already wired up

        var scrollViewer = FindDescendant<ScrollViewer>(HistoryList);
        if (scrollViewer != null)
        {
            _historyScrollViewer = scrollViewer;
            scrollViewer.ViewChanged += (_, _) =>
            {
                ShowScrollBar();
                UpdateScrollToTopButtonVisibility();
            };
        }

        _historyScrollBar = FindDescendant<ScrollBar>(HistoryList,
            sb => sb.Orientation == Orientation.Vertical);
        if (_historyScrollBar == null) return;

        _historyScrollBar.PointerEntered += (_, _) => ShowScrollBar();
        _historyScrollBar.PointerExited += (_, _) => ScheduleScrollBarHide();

        _scrollBarHideTimer = new DispatcherTimer { Interval = ScrollBarHideDelay };
        _scrollBarHideTimer.Tick += (_, _) =>
        {
            _scrollBarHideTimer!.Stop();
            FadeScrollBarTo(0, 400);
        };

        ScheduleScrollBarHide();
    }

    private void ShowScrollBar()
    {
        FadeScrollBarTo(1, 150);
        ScheduleScrollBarHide();
    }

    private void ScheduleScrollBarHide()
    {
        if (_scrollBarHideTimer == null) return;
        _scrollBarHideTimer.Stop();
        _scrollBarHideTimer.Start();
    }

    private void FadeScrollBarTo(double target, int durationMs)
    {
        if (_historyScrollBar == null) return;
        if (_historyScrollBar.Opacity == target) return;

        _scrollBarFadeStoryboard?.Stop();

        var animation = new DoubleAnimation
        {
            To = target,
            Duration = TimeSpan.FromMilliseconds(durationMs),
            EasingFunction = new QuadraticEase { EasingMode = EasingMode.EaseOut }
        };
        Storyboard.SetTarget(animation, _historyScrollBar);
        Storyboard.SetTargetProperty(animation, "Opacity");

        _scrollBarFadeStoryboard = new Storyboard();
        _scrollBarFadeStoryboard.Children.Add(animation);
        _scrollBarFadeStoryboard.Begin();
    }

    private void UpdateScrollToTopButtonVisibility()
    {
        if (_historyScrollViewer == null) return;
        var shouldShow = _historyScrollViewer.VerticalOffset > ScrollToTopThreshold;
        FadeScrollToTopButtonTo(shouldShow ? 1 : 0, 150);
    }

    private void FadeScrollToTopButtonTo(double target, int durationMs)
    {
        if (ScrollToTopButton.Opacity == target) return;

        ScrollToTopButton.IsHitTestVisible = target > 0;

        _scrollToTopFadeStoryboard?.Stop();

        var animation = new DoubleAnimation
        {
            To = target,
            Duration = TimeSpan.FromMilliseconds(durationMs),
            EasingFunction = new QuadraticEase { EasingMode = EasingMode.EaseOut }
        };
        Storyboard.SetTarget(animation, ScrollToTopButton);
        Storyboard.SetTargetProperty(animation, "Opacity");

        _scrollToTopFadeStoryboard = new Storyboard();
        _scrollToTopFadeStoryboard.Children.Add(animation);
        _scrollToTopFadeStoryboard.Begin();
    }

    private void OnScrollToTopClicked(object sender, RoutedEventArgs e) =>
        _historyScrollViewer?.ChangeView(null, 0, null);

    private static T? FindDescendant<T>(DependencyObject root, Func<T, bool>? predicate = null)
        where T : DependencyObject
    {
        var count = VisualTreeHelper.GetChildrenCount(root);
        for (var i = 0; i < count; i++)
        {
            var child = VisualTreeHelper.GetChild(root, i);
            if (child is T match && (predicate == null || predicate(match)))
                return match;

            var nested = FindDescendant(child, predicate);
            if (nested != null)
                return nested;
        }

        return null;
    }
}