MainWindow.xaml.cs

using System;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;
using Microsoft.Win32;
using SonicBoard.Helpers;
using SonicBoard.Models;
using SonicBoard.Services;

namespace SonicBoard
{
    public partial class MainWindow : Window
    {
        private readonly AudioEngine _audioEngine = new();
        private readonly HotkeyManager _hotkeyManager = new();
        private readonly ProfileManager _profileManager = new();
        private readonly string[] _defaultCategories = { "General", "Music", "Game Calls", "Voice Lines", "Memes", "SFX" };
        private AppSettings _settings = new();
        private SoundProfile _currentProfile = new();
        private ObservableCollection<SoundItem> _allSounds = new();
        private bool _isListView = true;
        private Key _capturedKey;
        private ModifierKeys _capturedModifiers;
        private string _selectedCategoryFilter = "All Categories";
        private bool _isUpdatingCategoryUi;

        public MainWindow()
        {
            InitializeComponent();
        }

        // ═══════════════════════════════════════════════════════
        //  WINDOW LIFECYCLE
        // ═══════════════════════════════════════════════════════

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            _hotkeyManager.Initialize(this);
            _settings = _profileManager.LoadSettings();

            // Check if running as Admin and update UI
            bool isAdmin = IsRunningAsAdmin();
            borderAdminWarning.Visibility = isAdmin ? Visibility.Collapsed : Visibility.Visible;
            lblAdminStatus.Visibility = isAdmin ? Visibility.Visible : Visibility.Collapsed;

            // Apply saved settings
            sliderLocalVolume.Value = _settings.LocalVolume * 100;
            sliderMicVolume.Value = _settings.VirtualMicVolume * 100;
            chkOverlap.IsChecked = _settings.AllowOverlap;
            chkAutoMuteMic.IsChecked = _settings.AutoMuteMic;
            chkSuppressHotkeys.IsChecked = _settings.SuppressHotkeys;
            _audioEngine.AutoMuteMic = _settings.AutoMuteMic;
            _hotkeyManager.SuppressHotkeys = _settings.SuppressHotkeys;
            Width = _settings.WindowWidth;
            Height = _settings.WindowHeight;

            // Load profiles
            RefreshProfileList();

            // Load devices
            RefreshDeviceList();

            // Load last profile
            var profile = _profileManager.LoadProfile(_settings.LastProfileName);
            if (profile != null)
                LoadProfile(profile);
            else
                LoadProfile(new SoundProfile());

            _audioEngine.OnSoundFinished += id =>
                Dispatcher.Invoke(() => UpdateStatus($"Sound finished"));

            // Real-time Audio Device Hotplugging listener
            _audioEngine.OnDevicesChanged += () =>
            {
                Dispatcher.Invoke(() =>
                {
                    RefreshDeviceList();
                    UpdateStatus("Audio devices updated (plug/unplug detected)");
                });
            };

            UpdateStatus("Ready - Drag & drop audio files or click Add Sound");
        }

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            SaveCurrentState();
            _hotkeyManager.Dispose();
            _audioEngine.Dispose();
        }

        private void TitleBar_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            if (e.ClickCount == 2) 
            {
                WindowState = WindowState == WindowState.Maximized 
                    ? WindowState.Normal : WindowState.Maximized;
            }
            else
                DragMove();
        }

        // ═══════════════════════════════════════════════════════
        //  SOUND MANAGEMENT
        // ═══════════════════════════════════════════════════════

        private void AddSound_Click(object sender, RoutedEventArgs e)
        {
            var dlg = new OpenFileDialog
            {
                Title = "Select Audio Files",
                Filter = "Audio Files|*.mp3;*.wav;*.ogg;*.flac;*.wma;*.aac;*.m4a;*.aiff|All Files|*.*",
                Multiselect = true
            };

            if (dlg.ShowDialog() == true)
            {
                foreach (string file in dlg.FileNames)
                    AddSoundFile(file);
            }
        }

        private void AddSoundFile(string filePath)
        {
            if (!File.Exists(filePath)) return;
            if (_allSounds.Any(s => s.FilePath.Equals(filePath, StringComparison.OrdinalIgnoreCase)))
            {
                UpdateStatus($"Sound already exists: {Path.GetFileName(filePath)}");
                return;
            }

            string initialCategory = (_selectedCategoryFilter != "All Categories" && !string.IsNullOrWhiteSpace(_selectedCategoryFilter))
                ? _selectedCategoryFilter
                : "General";

            var sound = new SoundItem
            {
                Name = Path.GetFileNameWithoutExtension(filePath),
                FilePath = filePath,
                Category = initialCategory
            };

            _audioEngine.PreloadSound(filePath);
            _allSounds.Add(sound);
            _currentProfile.Sounds.Add(sound);
            RefreshCategoryList();
            ApplyFilter();
            UpdateSoundCount();
            UpdateStatus($"Added: {sound.Name} [{sound.Category}]");
        }

        private void DeleteSound_Click(object sender, RoutedEventArgs e)
        {
            if (lvSounds.SelectedItems.Count == 0)
            {
                UpdateStatus("Select one or more sounds first to delete");
                return;
            }

            var selectedSounds = lvSounds.SelectedItems.Cast<SoundItem>().ToList();
            int deletedCount = selectedSounds.Count;

            foreach (var sound in selectedSounds)
            {
                _audioEngine.StopSound(sound.Id);
                _audioEngine.RemoveCachedSound(sound.FilePath);
                _hotkeyManager.UnregisterHotkey(sound.Id);
                _allSounds.Remove(sound);
                _currentProfile.Sounds.Remove(sound);
            }

            RefreshCategoryList();
            ApplyFilter();
            UpdateSoundCount();
            UpdateStatus(deletedCount == 1 
                ? $"Deleted: {selectedSounds[0].Name}" 
                : $"Deleted {deletedCount} sounds");
        }

        private void SoundList_DoubleClick(object sender, MouseButtonEventArgs e)
        {
            if (lvSounds.SelectedItem is SoundItem sound)
                PlayOrStopSound(sound);
        }

        private void PlayOrStopSound(SoundItem sound)
        {
            if (sound.IsFileMissing)
            {
                sound.RefreshFileStatus();
                UpdateStatus($"⚠️ File not found on disk: {sound.Name} ({sound.FilePath})");
                try { System.Media.SystemSounds.Exclamation.Play(); } catch { }
                return;
            }

            if (sound.IsPlaying)
            {
                _audioEngine.StopSound(sound.Id);
                UpdateStatus($"Stopped: {sound.Name}");
            }
            else
            {
                _audioEngine.PlaySound(sound, chkOverlap.IsChecked == true);
                UpdateStatus($"Playing: {sound.Name}");
            }
        }

        // ═══════════════════════════════════════════════════════
        //  PLAYBACK CONTROLS
        // ═══════════════════════════════════════════════════════

        private void StopAll_Click(object sender, RoutedEventArgs e)
        {
            _audioEngine.StopAll();
            UpdateStatus("All sounds stopped");
        }

        private void PauseAll_Click(object sender, RoutedEventArgs e)
        {
            // Toggle pause label
            if (btnPauseAll.Content.ToString()!.Contains("Pause"))
            {
                _audioEngine.StopAll();
                btnPauseAll.Content = "▶ Resume";
                UpdateStatus("All sounds paused");
            }
            else
            {
                btnPauseAll.Content = "⏸ Pause All";
                UpdateStatus("Ready");
            }
        }

        private void PlayRandom_Click(object sender, RoutedEventArgs e)
        {
            if (_allSounds.Count == 0) return;
            var rng = new Random();
            var sound = _allSounds[rng.Next(_allSounds.Count)];
            _audioEngine.PlaySound(sound, chkOverlap.IsChecked == true);
            UpdateStatus($"Random: {sound.Name}");
        }

        // ═══════════════════════════════════════════════════════
        //  HOTKEY MANAGEMENT
        // ═══════════════════════════════════════════════════════

        private void HotkeyCapture_KeyDown(object sender, System.Windows.Input.KeyEventArgs e)
        {
            e.Handled = true;
            var key = e.Key == Key.System ? e.SystemKey : e.Key;

            // Ignore modifier-only presses
            if (key == Key.LeftCtrl || key == Key.RightCtrl ||
                key == Key.LeftAlt || key == Key.RightAlt ||
                key == Key.LeftShift || key == Key.RightShift ||
                key == Key.LWin || key == Key.RWin)
                return;

            _capturedKey = key;
            _capturedModifiers = Keyboard.Modifiers;
            txtHotkey.Text = HotkeyManager.GetHotkeyDisplayString(_capturedModifiers, _capturedKey);
        }

        private void HotkeyCapture_GotFocus(object sender, RoutedEventArgs e)
        {
            _hotkeyManager.IsSuspended = true;
            txtHotkey.Text = "Press a key combo...";
            txtHotkey.BorderBrush = new SolidColorBrush(Color.FromRgb(255, 136, 0));
        }

        private void HotkeyCapture_LostFocus(object sender, RoutedEventArgs e)
        {
            _hotkeyManager.IsSuspended = false;
            txtHotkey.BorderBrush = (SolidColorBrush)FindResource("BorderBrush");
        }

        private void SetHotkey_Click(object sender, RoutedEventArgs e)
        {
            if (lvSounds.SelectedItem is not SoundItem sound) 
            {
                UpdateStatus("Select a sound first to set hotkey");
                return;
            }
            if (_capturedKey == Key.None)
            {
                UpdateStatus("Capture a hotkey first (click the hotkey box and press keys)");
                return;
            }

            int mods = HotkeyManager.ModifierKeysToInt(_capturedModifiers);
            int vk = HotkeyManager.KeyToVirtualKey(_capturedKey);
            string display = HotkeyManager.GetHotkeyDisplayString(_capturedModifiers, _capturedKey);

            // Check if any other sound already uses this hotkey
            var conflictingSound = _allSounds.FirstOrDefault(s => s.Id != sound.Id && s.HotkeyKey == vk && s.HotkeyModifiers == mods);
            if (conflictingSound != null)
            {
                var result = System.Windows.MessageBox.Show(
                    $"The hotkey '{display}' is already assigned to the sound '{conflictingSound.Name}'.\n\nDo you want to reassign this hotkey to '{sound.Name}' (it will be removed from '{conflictingSound.Name}')?",
                    "Duplicate Hotkey Warning",
                    MessageBoxButton.YesNo,
                    MessageBoxImage.Warning);

                if (result != MessageBoxResult.Yes)
                {
                    UpdateStatus($"Hotkey assignment cancelled. '{conflictingSound.Name}' retained '{display}'");
                    return;
                }

                // Unregister and clear hotkey from conflicting sound
                _hotkeyManager.UnregisterHotkey(conflictingSound.Id);
                conflictingSound.HotkeyModifiers = 0;
                conflictingSound.HotkeyKey = 0;
                conflictingSound.HotkeyDisplay = "";
            }

            sound.HotkeyModifiers = mods;
            sound.HotkeyKey = vk;
            sound.HotkeyDisplay = display;

            bool ok = _hotkeyManager.RegisterHotkey(sound.Id, mods, vk, () =>
            {
                Dispatcher.Invoke(() => PlayOrStopSound(sound));
            });

            if (conflictingSound != null)
            {
                UpdateStatus(ok ? $"Hotkey {display} reassigned to '{sound.Name}' (removed from '{conflictingSound.Name}')" 
                               : $"Failed to register hotkey {display}");
            }
            else
            {
                UpdateStatus(ok ? $"Hotkey {display} set for: {sound.Name}" 
                               : $"Failed to register hotkey {display} (may be in use)");
            }

            lvSounds.Items.Refresh();
            RefreshGridView();
        }

        private void ClearHotkey_Click(object sender, RoutedEventArgs e)
        {
            if (lvSounds.SelectedItems.Count == 0)
            {
                UpdateStatus("Select one or more sounds first to clear hotkey");
                return;
            }

            var selectedSounds = lvSounds.SelectedItems.Cast<SoundItem>().ToList();
            int clearedCount = 0;

            foreach (var sound in selectedSounds)
            {
                if (sound.HotkeyKey != 0)
                {
                    _hotkeyManager.UnregisterHotkey(sound.Id);
                    sound.HotkeyDisplay = "";
                    sound.HotkeyModifiers = 0;
                    sound.HotkeyKey = 0;
                    clearedCount++;
                }
            }

            if (clearedCount > 0)
            {
                lvSounds.Items.Refresh();
                RefreshGridView();
                UpdateStatus(clearedCount == 1 
                    ? "Hotkey cleared" 
                    : $"Cleared hotkeys for {clearedCount} sounds");
            }
            else
            {
                UpdateStatus("Selected sounds do not have any hotkeys set");
            }
            txtHotkey.Text = "";
            _capturedKey = Key.None;
            _capturedModifiers = ModifierKeys.None;
        }

        private void SoundList_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (lvSounds.SelectedItem is SoundItem sound)
            {
                txtHotkey.Text = sound.HotkeyDisplay;
                sliderSoundVolume.Value = sound.Volume * 100;
                chkLoop.IsChecked = sound.Loop;

                _isUpdatingCategoryUi = true;
                try
                {
                    cmbSoundCategory.Text = sound.Category;
                    cmbSoundCategory.SelectedItem = sound.Category;
                }
                finally
                {
                    _isUpdatingCategoryUi = false;
                }
            }
            else
            {
                txtHotkey.Text = "";
                _isUpdatingCategoryUi = true;
                try
                {
                    cmbSoundCategory.Text = "";
                    cmbSoundCategory.SelectedItem = null;
                }
                finally
                {
                    _isUpdatingCategoryUi = false;
                }
            }
        }

        private void SoundCategory_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (_isUpdatingCategoryUi) return;
            if (cmbSoundCategory.SelectedItem is string newCategory && !string.IsNullOrWhiteSpace(newCategory))
            {
                ApplyCategoryToSelectedSounds(newCategory);
            }
        }

        private void SoundCategory_LostFocus(object sender, RoutedEventArgs e)
        {
            if (_isUpdatingCategoryUi) return;
            string text = cmbSoundCategory.Text?.Trim() ?? string.Empty;
            if (!string.IsNullOrWhiteSpace(text))
            {
                ApplyCategoryToSelectedSounds(text);
            }
        }

        private void ApplyCategoryToSelectedSounds(string category)
        {
            if (lvSounds.SelectedItems.Count == 0) return;
            category = string.IsNullOrWhiteSpace(category) ? "General" : category.Trim();

            var selectedSounds = lvSounds.SelectedItems.Cast<SoundItem>().ToList();
            bool anyChanged = false;
            foreach (var sound in selectedSounds)
            {
                if (!string.Equals(sound.Category, category, StringComparison.OrdinalIgnoreCase))
                {
                    sound.Category = category;
                    anyChanged = true;
                }
            }

            if (anyChanged)
            {
                RefreshCategoryList();
                lvSounds.Items.Refresh();
                ApplyFilter();
                UpdateStatus(selectedSounds.Count == 1 
                    ? $"Category set to '{category}' for {selectedSounds[0].Name}" 
                    : $"Category set to '{category}' for {selectedSounds.Count} sounds");
            }
        }

        // ═══════════════════════════════════════════════════════
        //  VOLUME CONTROLS
        // ═══════════════════════════════════════════════════════

        private void LocalVolume_Changed(object sender, RoutedPropertyChangedEventArgs<double> e)
        {
            if (lblLocalVol == null) return;
            _audioEngine.LocalVolume = (float)(e.NewValue / 100.0);
            lblLocalVol.Text = $"{(int)e.NewValue}%";
        }

        private void MicVolume_Changed(object sender, RoutedPropertyChangedEventArgs<double> e)
        {
            if (lblMicVol == null) return;
            _audioEngine.VirtualMicVolume = (float)(e.NewValue / 100.0);
            lblMicVol.Text = $"{(int)e.NewValue}%";
        }

        private void SoundVolume_Changed(object sender, RoutedPropertyChangedEventArgs<double> e)
        {
            if (lblSoundVol == null) return;
            lblSoundVol.Text = $"{(int)e.NewValue}%";
            if (lvSounds.SelectedItem is SoundItem sound)
                sound.Volume = (float)(e.NewValue / 100.0);
        }

        private void LoopToggle_Changed(object sender, RoutedEventArgs e)
        {
            if (lvSounds.SelectedItem is SoundItem sound)
                sound.Loop = chkLoop.IsChecked == true;
        }

        private void OverlapToggle_Changed(object sender, RoutedEventArgs e) { }

        private void AutoMuteMicToggle_Changed(object sender, RoutedEventArgs e)
        {
            if (_audioEngine != null && chkAutoMuteMic != null)
            {
                _audioEngine.AutoMuteMic = chkAutoMuteMic.IsChecked == true;
            }
        }

        private void SuppressHotkeysToggle_Changed(object sender, RoutedEventArgs e)
        {
            if (_hotkeyManager != null && chkSuppressHotkeys != null)
            {
                _hotkeyManager.SuppressHotkeys = chkSuppressHotkeys.IsChecked == true;
            }
        }

        // ═══════════════════════════════════════════════════════
        //  DEVICE MANAGEMENT
        // ═══════════════════════════════════════════════════════

        private void RefreshDevices_Click(object sender, RoutedEventArgs e) => RefreshDeviceList();

        private void RefreshDeviceList()
        {
            spDevices.Children.Clear();
            var devices = _audioEngine.GetOutputDevices();

            foreach (var dev in devices)
            {
                var panel = new Grid { Margin = new Thickness(0, 2, 0, 2) };
                panel.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(40) });
                panel.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });

                bool isEnabled = _settings.EnabledDeviceIds.Contains(dev.Id) || (dev.IsDefault && _settings.EnabledDeviceIds.Count == 0);

                var toggle = new ToggleButton
                {
                    Style = (Style)FindResource("ToggleSwitch"),
                    IsChecked = isEnabled,
                    Tag = dev.Id
                };
                toggle.Checked += DeviceToggle_Changed;
                toggle.Unchecked += DeviceToggle_Changed;
                Grid.SetColumn(toggle, 0);

                var label = new TextBlock
                {
                    Text = TruncateDeviceName(dev.Name),
                    FontSize = 10,
                    Foreground = (SolidColorBrush)FindResource("TextSecondaryBrush"),
                    VerticalAlignment = VerticalAlignment.Center,
                    Margin = new Thickness(6, 0, 0, 0),
                    ToolTip = dev.Name,
                    TextTrimming = TextTrimming.CharacterEllipsis
                };
                Grid.SetColumn(label, 1);

                panel.Children.Add(toggle);
                panel.Children.Add(label);
                spDevices.Children.Add(panel);

                // Auto-enable device in engine and ensure it's in settings
                if (isEnabled)
                {
                    _audioEngine.EnableDevice(dev.Id, false);
                    if (!_settings.EnabledDeviceIds.Contains(dev.Id))
                        _settings.EnabledDeviceIds.Add(dev.Id);
                }
            }
        }

        private void DeviceToggle_Changed(object sender, RoutedEventArgs e)
        {
            if (sender is not ToggleButton toggle || toggle.Tag is not string devId) return;
            if (toggle.IsChecked == true)
            {
                _audioEngine.EnableDevice(devId, false);
                if (!_settings.EnabledDeviceIds.Contains(devId))
                    _settings.EnabledDeviceIds.Add(devId);
            }
            else
            {
                _audioEngine.DisableDevice(devId);
                _settings.EnabledDeviceIds.Remove(devId);
            }
            _profileManager.SaveSettings(_settings);
        }

        private string TruncateDeviceName(string name)
        {
            return name.Length > 28 ? name[..28] + "..." : name;
        }

        // ═══════════════════════════════════════════════════════
        //  PROFILE MANAGEMENT
        // ═══════════════════════════════════════════════════════

        private void SaveProfile_Click(object sender, RoutedEventArgs e)
        {
            _profileManager.SaveProfile(_currentProfile);
            SaveCurrentState();
            UpdateStatus($"Profile saved: {_currentProfile.Name}");
        }

        private void NewProfile_Click(object sender, RoutedEventArgs e)
        {
            string name = $"Profile {DateTime.Now:MMdd_HHmm}";
            var profile = new SoundProfile { Name = name };
            _profileManager.SaveProfile(profile);
            RefreshProfileList();
            LoadProfile(profile);
            UpdateStatus($"New profile created: {name}");
        }

        private void ProfileSelector_Changed(object sender, SelectionChangedEventArgs e)
        {
            if (cmbProfiles.SelectedItem is not string name) return;
            if (name == _currentProfile.Name) return;

            // Save current first
            _profileManager.SaveProfile(_currentProfile);
            var profile = _profileManager.LoadProfile(name);
            if (profile != null) LoadProfile(profile);
        }

        private void RefreshProfileList()
        {
            var names = _profileManager.GetProfileNames();
            cmbProfiles.ItemsSource = names;
            cmbProfiles.SelectedItem = _currentProfile.Name;
        }

        private void LoadProfile(SoundProfile profile)
        {
            _hotkeyManager.UnregisterAll();
            _audioEngine.ClearCache();
            _currentProfile = profile;
            _allSounds = new ObservableCollection<SoundItem>(profile.Sounds);
            lvSounds.ItemsSource = _allSounds;
            cmbProfiles.SelectedItem = profile.Name;

            foreach (var sound in _allSounds)
            {
                sound.RefreshFileStatus();
                if (sound.HotkeyKey != 0)
                {
                    var s = sound; // capture for closure
                    _hotkeyManager.RegisterHotkey(s.Id, s.HotkeyModifiers, s.HotkeyKey, () =>
                    {
                        Dispatcher.Invoke(() => PlayOrStopSound(s));
                    });
                }
            }

            AudioEngine.TrimMemory();
            RefreshCategoryList();
            ApplyFilter();
            UpdateSoundCount();
            UpdateStatus($"Loaded profile: {profile.Name}");
        }

        // ═══════════════════════════════════════════════════════
        //  VIEW TOGGLE
        // ═══════════════════════════════════════════════════════

        private void ToggleListView_Click(object sender, RoutedEventArgs e)
        {
            _isListView = true;
            lvSounds.Visibility = Visibility.Visible;
            gridViewPanel.Visibility = Visibility.Collapsed;
        }

        private void ToggleGridView_Click(object sender, RoutedEventArgs e)
        {
            _isListView = false;
            lvSounds.Visibility = Visibility.Collapsed;
            gridViewPanel.Visibility = Visibility.Visible;
            RefreshGridView();
        }

        private void RefreshGridView()
        {
            if (_isListView) return;
            wpButtons.Children.Clear();

            string query = txtSearch.Text.Trim();
            var filteredSounds = _allSounds.Where(sound =>
            {
                bool matchesCategory = string.IsNullOrEmpty(_selectedCategoryFilter) ||
                                       _selectedCategoryFilter == "All Categories" ||
                                       sound.Category.Equals(_selectedCategoryFilter, StringComparison.OrdinalIgnoreCase);

                bool matchesQuery = string.IsNullOrEmpty(query) ||
                                    sound.Name.Contains(query, StringComparison.OrdinalIgnoreCase) ||
                                    sound.FileName.Contains(query, StringComparison.OrdinalIgnoreCase) ||
                                    sound.Category.Contains(query, StringComparison.OrdinalIgnoreCase);

                return matchesCategory && matchesQuery;
            });

            foreach (var sound in filteredSounds)
            {
                bool missing = sound.IsFileMissing;
                string title = missing ? $"⚠️ {sound.Name}" : sound.Name;

                var btn = new Button
                {
                    Content = new TextBlock
                    {
                        Text = title,
                        TextWrapping = TextWrapping.Wrap,
                        TextAlignment = TextAlignment.Center,
                        FontSize = 11,
                        Foreground = missing ? (SolidColorBrush)FindResource("AccentOrangeBrush") : (SolidColorBrush)FindResource("TextPrimaryBrush")
                    },
                    Style = (Style)FindResource("SoundButton"),
                    Background = new SolidColorBrush((Color)ColorConverter.ConvertFromString(sound.ButtonColor)),
                    Width = _settings.ButtonSize,
                    Height = _settings.ButtonSize * 0.7,
                    Tag = sound,
                    ToolTip = missing
                        ? $"⚠️ FILE NOT FOUND ON DISK:\n{sound.FilePath}\n\n📁 Category: {sound.Category}\n⌨️ {sound.HotkeyDisplay}"
                        : $"{sound.Name}\n📁 Category: {sound.Category}\n⌨️ {sound.HotkeyDisplay}\n🔊 Vol: {(int)(sound.Volume*100)}%"
                };
                btn.Click += (s, _) =>
                {
                    if (s is Button b && b.Tag is SoundItem si)
                        PlayOrStopSound(si);
                };
                wpButtons.Children.Add(btn);
            }
        }

        // ═══════════════════════════════════════════════════════
        //  DRAG & DROP
        // ═══════════════════════════════════════════════════════

        private void Window_DragOver(object sender, System.Windows.DragEventArgs e)
        {
            e.Effects = e.Data.GetDataPresent(System.Windows.DataFormats.FileDrop)
                ? System.Windows.DragDropEffects.Copy : System.Windows.DragDropEffects.None;
            e.Handled = true;
        }

        private void Window_Drop(object sender, System.Windows.DragEventArgs e)
        {
            if (!e.Data.GetDataPresent(System.Windows.DataFormats.FileDrop)) return;
            var files = (string[])e.Data.GetData(System.Windows.DataFormats.FileDrop);
            string[] audioExts = { ".mp3", ".wav", ".ogg", ".flac", ".wma", ".aac", ".m4a", ".aiff" };
            int added = 0;
            foreach (string file in files)
            {
                if (audioExts.Contains(Path.GetExtension(file).ToLowerInvariant()))
                {
                    AddSoundFile(file);
                    added++;
                }
            }
            UpdateStatus(added > 0 ? $"Added {added} sound(s) via drag & drop" : "No supported audio files found");
        }

        // ═══════════════════════════════════════════════════════
        //  SEARCH & CATEGORY FILTER
        // ═══════════════════════════════════════════════════════

        private void CategoryFilter_Changed(object sender, SelectionChangedEventArgs e)
        {
            if (_isUpdatingCategoryUi) return;
            if (cmbCategoryFilter.SelectedItem is string cat)
            {
                _selectedCategoryFilter = cat;
                ApplyFilter();
            }
        }

        private void SearchBox_TextChanged(object sender, TextChangedEventArgs e)
        {
            ApplyFilter();
        }

        private void ApplyFilter()
        {
            string query = txtSearch.Text.Trim();
            txtSearchPlaceholder.Visibility = string.IsNullOrEmpty(query)
                ? Visibility.Visible : Visibility.Collapsed;

            var view = System.Windows.Data.CollectionViewSource.GetDefaultView(_allSounds);
            if (view != null)
            {
                view.Filter = item =>
                {
                    if (item is SoundItem sound)
                    {
                        bool matchesCategory = string.IsNullOrEmpty(_selectedCategoryFilter) ||
                                               _selectedCategoryFilter == "All Categories" ||
                                               sound.Category.Equals(_selectedCategoryFilter, StringComparison.OrdinalIgnoreCase);

                        bool matchesQuery = string.IsNullOrEmpty(query) ||
                                            sound.Name.Contains(query, StringComparison.OrdinalIgnoreCase) ||
                                            sound.FileName.Contains(query, StringComparison.OrdinalIgnoreCase) ||
                                            sound.Category.Contains(query, StringComparison.OrdinalIgnoreCase);

                        return matchesCategory && matchesQuery;
                    }
                    return false;
                };
            }

            RefreshGridView();
            UpdateSoundCount();
        }

        private void RefreshCategoryList()
        {
            _isUpdatingCategoryUi = true;
            try
            {
                var categories = _allSounds
                    .Select(s => s.Category)
                    .Where(c => !string.IsNullOrWhiteSpace(c))
                    .Distinct(StringComparer.OrdinalIgnoreCase)
                    .ToList();

                foreach (var defCat in _defaultCategories)
                {
                    if (!categories.Any(c => c.Equals(defCat, StringComparison.OrdinalIgnoreCase)))
                    {
                        categories.Add(defCat);
                    }
                }

                categories.Sort(StringComparer.OrdinalIgnoreCase);
                if (categories.Contains("General", StringComparer.OrdinalIgnoreCase))
                {
                    categories.RemoveAll(c => c.Equals("General", StringComparison.OrdinalIgnoreCase));
                    categories.Insert(0, "General");
                }

                // Populate bottom bar category picker
                string currentBottomCategory = cmbSoundCategory.Text;
                cmbSoundCategory.ItemsSource = categories.ToList();
                if (!string.IsNullOrEmpty(currentBottomCategory))
                {
                    cmbSoundCategory.Text = currentBottomCategory;
                }

                // Populate top filter combo
                var filterList = new List<string> { "All Categories" };
                filterList.AddRange(categories);

                string previousFilter = _selectedCategoryFilter;
                cmbCategoryFilter.ItemsSource = filterList;

                if (filterList.Contains(previousFilter, StringComparer.OrdinalIgnoreCase))
                {
                    cmbCategoryFilter.SelectedItem = filterList.First(c => c.Equals(previousFilter, StringComparison.OrdinalIgnoreCase));
                }
                else
                {
                    cmbCategoryFilter.SelectedIndex = 0;
                    _selectedCategoryFilter = "All Categories";
                }
            }
            finally
            {
                _isUpdatingCategoryUi = false;
            }
        }

        // ═══════════════════════════════════════════════════════
        //  HELPERS
        // ═══════════════════════════════════════════════════════

        private void SaveCurrentState()
        {
            _profileManager.SaveProfile(_currentProfile);
            _settings.LocalVolume = (float)(sliderLocalVolume.Value / 100.0);
            _settings.VirtualMicVolume = (float)(sliderMicVolume.Value / 100.0);
            _settings.AllowOverlap = chkOverlap.IsChecked == true;
            _settings.AutoMuteMic = chkAutoMuteMic.IsChecked == true;
            _settings.SuppressHotkeys = chkSuppressHotkeys.IsChecked == true;
            _settings.LastProfileName = _currentProfile.Name;
            _settings.WindowWidth = Width;
            _settings.WindowHeight = Height;
            _profileManager.SaveSettings(_settings);
        }

        private void UpdateStatus(string msg)
        {
            lblStatus.Text = msg;
        }

        private void UpdateSoundCount()
        {
            if (lblSoundCount == null) return;
            var view = System.Windows.Data.CollectionViewSource.GetDefaultView(_allSounds);
            int visibleCount = view?.Cast<SoundItem>().Count() ?? _allSounds.Count;

            if (visibleCount < _allSounds.Count)
            {
                lblSoundCount.Text = $"{visibleCount} of {_allSounds.Count} sound{(_allSounds.Count != 1 ? "s" : "")}";
            }
            else
            {
                lblSoundCount.Text = $"{_allSounds.Count} sound{(_allSounds.Count != 1 ? "s" : "")}";
            }
        }

        private bool IsRunningAsAdmin()
        {
            try
            {
                using (var identity = System.Security.Principal.WindowsIdentity.GetCurrent())
                {
                    var principal = new System.Security.Principal.WindowsPrincipal(identity);
                    return principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator);
                }
            }
            catch
            {
                return false;
            }
        }

        private void RunAsAdmin_Click(object sender, RoutedEventArgs e)
        {
            var processInfo = new System.Diagnostics.ProcessStartInfo
            {
                FileName = Environment.ProcessPath,
                UseShellExecute = true,
                Verb = "runas"
            };

            try
            {
                System.Diagnostics.Process.Start(processInfo);
                System.Windows.Application.Current.Shutdown();
            }
            catch (System.ComponentModel.Win32Exception)
            {
                UpdateStatus("Elevation failed. Admin rights are required to play sounds in games.");
            }
        }
    }
}