MainWindow.xaml.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text.RegularExpressions;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using AlwaysOnTop.Models;
using AlwaysOnTop.Services;

namespace AlwaysOnTop
{
    public partial class MainWindow : Window
    {
        private readonly WindowEnumerator _enumerator;
        private readonly WindowManager _windowManager;
        private readonly ObservableCollection<WindowInfo> _windows;

        public MainWindow()
        {
            InitializeComponent();

            _enumerator = new WindowEnumerator();
            _windowManager = new WindowManager();
            _windows = new ObservableCollection<WindowInfo>();

            WindowListView.ItemsSource = _windows;

            // Start monitoring
            _windowManager.StartMonitoring();

            // Load windows on startup
            LoadWindows();
        }

        private void LoadWindows()
        {
            try
            {
                var windows = _enumerator.GetAllWindows();
                
                _windows.Clear();
                foreach (var window in windows.OrderBy(w => w.DisplayName))
                {
                    _windows.Add(window);
                }

                UpdateCounts();
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error loading windows: {ex.Message}", 
                    "Error", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        private void UpdateCounts()
        {
            WindowCountText.Text = _windows.Count.ToString();
            SelectedCountText.Text = _windows.Count(w => w.IsSelected).ToString();
        }

        private void RefreshButton_Click(object sender, RoutedEventArgs e)
        {
            LoadWindows();
        }

        private void WindowListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            // Optional: handle selection changes if needed
        }

        private void WindowCheckBox_Changed(object sender, RoutedEventArgs e)
        {
            UpdateCounts();
        }

        private void PriorityTextBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
        {
            // Only allow numbers
            Regex regex = new Regex("[^0-9]+");
            e.Handled = regex.IsMatch(e.Text);
        }

        private void ApplyButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                var selectedWindows = _windows.Where(w => w.IsSelected).ToList();

                if (selectedWindows.Count == 0)
                {
                    MessageBox.Show("Please select at least one window.", 
                        "No Selection", MessageBoxButton.OK, MessageBoxImage.Information);
                    return;
                }

                // Validate priorities
                var invalidPriorities = selectedWindows.Where(w => w.Priority <= 0).ToList();
                if (invalidPriorities.Any())
                {
                    MessageBox.Show("Please assign a priority number (1 or higher) to all selected windows.", 
                        "Invalid Priority", MessageBoxButton.OK, MessageBoxImage.Warning);
                    return;
                }

                // Check for duplicate priorities
                var duplicates = selectedWindows.GroupBy(w => w.Priority)
                    .Where(g => g.Count() > 1)
                    .ToList();

                if (duplicates.Any())
                {
                    var result = MessageBox.Show(
                        "Some windows have the same priority. Windows with the same priority may not stack predictably.\n\n" +
                        "Do you want to continue anyway?",
                        "Duplicate Priorities", 
                        MessageBoxButton.YesNo, 
                        MessageBoxImage.Question);

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

                // Apply always-on-top to selected windows
                int successCount = 0;
                foreach (var window in selectedWindows)
                {
                    if (_windowManager.AddManagedWindow(window, window.Priority))
                    {
                        successCount++;
                    }
                }

                // Enforce the Z-order based on priorities
                _windowManager.EnforceZOrder();

                MessageBox.Show(
                    $"Successfully applied Always On Top to {successCount} window(s).\n\n" +
                    "The windows will maintain their priority order automatically.",
                    "Success", 
                    MessageBoxButton.OK, 
                    MessageBoxImage.Information);

                // Refresh the list to show updated status
                RefreshWindowStatus();
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error applying Always On Top: {ex.Message}", 
                    "Error", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        private void RemoveButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                var selectedWindows = _windows.Where(w => w.IsSelected).ToList();

                if (selectedWindows.Count == 0)
                {
                    MessageBox.Show("Please select at least one window to remove.", 
                        "No Selection", MessageBoxButton.OK, MessageBoxImage.Information);
                    return;
                }

                int successCount = 0;
                foreach (var window in selectedWindows)
                {
                    if (_windowManager.RemoveManagedWindow(window))
                    {
                        window.IsSelected = false;
                        successCount++;
                    }
                }

                MessageBox.Show($"Removed Always On Top from {successCount} window(s).", 
                    "Success", MessageBoxButton.OK, MessageBoxImage.Information);

                RefreshWindowStatus();
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error removing Always On Top: {ex.Message}", 
                    "Error", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        private void ClearAllButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                var result = MessageBox.Show(
                    "This will remove Always On Top from all managed windows.\n\nContinue?",
                    "Confirm Clear All", 
                    MessageBoxButton.YesNo, 
                    MessageBoxImage.Question);

                if (result != MessageBoxResult.Yes)
                    return;

                _windowManager.ClearAll();

                foreach (var window in _windows)
                {
                    window.IsSelected = false;
                    window.Priority = 0;
                }

                MessageBox.Show("All windows have been cleared.", 
                    "Success", MessageBoxButton.OK, MessageBoxImage.Information);

                RefreshWindowStatus();
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error clearing windows: {ex.Message}", 
                    "Error", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        private void RefreshWindowStatus()
        {
            foreach (var window in _windows)
            {
                _enumerator.UpdateWindowInfo(window);
            }
        }

        protected override void OnClosed(EventArgs e)
        {
            base.OnClosed(e);
            
            // Clean up
            _windowManager.StopMonitoring();
            _windowManager.Dispose();
        }
    }
}