MainWindow.xaml.cs

using System.Collections.ObjectModel;
using System.Windows;
using System.Windows.Controls;
using VioletTooth.Bluetooth;
using VioletTooth.Localization;
using VioletTooth.Services;

namespace VioletTooth;

public partial class MainWindow : Window
{
    private readonly BluetoothService _bluetooth = new();
    private readonly ObservableCollection<BluetoothDeviceItem> _paired = [];
    private readonly ObservableCollection<BluetoothDeviceItem> _nearby = [];
    private bool _suppressStartupToggle;
    private bool _suppressLanguageToggle;

    public MainWindow()
    {
        InitializeComponent();
        PairedList.ItemsSource = _paired;
        NearbyList.ItemsSource = _nearby;

        _bluetooth.DeviceDiscovered += item => Dispatcher.Invoke(() => UpsertNearby(item));
        _bluetooth.DeviceRemoved += id => Dispatcher.Invoke(() => RemoveNearby(id));
        _bluetooth.StatusChanged += text => Dispatcher.Invoke(() => SetStatus(text));

        _suppressStartupToggle = true;
        StartupCheckBox.IsChecked = StartupService.IsEnabled();
        _suppressStartupToggle = false;

        ApplyLanguage();
        Loc.LanguageChanged += OnLanguageChanged;

        Loaded += async (_, _) =>
        {
            App.Monitor.HistoryChanged += OnHistoryChanged;
            App.AutoKick.DevicesChanged += OnAutoKickDevicesChanged;
            App.AutoKick.StatusChanged += OnAutoKickStatus;
            await RefreshPairedAsync();
        };

        Closed += (_, _) =>
        {
            Loc.LanguageChanged -= OnLanguageChanged;
            App.Monitor.HistoryChanged -= OnHistoryChanged;
            App.AutoKick.DevicesChanged -= OnAutoKickDevicesChanged;
            App.AutoKick.StatusChanged -= OnAutoKickStatus;
            _bluetooth.StopDiscovery();
        };
    }

    private void ApplyLanguage()
    {
        Title = Loc.T("AppName");
        TitleText.Text = Loc.T("AppName");
        SubtitleText.Text = Loc.T("MainSubtitle");
        KickSettingsButton.Content = Loc.T("KickSettings");
        RefreshButton.Content = Loc.T("RefreshPaired");
        ScanButton.Content = Loc.T("ScanDevices");
        StopScanButton.Content = Loc.T("StopScan");
        PairedTitle.Text = Loc.T("PairedDevices");
        UnpairButton.Content = Loc.T("RemovePairing");
        NearbyTitle.Text = Loc.T("NearbyDevices");
        PairButton.Content = Loc.T("AddPairing");
        StartupCheckBox.Content = Loc.T("StartupCheckbox");
        if (string.IsNullOrWhiteSpace(StatusText.Text) || StatusText.Text is "就绪" or "Ready")
        {
            StatusText.Text = Loc.T("Ready");
        }

        _suppressLanguageToggle = true;
        LanguageCombo.Items.Clear();
        LanguageCombo.Items.Add(new ComboBoxItem { Content = "中文", Tag = Loc.Zh });
        LanguageCombo.Items.Add(new ComboBoxItem { Content = "English", Tag = Loc.En });
        LanguageCombo.SelectedIndex = Loc.IsChinese ? 0 : 1;
        _suppressLanguageToggle = false;

        // Refresh bound localized texts on device rows.
        PairedList.Items.Refresh();
        NearbyList.Items.Refresh();
    }

    private void OnLanguageChanged()
        => Dispatcher.Invoke(ApplyLanguage);

    private void LanguageCombo_SelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        if (_suppressLanguageToggle || LanguageCombo.SelectedItem is not ComboBoxItem item || item.Tag is not string code)
        {
            return;
        }

        Loc.SetLanguage(code);
        SetStatus(Loc.T("Ready"));
    }

    private async void KickSettings_Click(object sender, RoutedEventArgs e)
    {
        var window = new KickSettingsWindow(App.KickSettings) { Owner = this };
        if (window.ShowDialog() == true)
        {
            SetStatus(Loc.T("KickRulesSaved"));
            await App.AutoKick.EvaluateNowAsync(includeBootRules: false);
            await RefreshPairedAsync();
        }
    }

    private async void RefreshPaired_Click(object sender, RoutedEventArgs e)
        => await RefreshPairedAsync();

    private void Scan_Click(object sender, RoutedEventArgs e)
    {
        _nearby.Clear();
        _bluetooth.StartDiscovery();
        ScanButton.IsEnabled = false;
    }

    private void StopScan_Click(object sender, RoutedEventArgs e)
    {
        _bluetooth.StopDiscovery();
        ScanButton.IsEnabled = true;
        SetStatus(Loc.T("ScanStopped"));
    }

    private async void Pair_Click(object sender, RoutedEventArgs e)
    {
        if (NearbyList.SelectedItem is not BluetoothDeviceItem item)
        {
            SetStatus(Loc.T("SelectNearbyFirst"));
            return;
        }

        SetStatus(Loc.T("PairingProgress", item.Name));
        var (ok, message) = await _bluetooth.PairAsync(item.Id);
        SetStatus(message);

        if (ok)
        {
            await RefreshPairedAsync();
            RemoveNearby(item.Id);
        }
    }

    private async void Unpair_Click(object sender, RoutedEventArgs e)
    {
        if (PairedList.SelectedItem is not BluetoothDeviceItem item)
        {
            SetStatus(Loc.T("SelectPairedFirst"));
            return;
        }

        var confirm = System.Windows.MessageBox.Show(
            Loc.T("ConfirmUnpair", item.Name),
            Loc.T("ConfirmUnpairTitle"),
            MessageBoxButton.YesNo,
            MessageBoxImage.Question);

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

        SetStatus(Loc.T("RemovingProgress", item.Name));
        var (ok, message) = await _bluetooth.UnpairAsync(item.Id);
        SetStatus(message);

        if (ok)
        {
            await RefreshPairedAsync();
        }
    }

    private void PairedList_SelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        if (PairedList.SelectedItem is BluetoothDeviceItem item)
        {
            SetStatus(Loc.T("SelectedDevice", item.Name, item.StatusText));
        }
    }

    private void StartupCheckBox_Changed(object sender, RoutedEventArgs e)
    {
        if (_suppressStartupToggle)
        {
            return;
        }

        try
        {
            StartupService.SetEnabled(StartupCheckBox.IsChecked == true);
            SetStatus(StartupCheckBox.IsChecked == true
                ? Loc.T("StartupEnabled")
                : Loc.T("StartupDisabled"));
        }
        catch (Exception ex)
        {
            _suppressStartupToggle = true;
            StartupCheckBox.IsChecked = StartupService.IsEnabled();
            _suppressStartupToggle = false;
            SetStatus(Loc.T("StartupFailed", ex.Message));
        }
    }

    private void OnHistoryChanged()
        => Dispatcher.InvokeAsync(async () => await RefreshPairedAsync());

    private void OnAutoKickDevicesChanged()
        => Dispatcher.InvokeAsync(async () => await RefreshPairedAsync());

    private void OnAutoKickStatus(string text)
        => Dispatcher.Invoke(() => SetStatus(text));

    private async Task RefreshPairedAsync()
    {
        try
        {
            SetStatus(Loc.T("ReadingPaired"));
            var devices = await _bluetooth.GetPairedDevicesAsync();
            _paired.Clear();
            foreach (var device in devices)
            {
                App.Monitor.ApplyHistory(device);
                if (device.IsConnected)
                {
                    var key = string.IsNullOrWhiteSpace(device.Address) ? device.Id : device.Address;
                    App.History.RecordConnected(key);
                    App.Monitor.ApplyHistory(device);
                }

                _paired.Add(device);
            }

            SetStatus(Loc.T("LoadedPaired", _paired.Count));
        }
        catch (Exception ex)
        {
            SetStatus(Loc.T("ReadFailed", ex.Message));
        }
    }

    private void UpsertNearby(BluetoothDeviceItem item)
    {
        for (var i = 0; i < _nearby.Count; i++)
        {
            if (_nearby[i].Id == item.Id)
            {
                _nearby[i] = item;
                return;
            }
        }

        _nearby.Add(item);
    }

    private void RemoveNearby(string id)
    {
        var existing = _nearby.FirstOrDefault(d => d.Id == id);
        if (existing is not null)
        {
            _nearby.Remove(existing);
        }
    }

    private void SetStatus(string text) => StatusText.Text = text;
}