zengzy / hhrcs_service · Files

using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Rcs.Application.Common;
using Rcs.Application.Services.PathFind;
using Rcs.Application.Services.PathFind.Models;
using Rcs.Application.Services.Protocol;
using Rcs.Application.Shared;
using Rcs.Domain.Entities;
using Rcs.Domain.Enums;
using Rcs.Domain.Repositories;
using Rcs.Domain.Settings;
using StackExchange.Redis;

namespace Rcs.Infrastructure.Services;

/// <summary>
/// 网络动作执行服务实现
/// @author zzy
/// </summary>
public class NetActionExecutionService : INetActionExecutionService
{
    private readonly ILogger<NetActionExecutionService> _logger;
    private readonly IConnectionMultiplexer _redis;
    private readonly INetActionPropertysRepository _netActionRepository;
    private readonly IHttpClientService _httpClientService;
    private readonly IServiceProvider _serviceProvider;
    private readonly IRobotRepository _robotRepository;
    private readonly IRobotTaskRepository _taskRepository;
    private readonly IRobotSubTaskRepository _subTaskRepository;
    private readonly AppSettings _settings;

    // Redis Key前缀
    private const string NetActionContextKeyPrefix = "net_action:context:";
    private const string NetActionIndexKeyPrefix = "net_action:index:";

    public NetActionExecutionService(
        ILogger<NetActionExecutionService> logger,
        IConnectionMultiplexer redis,
        INetActionPropertysRepository netActionRepository,
        IHttpClientService httpClientService,
        IServiceProvider serviceProvider,
        IRobotRepository robotRepository,
        IRobotTaskRepository taskRepository,
        IRobotSubTaskRepository subTaskRepository,
        IOptions<AppSettings> settings)
    {
        _logger = logger;
        _redis = redis;
        _netActionRepository = netActionRepository;
        _httpClientService = httpClientService;
        _serviceProvider = serviceProvider;
        _robotRepository = robotRepository;
        _taskRepository = taskRepository;
        _subTaskRepository = subTaskRepository;
        _settings = settings.Value;
    }

    /// <summary>
    /// 检查路径段是否需要执行网络动作
    /// @author zzy
    /// </summary>
    public async Task<SegmentNetActionCheckResult> CheckSegmentNetActionsAsync(SegmentNetActionCheckRequest request)
    {
        var result = new SegmentNetActionCheckResult
        {
            HasNetAction = false,
            CanContinue = true
        };

        if (request.Segments.Count == 0)
        {
            return result;
        }

        // 获取最后一段的终点网络动作（从字典中获取ActionType为Apply的网络动作）
        var lastSegment = request.Segments.Last();
        var netActionIds = lastSegment.EndNodeNetActionTypes
            .Where(kv => kv.Value == ActionType.Apply)
            .Select(kv => kv.Key)
            .ToList();

        if (netActionIds.Count == 0)
        {
            return result;
        }

        // 检查是否有正在进行的网络动作
        var hasInProgress = await HasInProgressNetActionAsync(
            request.RobotId, request.TaskId, request.SubTaskId,
            request.JunctionIndex, request.ResourceIndex);

        if (hasInProgress)
        {
            result.HasNetAction = true;
            result.CanContinue = false;
            result.Message = "网络动作正在执行中";
            return result;
        }

        // 检查是否有等待异步响应的网络动作
        var hasWaitingAsync = await HasWaitingAsyncResponseAsync(
            request.RobotId, request.TaskId, request.SubTaskId);

        if (hasWaitingAsync)
        {
            result.HasNetAction = true;
            result.CanContinue = false;
            result.IsWaitingAsync = true;
            result.Message = "等待异步响应中";
            return result;
        }

        result.HasNetAction = true;
        result.CanContinue = false;
        result.Message = $"发现{netActionIds.Count}个终点网络动作需要执行";

        return result;
    }

    /// <summary>
    /// 执行网络动作
    /// @author zzy
    /// </summary>
    public async Task<NetActionExecuteResult> ExecuteNetActionAsync(NetActionExecuteRequest request)
    {
        var netAction = await _netActionRepository.GetByIdAsync(request.NetActionId);
        if (netAction == null)
        {
            return new NetActionExecuteResult
            {
                Success = false,
                Message = $"网络动作不存在: {request.NetActionId}",
                ContextId = request.ContextId
            };
        }

        if (!netAction.IsActive)
        {
            return new NetActionExecuteResult
            {
                Success = true,
                Message = "网络动作已禁用，跳过执行",
                ContextId = request.ContextId
            };
        }

        // 创建执行上下文
        var context = new NetActionExecutionContext
        {
            ContextId = request.ContextId,
            RobotId = request.RobotId,
            TaskId = request.TaskId,
            SubTaskId = request.SubTaskId,
            NetActionId = request.NetActionId,
            ActionPosition = NetActionPosition.End,
            ExecutionStatus = NetActionExecutionStatus.Executing,
            ResponseWaitType = netAction.WaitResponseType,
            CreatedAt = DateTime.UtcNow,
            ExecutedAt = DateTime.UtcNow,
            // 使用网络动作配置的重试参数
            MaxRetryCount = netAction.RepeatCount ?? 3,
            RetryIntervalMs = netAction.IntervalTimeMs ?? 5000
        };

        // 如果是异步响应类型，生成回调令牌
        if (netAction.WaitResponseType == ResponseWaitType.Async)
        {
            context.AsyncCallbackToken = GenerateCallbackToken(request.ContextId);
            context.ExecutionStatus = NetActionExecutionStatus.WaitingAsyncResponse;
        }

        // 保存上下文到Redis
        await SaveExecutionContextAsync(context);

        // 构建请求参数
        var requestParams = BuildRequestParameters(netAction, request);

        try
        {
            _logger.LogInformation("[网络动作] 开始执行: ContextId={ContextId}, NetActionId={NetActionId}, " +
                "WaitType={WaitType}, Url={Url}",
                request.ContextId, request.NetActionId, netAction.WaitResponseType, netAction.RequestUrl);

            // 发送HTTP请求
            var httpMethod = netAction.RequestMethod?.ToUpperInvariant() ?? "POST";
            HttpResponseMessage? response = null;

            switch (httpMethod)
            {
                case "GET":
                    response = await _httpClientService.GetAsync<HttpResponseMessage>(
                        netAction.RequestUrl! + BuildQueryString(requestParams));
                    break;
                case "POST":
                    response = await _httpClientService.PostAsync<object>(
                        netAction.RequestUrl!, requestParams);
                    break;
                case "PUT":
                    response = await _httpClientService.PutAsync<object>(
                        netAction.RequestUrl!, requestParams);
                    break;
               
                default:
                    response = await _httpClientService.PostAsync<object>(
                        netAction.RequestUrl!, requestParams);
                    break;
            }

            // 无响应类型：请求成功即视为成功
            if (netAction.WaitResponseType == ResponseWaitType.None)
            {
                context.ExecutionStatus = NetActionExecutionStatus.Success;
                context.CompletedAt = DateTime.UtcNow;
                context.IsSuccess = true;
                context.ResultMessage = "请求发送成功";
                await SaveExecutionContextAsync(context);

                _logger.LogInformation("[网络动作] 无响应类型执行成功: ContextId={ContextId}", request.ContextId);

                return new NetActionExecuteResult
                {
                    Success = true,
                    Message = "网络动作执行成功（无响应类型）",
                    ContextId = request.ContextId,
                    IsAsyncWaiting = false
                };
            }

            // 同步响应类型：验证响应结果
            if (netAction.WaitResponseType == ResponseWaitType.Sync)
            {
                var responseContent = await response.Content.ReadAsStringAsync();
                var isValid = ValidateResponse(responseContent, netAction.ResponseValidationRule);

                if (isValid)
                {
                    context.ExecutionStatus = NetActionExecutionStatus.Success;
                    context.CompletedAt = DateTime.UtcNow;
                    context.IsSuccess = true;
                    context.ResultMessage = responseContent;
                    await SaveExecutionContextAsync(context);

                    _logger.LogInformation("[网络动作] 同步响应验证成功: ContextId={ContextId}", request.ContextId);

                    return new NetActionExecuteResult
                    {
                        Success = true,
                        Message = "网络动作执行成功（同步响应验证通过）",
                        ContextId = request.ContextId,
                        IsAsyncWaiting = false
                    };
                }
                else
                {
                    context.ExecutionStatus = NetActionExecutionStatus.Failed;
                    context.CompletedAt = DateTime.UtcNow;
                    context.IsSuccess = false;
                    context.ResultMessage = $"响应验证失败: {responseContent}";
                    await SaveExecutionContextAsync(context);

                    _logger.LogWarning("[网络动作] 同步响应验证失败: ContextId={ContextId}, Response={Response}",
                        request.ContextId, responseContent);

                    return new NetActionExecuteResult
                    {
                        Success = false,
                        Message = "网络动作响应验证失败",
                        ContextId = request.ContextId,
                        IsAsyncWaiting = false
                    };
                }
            }

            // 异步响应类型：等待回调
            _logger.LogInformation("[网络动作] 异步响应类型，等待回调: ContextId={ContextId}, Token={Token}",
                request.ContextId, context.AsyncCallbackToken);

            return new NetActionExecuteResult
            {
                Success = true,
                Message = "网络动作请求已发送，等待异步回调",
                ContextId = request.ContextId,
                IsAsyncWaiting = true
            };
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "[网络动作] 执行失败: ContextId={ContextId}", request.ContextId);

            context.ExecutionStatus = NetActionExecutionStatus.Failed;
            context.CompletedAt = DateTime.UtcNow;
            context.IsSuccess = false;
            context.ResultMessage = $"执行异常: {ex.Message}";
            await SaveExecutionContextAsync(context);

            return new NetActionExecuteResult
            {
                Success = false,
                Message = $"网络动作执行失败: {ex.Message}",
                ContextId = request.ContextId
            };
        }
    }

    /// <summary>
    /// 批量执行多个网络动作
    /// @author zzy
    /// </summary>
    public async Task<NetActionExecuteResult> ExecuteNetActionsAsync(List<NetActionExecuteRequest> requests)
    {
        if (requests.Count == 0)
        {
            return new NetActionExecuteResult
            {
                Success = true,
                Message = "没有网络动作需要执行"
            };
        }

        // 串行执行，确保顺序
        foreach (var request in requests)
        {
            var result = await ExecuteNetActionAsync(request);

            // 如果某个动作失败且不是异步等待，则停止执行
            if (!result.Success && !result.IsAsyncWaiting)
            {
                return result;
            }

            // 如果是异步等待，返回等待状态
            if (result.IsAsyncWaiting)
            {
                return result;
            }
        }

        return new NetActionExecuteResult
        {
            Success = true,
            Message = "所有网络动作执行成功",
            ContextId = requests.Last().ContextId
        };
    }

    /// <summary>
    /// 获取网络动作执行上下文
    /// @author zzy
    /// </summary>
    public async Task<NetActionExecutionContext?> GetExecutionContextAsync(string contextId)
    {
        var key = NetActionContextKeyPrefix + contextId;
        var data = await _redis.GetDatabase().StringGetAsync(key);

        if (data.IsNullOrEmpty)
        {
            return null;
        }

        try
        {
            return JsonSerializer.Deserialize<NetActionExecutionContext>(data.ToString());
        }
        catch
        {
            return null;
        }
    }

    /// <summary>
    /// 处理异步回调
    /// @author zzy
    /// </summary>
    public async Task<NetActionCallbackResponse> HandleCallbackAsync(NetActionCallbackRequest request)
    {
        _logger.LogInformation("[网络动作] 收到异步回调: ContextId={ContextId}, Success={Success}",
            request.ContextId, request.Success);

        // 获取执行上下文
        var context = await GetExecutionContextAsync(request.ContextId);
        if (context == null)
        {
            _logger.LogWarning("[网络动作] 回调上下文不存在: ContextId={ContextId}", request.ContextId);
            return new NetActionCallbackResponse
            {
                Success = false,
                Message = "上下文不存在或已过期",
                Action = "Abort"
            };
        }

        // 验证回调令牌
        if (context.AsyncCallbackToken != request.CallbackToken)
        {
            _logger.LogWarning("[网络动作] 回调令牌验证失败: ContextId={ContextId}", request.ContextId);
            return new NetActionCallbackResponse
            {
                Success = false,
                Message = "回调令牌验证失败",
                Action = "Abort"
            };
        }

        // 更新上下文状态
        context.ExecutionStatus = request.Success ? NetActionExecutionStatus.Success : NetActionExecutionStatus.Failed;
        context.CompletedAt = DateTime.UtcNow;
        context.IsSuccess = request.Success;
        context.ResultMessage = request.Message;
        await SaveExecutionContextAsync(context);

        _logger.LogInformation("[网络动作] 回调处理成功: ContextId={ContextId}, Status={Status}",
            request.ContextId, context.ExecutionStatus);

        // 如果回调成功，尝试继续发送下一段
        if (request.Success)
        {
            var continueResult = await TryContinueToNextSegmentAsync(request.ContextId);

            return new NetActionCallbackResponse
            {
                Success = true,
                Message = "回调处理成功，" + (continueResult.Success ? "已继续发送下一段" : continueResult.Message),
                Action = continueResult.Success ? "Continue" : "Retry"
            };
        }

        return new NetActionCallbackResponse
        {
            Success = true,
            Message = "回调处理成功，网络动作执行失败",
            Action = "Abort"
        };
    }

    /// <summary>
    /// 检查指定路径段是否有正在进行的网络动作
    /// @author zzy
    /// 2026-02-07 优化：使用Set索引结构
    /// </summary>
    public async Task<bool> HasInProgressNetActionAsync(
        Guid robotId,
        Guid taskId,
        Guid subTaskId,
        int junctionIndex,
        int resourceIndex)
    {
        var db = _redis.GetDatabase();

        // 使用任务级Set索引查询
        var taskIndexKey = $"{NetActionTaskIndexKeyPrefix}{robotId}:{taskId}:{subTaskId}";
        var contextIds = await db.SetMembersAsync(taskIndexKey);

        foreach (var contextIdValue in contextIds)
        {
            var contextId = contextIdValue.ToString();
            var context = await GetExecutionContextAsync(contextId);

            if (context != null &&
                context.JunctionIndex == junctionIndex &&
                context.ResourceIndex == resourceIndex &&
                (context.ExecutionStatus == NetActionExecutionStatus.Executing ||
                 context.ExecutionStatus == NetActionExecutionStatus.Pending))
            {
                return true;
            }
        }

        return false;
    }

    /// <summary>
    /// 检查指定任务是否有等待异步响应的网络动作
    /// @author zzy
    /// 2026-02-07 优化：使用Set索引结构
    /// </summary>
    public async Task<bool> HasWaitingAsyncResponseAsync(Guid robotId, Guid taskId, Guid subTaskId)
    {
        var db = _redis.GetDatabase();

        // 使用任务级Set索引查询
        var taskIndexKey = $"{NetActionTaskIndexKeyPrefix}{robotId}:{taskId}:{subTaskId}";
        var contextIds = await db.SetMembersAsync(taskIndexKey);

        foreach (var contextIdValue in contextIds)
        {
            var contextId = contextIdValue.ToString();
            var context = await GetExecutionContextAsync(contextId);

            if (context != null && context.ExecutionStatus == NetActionExecutionStatus.WaitingAsyncResponse)
            {
                return true;
            }
        }

        return false;
    }

    /// <summary>
    /// 尝试继续发送下一段
    /// 使用延迟获取 IProtocolServiceFactory 以避免循环依赖
    /// @author zzy
    /// </summary>
    public async Task<ApiResponse> TryContinueToNextSegmentAsync(string contextId)
    {
        var context = await GetExecutionContextAsync(contextId);
        if (context == null)
        {
            return ApiResponse.Failed("执行上下文不存在");
        }

        // 获取机器人信息
        var robot = await _robotRepository.GetByIdAsync(context.RobotId);
        if (robot == null)
        {
            return ApiResponse.Failed("机器人不存在");
        }

        // 延迟获取协议服务工厂，避免循环依赖
        var protocolServiceFactory = _serviceProvider.GetRequiredService<IProtocolServiceFactory>();
        var protocolService = protocolServiceFactory.GetService(robot.ProtocolType);

        var subTask = await _subTaskRepository.GetByIdAsync(context.SubTaskId);
        if (subTask == null)
        {
            return ApiResponse.Failed("子任务不存在");
        }

        return await protocolService.SendNextSegmentAsync(robot, subTask);
    }

    /// <summary>
    /// 取消指定任务的所有网络动作
    /// @author zzy
    /// </summary>
    public async Task<int> CancelTaskNetActionsAsync(Guid robotId, Guid taskId, Guid subTaskId)
    {
        var pattern = $"{NetActionIndexKeyPrefix}{robotId}:{taskId}:{subTaskId}:*";
        var server = _redis.GetServer(_redis.GetEndPoints().First());
        var keys = server.Keys(pattern: pattern).ToArray();

        int count = 0;
        foreach (var key in keys)
        {
            var contextId = await _redis.GetDatabase().StringGetAsync(key);
            if (!contextId.IsNullOrEmpty)
            {
                var context = await GetExecutionContextAsync(contextId.ToString());
                if (context != null &&
                    (context.ExecutionStatus == NetActionExecutionStatus.Pending ||
                     context.ExecutionStatus == NetActionExecutionStatus.Executing ||
                     context.ExecutionStatus == NetActionExecutionStatus.WaitingAsyncResponse))
                {
                    context.ExecutionStatus = NetActionExecutionStatus.Cancelled;
                    context.CompletedAt = DateTime.UtcNow;
                    await SaveExecutionContextAsync(context);
                    count++;
                }
            }
        }

        _logger.LogInformation("[网络动作] 取消任务网络动作: RobotId={RobotId}, TaskId={TaskId}, Count={Count}",
            robotId, taskId, count);

        return count;
    }

    /// <summary>
    /// 清理过期的网络动作上下文
    /// @author zzy
    /// </summary>
    public async Task<int> CleanExpiredContextsAsync()
    {
        var db = _redis.GetDatabase();
        var taskIndexKey = NetActionTaskIndexKeyPrefix + "*";

        int count = 0;

        // 遍历所有任务索引
        var server = _redis.GetServer(_redis.GetEndPoints().First());
        var taskKeys = server.Keys(pattern: taskIndexKey).ToArray();

        foreach (var taskKey in taskKeys)
        {
            var contextIds = await db.SetMembersAsync(taskKey);
            foreach (var contextIdValue in contextIds)
            {
                var contextId = contextIdValue.ToString();
                var context = await GetExecutionContextAsync(contextId);
                if (context == null)
                {
                    // 上下文已过期，从索引中移除
                    await db.SetRemoveAsync(taskKey, contextId);
                    count++;
                }
            }

            // 如果索引集合为空，删除索引Key
            var remaining = await db.SetLengthAsync(taskKey);
            if (remaining == 0)
            {
                await db.KeyDeleteAsync(taskKey);
            }
        }

        _logger.LogInformation("[网络动作] 清理过期上下文完成，清理数量: {Count}", count);
        return count;
    }

    /// <summary>
    /// 检查并处理超时的异步网络动作
    /// @author zzy
    /// 2026-02-07 新增
    /// 2026-02-07 更新：使用网络动作配置的重试参数
    /// </summary>
    public async Task<int> CheckAndHandleTimeoutActionsAsync()
    {
        var db = _redis.GetDatabase();
        var taskIndexKey = NetActionTaskIndexKeyPrefix + "*";

        int count = 0;

        var server = _redis.GetServer(_redis.GetEndPoints().First());
        var taskKeys = server.Keys(pattern: taskIndexKey).ToArray();

        foreach (var taskKey in taskKeys)
        {
            var contextIds = await db.SetMembersAsync(taskKey);
            foreach (var contextIdValue in contextIds)
            {
                var contextId = contextIdValue.ToString();
                var context = await GetExecutionContextAsync(contextId);

                if (context == null) continue;

                // 检查是否超时
                if (context.IsTimeout)
                {
                    _logger.LogWarning("[网络动作] 检测到超时的异步动作: ContextId={ContextId}, ExecutedAt={ExecutedAt}, TimeoutSeconds={TimeoutSeconds}",
                        contextId, context.ExecutedAt, context.AsyncTimeoutSeconds);

                    // 使用 CanRetry 属性检查是否可以重试（考虑重试次数和间隔时间）
                    if (context.CanRetry)
                    {
                        // 尝试重试
                        var retryResult = await RetryNetActionAsync(contextId);
                        if (retryResult.Success || retryResult.IsAsyncWaiting)
                        {
                            _logger.LogInformation("[网络动作] 超时动作重试成功: ContextId={ContextId}, RetryCount={RetryCount}, MaxRetry={MaxRetry}",
                                contextId, context.RetryCount + 1, context.MaxRetryCount);
                        }
                        else
                        {
                            _logger.LogWarning("[网络动作] 超时动作重试失败: ContextId={ContextId}, Message={Message}",
                                contextId, retryResult.Message);
                        }
                    }
                    else
                    {
                        // 不可重试（达到最大次数或间隔时间未到）
                        var isMaxRetryReached = context.MaxRetryCount != -1 && context.RetryCount >= context.MaxRetryCount;
                        if (isMaxRetryReached)
                        {
                            // 超过最大重试次数，标记为失败
                            context.ExecutionStatus = NetActionExecutionStatus.Failed;
                            context.CompletedAt = DateTime.UtcNow;
                            context.IsSuccess = false;
                            context.ResultMessage = $"异步回调超时，已重试{context.RetryCount}次（最大{context.MaxRetryCount}次）";
                            await SaveExecutionContextAsync(context);

                            _logger.LogError("[网络动作] 超时动作已达最大重试次数，标记为失败: ContextId={ContextId}, RetryCount={RetryCount}",
                                contextId, context.RetryCount);
                        }
                        // 如果是间隔时间未到，不做处理，等待下次检查
                    }

                    count++;
                }
            }
        }

        return count;
    }

    /// <summary>
    /// 重试失败的网络动作
    /// @author zzy
    /// 2026-02-07 新增
    /// 2026-02-07 更新：使用网络动作配置的重试参数
    /// </summary>
    public async Task<NetActionExecuteResult> RetryNetActionAsync(string contextId)
    {
        var context = await GetExecutionContextAsync(contextId);
        if (context == null)
        {
            return new NetActionExecuteResult
            {
                Success = false,
                Message = "执行上下文不存在",
                ContextId = contextId
            };
        }

        // 使用 CanRetry 属性检查是否可以重试
        if (!context.CanRetry)
        {
            var reason = context.MaxRetryCount != -1 && context.RetryCount >= context.MaxRetryCount
                ? $"已达最大重试次数({context.MaxRetryCount})"
                : $"重试间隔时间未到（间隔{context.RetryIntervalMs}ms）";
            return new NetActionExecuteResult
            {
                Success = false,
                Message = reason,
                ContextId = contextId
            };
        }

        // 获取网络动作配置
        var netAction = await _netActionRepository.GetByIdAsync(context.NetActionId);
        if (netAction == null)
        {
            return new NetActionExecuteResult
            {
                Success = false,
                Message = "网络动作配置不存在",
                ContextId = contextId
            };
        }

        // 获取机器人信息
        var robot = await _robotRepository.GetByIdAsync(context.RobotId);
        if (robot == null)
        {
            return new NetActionExecuteResult
            {
                Success = false,
                Message = "机器人不存在",
                ContextId = contextId
            };
        }

        // 获取任务信息
        var task = await _taskRepository.GetByIdAsync(context.TaskId);
        var taskCode = task?.TaskCode ?? context.TaskId.ToString();

        // 构建重试请求
        var request = new NetActionExecuteRequest
        {
            NetActionId = context.NetActionId,
            ContextId = contextId, // 保持原有的ContextId
            RobotId = context.RobotId,
            RobotCode = robot.RobotCode,
            TaskId = context.TaskId,
            TaskCode = taskCode,
            SubTaskId = context.SubTaskId,
            NodeCode = "", // 重试时可能没有节点信息
            NodeId = Guid.Empty
        };

        // 增加重试次数并记录重试时间
        context.RetryCount++;
        context.LastRetryAt = DateTime.UtcNow;
        context.ExecutionStatus = NetActionExecutionStatus.Executing;
        context.ExecutedAt = DateTime.UtcNow;

        // 如果是异步响应类型，重新生成回调令牌
        if (netAction.WaitResponseType == ResponseWaitType.Async)
        {
            context.AsyncCallbackToken = GenerateCallbackToken(contextId + ":" + context.RetryCount);
            context.ExecutionStatus = NetActionExecutionStatus.WaitingAsyncResponse;
        }

        await SaveExecutionContextAsync(context);

        // 构建请求参数
        var requestParams = BuildRequestParameters(netAction, request);
        // 添加回调令牌到请求参数
        if (!string.IsNullOrEmpty(context.AsyncCallbackToken))
        {
            requestParams["callbackToken"] = context.AsyncCallbackToken;
        }

        try
        {
            _logger.LogInformation("[网络动作] 开始重试: ContextId={ContextId}, RetryCount={RetryCount}, Url={Url}",
                contextId, context.RetryCount, netAction.RequestUrl);

            // 发送HTTP请求
            var httpMethod = netAction.RequestMethod?.ToUpperInvariant() ?? "POST";
            HttpResponseMessage? response = null;

            switch (httpMethod)
            {
                case "GET":
                    response = await _httpClientService.GetAsync<HttpResponseMessage>(
                        netAction.RequestUrl! + BuildQueryString(requestParams));
                    break;
                case "POST":
                    response = await _httpClientService.PostAsync<object>(
                        netAction.RequestUrl!, requestParams);
                    break;
                case "PUT":
                    response = await _httpClientService.PutAsync<object>(
                        netAction.RequestUrl!, requestParams);
                    break;
                default:
                    response = await _httpClientService.PostAsync<object>(
                        netAction.RequestUrl!, requestParams);
                    break;
            }

            // 处理响应（与ExecuteNetActionAsync逻辑相同）
            if (netAction.WaitResponseType == ResponseWaitType.None)
            {
                context.ExecutionStatus = NetActionExecutionStatus.Success;
                context.CompletedAt = DateTime.UtcNow;
                context.IsSuccess = true;
                context.ResultMessage = "重试成功（无响应类型）";
                await SaveExecutionContextAsync(context);

                return new NetActionExecuteResult
                {
                    Success = true,
                    Message = "网络动作重试成功（无响应类型）",
                    ContextId = contextId,
                    IsAsyncWaiting = false
                };
            }

            if (netAction.WaitResponseType == ResponseWaitType.Sync)
            {
                var responseContent = await response.Content.ReadAsStringAsync();
                var isValid = ValidateResponse(responseContent, netAction.ResponseValidationRule);

                if (isValid)
                {
                    context.ExecutionStatus = NetActionExecutionStatus.Success;
                    context.CompletedAt = DateTime.UtcNow;
                    context.IsSuccess = true;
                    context.ResultMessage = responseContent;
                    await SaveExecutionContextAsync(context);

                    return new NetActionExecuteResult
                    {
                        Success = true,
                        Message = "网络动作重试成功（同步响应验证通过）",
                        ContextId = contextId,
                        IsAsyncWaiting = false
                    };
                }
                else
                {
                    context.ExecutionStatus = NetActionExecutionStatus.Failed;
                    context.CompletedAt = DateTime.UtcNow;
                    context.IsSuccess = false;
                    context.ResultMessage = $"重试响应验证失败: {responseContent}";
                    await SaveExecutionContextAsync(context);

                    return new NetActionExecuteResult
                    {
                        Success = false,
                        Message = "网络动作重试响应验证失败",
                        ContextId = contextId,
                        IsAsyncWaiting = false
                    };
                }
            }

            // 异步响应类型
            return new NetActionExecuteResult
            {
                Success = true,
                Message = "网络动作重试请求已发送，等待异步回调",
                ContextId = contextId,
                IsAsyncWaiting = true
            };
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "[网络动作] 重试失败: ContextId={ContextId}", contextId);

            context.ExecutionStatus = NetActionExecutionStatus.Failed;
            context.CompletedAt = DateTime.UtcNow;
            context.IsSuccess = false;
            context.ResultMessage = $"重试异常: {ex.Message}";
            await SaveExecutionContextAsync(context);

            return new NetActionExecuteResult
            {
                Success = false,
                Message = $"网络动作重试失败: {ex.Message}",
                ContextId = contextId
            };
        }
    }

    #region 私有方法

    // 任务级索引Key前缀（使用Set结构存储该任务下所有的ContextId）
    private const string NetActionTaskIndexKeyPrefix = "net_action:task_index:";

    /// <summary>
    /// 保存执行上下文到Redis
    /// 使用Set结构存储任务级索引，避免Keys命令扫描
    /// @author zzy
    /// 2026-02-07 优化：使用Set结构替代String索引
    /// </summary>
    private async Task SaveExecutionContextAsync(NetActionExecutionContext context)
    {
        var db = _redis.GetDatabase();

        // 保存上下文数据
        var contextKey = NetActionContextKeyPrefix + context.ContextId;
        var value = JsonSerializer.Serialize(context);
        await db.StringSetAsync(contextKey, value, context.Expiry);

        // 使用Set结构存储任务级索引（便于查询该任务下所有的网络动作）
        var taskIndexKey = $"{NetActionTaskIndexKeyPrefix}{context.RobotId}:{context.TaskId}:{context.SubTaskId}";
        await db.SetAddAsync(taskIndexKey, context.ContextId);
        await db.KeyExpireAsync(taskIndexKey, context.Expiry);

        // 保存段级索引（用于快速判断某个段是否有进行中的网络动作）
        var segmentIndexKey = $"{NetActionIndexKeyPrefix}{context.RobotId}:{context.TaskId}:{context.SubTaskId}:{context.JunctionIndex}:{context.ResourceIndex}:{context.NetActionId}";
        await db.StringSetAsync(segmentIndexKey, context.ContextId, context.Expiry);
    }

    /// <summary>
    /// 生成回调令牌
    /// @author zzy
    /// </summary>
    private static string GenerateCallbackToken(string contextId)
    {
        using var sha256 = SHA256.Create();
        var hash = sha256.ComputeHash(Encoding.UTF8.GetBytes(contextId + ":" + DateTime.UtcNow.Ticks));
        return Convert.ToHexString(hash)[..16];
    }

    /// <summary>
    /// 构建请求参数
    /// @author zzy
    /// </summary>
    private static Dictionary<string, object> BuildRequestParameters(NetActionPropertys netAction, NetActionExecuteRequest request)
    {
        var result = new Dictionary<string, object>
        {
            ["contextId"] = request.ContextId,
            ["robotId"] = request.RobotId,
            ["robotCode"] = request.RobotCode,
            ["taskId"] = request.TaskId,
            ["taskCode"] = request.TaskCode,
            ["subTaskId"] = request.SubTaskId,
            ["nodeId"] = request.NodeId,
            ["nodeCode"] = request.NodeCode,
            ["timestamp"] = DateTime.UtcNow.ToString("O")
        };

        // 解析配置的请求参数并合并
        if (!string.IsNullOrEmpty(netAction.RequestParams))
        {
            try
            {
                var configParams = JsonSerializer.Deserialize<Dictionary<string, object>>(netAction.RequestParams);
                if (configParams != null)
                {
                    foreach (var param in configParams)
                    {
                        result[param.Key] = param.Value;
                    }
                }
            }
            catch
            {
                // 配置参数解析失败，忽略
            }
        }

        return result;
    }

    /// <summary>
    /// 构建查询字符串
    /// @author zzy
    /// </summary>
    private static string BuildQueryString(Dictionary<string, object> parameters)
    {
        if (parameters.Count == 0)
        {
            return string.Empty;
        }

        var query = string.Join("&", parameters.Select(p => $"{Uri.EscapeDataString(p.Key)}={Uri.EscapeDataString(p.Value?.ToString() ?? "")}"));
        return "?" + query;
    }

    /// <summary>
    /// 验证响应结果
    /// @author zzy
    /// </summary>
    private static bool ValidateResponse(string responseContent, string? validationRule)
    {
        if (string.IsNullOrEmpty(validationRule))
        {
            // 没有验证规则，默认成功
            return true;
        }

        try
        {
            // 简单的验证规则支持
            // 格式: "key=value" 或 "key!=value" 或 "key"（检查key存在）
            var rules = validationRule.Split(';', StringSplitOptions.RemoveEmptyEntries);
            var responseData = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(responseContent);

            if (responseData == null)
            {
                return false;
            }

            foreach (var rule in rules)
            {
                if (!ValidateSingleRule(rule, responseData))
                {
                    return false;
                }
            }

            return true;
        }
        catch
        {
            // 验证失败，返回false
            return false;
        }
    }

    /// <summary>
    /// 验证单个规则
    /// @author zzy
    /// </summary>
    private static bool ValidateSingleRule(string rule, Dictionary<string, JsonElement> data)
    {
        rule = rule.Trim();

        if (rule.Contains("!="))
        {
            var parts = rule.Split("!=", 2);
            if (parts.Length != 2) return false;

            var key = parts[0].Trim();
            var expectedValue = parts[1].Trim();

            if (!data.TryGetValue(key, out var value)) return true; // 不存在时，不等于条件成立
            return value.ToString() != expectedValue;
        }

        if (rule.Contains("="))
        {
            var parts = rule.Split("=", 2);
            if (parts.Length != 2) return false;

            var key = parts[0].Trim();
            var expectedValue = parts[1].Trim();

            if (!data.TryGetValue(key, out var value)) return false;
            return value.ToString() == expectedValue;
        }

        // 只检查key是否存在
        return data.ContainsKey(rule);
    }

    #endregion
}