NetworkTool/windows/NetworkTool.Client/DeviceDetailsWindow.xaml.cs

using System.Globalization;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using NetworkTool.Client.Models;
using NetworkTool.Client.Services;

namespace NetworkTool.Client;

public partial class DeviceDetailsWindow : Window
{
    private readonly ServerApiService _serverApiService = new();
    private readonly ObservableCollection<InterfaceEditor> _interfaces = [];
    private readonly string _baseAddress;
    private readonly string _remoteHost;
    private readonly string _localIPv4;
    private readonly string _password;
    private bool _configValidated;
    private bool _configDirty;
    private bool _isBusy;
    private bool _suppressConfigChangeHandling;
    private CancellationTokenSource? _statusMessageCts;

    public DeviceDetailsWindow(string baseAddress, string localIPv4, string password)
    {
        InitializeComponent();
        InterfacesItemsControl.ItemsSource = _interfaces;
        _baseAddress = baseAddress;
        _remoteHost = GetRemoteHost(baseAddress);
        _localIPv4 = localIPv4;
        _password = password;
        UpdateWindowTitle();
        Loaded += DeviceDetailsWindow_OnLoaded;
        Closing += DeviceDetailsWindow_OnClosing;
    }

    private async void DeviceDetailsWindow_OnLoaded(object sender, RoutedEventArgs e)
    {
        try
        {
            await LoadRemoteDetailsAsync();
            UpdateButtonStates();
        }
        catch (Exception ex)
        {
            ShowStatusMessage($"读取设备信息失败：{ex.Message}", StatusMessageType.Error);
            SetBusyState(false);
        }
    }

    private async Task LoadRemoteDetailsAsync()
    {
        ClearDetails();
        var device = await _serverApiService.GetDeviceInfoAsync(_baseAddress, _password, _localIPv4);
        if (device is not null)
        {
            UpdateWindowTitle(device.Hostname, device.ServerVersion);
        }

        var interfaces = await _serverApiService.GetInterfacesAsync(_baseAddress, _password, _localIPv4);
        if (interfaces is null)
        {
            ShowStatusMessage("设备已连接，但暂时无法读取 Linux 网口列表。", StatusMessageType.Warning);
            return;
        }

        SetConfigStateMessage($"当前管理网口：{interfaces.ManagementInterface}。正在读取全部网口配置。", false);
        for (var i = 0; i < interfaces.Interfaces.Count; i++)
        {
            var editor = new InterfaceEditor(interfaces.Interfaces[i], i + 1);
            _interfaces.Add(editor);
            await LoadRemoteInterfaceConfigAsync(editor);
        }

        _configValidated = false;
        _configDirty = false;
        SetConfigStateMessage("已读取全部网口配置。", false);
        ShowStatusMessage("已读取全部网口配置。", StatusMessageType.Success);
    }

    private void ClearDetails()
    {
        UpdateWindowTitle();
        _interfaces.Clear();
        _configValidated = false;
        _configDirty = false;
    }

    private void UpdateWindowTitle(string? hostname = null, string? serverVersion = null)
    {
        var hostPart = string.IsNullOrWhiteSpace(hostname) ? _remoteHost : $"{hostname} ({_remoteHost})";
        var versionPart = string.IsNullOrWhiteSpace(serverVersion) ? string.Empty : $" - Server {serverVersion}";
        Title = string.IsNullOrWhiteSpace(hostPart) ? $"设备信息与网口配置{versionPart}" : $"设备信息与网口配置 - {hostPart}{versionPart}";
    }

    private static string GetRemoteHost(string baseAddress)
    {
        return Uri.TryCreate(baseAddress, UriKind.Absolute, out var uri) ? uri.Host : baseAddress;
    }

    private async Task LoadRemoteInterfaceConfigAsync(InterfaceEditor editor, bool useBusyState = false)
    {
        if (useBusyState)
        {
            SetBusyState(true, "正在读取 Linux 端 IP 配置...");
        }

        try
        {
            var result = await _serverApiService.GetInterfaceConfigAsync(_baseAddress, _password, _localIPv4, editor.SystemName);
            if (!result.Success || result.Data is null)
            {
                ShowStatusMessage($"读取目标网口 {editor.DisplayLabel} 配置失败：{result.Message}", StatusMessageType.Error);
                return;
            }

            var config = result.Data;
            _suppressConfigChangeHandling = true;
            editor.Dhcp4 = config.Dhcp4;
            editor.Addresses.Clear();
            foreach (var address in config.EffectiveAddresses)
            {
                editor.Addresses.Add(new EditableAddress(editor) { IP = address.IP, Mask = PrefixToMask(address.Prefix) });
            }
            editor.Routes.Clear();
            editor.DefaultGatewayEnabled = false;
            editor.DefaultGateway = string.Empty;
            foreach (var route in config.EffectiveRoutes)
            {
                if (route.To.Equals("default", StringComparison.OrdinalIgnoreCase))
                {
                    editor.DefaultGatewayEnabled = true;
                    editor.DefaultGateway = route.Via;
                }
                else
                {
                    editor.Routes.Add(CreateEditableRoute(editor, route));
                }
            }
            editor.CustomRoutesEnabled = editor.Routes.Count > 0;
            editor.Dns.Clear();
            if (config.Dns is not null)
            {
                foreach (var dns in config.Dns)
                {
                    editor.Dns.Add(new EditableDns(editor) { Address = dns });
                }
            }
            editor.CaptureOriginalConfiguration();
            _suppressConfigChangeHandling = false;
            UpdateButtonStates();
        }
        finally
        {
            _suppressConfigChangeHandling = false;
            if (useBusyState)
            {
                SetBusyState(false);
            }
        }
    }

    private async void ReloadInterfaceConfigButton_OnClick(object sender, RoutedEventArgs e)
    {
        if (!ConfirmDiscardPendingChanges("当前配置已修改但尚未保存，重新获取会丢失未保存内容。是否继续重新获取？", "确认重新获取配置"))
        {
            return;
        }

        SetBusyState(true, "正在重新获取全部网口配置...");
        try
        {
            foreach (var editor in _interfaces)
            {
                await LoadRemoteInterfaceConfigAsync(editor);
            }

            _configValidated = false;
            _configDirty = false;
            SetConfigStateMessage("已重新获取全部网口配置。", false);
            ShowStatusMessage("已重新获取全部网口配置。", StatusMessageType.Success);
        }
        finally
        {
            SetBusyState(false);
        }
    }

    private void DeviceDetailsWindow_OnClosing(object? sender, CancelEventArgs e)
    {
        if (!ConfirmDiscardPendingChanges("当前配置已修改但尚未保存。是否关闭窗口？", "确认关闭窗口"))
        {
            e.Cancel = true;
        }
    }

    private bool ConfirmDiscardPendingChanges(string message, string title)
    {
        if (!_configDirty)
        {
            return true;
        }

        return MessageBox.Show(this, message, title, MessageBoxButton.OKCancel, MessageBoxImage.Warning) == MessageBoxResult.OK;
    }

    private async void ValidateConfigButton_OnClick(object sender, RoutedEventArgs e)
    {
        var request = BuildConfigRequests();
        if (request is null)
        {
            return;
        }

        SetBusyState(true, "正在校验配置，请稍候...");
        try
        {
            var result = await _serverApiService.ValidateInterfaceConfigsAsync(_baseAddress, _password, _localIPv4, 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;
                SetConfigStateMessage(_configValidated ? "配置已校验通过，可以保存。" : "配置校验未通过，请修正后重新校验。", !_configValidated);
                ShowStatusMessage(
                    _configValidated ? $"全部网口校验通过，可保存配置。{warnings}" : $"校验失败。{errors}{warnings}",
                    _configValidated ? StatusMessageType.Success : StatusMessageType.Error);
            }
            else
            {
                SetConfigStateMessage("配置校验未通过，请修正后重新校验。", true);
                ShowStatusMessage($"校验失败：{result.Message}", StatusMessageType.Error);
            }

            UpdateButtonStates();
        }
        finally
        {
            SetBusyState(false);
        }
    }

    private async void ApplyConfigButton_OnClick(object sender, RoutedEventArgs e)
    {
        var request = BuildConfigRequests();
        if (request is null)
        {
            return;
        }

        var changeSummary = FormatChangeSummary();
        var confirmMessage = string.IsNullOrWhiteSpace(changeSummary)
            ? "将要一次性保存以下网口配置：\n\n" + FormatConfigSummary(request) + "\n\n请确认是否继续。"
            : "将要一次性保存以下已修改配置：\n\n" + changeSummary + "\n\n完整目标配置：\n\n" + FormatConfigSummary(request) + "\n\n请确认是否继续。";
        if (MessageBox.Show(this, confirmMessage, "确认保存配置", MessageBoxButton.OKCancel, MessageBoxImage.Question) != MessageBoxResult.OK)
        {
            return;
        }

        SetBusyState(true, "正在提交并保存配置，请稍候...");
        try
        {
            var applyResult = await _serverApiService.ApplyInterfaceConfigsAsync(_baseAddress, _password, _localIPv4, request);
            if (!applyResult.Success || applyResult.Data is null)
            {
                ShowStatusMessage($"提交配置任务失败：{applyResult.Message}", StatusMessageType.Error);
                return;
            }

            ShowStatusMessage("配置任务已提交，正在保存并等待连通确认...", StatusMessageType.Info);
            await PollTaskAsync(applyResult.Data.TaskId);
        }
        finally
        {
            SetBusyState(false);
        }
    }

    private async Task PollTaskAsync(string taskId)
    {
        var transientFailureCount = 0;
        var confirmationRequested = false;
        string? lastTaskMessage = null;
        for (var i = 0; i < 20; i++)
        {
            await Task.Delay(1000);
            var result = await _serverApiService.GetTaskAsync(_baseAddress, _password, _localIPv4, taskId);
            if (!result.Success || result.Data is null)
            {
                if (result.StatusCode is null)
                {
                    transientFailureCount++;
                    ShowStatusMessage($"设备连接短暂中断，正在重试（{transientFailureCount}）。", StatusMessageType.Warning);
                    continue;
                }

                ShowStatusMessage($"读取任务状态失败：{result.Message}", StatusMessageType.Error);
                return;
            }

            transientFailureCount = 0;
            var task = result.Data;
            var (taskMessage, taskMessageType) = FormatTaskStatusMessage(task);
            if (!string.Equals(taskMessage, lastTaskMessage, StringComparison.Ordinal))
            {
                lastTaskMessage = taskMessage;
                ShowStatusMessage(taskMessage, taskMessageType);
            }
            if (task.Status == "running" && task.Step == "confirming" && !confirmationRequested)
            {
                confirmationRequested = true;
                var confirmResult = await _serverApiService.ConfirmApplyTaskAsync(_baseAddress, _password, _localIPv4, taskId);
                ShowStatusMessage(
                    confirmResult.Success ? "设备连接已恢复，已自动确认保留配置。" : $"自动确认保留配置失败：{confirmResult.Message}",
                    confirmResult.Success ? StatusMessageType.Success : StatusMessageType.Error);
            }

            if (task.Status is "success" or "failed" or "rolled_back")
            {
                if (task.Status == "success")
                {
                    _configValidated = false;
                    _configDirty = false;
                    SetConfigStateMessage("配置已保存，当前显示为设备最新配置。", false);
                    foreach (var editor in _interfaces)
                    {
                        await LoadRemoteInterfaceConfigAsync(editor);
                    }
                }

                ShowTaskCompletionDialog(task);

                return;
            }
        }

        ShowStatusMessage($"任务 {taskId} 轮询超时，请稍后手动刷新。", StatusMessageType.Warning);
    }

    private async void RebootButton_OnClick(object sender, RoutedEventArgs e)
    {
        await ExecuteSystemActionAsync(
            "重启设备",
            "设备将立即重启，当前窗口和连接可能马上中断。是否继续？",
            () => _serverApiService.RebootAsync(_baseAddress, _password, _localIPv4));
    }

    private async void ShutdownButton_OnClick(object sender, RoutedEventArgs e)
    {
        await ExecuteSystemActionAsync(
            "关闭设备",
            "设备将立即关机，当前窗口和连接可能马上中断。是否继续？",
            () => _serverApiService.ShutdownAsync(_baseAddress, _password, _localIPv4));
    }

    private async Task ExecuteSystemActionAsync(string title, string confirmMessage, Func<Task<ApiCallResult<RemoteSystemActionResponse>>> action)
    {
        if (MessageBox.Show(this, confirmMessage, title, MessageBoxButton.OKCancel, MessageBoxImage.Warning) != MessageBoxResult.OK)
        {
            return;
        }

        var result = await action();
        if (!result.Success || result.Data is null)
        {
            ShowStatusMessage($"{title}失败：{result.Message}", StatusMessageType.Error);
            return;
        }

        ShowStatusMessage($"{title}任务已提交：{result.Data.TaskId}。命令已发出，设备可能立即断开。", StatusMessageType.Success);
    }

    private RemoteInterfaceConfig[]? BuildConfigRequests()
    {
        CommitConfigEdits();
        var result = new List<RemoteInterfaceConfig>();
        foreach (var editor in _interfaces)
        {
            var request = BuildConfigRequest(editor);
            if (request is null)
            {
                return null;
            }

            result.Add(request);
        }

        if (result.Count == 0)
        {
            ShowStatusMessage("网口配置不能为空。", StatusMessageType.Error);
            return null;
        }

        return result.ToArray();
    }

    private RemoteInterfaceConfig? BuildConfigRequest(InterfaceEditor editor)
    {
        var dhcp4 = editor.Dhcp4;
        var addresses = Array.Empty<RemoteInterfaceAddressConfig>();
        var routes = Array.Empty<RemoteInterfaceRouteConfig>();
        if (!dhcp4)
        {
            if (editor.Addresses.Count == 0)
            {
                ShowStatusMessage($"{editor.SystemName}：IP 地址不能为空，至少需要填写一行地址。", StatusMessageType.Error);
                return null;
            }

            if (!TryBuildAddresses(editor, out addresses, out var addressError))
            {
                ShowStatusMessage($"{editor.SystemName}：{addressError}", StatusMessageType.Error);
                return null;
            }

            if (!TryBuildRoutes(editor, out routes, out var routeError))
            {
                ShowStatusMessage($"{editor.SystemName}：{routeError}", StatusMessageType.Error);
                return null;
            }
        }

        if (!TryBuildDns(editor, out var dns, out var dnsError))
        {
            ShowStatusMessage($"{editor.SystemName}：{dnsError}", StatusMessageType.Error);
            return null;
        }

        return new RemoteInterfaceConfig
        {
            Interface = editor.SystemName,
            Dhcp4 = dhcp4,
            Addresses = dhcp4 ? Array.Empty<RemoteInterfaceAddressConfig>() : addresses,
            Routes = dhcp4 ? Array.Empty<RemoteInterfaceRouteConfig>() : routes,
            Dns = dns,
        };
    }

    private void CommitConfigEdits()
    {
        CommitDataGridEdits(InterfacesItemsControl);
    }

    private static void CommitDataGridEdits(DependencyObject root)
    {
        for (var i = 0; i < VisualTreeHelper.GetChildrenCount(root); i++)
        {
            var child = VisualTreeHelper.GetChild(root, i);
            if (child is DataGrid dataGrid)
            {
                dataGrid.CommitEdit(DataGridEditingUnit.Cell, true);
                dataGrid.CommitEdit(DataGridEditingUnit.Row, true);
            }
            CommitDataGridEdits(child);
        }
    }

    private static string FormatCurrentIp(RemoteInterfaceConfig config)
    {
        if (config.EffectiveAddresses.Count == 0)
        {
            return config.Dhcp4 ? "DHCP 自动获取，暂无 IPv4" : "无";
        }

        var text = FormatAddresses(config.EffectiveAddresses);
        return config.Dhcp4 ? $"{text} (DHCP)" : text;
    }

    private static string FormatAddresses(IReadOnlyList<RemoteInterfaceAddressConfig> addresses)
    {
        return addresses.Count == 0 ? "无" : string.Join(Environment.NewLine, addresses.Select(item => $"{item.IP}/{item.Prefix}"));
    }

    private static string FormatRoutes(IReadOnlyList<RemoteInterfaceRouteConfig> routes)
    {
        return routes.Count == 0 ? "无" : string.Join(Environment.NewLine, routes.Select(item => $"{item.To} via {item.Via}"));
    }

    private static string FormatConfigSummary(IReadOnlyList<RemoteInterfaceConfig> configs)
    {
        return string.Join(Environment.NewLine + Environment.NewLine, configs.Select(item =>
            $"网口：{item.Interface}\n" +
            $"模式：{(item.Dhcp4 ? "DHCP 自动获取" : "静态 IPv4")}\n" +
            $"IP：{(item.Dhcp4 ? "自动获取" : FormatAddresses(item.Addresses))}\n" +
            $"路由：{(item.Dhcp4 ? "自动获取" : FormatRoutes(item.Routes))}\n" +
            $"DNS：{(item.Dns.Count == 0 ? "无" : string.Join(", ", item.Dns))}"));
    }

    private string FormatChangeSummary()
    {
        var changed = _interfaces.Where(item => item.HasChanges).Select(item => item.FormatChangeSummary()).Where(item => item != string.Empty);
        return string.Join(Environment.NewLine + Environment.NewLine, changed);
    }

    private static EditableRoute CreateEditableRoute(InterfaceEditor owner, RemoteInterfaceRouteConfig route)
    {
        var to = route.To.Trim();
        var mask = string.Empty;
        if (to.Contains('/'))
        {
            var parts = to.Split('/', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
            if (parts.Length == 2 && int.TryParse(parts[1], out var prefix) && prefix >= 0 && prefix <= 32)
            {
                to = parts[0];
                mask = PrefixToMask(prefix);
            }
        }

        return new EditableRoute(owner) { To = to, Mask = mask, Via = route.Via };
    }

    private bool TryBuildAddresses(InterfaceEditor editor, out RemoteInterfaceAddressConfig[] addresses, out string error)
    {
        var result = new List<RemoteInterfaceAddressConfig>();
        for (var i = 0; i < editor.Addresses.Count; i++)
        {
            var row = editor.Addresses[i];
            var ip = row.IP.Trim();
            var maskText = row.Mask.Trim();
            if (ip == string.Empty && maskText == string.Empty)
            {
                addresses = [];
                error = $"第 {i + 1} 行 IP 配置为空，请填写或删除该行。";
                return false;
            }
            if (ip.Contains('/'))
            {
                var parts = ip.Split('/', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
                if (parts.Length != 2 || !int.TryParse(parts[1], out var cidrPrefix) || cidrPrefix < 0 || cidrPrefix > 32)
                {
                    addresses = [];
                    error = $"地址格式不正确：{ip}";
                    return false;
                }
                row.IP = parts[0];
                row.Mask = PrefixToMask(cidrPrefix);
                result.Add(new RemoteInterfaceAddressConfig { IP = parts[0], Prefix = cidrPrefix });
                continue;
            }
            if (ip == string.Empty || maskText == string.Empty)
            {
                addresses = [];
                error = "IP 地址和子网掩码都需要填写。";
                return false;
            }
            if (!TryMaskOrPrefixToPrefix(maskText, out var prefix))
            {
                addresses = [];
                error = $"子网掩码格式不正确：{ip} {maskText}";
                return false;
            }
            row.Mask = PrefixToMask(prefix);
            result.Add(new RemoteInterfaceAddressConfig { IP = ip, Prefix = prefix });
        }

        addresses = result.ToArray();
        if (addresses.Length == 0)
        {
            error = "IP 地址不能为空，至少需要填写一行地址。";
            return false;
        }

        error = string.Empty;
        return true;
    }

    private bool TryBuildRoutes(InterfaceEditor editor, out RemoteInterfaceRouteConfig[] routes, out string error)
    {
        var result = new List<RemoteInterfaceRouteConfig>();
        if (editor.DefaultGatewayEnabled)
        {
            var gateway = editor.DefaultGateway.Trim();
            if (gateway == string.Empty)
            {
                routes = [];
                error = "启用默认网关时，网关地址不能为空。";
                return false;
            }
            result.Add(new RemoteInterfaceRouteConfig { To = "default", Via = gateway });
        }
        if (editor.CustomRoutesEnabled)
        {
            for (var i = 0; i < editor.Routes.Count; i++)
            {
                var row = editor.Routes[i];
                var to = row.To.Trim();
                var maskText = row.Mask.Trim();
                var via = row.Via.Trim();
                if (to == string.Empty && maskText == string.Empty && via == string.Empty)
                {
                    routes = [];
                    error = $"自定义路由第 {i + 1} 行为空，请填写或删除该行。";
                    return false;
                }
                if (to.Contains('/'))
                {
                    var parts = to.Split('/', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
                    if (parts.Length != 2 || !int.TryParse(parts[1], out var cidrPrefix) || cidrPrefix < 0 || cidrPrefix > 32)
                    {
                        routes = [];
                        error = $"自定义路由目标网段格式不正确：{to}";
                        return false;
                    }
                    to = parts[0];
                    maskText = PrefixToMask(cidrPrefix);
                    row.To = to;
                    row.Mask = maskText;
                }
                if (to == string.Empty || maskText == string.Empty || via == string.Empty)
                {
                    routes = [];
                    error = "自定义路由的目标网段、子网掩码和网关地址都需要填写。";
                    return false;
                }
                if (!TryMaskOrPrefixToPrefix(maskText, out var prefix))
                {
                    routes = [];
                    error = $"自定义路由子网掩码格式不正确：{to} {maskText}";
                    return false;
                }
                row.Mask = PrefixToMask(prefix);
                result.Add(new RemoteInterfaceRouteConfig { To = $"{to}/{prefix}", Via = via });
            }
        }

        routes = result.ToArray();
        error = string.Empty;
        return true;
    }

    private static bool TryBuildDns(InterfaceEditor editor, out string[] dns, out string error)
    {
        var result = new List<string>();
        for (var i = 0; i < editor.Dns.Count; i++)
        {
            var address = editor.Dns[i].Address.Trim();
            if (address == string.Empty)
            {
                dns = [];
                error = $"DNS 第 {i + 1} 行为空，请填写或删除该行。";
                return false;
            }

            result.Add(address);
        }

        dns = result.ToArray();
        error = string.Empty;
        return true;
    }

    private static bool TryParseAddresses(string text, out RemoteInterfaceAddressConfig[] addresses, out string error)
    {
        var result = new List<RemoteInterfaceAddressConfig>();
        foreach (var line in ParseListText(text))
        {
            var parts = line.Split(' ', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
            if (parts.Length == 1 && line.Contains('/'))
            {
                var cidrParts = line.Split('/', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
                if (cidrParts.Length != 2 || !int.TryParse(cidrParts[1], out var prefix) || prefix < 0 || prefix > 32)
                {
                    addresses = [];
                    error = $"地址格式不正确：{line}";
                    return false;
                }
                result.Add(new RemoteInterfaceAddressConfig { IP = cidrParts[0], Prefix = prefix });
                continue;
            }

            if (parts.Length != 2)
            {
                addresses = [];
                error = $"地址格式不正确：{line}";
                return false;
            }
            if (!TryMaskOrPrefixToPrefix(parts[1], out var parsedPrefix))
            {
                addresses = [];
                error = $"子网掩码或前缀格式不正确：{line}";
                return false;
            }
            result.Add(new RemoteInterfaceAddressConfig { IP = parts[0], Prefix = parsedPrefix });
        }

        addresses = result.ToArray();
        error = string.Empty;
        return addresses.Length > 0;
    }

    private static bool TryParseRoutes(string text, out RemoteInterfaceRouteConfig[] routes, out string error)
    {
        var result = new List<RemoteInterfaceRouteConfig>();
        foreach (var line in ParseListText(text))
        {
            var parts = line.Split(' ', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
            if (parts.Length == 1)
            {
                result.Add(new RemoteInterfaceRouteConfig { To = "default", Via = parts[0] });
                continue;
            }
            if (parts.Length == 3 && parts[1].Equals("via", StringComparison.OrdinalIgnoreCase))
            {
                result.Add(new RemoteInterfaceRouteConfig { To = parts[0], Via = parts[2] });
                continue;
            }

            routes = [];
            error = $"路由格式不正确：{line}";
            return false;
        }

        routes = result.ToArray();
        error = string.Empty;
        return true;
    }

    private static string[] ParseListText(string text)
    {
        return text.Split(['\r', '\n', ',', ';'], StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
    }

    private static bool TryMaskOrPrefixToPrefix(string text, out int prefix)
    {
        if (int.TryParse(text, out prefix) && prefix >= 0 && prefix <= 32)
        {
            return true;
        }
        return TryMaskToPrefix(text, out prefix);
    }

    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)
    {
        MarkConfigChanged();
    }

    private void ConfigModeChanged_OnChanged(object sender, RoutedEventArgs e)
    {
        if (_suppressConfigChangeHandling)
        {
            UpdateButtonStates();
            return;
        }

        MarkConfigChanged();
    }

    private void GatewayOrRouteModeChanged_OnChanged(object sender, RoutedEventArgs e)
    {
        if (_suppressConfigChangeHandling)
        {
            UpdateButtonStates();
            return;
        }

        MarkConfigChanged();
    }

    private void ConfigGrid_OnCellEditEnding(object sender, DataGridCellEditEndingEventArgs e)
    {
        if (e.Row.Item is EditableAddress address)
        {
            NormalizeAddressRow(address);
        }
        else if (e.Row.Item is EditableRoute route)
        {
            NormalizeRouteRow(route);
        }
        MarkConfigChanged();
    }

    private void DataGrid_OnPreviewMouseWheel(object sender, MouseWheelEventArgs e)
    {
        if (sender is not DataGrid dataGrid)
        {
            return;
        }

        e.Handled = true;
        var eventArg = new MouseWheelEventArgs(e.MouseDevice, e.Timestamp, e.Delta)
        {
            RoutedEvent = MouseWheelEvent,
            Source = dataGrid,
        };
        ContentScrollViewer.RaiseEvent(eventArg);
    }

    private void ConfigGrid_OnLostKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
    {
        if (sender is not DataGrid dataGrid)
        {
            return;
        }

        Dispatcher.BeginInvoke(() =>
        {
            if (!dataGrid.IsKeyboardFocusWithin)
            {
                dataGrid.UnselectAllCells();
                dataGrid.UnselectAll();
            }
        }, System.Windows.Threading.DispatcherPriority.Input);
    }

    private void AddAddressButton_OnClick(object sender, RoutedEventArgs e)
    {
        if ((sender as FrameworkElement)?.DataContext is not InterfaceEditor editor)
        {
            return;
        }
        editor.Addresses.Add(new EditableAddress(editor) { Mask = "255.255.255.0" });
        MarkConfigChanged();
    }

    private void AddRouteButton_OnClick(object sender, RoutedEventArgs e)
    {
        if ((sender as FrameworkElement)?.DataContext is not InterfaceEditor editor)
        {
            return;
        }
        editor.Routes.Add(new EditableRoute(editor));
        MarkConfigChanged();
    }

    private void AddDnsButton_OnClick(object sender, RoutedEventArgs e)
    {
        if ((sender as FrameworkElement)?.DataContext is not InterfaceEditor editor)
        {
            return;
        }
        editor.Dns.Add(new EditableDns(editor));
        MarkConfigChanged();
    }

    private void DeleteAddressButton_OnClick(object sender, RoutedEventArgs e)
    {
        if ((sender as FrameworkElement)?.DataContext is not EditableAddress address)
        {
            return;
        }
        address.Owner.Addresses.Remove(address);
        MarkConfigChanged();
    }

    private void DeleteRouteButton_OnClick(object sender, RoutedEventArgs e)
    {
        if ((sender as FrameworkElement)?.DataContext is EditableRoute route)
        {
            route.Owner.Routes.Remove(route);
            MarkConfigChanged();
        }
    }

    private void DeleteDnsButton_OnClick(object sender, RoutedEventArgs e)
    {
        if ((sender as FrameworkElement)?.DataContext is EditableDns dns)
        {
            dns.Owner.Dns.Remove(dns);
            MarkConfigChanged();
        }
    }

    private void MarkConfigChanged()
    {
        if (_suppressConfigChangeHandling)
        {
            return;
        }

        _configValidated = false;
        RefreshChangeState();
        SetConfigStateMessage(
            _configDirty ? "配置已修改，需重新校验后才能保存。" : "配置未修改。",
            _configDirty);
        UpdateButtonStates();
    }

    private void RefreshChangeState()
    {
        foreach (var editor in _interfaces)
        {
            editor.NotifyChangeState();
        }

        _configDirty = _interfaces.Any(item => item.HasChanges);
    }

    private string FormatChangedFields()
    {
        var fields = _interfaces.Where(item => item.HasChanges).Select(item => $"{item.DisplayLabel} 的 {item.ChangedFieldsText}");
        return string.Join("；", fields);
    }

    private void SetConfigStateMessage(string message, bool requiresAttention)
    {
        ConfigStateTextBlock.Text = message;
        ConfigStateTextBlock.Foreground = requiresAttention
            ? new SolidColorBrush((Color)ColorConverter.ConvertFromString("#C2410C"))
            : new SolidColorBrush((Color)ColorConverter.ConvertFromString("#6B7280"));
    }

    private static void NormalizeAddressRow(EditableAddress row)
    {
        var ip = row.IP.Trim();
        if (!ip.Contains('/'))
        {
            return;
        }
        var parts = ip.Split('/', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
        if (parts.Length == 2 && int.TryParse(parts[1], out var prefix) && prefix >= 0 && prefix <= 32)
        {
            row.IP = parts[0];
            row.Mask = PrefixToMask(prefix);
        }
    }

    private static void NormalizeRouteRow(EditableRoute row)
    {
        var to = row.To.Trim();
        if (!to.Contains('/'))
        {
            return;
        }
        var parts = to.Split('/', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
        if (parts.Length == 2 && int.TryParse(parts[1], out var prefix) && prefix >= 0 && prefix <= 32)
        {
            row.To = parts[0];
            row.Mask = PrefixToMask(prefix);
        }
    }

    private void ShowStatusMessage(string message, StatusMessageType type)
    {
        ApplyStatusMessageStyle(type);
        StatusMessageTextBlock.Text = message;
        StatusMessageBorder.Opacity = 0;
        StatusMessageBorder.Visibility = Visibility.Visible;
        StatusMessageBorder.BeginAnimation(OpacityProperty, new DoubleAnimation(1, TimeSpan.FromMilliseconds(160)));
        _statusMessageCts?.Cancel();
        _statusMessageCts = new CancellationTokenSource();
        _ = HideStatusMessageAsync(_statusMessageCts.Token);
    }

    private async Task HideStatusMessageAsync(CancellationToken cancellationToken)
    {
        try
        {
            await Task.Delay(3000, cancellationToken);
            await Dispatcher.InvokeAsync(() =>
            {
                var animation = new DoubleAnimation(0, TimeSpan.FromMilliseconds(200));
                animation.Completed += (_, _) =>
                {
                    if (!cancellationToken.IsCancellationRequested)
                    {
                        StatusMessageBorder.Visibility = Visibility.Collapsed;
                    }
                };
                StatusMessageBorder.BeginAnimation(OpacityProperty, animation);
            });
        }
        catch (TaskCanceledException)
        {
        }
    }

    private void ApplyStatusMessageStyle(StatusMessageType type)
    {
        var (background, icon) = GetStatusMessageVisuals(type);
        StatusIconBorder.Background = background;
        StatusIconTextBlock.Text = icon;
        StatusMessageTextBlock.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#1F2937"));
    }

    private static (Brush Background, string Icon) GetStatusMessageVisuals(StatusMessageType type)
    {
        return type switch
        {
            StatusMessageType.Success => (new SolidColorBrush((Color)ColorConverter.ConvertFromString("#27C346")), "✓"),
            StatusMessageType.Error => (new SolidColorBrush((Color)ColorConverter.ConvertFromString("#F76965")), "×"),
            StatusMessageType.Warning => (new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FF9626")), "!"),
            _ => (new SolidColorBrush((Color)ColorConverter.ConvertFromString("#508DF8")), "i"),
        };
    }

    private static (string Message, StatusMessageType Type) FormatTaskStatusMessage(RemoteTaskResult task)
    {
        return task.Status switch
        {
            "success" => (string.IsNullOrWhiteSpace(task.Detail) ? "配置已成功保存。" : task.Detail, StatusMessageType.Success),
            "failed" => (string.IsNullOrWhiteSpace(task.Detail) ? "配置保存失败。" : task.Detail, StatusMessageType.Error),
            "rolled_back" => (string.IsNullOrWhiteSpace(task.Detail) ? "配置保存失败，已自动回滚。" : task.Detail, StatusMessageType.Error),
            _ => task.Step switch
            {
                "validating" => ("正在校验配置...", StatusMessageType.Info),
                "writing_netplan" => ("正在写入 Linux 网络配置...", StatusMessageType.Info),
                "applying" => ("正在保存 Linux 网络配置...", StatusMessageType.Info),
                "confirming" => ("设备连接已恢复，正在自动确认保留配置...", StatusMessageType.Info),
                "rolling_back" => ("配置保存失败，正在自动回滚...", StatusMessageType.Warning),
                _ => (string.IsNullOrWhiteSpace(task.Detail) ? "正在处理，请稍候..." : task.Detail, StatusMessageType.Info),
            }
        };
    }

    private void ShowTaskCompletionDialog(RemoteTaskResult task)
    {
        var (message, _) = FormatTaskStatusMessage(task);
        var title = task.Status == "success" ? "保存配置成功" : "保存配置失败";
        var image = task.Status == "success" ? MessageBoxImage.Information : MessageBoxImage.Warning;
        MessageBox.Show(this, message, title, MessageBoxButton.OK, image);
    }

    private void UpdateButtonStates()
    {
        var hasInterfaces = _interfaces.Count > 0;
        InterfacesItemsControl.IsEnabled = !_isBusy && hasInterfaces;
        ReloadInterfaceConfigButton.IsEnabled = !_isBusy && hasInterfaces;
        ValidateConfigButton.IsEnabled = !_isBusy && hasInterfaces;
        ApplyConfigButton.IsEnabled = !_isBusy && _configValidated && hasInterfaces;
        RebootButton.IsEnabled = !_isBusy;
        ShutdownButton.IsEnabled = !_isBusy;
    }

    private void SetBusyState(bool isBusy, string? message = null)
    {
        _isBusy = isBusy;
        BusyOverlay.Visibility = isBusy ? Visibility.Visible : Visibility.Collapsed;
        BusyMessageTextBlock.Text = string.IsNullOrWhiteSpace(message) ? "正在处理，请稍候..." : message;
        UpdateButtonStates();
    }

    private sealed class InterfaceEditor : INotifyPropertyChanged
    {
        private bool _dhcp4;
        private bool _defaultGatewayEnabled;
        private bool _customRoutesEnabled;
        private string _defaultGateway = string.Empty;
        private bool _originalDhcp4;
        private string[] _originalAddressKeys = [];
        private string[] _originalGatewayKeys = [];
        private string[] _originalDnsKeys = [];

        public InterfaceEditor(RemoteInterfaceInfo info, int displayIndex)
        {
            SystemName = info.SystemName;
            DisplayLabel = $"网口{displayIndex}：{SystemName}";
            StatusSummary = info.StatusSummary;
            LinkUp = info.LinkUp;
        }

        public string SystemName { get; }
        public string DisplayLabel { get; }
        public string StatusSummary { get; }
        public bool LinkUp { get; }
        public ObservableCollection<EditableAddress> Addresses { get; } = [];
        public ObservableCollection<EditableRoute> Routes { get; } = [];
        public ObservableCollection<EditableDns> Dns { get; } = [];
        public bool IsAddressModified => _originalDhcp4 != Dhcp4 || !GetAddressKeys().SequenceEqual(_originalAddressKeys);
        public bool IsGatewayModified => _originalDhcp4 != Dhcp4 || !GetGatewayKeys().SequenceEqual(_originalGatewayKeys);
        public bool IsDnsModified => !GetDnsKeys().SequenceEqual(_originalDnsKeys);
        public bool HasChanges => IsAddressModified || IsGatewayModified || IsDnsModified;
        public string ChangedFieldsText => string.Join("、", new[]
        {
            IsAddressModified ? "IP 地址" : string.Empty,
            IsGatewayModified ? "网关" : string.Empty,
            IsDnsModified ? "DNS" : string.Empty,
        }.Where(item => item != string.Empty));

        public bool Dhcp4
        {
            get => _dhcp4;
            set => SetField(ref _dhcp4, value);
        }

        public bool DefaultGatewayEnabled
        {
            get => _defaultGatewayEnabled;
            set => SetField(ref _defaultGatewayEnabled, value);
        }

        public bool CustomRoutesEnabled
        {
            get => _customRoutesEnabled;
            set => SetField(ref _customRoutesEnabled, value);
        }

        public string DefaultGateway
        {
            get => _defaultGateway;
            set => SetField(ref _defaultGateway, value);
        }

        public event PropertyChangedEventHandler? PropertyChanged;

        public void CaptureOriginalConfiguration()
        {
            _originalDhcp4 = Dhcp4;
            _originalAddressKeys = GetAddressKeys();
            _originalGatewayKeys = GetGatewayKeys();
            _originalDnsKeys = GetDnsKeys();
            NotifyChangeState();
        }

        public void NotifyChangeState()
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsAddressModified)));
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsGatewayModified)));
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsDnsModified)));
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(HasChanges)));
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(ChangedFieldsText)));
        }

        public string FormatChangeSummary()
        {
            var lines = new List<string> { DisplayLabel };
            if (IsAddressModified)
            {
                lines.Add($"IP：{FormatAddressSummary(_originalDhcp4, _originalAddressKeys)} 将改为 {FormatAddressSummary(Dhcp4, GetAddressKeys())}");
            }
            if (IsGatewayModified)
            {
                lines.Add($"网关：{FormatGatewaySummary(_originalDhcp4, _originalGatewayKeys)} 将改为 {FormatGatewaySummary(Dhcp4, GetGatewayKeys())}");
            }
            if (IsDnsModified)
            {
                lines.Add($"DNS：{FormatKeys(_originalDnsKeys)} 将改为 {FormatKeys(GetDnsKeys())}");
            }

            return lines.Count == 1 ? string.Empty : string.Join(Environment.NewLine, lines);
        }

        private string[] GetAddressKeys()
        {
            return Addresses
                .Select(item => $"{item.IP.Trim()}/{item.Mask.Trim()}")
                .Where(item => item != "/")
                .ToArray();
        }

        private string[] GetGatewayKeys()
        {
            var keys = new List<string>();
            keys.Add($"default enabled {DefaultGatewayEnabled}");
            if (!string.IsNullOrWhiteSpace(DefaultGateway))
            {
                keys.Add($"default via {DefaultGateway.Trim()}");
            }
            keys.Add($"custom routes enabled {CustomRoutesEnabled}");
            if (CustomRoutesEnabled)
            {
                keys.AddRange(Routes
                    .Select(item => $"{item.To.Trim()}/{item.Mask.Trim()} via {item.Via.Trim()}")
                    .Where(item => item != "/ via"));
            }

            return keys.ToArray();
        }

        private string[] GetDnsKeys()
        {
            return Dns.Select(item => item.Address.Trim()).Where(item => item != string.Empty).ToArray();
        }

        private static string FormatKeys(IReadOnlyList<string> keys)
        {
            return keys.Count == 0 ? "无" : string.Join(", ", keys);
        }

        private static string FormatAddressSummary(bool dhcp4, IReadOnlyList<string> keys)
        {
            return dhcp4 ? "自动获取" : FormatKeys(keys);
        }

        private static string FormatGatewaySummary(bool dhcp4, IReadOnlyList<string> keys)
        {
            if (dhcp4)
            {
                return "自动获取";
            }

            var defaultGatewayEnabled = keys.Contains("default enabled True");
            var customRoutesEnabled = keys.Contains("custom routes enabled True");
            var displayItems = new List<string>();
            if (defaultGatewayEnabled)
            {
                var defaultGateway = keys.FirstOrDefault(item => item.StartsWith("default via ", StringComparison.Ordinal));
                displayItems.Add(defaultGateway is null ? "默认网关已启用（未填写）" : $"默认网关：{defaultGateway[12..]}");
            }
            if (customRoutesEnabled)
            {
                displayItems.AddRange(keys.Where(item => !item.StartsWith("default ", StringComparison.Ordinal) && !item.StartsWith("custom routes enabled ", StringComparison.Ordinal)));
            }

            return FormatKeys(displayItems);
        }

        private void SetField<T>(ref T field, T value, [CallerMemberName] string propertyName = "")
        {
            if (EqualityComparer<T>.Default.Equals(field, value))
            {
                return;
            }
            field = value;
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            NotifyChangeState();
        }
    }

    private sealed class EditableAddress : INotifyPropertyChanged
    {
        private string _ip = string.Empty;
        private string _mask = string.Empty;

        public EditableAddress(InterfaceEditor owner)
        {
            Owner = owner;
        }

        public InterfaceEditor Owner { get; }

        public string IP
        {
            get => _ip;
            set => SetField(ref _ip, value);
        }

        public string Mask
        {
            get => _mask;
            set => SetField(ref _mask, value);
        }

        public event PropertyChangedEventHandler? PropertyChanged;

        private void SetField<T>(ref T field, T value, [CallerMemberName] string propertyName = "")
        {
            if (EqualityComparer<T>.Default.Equals(field, value))
            {
                return;
            }
            field = value;
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            Owner.NotifyChangeState();
        }
    }

    private sealed class EditableRoute : INotifyPropertyChanged
    {
        private string _to = string.Empty;
        private string _mask = string.Empty;
        private string _via = string.Empty;

        public EditableRoute(InterfaceEditor owner)
        {
            Owner = owner;
        }

        public InterfaceEditor Owner { get; }

        public string To
        {
            get => _to;
            set => SetField(ref _to, value);
        }

        public string Mask
        {
            get => _mask;
            set => SetField(ref _mask, value);
        }

        public string Via
        {
            get => _via;
            set => SetField(ref _via, value);
        }

        public event PropertyChangedEventHandler? PropertyChanged;

        private void SetField<T>(ref T field, T value, [CallerMemberName] string propertyName = "")
        {
            if (EqualityComparer<T>.Default.Equals(field, value))
            {
                return;
            }
            field = value;
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            Owner.NotifyChangeState();
        }
    }

    private sealed class EditableDns : INotifyPropertyChanged
    {
        private string _address = string.Empty;

        public EditableDns(InterfaceEditor owner)
        {
            Owner = owner;
        }

        public InterfaceEditor Owner { get; }

        public string Address
        {
            get => _address;
            set => SetField(ref _address, value);
        }

        public event PropertyChangedEventHandler? PropertyChanged;

        private void SetField<T>(ref T field, T value, [CallerMemberName] string propertyName = "")
        {
            if (EqualityComparer<T>.Default.Equals(field, value))
            {
                return;
            }
            field = value;
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            Owner.NotifyChangeState();
        }
    }
}

internal static class ApplyConfirmationDialogElementExtensions
{
    public static T SetGridRow<T>(this T element, int row) where T : UIElement
    {
        Grid.SetRow(element, row);
        return element;
    }

    public static T SetMargin<T>(this T element, Thickness margin) where T : FrameworkElement
    {
        element.Margin = margin;
        return element;
    }
}