MainWindow.xaml.cs

using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Threading;
using ClipStack.Models;
using ClipStack.Services;

namespace ClipStack;

public partial class MainWindow : Window
{
    private readonly ObservableCollection<PhraseItem> _phrases = [];
    private readonly PhraseStore _store = new();
    private readonly DispatcherTimer _statusTimer;
    private readonly PhraseReorderController _reorderController;
    private ICollectionView? _phrasesView;

    public MainWindow()
    {
        InitializeComponent();
        SourceInitialized += (_, _) => WindowTheme.UseDarkTitleBar(this);

        _phrasesView = CollectionViewSource.GetDefaultView(_phrases);
        _phrasesView.Filter = PhraseMatchesSearch;
        PhraseList.ItemsSource = _phrasesView;
        _reorderController = new PhraseReorderController(
            _phrases,
            PhraseList,
            DragPreviewLayer,
            DragPreviewCard,
            (Brush)FindResource("AccentBrush"));
        _statusTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(2.5) };
        _statusTimer.Tick += (_, _) =>
        {
            _statusTimer.Stop();
            StatusText.Text = string.Empty;
        };

        LoadPhrases();
        UpdateInterface();
    }

    private void LoadPhrases()
    {
        try
        {
            foreach (var phrase in _store.Load())
            {
                _phrases.Add(phrase);
            }

            NormalizeManualOrder();
        }
        catch (Exception exception)
        {
            MessageBox.Show(
                this,
                $"ClipStack could not load your saved phrases. The data file was left untouched.\n\n{exception.Message}",
                "ClipStack",
                MessageBoxButton.OK,
                MessageBoxImage.Error);
        }
    }

    private void AddPhrase_Click(object sender, RoutedEventArgs e)
    {
        var dialog = new PhraseDialog("Add a phrase") { Owner = this };
        if (dialog.ShowDialog() != true)
        {
            return;
        }

        _phrases.Add(new PhraseItem
        {
            Title = dialog.PhraseTitle,
            Text = dialog.PhraseText,
            ManualOrder = _phrases.Count
        });

        NormalizeManualOrder();
        SavePhrases();
        UpdateInterface();
        ShowStatus("Phrase added");
    }

    private void PhraseCopy_Click(object sender, RoutedEventArgs e)
    {
        if ((sender as Button)?.Tag is not PhraseItem phrase)
        {
            return;
        }

        try
        {
            Clipboard.SetText(phrase.Text);
            if (phrase.UsageCount < int.MaxValue)
            {
                phrase.UsageCount++;
            }

            SavePhrases();
            ShowStatus("Copied to clipboard");
        }
        catch (Exception exception)
        {
            ShowStatus($"Could not copy: {exception.Message}", isError: true);
        }
    }

    private void EditPhrase_Click(object sender, RoutedEventArgs e)
    {
        if ((sender as Button)?.Tag is not PhraseItem phrase)
        {
            return;
        }

        var dialog = new PhraseDialog("Edit phrase", phrase.Title, phrase.Text) { Owner = this };
        if (dialog.ShowDialog() != true)
        {
            return;
        }

        phrase.Title = dialog.PhraseTitle;
        phrase.Text = dialog.PhraseText;
        _phrasesView?.Refresh();
        SavePhrases();
        UpdateInterface();
        ShowStatus("Phrase updated");
    }

    private void DeletePhrase_Click(object sender, RoutedEventArgs e)
    {
        if ((sender as Button)?.Tag is not PhraseItem phrase)
        {
            return;
        }

        var result = MessageBox.Show(
            this,
            "Delete this phrase? This cannot be undone.",
            "Delete phrase",
            MessageBoxButton.YesNo,
            MessageBoxImage.Warning,
            MessageBoxResult.No);

        if (result != MessageBoxResult.Yes)
        {
            return;
        }

        _phrases.Remove(phrase);
        NormalizeManualOrder();
        SavePhrases();
        UpdateInterface();
        ShowStatus("Phrase deleted");
    }

    private void PinPhrase_Click(object sender, RoutedEventArgs e)
    {
        if ((sender as Button)?.Tag is not PhraseItem phrase)
        {
            return;
        }

        phrase.IsPinned = !phrase.IsPinned;
        ApplySequence(_phrases
            .OrderByDescending(item => item.IsPinned)
            .ThenBy(item => item.ManualOrder)
            .ToList());
        SavePhrases();
        ShowStatus(phrase.IsPinned ? "Phrase pinned to the top" : "Phrase unpinned");
    }

    private void OrderByUsage_Click(object sender, RoutedEventArgs e)
    {
        if (_phrases.Count < 2)
        {
            ShowStatus(_phrases.Count == 0 ? "Add phrases before ordering" : "Only one phrase to order");
            return;
        }

        ApplySequence(_phrases
            .OrderByDescending(item => item.IsPinned)
            .ThenByDescending(item => item.UsageCount)
            .ThenBy(item => item.ManualOrder)
            .ToList());
        SavePhrases();
        ShowStatus("Ordered by usage");
    }

    private void ResetCounts_Click(object sender, RoutedEventArgs e)
    {
        if (_phrases.Count == 0)
        {
            ShowStatus("There are no copy counts to reset");
            return;
        }

        var result = MessageBox.Show(
            this,
            "Reset the copy count for every phrase? Your phrases and their order will stay the same.",
            "Reset copy counts",
            MessageBoxButton.YesNo,
            MessageBoxImage.Question,
            MessageBoxResult.No);

        if (result != MessageBoxResult.Yes)
        {
            return;
        }

        foreach (var phrase in _phrases)
        {
            phrase.UsageCount = 0;
        }

        SavePhrases();
        ShowStatus("Copy counts reset");
    }

    private void TopmostButton_Click(object sender, RoutedEventArgs e)
    {
        Topmost = !Topmost;

        TopmostButton.Background = Topmost
            ? (Brush)FindResource("AccentSoftBrush")
            : Brushes.Transparent;
        TopmostButton.BorderBrush = Topmost
            ? (Brush)FindResource("AccentBrush")
            : Brushes.Transparent;
        TopmostIcon.Foreground = (Brush)FindResource(Topmost ? "AccentBrush" : "MutedTextBrush");
        TopmostButton.ToolTip = Topmost
            ? "Stop keeping ClipStack always on top"
            : "Keep ClipStack always on top";

        ShowStatus(Topmost ? "Always on top enabled" : "Always on top disabled");
    }

    private void DragHandle_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
    {
        _reorderController.ArmDrag(sender, e);
    }

    private void DragHandle_PreviewMouseMove(object sender, MouseEventArgs e)
    {
        _reorderController.TryStartDrag(sender, e);
    }

    private void PhraseList_DragOver(object sender, DragEventArgs e)
    {
        _reorderController.HandleDragOver(e);
    }

    private void PhraseList_DragLeave(object sender, DragEventArgs e)
    {
        _reorderController.HandleDragLeave(e);
    }

    private void PhraseList_Drop(object sender, DragEventArgs e)
    {
        if (!_reorderController.TryPrepareDrop(e, out var sourceIndex, out var destinationIndex))
        {
            return;
        }

        _phrases.Move(sourceIndex, destinationIndex);
        NormalizeManualOrder();
        SavePhrases();
        ShowStatus("Order updated");
    }

    private void ApplySequence(IReadOnlyList<PhraseItem> orderedPhrases)
    {
        _phrases.Clear();
        foreach (var phrase in orderedPhrases)
        {
            _phrases.Add(phrase);
        }

        NormalizeManualOrder();
    }

    private void NormalizeManualOrder()
    {
        for (var index = 0; index < _phrases.Count; index++)
        {
            _phrases[index].ManualOrder = index;
        }
    }

    private void SavePhrases()
    {
        try
        {
            _store.Save(_phrases);
        }
        catch (Exception exception)
        {
            MessageBox.Show(
                this,
                $"ClipStack could not save your changes.\n\n{exception.Message}",
                "ClipStack",
                MessageBoxButton.OK,
                MessageBoxImage.Error);
        }
    }

    private void UpdateInterface()
    {
        var hasPhrases = _phrases.Count > 0;
        var hasSearch = !string.IsNullOrWhiteSpace(SearchTextBox.Text);
        var visiblePhraseCount = _phrasesView?.Cast<PhraseItem>().Count() ?? _phrases.Count;

        EmptyState.Visibility = hasPhrases ? Visibility.Collapsed : Visibility.Visible;
        NoSearchResultsState.Visibility = hasPhrases && hasSearch && visiblePhraseCount == 0
            ? Visibility.Visible
            : Visibility.Collapsed;
        OrderByUsageButton.IsEnabled = _phrases.Count > 1;
        ResetCountsButton.IsEnabled = hasPhrases;
        PhraseList.AllowDrop = !hasSearch;
        DragHintText.Visibility = _phrases.Count > 1 && !hasSearch
            ? Visibility.Visible
            : Visibility.Collapsed;
        PhraseCountText.Text = hasSearch
            ? $"{visiblePhraseCount:N0} of {_phrases.Count:N0} phrases"
            : _phrases.Count switch
        {
            0 => "No phrases yet",
            1 => "1 phrase",
            _ => $"{_phrases.Count:N0} phrases"
        };
    }

    private bool PhraseMatchesSearch(object item)
    {
        if (item is not PhraseItem phrase)
        {
            return false;
        }

        var searchText = SearchTextBox.Text.Trim();
        return searchText.Length == 0 ||
               phrase.Title.Contains(searchText, StringComparison.CurrentCultureIgnoreCase) ||
               phrase.Text.Contains(searchText, StringComparison.CurrentCultureIgnoreCase);
    }

    private void SearchTextBox_TextChanged(object sender, TextChangedEventArgs e)
    {
        SearchPlaceholderText.Visibility = string.IsNullOrEmpty(SearchTextBox.Text)
            ? Visibility.Visible
            : Visibility.Collapsed;
        _phrasesView?.Refresh();
        UpdateInterface();
    }

    private void ShowStatus(string message, bool isError = false)
    {
        StatusText.Text = message;
        StatusText.Foreground = (Brush)FindResource(isError ? "DangerBrush" : "SuccessBrush");
        _statusTimer.Stop();
        _statusTimer.Start();
    }

    private void Window_KeyDown(object sender, KeyEventArgs e)
    {
        if (e.Key == Key.F && Keyboard.Modifiers == ModifierKeys.Control)
        {
            e.Handled = true;
            SearchTextBox.Focus();
            SearchTextBox.SelectAll();
            return;
        }

        if (e.Key == Key.Escape && !string.IsNullOrEmpty(SearchTextBox.Text))
        {
            e.Handled = true;
            SearchTextBox.Clear();
            return;
        }

        if (e.Key == Key.N && Keyboard.Modifiers == ModifierKeys.Control)
        {
            e.Handled = true;
            AddPhrase_Click(this, new RoutedEventArgs());
        }
    }

}