NetworkTool/windows/NetworkTool.Client/Services/ServerApiService.cs

using System.Net;
using System.Net.Http;
using System.Net.Http.Json;
using System.Net.Sockets;
using System.Text.Json;
using NetworkTool.Client.Models;

namespace NetworkTool.Client.Services;

public sealed class ServerApiService
{
    private readonly JsonSerializerOptions _jsonOptions = new()
    {
        PropertyNameCaseInsensitive = true,
    };

    public async Task<HealthCheckResult> CheckHealthAsync(string baseAddress, string password, string localIPv4, CancellationToken cancellationToken = default)
    {
        try
        {
            using var handler = new SocketsHttpHandler();
            if (!string.IsNullOrWhiteSpace(localIPv4))
            {
                handler.ConnectCallback = async (context, token) =>
                {
                    var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    socket.Bind(new IPEndPoint(IPAddress.Parse(localIPv4), 0));
                    await socket.ConnectAsync(context.DnsEndPoint, token);
                    return new NetworkStream(socket, ownsSocket: true);
                };
            }

            using var client = new HttpClient(handler) { BaseAddress = new Uri(baseAddress), Timeout = TimeSpan.FromSeconds(5) };
            client.DefaultRequestHeaders.Add("X-Admin-Password", password);

            using var response = await client.GetAsync("/api/health", cancellationToken);
            return new HealthCheckResult
            {
                Success = response.IsSuccessStatusCode,
                StatusCode = (int)response.StatusCode,
                Message = response.IsSuccessStatusCode
                    ? "HTTP 健康检查通过。"
                    : $"HTTP 健康检查返回状态码 {(int)response.StatusCode}。",
            };
        }
        catch (Exception ex)
        {
            return new HealthCheckResult
            {
                Success = false,
                StatusCode = null,
                Message = ex.Message,
            };
        }
    }

    public async Task<RemoteDeviceInfo?> GetDeviceInfoAsync(string baseAddress, string password, string localIPv4, CancellationToken cancellationToken = default)
    {
        try
        {
            using var client = CreateClient(baseAddress, password, localIPv4);
            using var response = await client.GetAsync("/api/device/info", cancellationToken);
            if (!response.IsSuccessStatusCode)
            {
                return null;
            }

            await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
            var wrapper = await JsonSerializer.DeserializeAsync<ApiEnvelope<RemoteDeviceInfo>>(stream, _jsonOptions, cancellationToken);
            return wrapper?.Data;
        }
        catch
        {
            return null;
        }
    }

    public async Task<RemoteInterfacesInfo?> GetInterfacesAsync(string baseAddress, string password, string localIPv4, CancellationToken cancellationToken = default)
    {
        try
        {
            using var client = CreateClient(baseAddress, password, localIPv4);
            using var response = await client.GetAsync("/api/network/interfaces", cancellationToken);
            if (!response.IsSuccessStatusCode)
            {
                return null;
            }

            await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
            var wrapper = await JsonSerializer.DeserializeAsync<ApiEnvelope<RemoteInterfacesInfo>>(stream, _jsonOptions, cancellationToken);
            return wrapper?.Data;
        }
        catch
        {
            return null;
        }
    }

    public async Task<ApiCallResult<RemoteInterfaceConfig>> GetInterfaceConfigAsync(string baseAddress, string password, string localIPv4, string interfaceName, CancellationToken cancellationToken = default)
    {
        try
        {
            using var client = CreateClient(baseAddress, password, localIPv4);
            using var response = await client.GetAsync($"/api/network/config?interface={Uri.EscapeDataString(interfaceName)}", cancellationToken);
            if (!response.IsSuccessStatusCode)
            {
                return new ApiCallResult<RemoteInterfaceConfig>
                {
                    Success = false,
                    StatusCode = (int)response.StatusCode,
                    Message = $"读取接口配置失败，HTTP 状态码 {(int)response.StatusCode}。",
                };
            }

            await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
            var wrapper = await JsonSerializer.DeserializeAsync<ApiEnvelope<RemoteInterfaceConfig>>(stream, _jsonOptions, cancellationToken);
            if (wrapper?.Data is null)
            {
                return new ApiCallResult<RemoteInterfaceConfig>
                {
                    Success = false,
                    Message = "接口配置返回内容为空。",
                };
            }

            return new ApiCallResult<RemoteInterfaceConfig>
            {
                Success = true,
                StatusCode = (int)response.StatusCode,
                Message = "成功",
                Data = wrapper.Data,
            };
        }
        catch (Exception ex)
        {
            return new ApiCallResult<RemoteInterfaceConfig>
            {
                Success = false,
                Message = ex.Message,
            };
        }
    }

    public async Task<ApiCallResult<RemoteValidateResult>> ValidateInterfaceConfigAsync(string baseAddress, string password, string localIPv4, RemoteInterfaceConfig input, CancellationToken cancellationToken = default)
    {
        try
        {
            using var client = CreateClient(baseAddress, password, localIPv4);
            using var response = await client.PostAsJsonAsync("/api/network/validate", input, _jsonOptions, cancellationToken);
            await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
            var wrapper = await JsonSerializer.DeserializeAsync<ApiEnvelope<RemoteValidateResult>>(stream, _jsonOptions, cancellationToken);

            return new ApiCallResult<RemoteValidateResult>
            {
                Success = response.IsSuccessStatusCode && wrapper?.Data is not null,
                StatusCode = (int)response.StatusCode,
                Message = wrapper?.Message ?? (response.IsSuccessStatusCode ? "校验通过" : $"校验失败，HTTP 状态码 {(int)response.StatusCode}。"),
                Data = wrapper?.Data,
            };
        }
        catch (Exception ex)
        {
            return new ApiCallResult<RemoteValidateResult>
            {
                Success = false,
                Message = ex.Message,
            };
        }
    }

    public async Task<ApiCallResult<RemoteApplyTaskResponse>> ApplyInterfaceConfigAsync(string baseAddress, string password, string localIPv4, RemoteInterfaceConfig input, CancellationToken cancellationToken = default)
    {
        try
        {
            using var client = CreateClient(baseAddress, password, localIPv4);
            using var response = await client.PostAsJsonAsync("/api/network/apply", input, _jsonOptions, cancellationToken);
            await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
            var wrapper = await JsonSerializer.DeserializeAsync<ApiEnvelope<RemoteApplyTaskResponse>>(stream, _jsonOptions, cancellationToken);

            return new ApiCallResult<RemoteApplyTaskResponse>
            {
                Success = response.IsSuccessStatusCode && wrapper?.Data is not null,
                StatusCode = (int)response.StatusCode,
                Message = wrapper?.Message ?? (response.IsSuccessStatusCode ? "配置任务已提交" : $"提交失败，HTTP 状态码 {(int)response.StatusCode}。"),
                Data = wrapper?.Data,
            };
        }
        catch (Exception ex)
        {
            return new ApiCallResult<RemoteApplyTaskResponse>
            {
                Success = false,
                Message = ex.Message,
            };
        }
    }

    public async Task<ApiCallResult<RemoteTaskResult>> GetTaskAsync(string baseAddress, string password, string localIPv4, string taskId, CancellationToken cancellationToken = default)
    {
        try
        {
            using var client = CreateClient(baseAddress, password, localIPv4);
            using var response = await client.GetAsync($"/api/tasks/{Uri.EscapeDataString(taskId)}", cancellationToken);
            await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
            var wrapper = await JsonSerializer.DeserializeAsync<ApiEnvelope<RemoteTaskResult>>(stream, _jsonOptions, cancellationToken);

            return new ApiCallResult<RemoteTaskResult>
            {
                Success = response.IsSuccessStatusCode && wrapper?.Data is not null,
                StatusCode = (int)response.StatusCode,
                Message = wrapper?.Message ?? (response.IsSuccessStatusCode ? "成功" : $"任务查询失败，HTTP 状态码 {(int)response.StatusCode}。"),
                Data = wrapper?.Data,
            };
        }
        catch (Exception ex)
        {
            return new ApiCallResult<RemoteTaskResult>
            {
                Success = false,
                Message = ex.Message,
            };
        }
    }

    public async Task<ApiCallResult<RemoteApplyTaskResponse>> ConfirmApplyTaskAsync(string baseAddress, string password, string localIPv4, string taskId, CancellationToken cancellationToken = default)
    {
        try
        {
            using var client = CreateClient(baseAddress, password, localIPv4);
            using var response = await client.PostAsJsonAsync("/api/network/apply/confirm", new { task_id = taskId }, _jsonOptions, cancellationToken);
            await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
            var wrapper = await JsonSerializer.DeserializeAsync<ApiEnvelope<RemoteApplyTaskResponse>>(stream, _jsonOptions, cancellationToken);

            return new ApiCallResult<RemoteApplyTaskResponse>
            {
                Success = response.IsSuccessStatusCode,
                StatusCode = (int)response.StatusCode,
                Message = wrapper?.Message ?? (response.IsSuccessStatusCode ? "已确认保留配置" : $"确认失败，HTTP 状态码 {(int)response.StatusCode}。"),
                Data = wrapper?.Data,
            };
        }
        catch (Exception ex)
        {
            return new ApiCallResult<RemoteApplyTaskResponse>
            {
                Success = false,
                Message = ex.Message,
            };
        }
    }

    public async Task<ApiCallResult<RemoteApplyTaskResponse>> CancelApplyTaskAsync(string baseAddress, string password, string localIPv4, string taskId, CancellationToken cancellationToken = default)
    {
        try
        {
            using var client = CreateClient(baseAddress, password, localIPv4);
            using var response = await client.PostAsJsonAsync("/api/network/apply/cancel", new { task_id = taskId }, _jsonOptions, cancellationToken);
            await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
            var wrapper = await JsonSerializer.DeserializeAsync<ApiEnvelope<RemoteApplyTaskResponse>>(stream, _jsonOptions, cancellationToken);

            return new ApiCallResult<RemoteApplyTaskResponse>
            {
                Success = response.IsSuccessStatusCode,
                StatusCode = (int)response.StatusCode,
                Message = wrapper?.Message ?? (response.IsSuccessStatusCode ? "已取消保留配置" : $"取消失败，HTTP 状态码 {(int)response.StatusCode}。"),
                Data = wrapper?.Data,
            };
        }
        catch (Exception ex)
        {
            return new ApiCallResult<RemoteApplyTaskResponse>
            {
                Success = false,
                Message = ex.Message,
            };
        }
    }

    public Task<ApiCallResult<RemoteSystemActionResponse>> RebootAsync(string baseAddress, string password, string localIPv4, CancellationToken cancellationToken = default)
    {
        return PostSystemActionAsync(baseAddress, password, localIPv4, "/api/system/reboot", cancellationToken);
    }

    public Task<ApiCallResult<RemoteSystemActionResponse>> ShutdownAsync(string baseAddress, string password, string localIPv4, CancellationToken cancellationToken = default)
    {
        return PostSystemActionAsync(baseAddress, password, localIPv4, "/api/system/shutdown", cancellationToken);
    }

    private HttpClient CreateClient(string baseAddress, string password, string localIPv4)
    {
        var handler = new SocketsHttpHandler();
        if (!string.IsNullOrWhiteSpace(localIPv4))
        {
            handler.ConnectCallback = async (context, token) =>
            {
                var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                socket.Bind(new IPEndPoint(IPAddress.Parse(localIPv4), 0));
                await socket.ConnectAsync(context.DnsEndPoint, token);
                return new NetworkStream(socket, ownsSocket: true);
            };
        }

        var client = new HttpClient(handler) { BaseAddress = new Uri(baseAddress), Timeout = TimeSpan.FromSeconds(5) };
        client.DefaultRequestHeaders.Add("X-Admin-Password", password);
        return client;
    }

    private async Task<ApiCallResult<RemoteSystemActionResponse>> PostSystemActionAsync(string baseAddress, string password, string localIPv4, string path, CancellationToken cancellationToken)
    {
        try
        {
            using var client = CreateClient(baseAddress, password, localIPv4);
            using var response = await client.PostAsync(path, content: null, cancellationToken);
            await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
            var wrapper = await JsonSerializer.DeserializeAsync<ApiEnvelope<RemoteSystemActionResponse>>(stream, _jsonOptions, cancellationToken);

            return new ApiCallResult<RemoteSystemActionResponse>
            {
                Success = response.IsSuccessStatusCode && wrapper?.Data is not null,
                StatusCode = (int)response.StatusCode,
                Message = wrapper?.Message ?? (response.IsSuccessStatusCode ? "系统任务已提交" : $"提交失败，HTTP 状态码 {(int)response.StatusCode}。"),
                Data = wrapper?.Data,
            };
        }
        catch (Exception ex)
        {
            return new ApiCallResult<RemoteSystemActionResponse>
            {
                Success = false,
                Message = ex.Message,
            };
        }
    }

    private sealed class ApiEnvelope<T>
    {
        public int Code { get; set; }
        public string Message { get; set; } = string.Empty;
        public T? Data { get; set; }
    }
}