NetworkTool/windows/QuickIP.Client/MainWindow.xaml.cs

using System.Collections.Generic;
using System.Globalization;
using System.Windows;
using System.Windows.Controls;
using QuickIP.Client.Models;
using QuickIP.Client.Services;

namespace QuickIP.Client;

public partial class MainWindow : Window
{
    private readonly NetworkAdapterService _networkAdapterService = new();
    private readonly PasswordStoreService _passwordStoreService = new();
    private readonly NetworkConfigurationService _networkConfigurationService = new();
    private readonly DiscoveryService _discoveryService = new();
    private readonly AgentApiService _agentApiService = new();
    private readonly AdminPrivilegeService _adminPrivilegeService = new();
    private IReadOnlyList<AdapterInfo> _adapters = [];
    private string _connectedBaseAddress = string.Empty;
    private string _connectedLocalIPv4 = string.Empty;
    private bool _configValidated;
    private bool _suppressConfigChangeHandling;
    private bool _isShowingPassword;
    private bool _isBusy;
    private bool _suppressPasswordSync;

    public MainWindow()
    {
        InitializeComponent();
        Loaded += MainWindow_OnLoaded;
    }

    private async void MainWindow_OnLoaded(object sender, RoutedEventArgs e)
    {
        await LoadInitialStateAsync();
    }

    private async Task LoadInitialStateAsync()
    {
        AdminStateTextBlock.Text = _adminPrivilegeService.IsAdministrator()
            ? "管理员状态：当前已以管理员身份运行，可执行本机网卡切换。"
            : "管理员状态：当前不是管理员运行，切换到维护网络会失败。";

        _adapters = _networkAdapterService.GetEthernetAdapters();
        await _networkAdapterService.ProbeMaintenanceReachabilityAsync(_adapters);
        _adapters = _adapters
            .OrderByDescending(adapter => adapter.RecommendationScore)
            .ThenBy(adapter => adapter.Name)
            .ToList();
        AdapterComboBox.ItemsSource = _adapters;

        var recommendedAdapter = _networkAdapterService.GetRecommendedAdapter(_adapters);

        var savedPassword = _passwordStoreService.LoadPassword();
        if (!string.IsNullOrWhiteSpace(savedPassword))
        {
            PasswordBox.Password = savedPassword;
            PasswordTextBox.Text = savedPassword;
        }

        if (recommendedAdapter is not null)
        {
            AdapterComboBox.SelectedItem = recommendedAdapter;
            UpdateAdapterDetails(recommendedAdapter);
        }
        else if (_adapters.Count > 0)
        {
            AdapterComboBox.SelectedIndex = 0;
            UpdateAdapterDetails(_adapters[0]);
        }

        AppendLog("客户端已加载连接页。", true);
        ClearRemoteDetails();
        UpdateButtonStates();
    }

    private void AdapterComboBox_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        if (AdapterComboBox.SelectedItem is not AdapterInfo adapter)
        {
            UpdateAdapterDetails(null);
            ClearRemoteDetails();
            SetStatus("请选择一块有线网卡。", false);
            UpdateButtonStates();
            return;
        }

        UpdateAdapterDetails(adapter);
        ClearRemoteDetails();
        SetStatus(adapter.HasLink
            ? $"已选择 {adapter.RecommendationLabel} 网卡，可切换到维护网络。{adapter.RecommendationReason}"
            : "当前网卡未检测到链路，请检查网线连接。", true);

        UpdateButtonStates();
    }

    private async void SwitchMaintenanceButton_OnClick(object sender, RoutedEventArgs e)
    {
        if (!_adminPrivilegeService.IsAdministrator())
        {
            SetStatus("当前程序未以管理员身份运行，无法修改本机网卡。", true);
            MessageBox.Show(this, "请以管理员身份运行客户端后再切换到维护网络。", "需要管理员权限", MessageBoxButton.OK, MessageBoxImage.Warning);
            return;
        }

        if (AdapterComboBox.SelectedItem is not AdapterInfo adapter)
        {
            SetStatus("请先选择一块网卡。", true);
            return;
        }

        PersistPasswordIfNeeded();

        if (adapter.IsReachableToMaintenance)
        {
            SetStatus("当前网卡已经可以直接访问 169.254.100.2，无需切换到维护网络。", true);
            return;
        }

        SetBusyState(true);
        SetStatus("正在切换到维护网络，请稍候。", true);
        await Dispatcher.InvokeAsync(() => { }, System.Windows.Threading.DispatcherPriority.Render);

        try
        {
            await _networkConfigurationService.ConfigureMaintenanceNetworkAsync(adapter);
            SetStatus("已切换到维护网络。", true);
            await RefreshAdaptersAsync(adapter.Id);
        }
        catch (Exception ex)
        {
            SetStatus($"切换维护网络失败：{ex.Message}", true);
            MessageBox.Show(this, ex.Message, "切换维护网络失败", MessageBoxButton.OK, MessageBoxImage.Error);
        }
        finally
        {
            SetBusyState(false);
        }
    }

    private async void RefreshAdaptersButton_OnClick(object sender, RoutedEventArgs e)
    {
        SetBusyState(true);
        try
        {
            await RefreshAdaptersAsync();
            SetStatus("已刷新本机网卡和管理口探测结果。", true);
        }
        catch (Exception ex)
        {
            SetStatus($"刷新本机网卡失败：{ex.Message}", true);
            MessageBox.Show(this, ex.Message, "刷新失败", MessageBoxButton.OK, MessageBoxImage.Error);
        }
        finally
        {
            SetBusyState(false);
        }
    }

    private async void DiscoverConnectButton_OnClick(object sender, RoutedEventArgs e)
    {
        if (string.IsNullOrWhiteSpace(GetCurrentPassword()))
        {
            SetStatus("请输入管理密码。", true);
            MessageBox.Show(this, "请先在右侧“管理密码（必填）”区域输入密码。", "缺少管理密码", MessageBoxButton.OK, MessageBoxImage.Information);
            return;
        }

        PersistPasswordIfNeeded();
        SetBusyState(true);
        SetStatus("正在检查当前网卡是否可直接访问管理口。", true);
        await Dispatcher.InvokeAsync(() => { }, System.Windows.Threading.DispatcherPriority.Render);

        try
        {
            if (AdapterComboBox.SelectedItem is AdapterInfo adapter && adapter.IsReachableToMaintenance)
            {
                var directResult = await _agentApiService.CheckHealthAsync("http://169.254.100.2:48888", GetCurrentPassword(), adapter.IPv4Address);
                if (directResult.Success)
                {
                    _connectedBaseAddress = "http://169.254.100.2:48888";
                    _connectedLocalIPv4 = adapter.IPv4Address;
                    SetStatus("连接成功，无需切换本机网卡。", true);
                    OpenDeviceDetailsWindow(_connectedBaseAddress, _connectedLocalIPv4);
                    return;
                }

                if (directResult.StatusCode == 401)
                {
                    SetStatus("该网卡可以直连管理口，但管理密码错误。", true);
                    MessageBox.Show(this, "当前网卡已经可以直连 Agent，但密码校验失败，请确认密码是否正确。", "密码错误", MessageBoxButton.OK, MessageBoxImage.Warning);
                    return;
                }

                if (directResult.StatusCode == 403)
                {
                    SetStatus("该网卡可以直连管理口，但 Agent 拒绝访问，请确认远端是否还是旧版本。", true);
                    MessageBox.Show(this, "当前网卡已经可以直连 Agent，但请求被拒绝。请确认 Linux 端是否运行的是最新版本 Agent。", "访问被拒绝", MessageBoxButton.OK, MessageBoxImage.Warning);
                    return;
                }

                SetStatus($"该网卡虽可建立连接，但直连 HTTP 校验失败：{directResult.Message}。正在尝试设备发现。", true);
            }

            SetStatus("当前网卡无法完成直连校验，正在发现设备，请稍候。", true);
            var selectedAdapter = AdapterComboBox.SelectedItem as AdapterInfo;
            var device = await _discoveryService.DiscoverAsync(selectedAdapter?.IPv4Address ?? string.Empty);
            if (device is null)
            {
                SetStatus("未发现设备。如果当前网卡不可达，请先切换到维护网络。", true);
                return;
            }

            SetStatus("已发现设备，正在验证连接。", true);

            var discoveredResult = await _agentApiService.CheckHealthAsync($"http://{device.Lan2Ip}:48888", GetCurrentPassword(), selectedAdapter?.IPv4Address ?? string.Empty);
            if (discoveredResult.Success)
            {
                _connectedBaseAddress = $"http://{device.Lan2Ip}:48888";
                _connectedLocalIPv4 = selectedAdapter?.IPv4Address ?? string.Empty;
                SetStatus("连接成功。", true);
                OpenDeviceDetailsWindow(_connectedBaseAddress, _connectedLocalIPv4);
            }
            else
            {
                SetStatus($"设备已发现，但 HTTP 验证失败：{discoveredResult.Message}", true);
            }
        }
        catch (Exception ex)
        {
            ClearRemoteDetails();
            SetStatus($"连接失败：{ex.Message}", true);
            MessageBox.Show(this, ex.Message, "连接失败", MessageBoxButton.OK, MessageBoxImage.Error);
        }
        finally
        {
            SetBusyState(false);
        }
    }

    private void PersistPasswordIfNeeded()
    {
        var password = GetCurrentPassword();
        if (!string.IsNullOrWhiteSpace(password))
        {
            _passwordStoreService.SavePassword(password);
            return;
        }
    }

    private string GetCurrentPassword()
    {
        return _isShowingPassword ? PasswordTextBox.Text : PasswordBox.Password;
    }

    private void UpdateButtonStates()
    {
        var adapter = AdapterComboBox.SelectedItem as AdapterInfo;
        var hasAdapter = adapter is not null;
        RefreshAdaptersButton.IsEnabled = !_isBusy;
        SwitchMaintenanceButton.IsEnabled = !_isBusy && hasAdapter;
        DiscoverConnectButton.IsEnabled = !_isBusy && hasAdapter && adapter!.HasLink;
        ReloadInterfaceConfigButton.IsEnabled = RemoteTargetInterfaceComboBox.SelectedItem is RemoteInterfaceInfo;
        ValidateConfigButton.IsEnabled = RemoteTargetInterfaceComboBox.SelectedItem is RemoteInterfaceInfo;
        ApplyConfigButton.IsEnabled = _configValidated && RemoteTargetInterfaceComboBox.SelectedItem is RemoteInterfaceInfo;
    }

    private async Task RefreshAdaptersAsync(string? selectedAdapterId = null)
    {
        _adapters = _networkAdapterService.GetEthernetAdapters();
        await _networkAdapterService.ProbeMaintenanceReachabilityAsync(_adapters);
        _adapters = _adapters
            .OrderByDescending(adapter => adapter.RecommendationScore)
            .ThenBy(adapter => adapter.Name)
            .ToList();
        AdapterComboBox.ItemsSource = _adapters;

        var selected = selectedAdapterId is null
            ? _networkAdapterService.GetRecommendedAdapter(_adapters)
            : _adapters.FirstOrDefault(adapter => adapter.Id == selectedAdapterId) ?? _networkAdapterService.GetRecommendedAdapter(_adapters);

        if (selected is not null)
        {
            AdapterComboBox.SelectedItem = selected;
            UpdateAdapterDetails(selected);
        }
    }

    private void UpdateAdapterDetails(AdapterInfo? adapter)
    {
        if (adapter is null)
        {
            AdapterProbeTextBlock.Text = "-";
            return;
        }

        AdapterProbeTextBlock.Text = $"{adapter.ProbeStatus} / {adapter.ProbeReason}";
    }

    private async Task LoadRemoteDetailsAsync(string baseAddress, string localIPv4)
    {
        ClearRemoteDetails();
        RemoteDetailsBorder.Visibility = Visibility.Visible;
        SetStatus("正在读取设备信息。", true);
        var device = await _agentApiService.GetDeviceInfoAsync(baseAddress, GetCurrentPassword(), localIPv4);
        if (device is not null)
        {
            RemoteDeviceIdTextBlock.Text = device.DeviceId;
            RemoteHostnameTextBlock.Text = device.Hostname;
            RemoteOsVersionTextBlock.Text = device.OSVersion;
            RemoteAgentVersionTextBlock.Text = device.AgentVersion;
        }

        SetStatus("正在读取 Linux 接口列表。", true);
        var interfaces = await _agentApiService.GetInterfacesAsync(baseAddress, GetCurrentPassword(), localIPv4);
        if (interfaces is not null)
        {
            RemoteSummaryTextBlock.Text = $"当前管理接口：{interfaces.ManagementInterface}；建议目标接口：{interfaces.SuggestedTargetInterface}；{(interfaces.RequiresTargetSelection ? "需要手动选择目标接口。" : "已自动识别建议目标接口。")}";

            var suggested = interfaces.Interfaces.FirstOrDefault(item => item.SystemName == interfaces.SuggestedTargetInterface)
                ?? interfaces.Interfaces.FirstOrDefault(item => item.IsSuggestedTarget)
                ?? interfaces.Interfaces.FirstOrDefault(item => !item.IsManagementInterface);

            RemoteTargetInterfaceComboBox.ItemsSource = interfaces.Interfaces;
            if (suggested is not null)
            {
                RemoteTargetInterfaceComboBox.SelectedItem = suggested;
                await LoadRemoteInterfaceConfigAsync(suggested.SystemName);
            }

            SetStatus("已加载设备信息和 Linux 接口列表。", true);
            return;
        }

        RemoteSummaryTextBlock.Text = "设备已连接，但暂时无法读取 Linux 接口列表。";
    }

    private void OpenDeviceDetailsWindow(string baseAddress, string localIPv4)
    {
        var window = new DeviceDetailsWindow(baseAddress, localIPv4, GetCurrentPassword())
        {
            Owner = this,
        };
        window.ShowDialog();
    }

    private void ClearRemoteDetails()
    {
        RemoteDetailsBorder.Visibility = Visibility.Collapsed;
        RemoteDeviceIdTextBlock.Text = "-";
        RemoteHostnameTextBlock.Text = "-";
        RemoteOsVersionTextBlock.Text = "-";
        RemoteAgentVersionTextBlock.Text = "-";
        RemoteTargetInterfaceComboBox.ItemsSource = null;
        RemoteConfigInterfaceTextBlock.Text = "-";
        RemoteConfigIpTextBlock.Text = "-";
        RemoteConfigGatewayTextBlock.Text = "-";
        RemoteConfigDnsTextBlock.Text = "-";
        NewIpTextBox.Text = string.Empty;
        NewMaskTextBox.Text = string.Empty;
        NewGatewayTextBox.Text = string.Empty;
        NewDnsTextBox.Text = string.Empty;
        ConfigValidationTextBlock.Text = "读取目标接口当前配置后，可在此修改并校验。";
        ApplyTaskStatusTextBlock.Text = "尚未提交配置任务。";
        _configValidated = false;
        RemoteSummaryTextBlock.Text = "连接成功后，这里会显示 Linux 管理接口和建议目标接口。";
        UpdateButtonStates();
    }

    private async void RemoteTargetInterfaceComboBox_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        if (RemoteTargetInterfaceComboBox.SelectedItem is not RemoteInterfaceInfo selected || string.IsNullOrWhiteSpace(_connectedBaseAddress))
        {
            return;
        }

        await LoadRemoteInterfaceConfigAsync(selected.SystemName);
    }

    private async Task LoadRemoteInterfaceConfigAsync(string interfaceName)
    {
        SetStatus($"正在读取目标接口 {interfaceName} 当前配置。", true);
        var result = await _agentApiService.GetInterfaceConfigAsync(_connectedBaseAddress, GetCurrentPassword(), _connectedLocalIPv4, interfaceName);
        if (!result.Success || result.Data is null)
        {
            RemoteConfigInterfaceTextBlock.Text = interfaceName;
            RemoteConfigIpTextBlock.Text = "读取失败";
            RemoteConfigGatewayTextBlock.Text = "读取失败";
            RemoteConfigDnsTextBlock.Text = "读取失败";
            SetStatus($"读取目标接口 {interfaceName} 配置失败：{result.Message}", true);
            return;
        }

        var config = result.Data;
        RemoteConfigInterfaceTextBlock.Text = config.Interface;
        RemoteConfigIpTextBlock.Text = string.IsNullOrWhiteSpace(config.IP) ? "无" : $"{config.IP}/{config.Prefix}";
        RemoteConfigGatewayTextBlock.Text = string.IsNullOrWhiteSpace(config.Gateway) ? "无" : config.Gateway;
        RemoteConfigDnsTextBlock.Text = config.DnsSummary;
        _suppressConfigChangeHandling = true;
        NewIpTextBox.Text = config.IP;
        NewMaskTextBox.Text = PrefixToMask(config.Prefix);
        NewGatewayTextBox.Text = config.Gateway;
        NewDnsTextBox.Text = config.Dns.FirstOrDefault() ?? string.Empty;
        _suppressConfigChangeHandling = false;
        _configValidated = false;
        ConfigValidationTextBlock.Text = "已回填目标接口当前配置，可直接修改后校验。";
        ApplyTaskStatusTextBlock.Text = "尚未提交配置任务。";
        UpdateButtonStates();
        SetStatus($"已读取目标接口 {interfaceName} 当前配置。", true);
    }

    private async void ReloadInterfaceConfigButton_OnClick(object sender, RoutedEventArgs e)
    {
        if (RemoteTargetInterfaceComboBox.SelectedItem is not RemoteInterfaceInfo selected)
        {
            return;
        }

        await LoadRemoteInterfaceConfigAsync(selected.SystemName);
    }

    private async void ValidateConfigButton_OnClick(object sender, RoutedEventArgs e)
    {
        if (RemoteTargetInterfaceComboBox.SelectedItem is not RemoteInterfaceInfo selected)
        {
            return;
        }

        var request = BuildConfigRequest(selected.SystemName);
        if (request is null)
        {
            return;
        }

        SetStatus($"正在校验目标接口 {selected.SystemName} 的新配置。", true);
        var result = await _agentApiService.ValidateInterfaceConfigAsync(_connectedBaseAddress, GetCurrentPassword(), _connectedLocalIPv4, request);
        _configValidated = result.Success && result.Data?.Valid == true;
        if (result.Data is not null)
        {
            var warnings = result.Data.Warnings.Count > 0 ? $" 警告：{string.Join("；", result.Data.Warnings)}" : string.Empty;
            var errors = result.Data.Errors.Count > 0 ? $" 错误：{string.Join("；", result.Data.Errors)}" : string.Empty;
            ConfigValidationTextBlock.Text = result.Success ? $"校验通过。{warnings}" : $"校验失败。{errors}{warnings}";
        }
        else
        {
            ConfigValidationTextBlock.Text = $"校验失败：{result.Message}";
        }

        ApplyTaskStatusTextBlock.Text = _configValidated ? "配置已通过校验，可提交应用。" : "当前配置尚未通过校验。";
        UpdateButtonStates();
    }

    private async void ApplyConfigButton_OnClick(object sender, RoutedEventArgs e)
    {
        if (RemoteTargetInterfaceComboBox.SelectedItem is not RemoteInterfaceInfo selected)
        {
            return;
        }

        var request = BuildConfigRequest(selected.SystemName);
        if (request is null)
        {
            return;
        }

        var confirmMessage = $"将要把以下配置应用到接口 {selected.SystemName}：\n\n" +
                             $"IP：{request.IP}/{request.Prefix}\n" +
                             $"网关：{(string.IsNullOrWhiteSpace(request.Gateway) ? "无" : request.Gateway)}\n" +
                             $"DNS：{(request.Dns.Count == 0 ? "无" : string.Join(", ", request.Dns))}\n\n" +
                             "请确认是否继续。";
        if (MessageBox.Show(this, confirmMessage, "确认应用配置", MessageBoxButton.OKCancel, MessageBoxImage.Question) != MessageBoxResult.OK)
        {
            return;
        }

        SetStatus($"正在提交目标接口 {selected.SystemName} 的配置任务。", true);
        var applyResult = await _agentApiService.ApplyInterfaceConfigAsync(_connectedBaseAddress, GetCurrentPassword(), _connectedLocalIPv4, request);
        if (!applyResult.Success || applyResult.Data is null)
        {
            ApplyTaskStatusTextBlock.Text = $"提交配置任务失败：{applyResult.Message}";
            return;
        }

        ApplyTaskStatusTextBlock.Text = $"配置任务已提交：{applyResult.Data.TaskId}，正在轮询状态。";
        await PollTaskAsync(applyResult.Data.TaskId);
    }

    private async Task PollTaskAsync(string taskId)
    {
        var transientFailureCount = 0;
        for (var i = 0; i < 20; i++)
        {
            await Task.Delay(1000);
            var result = await _agentApiService.GetTaskAsync(_connectedBaseAddress, GetCurrentPassword(), _connectedLocalIPv4, taskId);
            if (!result.Success || result.Data is null)
            {
                if (result.StatusCode is null)
                {
                    transientFailureCount++;
                    ApplyTaskStatusTextBlock.Text = $"任务 {taskId} 轮询中，检测到短暂断连，正在重试（{transientFailureCount}）。";
                    continue;
                }

                ApplyTaskStatusTextBlock.Text = $"读取任务状态失败：{result.Message}";
                return;
            }

            transientFailureCount = 0;
            var task = result.Data;
            ApplyTaskStatusTextBlock.Text = $"任务 {task.TaskId} / {task.Status} / {task.Step} / {task.Detail}";
            if (task.Status is "success" or "failed" or "rolled_back")
            {
                if (RemoteTargetInterfaceComboBox.SelectedItem is RemoteInterfaceInfo selected)
                {
                    await LoadRemoteInterfaceConfigAsync(selected.SystemName);
                }

                return;
            }
        }

        ApplyTaskStatusTextBlock.Text = $"任务 {taskId} 轮询超时，请稍后手动刷新。";
    }

    private RemoteInterfaceConfig? BuildConfigRequest(string interfaceName)
    {
        if (string.IsNullOrWhiteSpace(NewIpTextBox.Text))
        {
            ConfigValidationTextBlock.Text = "IP 地址不能为空。";
            return null;
        }

        if (!TryMaskToPrefix(NewMaskTextBox.Text, out var prefix))
        {
            ConfigValidationTextBlock.Text = "子网掩码格式不正确。";
            return null;
        }

        var dns = string.IsNullOrWhiteSpace(NewDnsTextBox.Text)
            ? Array.Empty<string>()
            : new[] { NewDnsTextBox.Text.Trim() };

        return new RemoteInterfaceConfig
        {
            Interface = interfaceName,
            IP = NewIpTextBox.Text.Trim(),
            Prefix = prefix,
            Gateway = NewGatewayTextBox.Text.Trim(),
            Dns = dns,
        };
    }

    private static string PrefixToMask(int prefix)
    {
        if (prefix < 0 || prefix > 32)
        {
            return string.Empty;
        }

        var mask = prefix == 0 ? 0u : uint.MaxValue << (32 - prefix);
        return string.Join('.', new[]
        {
            (mask >> 24) & 255,
            (mask >> 16) & 255,
            (mask >> 8) & 255,
            mask & 255,
        });
    }

    private static bool TryMaskToPrefix(string maskText, out int prefix)
    {
        prefix = 0;
        if (string.IsNullOrWhiteSpace(maskText))
        {
            return false;
        }

        var parts = maskText.Trim().Split('.');
        if (parts.Length != 4)
        {
            return false;
        }

        uint mask = 0;
        foreach (var part in parts)
        {
            if (!byte.TryParse(part, out var octet))
            {
                return false;
            }

            mask = (mask << 8) | octet;
        }

        var seenZero = false;
        for (var i = 31; i >= 0; i--)
        {
            var bit = (mask & (1u << i)) != 0;
            if (bit && seenZero)
            {
                return false;
            }

            if (bit)
            {
                prefix++;
            }
            else
            {
                seenZero = true;
            }
        }

        return true;
    }

    private void ConfigInputChanged_OnChanged(object sender, TextChangedEventArgs e)
    {
        if (_suppressConfigChangeHandling)
        {
            return;
        }

        _configValidated = false;
        ConfigValidationTextBlock.Text = "配置内容已变更，请重新点击“校验配置”。";
        ApplyTaskStatusTextBlock.Text = "当前配置尚未通过校验。";
        UpdateButtonStates();
    }

    private void SetStatus(string message, bool addLog)
    {
        StatusTextBlock.Text = message;
        if (addLog)
        {
            AppendLog(message, false);
        }
    }

    private void AppendLog(string message, bool isInitial)
    {
        var prefix = DateTime.Now.ToString("HH:mm:ss", CultureInfo.InvariantCulture);
        EventLogListBox.Items.Add($"[{prefix}] {message}");
        if (!isInitial)
        {
            EventLogListBox.ScrollIntoView(EventLogListBox.Items[^1]);
        }
    }

    private void SetBusyState(bool isBusy)
    {
        _isBusy = isBusy;
        AdapterComboBox.IsEnabled = !isBusy;
        RefreshAdaptersButton.IsEnabled = !isBusy;
        PasswordBox.IsEnabled = !isBusy;
        PasswordTextBox.IsEnabled = !isBusy;
        TogglePasswordVisibilityButton.IsEnabled = !isBusy;
        SwitchMaintenanceButton.IsEnabled = !isBusy && AdapterComboBox.SelectedItem is AdapterInfo;
        DiscoverConnectButton.IsEnabled = !isBusy && AdapterComboBox.SelectedItem is AdapterInfo adapter && adapter.HasLink;
    }

    private void TogglePasswordVisibilityButton_OnClick(object sender, RoutedEventArgs e)
    {
        _isShowingPassword = !_isShowingPassword;
        if (_isShowingPassword)
        {
            PasswordTextBox.Text = PasswordBox.Password;
            PasswordBox.Visibility = Visibility.Collapsed;
            PasswordTextBox.Visibility = Visibility.Visible;
            TogglePasswordVisibilityButton.Content = "🙈";
            PasswordTextBox.Focus();
            PasswordTextBox.CaretIndex = PasswordTextBox.Text.Length;
            return;
        }

        PasswordBox.Password = PasswordTextBox.Text;
        PasswordTextBox.Visibility = Visibility.Collapsed;
        PasswordBox.Visibility = Visibility.Visible;
        TogglePasswordVisibilityButton.Content = "👁";
        PasswordBox.Focus();
    }

    private void PasswordBox_OnPasswordChanged(object sender, RoutedEventArgs e)
    {
        if (_suppressPasswordSync)
        {
            return;
        }

        _suppressPasswordSync = true;
        PasswordTextBox.Text = PasswordBox.Password;
        _suppressPasswordSync = false;
    }

    private void PasswordTextBox_OnTextChanged(object sender, TextChangedEventArgs e)
    {
        if (_suppressPasswordSync)
        {
            return;
        }

        _suppressPasswordSync = true;
        PasswordBox.Password = PasswordTextBox.Text;
        _suppressPasswordSync = false;
    }
}