zengzy / hhrcs_service · Files

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Rcs.Application.Services;
using Rcs.Domain.Entities;
using Rcs.Domain.Repositories;
using Rcs.Domain.Settings;
using StackExchange.Redis;

namespace Rcs.Infrastructure.Services
{
    /// <summary>
    /// 数据同步后台服务 - 程序启动时将地图和机器人数据同步到Redis
    /// @author zzy
    /// </summary>
    public class DataSyncBackgroundService : IHostedService, IDataSyncService
    {
        private readonly ILogger<DataSyncBackgroundService> _logger;
        private readonly IServiceProvider _serviceProvider;
        private readonly IConnectionMultiplexer _redis;
        private readonly AppSettings _settings;

        // JSON序列化选项，允许特殊浮点数值（Infinity、NaN）
        private static readonly JsonSerializerOptions _jsonOptions = new()
        {
            NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals
        };

        public DataSyncBackgroundService(
            ILogger<DataSyncBackgroundService> logger,
            IServiceProvider serviceProvider,
            IConnectionMultiplexer redis,
            IOptions<AppSettings> settings)
        {
            _logger = logger;
            _serviceProvider = serviceProvider;
            _redis = redis;
            _settings = settings.Value;
        }

        /// <summary>
        /// 服务启动时执行数据同步
        /// @author zzy
        /// </summary>
        public async Task StartAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("[数据同步] === StartAsync 开始执行 ===");
            _logger.LogInformation("[数据同步] 依赖注入检查 - _serviceProvider: {SP}, _redis: {Redis}, _settings: {Settings}",
                _serviceProvider == null ? "null" : "ok",
                _redis == null ? "null" : "ok",
                _settings == null ? "null" : "ok");

            if (_settings?.Redis?.KeyPrefixes == null)
            {
                _logger.LogError("[数据同步] _settings.Redis.KeyPrefixes 为 null！");
            }
            else
            {
                _logger.LogInformation("[数据同步] Redis KeyPrefixes - Map: {Map}, MapList: {MapList}, Robot: {Robot}",
                    _settings.Redis.KeyPrefixes.Map ?? "null",
                    _settings.Redis.KeyPrefixes.MapList ?? "null",
                    _settings.Redis.KeyPrefixes.Robot ?? "null");
            }

            try
            {
                _logger.LogInformation("[数据同步] 开始调用 SyncAllAsync...");
                await SyncAllAsync(cancellationToken);
                _logger.LogInformation("[数据同步] 数据同步服务启动完成");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "[数据同步] 数据同步服务启动失败，异常类型: {Type}, 消息: {Message}", ex.GetType().FullName, ex.Message);
                _logger.LogError("[数据同步] 异常堆栈: {StackTrace}", ex.StackTrace);
                if (ex.InnerException != null)
                {
                    _logger.LogError("[数据同步] 内部异常: {Type} - {Message}", ex.InnerException.GetType().FullName, ex.InnerException.Message);
                }
            }
            
            _logger.LogInformation("[数据同步] === StartAsync 执行结束 ===");
        }

        /// <summary>
        /// 服务停止
        /// @author zzy
        /// </summary>
        public Task StopAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("[数据同步] 数据同步服务已停止");
            return Task.CompletedTask;
        }

        /// <summary>
        /// 同步所有数据到Redis
        /// @author zzy
        /// </summary>
        public async Task SyncAllAsync(CancellationToken cancellationToken = default)
        {
            _logger.LogInformation("[数据同步] === SyncAllAsync 开始 ===");
            
            try
            {
                _logger.LogInformation("[数据同步] 开始同步地图数据...");
                await SyncMapsAsync(cancellationToken);
                _logger.LogInformation("[数据同步] 地图数据同步完成");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "[数据同步] 地图数据同步失败");
                throw;
            }

            try
            {
                _logger.LogInformation("[数据同步] 开始同步机器人数据...");
                await SyncRobotsAsync(cancellationToken);
                _logger.LogInformation("[数据同步] 机器人数据同步完成");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "[数据同步] 机器人数据同步失败");
                throw;
            }
            
            _logger.LogInformation("[数据同步] === SyncAllAsync 完成 ===");
        }

        /// <summary>
        /// 同步所有地图数据到Redis（包含节点、边、资源）
        /// @author zzy
        /// </summary>
        public async Task SyncMapsAsync(CancellationToken cancellationToken = default)
        {
            _logger.LogInformation("[数据同步-地图] === SyncMapsAsync 开始执行 ===");
            
            using var scope = _serviceProvider.CreateScope();
            _logger.LogInformation("[数据同步-地图] 依赖注入作用域已创建");
            
            var mapRepo = scope.ServiceProvider.GetRequiredService<IMapRepository>();
            _logger.LogInformation("[数据同步-地图] IMapRepository 已获取: {Type}", mapRepo?.GetType()?.FullName ?? "null");
            
            var db = _redis.GetDatabase();
            _logger.LogInformation("[数据同步-地图] Redis数据库已获取: {IsNull}", db == null ? "null" : "not null");

            _logger.LogInformation("[数据同步-地图] 开始调用 GetAllAsync 获取地图列表...");
            var maps = await mapRepo.GetAllAsync(cancellationToken);
            _logger.LogInformation("[数据同步-地图] GetAllAsync 返回结果: {IsNull}, Type: {Type}", 
                maps == null ? "null" : "not null", maps?.GetType()?.FullName ?? "N/A");

            if (maps == null)
            {
                _logger.LogError("[数据同步-地图] GetAllAsync 返回 null 集合！");
                return;
            }

            var mapList = maps.ToList();
            _logger.LogInformation("[数据同步-地图] 地图列表转换为List完成，Count = {Count}", mapList.Count);

            var mapIds = new List<string>();
            int index = 0;

            foreach (var mapBasic in mapList)
            {
                _logger.LogInformation("[数据同步-地图] 处理第 {Index} 个地图...", index);
                
                if (mapBasic == null)
                {
                    _logger.LogWarning("[数据同步-地图] 第 {Index} 个地图为 null，跳过", index);
                    index++;
                    continue;
                }

                _logger.LogInformation("[数据同步-地图] 地图基本信息 - MapId: {MapId}, MapCode: {MapCode}, MapName: {MapName}",
                    mapBasic.MapId, mapBasic.MapCode, mapBasic.MapName);
                
                // 获取包含完整关联数据的地图
                _logger.LogInformation("[数据同步-地图] 开始调用 GetWithFullDetailsAsync(MapId={MapId})...", mapBasic.MapId);
                Map? map = null;
                try
                {
                    map = await mapRepo.GetWithFullDetailsAsync(mapBasic.MapId, cancellationToken);
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "[数据同步-地图] GetWithFullDetailsAsync 抛出异常 - MapId={MapId}", mapBasic.MapId);
                    throw;
                }
                
                _logger.LogInformation("[数据同步-地图] GetWithFullDetailsAsync 返回: {IsNull}", map == null ? "null" : "not null");
                
                if (map == null)
                {
                    _logger.LogWarning("[数据同步-地图] 地图 {MapId} 的详细数据为 null，跳过", mapBasic.MapId);
                    index++;
                    continue;
                }

                _logger.LogInformation("[数据同步-地图] 地图详细数据 - MapId: {MapId}, Nodes: {NodeCount}, Edges: {EdgeCount}, Resources: {ResourceCount}",
                    map.MapId,
                    map.MapNodes?.Count ?? 0,
                    map.MapEdges?.Count ?? 0,
                    map.MapResources?.Count ?? 0);

                // 检查导航属性是否为null
                if (map.MapNodes == null)
                    _logger.LogWarning("[数据同步-地图] 地图 {MapId} 的 MapNodes 为 null", map.MapId);
                if (map.MapEdges == null)
                    _logger.LogWarning("[数据同步-地图] 地图 {MapId} 的 MapEdges 为 null", map.MapId);
                if (map.MapResources == null)
                    _logger.LogWarning("[数据同步-地图] 地图 {MapId} 的 MapResources 为 null", map.MapId);

                // 将单个地图数据写入Redis
                _logger.LogInformation("[数据同步-地图] 开始写入Redis...");
                try
                {
                    await WriteMapToRedisAsync(db, map);
                    _logger.LogInformation("[数据同步-地图] 写入Redis成功");
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "[数据同步-地图] 写入Redis失败 - MapId={MapId}", map.MapId);
                    throw;
                }
                
                mapIds.Add(map.MapId.ToString());
                _logger.LogInformation("[数据同步-地图] 第 {Index} 个地图处理完成", index);
                index++;
            }

            _logger.LogInformation("[数据同步-地图] 循环结束，共处理 {ProcessedCount} 个地图，准备存储地图ID列表...", mapIds.Count);

            // 存储地图ID列表
            var mapListKey = _settings?.Redis?.KeyPrefixes?.MapList;
            _logger.LogInformation("[数据同步-地图] Redis Key: {Key}", mapListKey ?? "null");
            
            if (string.IsNullOrEmpty(mapListKey))
            {
                _logger.LogError("[数据同步-地图] Redis KeyPrefixes.MapList 为空！");
            }
            else
            {
                var json = JsonSerializer.Serialize(mapIds, _jsonOptions);
                _logger.LogInformation("[数据同步-地图] 序列化后的JSON长度: {Length}", json?.Length ?? 0);
                await db.StringSetAsync(mapListKey, json);
                _logger.LogInformation("[数据同步-地图] 地图ID列表已写入Redis");
            }

            _logger.LogInformation("[数据同步-地图] === SyncMapsAsync 执行完成，已同步 {Count} 个地图 ===", mapIds.Count);
        }

        /// <summary>
        /// 同步单个地图数据到Redis（用于地图数据修改后的热加载）
        /// @author zzy
        /// </summary>
        /// <param name="mapId">地图ID</param>
        /// <param name="cancellationToken">取消令牌</param>
        public async Task SyncMapAsync(Guid mapId, CancellationToken cancellationToken = default)
        {
            using var scope = _serviceProvider.CreateScope();
            var mapRepo = scope.ServiceProvider.GetRequiredService<IMapRepository>();
            var db = _redis.GetDatabase();

            var map = await mapRepo.GetWithFullDetailsAsync(mapId, cancellationToken);
            if (map == null)
            {
                _logger.LogWarning("[数据同步] 地图 {MapId} 不存在，跳过同步", mapId);
                return;
            }

            // 将单个地图数据写入Redis
            await WriteMapToRedisAsync(db, map);

            // 更新地图ID列表（确保新增地图也能被加入列表）
            var mapListJson = await db.StringGetAsync(_settings.Redis.KeyPrefixes.MapList);
            var mapIds = mapListJson.HasValue
                ? JsonSerializer.Deserialize<List<string>>(mapListJson!, _jsonOptions) ?? new List<string>()
                : new List<string>();

            var mapIdStr = mapId.ToString();
            if (!mapIds.Contains(mapIdStr))
            {
                mapIds.Add(mapIdStr);
                await db.StringSetAsync(_settings.Redis.KeyPrefixes.MapList, JsonSerializer.Serialize(mapIds, _jsonOptions));
            }

            _logger.LogInformation("[数据同步] 已同步地图 {MapId}({MapCode}) 到Redis", map.MapId, map.MapCode);
        }

        /// <summary>
        /// 直接将地图实体同步到Redis（不查库，适用于数据尚未持久化的场景）
        /// @author zzy
        /// </summary>
        /// <param name="map">地图实体（需包含完整关联数据：Nodes/Edges/Resources）</param>
        public async Task SyncMapAsync(Map map)
        {
            var db = _redis.GetDatabase();

            // 将地图数据写入Redis
            await WriteMapToRedisAsync(db, map);

            // 更新地图ID列表（确保新增地图也能被加入列表）
            var mapListJson = await db.StringGetAsync(_settings.Redis.KeyPrefixes.MapList);
            var mapIds = mapListJson.HasValue
                ? JsonSerializer.Deserialize<List<string>>(mapListJson!, _jsonOptions) ?? new List<string>()
                : new List<string>();

            var mapIdStr = map.MapId.ToString();
            if (!mapIds.Contains(mapIdStr))
            {
                mapIds.Add(mapIdStr);
                await db.StringSetAsync(_settings.Redis.KeyPrefixes.MapList, JsonSerializer.Serialize(mapIds, _jsonOptions));
            }

            _logger.LogInformation("[数据同步] 已通过实体直接同步地图 {MapId}({MapCode}) 到Redis", map.MapId, map.MapCode);
        }

        /// <summary>
        /// 将单个地图数据序列化并写入Redis
        /// @author zzy
        /// </summary>
        /// <param name="db">Redis数据库实例</param>
        /// <param name="map">地图实体（含完整关联数据）</param>
        private async Task WriteMapToRedisAsync(IDatabase db, Domain.Entities.Map map)
        {
            _logger.LogInformation("[数据同步-写入Redis] WriteMapToRedisAsync 开始 - MapId={MapId}", map?.MapId);
            
            if (map == null)
            {
                _logger.LogError("[数据同步-写入Redis] map 参数为 null！");
                throw new ArgumentNullException(nameof(map));
            }
            
            if (_settings?.Redis?.KeyPrefixes?.Map == null)
            {
                _logger.LogError("[数据同步-写入Redis] _settings.Redis.KeyPrefixes.Map 为 null！");
                throw new InvalidOperationException("Redis KeyPrefixes.Map 未配置");
            }
            
            var key = $"{_settings.Redis.KeyPrefixes.Map}:{map.MapId}";
            _logger.LogInformation("[数据同步-写入Redis] Redis Key: {Key}", key);
            
            _logger.LogInformation("[数据同步-写入Redis] 开始构建缓存数据...");
            var cacheData = BuildMapCacheData(map);
            _logger.LogInformation("[数据同步-写入Redis] 缓存数据构建完成");
            
            _logger.LogInformation("[数据同步-写入Redis] 开始序列化...");
            var json = JsonSerializer.Serialize(cacheData, _jsonOptions);
            _logger.LogInformation("[数据同步-写入Redis] 序列化完成，JSON长度: {Length}", json?.Length ?? 0);
            
            _logger.LogInformation("[数据同步-写入Redis] 开始写入Redis...");
            await db.StringSetAsync(key, json);
            _logger.LogInformation("[数据同步-写入Redis] 写入Redis完成");
        }

        /// <summary>
        /// 构建地图缓存数据对象
        /// @author zzy
        /// </summary>
        /// <param name="map">地图实体（含完整关联数据）</param>
        /// <returns>地图缓存数据</returns>
        private static MapCacheData BuildMapCacheData(Domain.Entities.Map map)
        {
            if (map == null) throw new ArgumentNullException(nameof(map));
            
            // 防御性处理导航属性为null的情况
            var nodes = map.MapNodes ?? new List<MapNode>();
            var edges = map.MapEdges ?? new List<MapEdge>();
            var resources = map.MapResources ?? new List<MapResource>();
            
            return new MapCacheData
            {
                MapId = map.MapId,
                MapCode = map.MapCode,
                MapName = map.MapName,
                MapType = (int)map.MapType,
                Version = map.Version,
                Active = map.Active,
                Nodes = nodes.Select(n => new MapNodeCache
                {
                    NodeId = n.NodeId,
                    NodeCode = n.NodeCode,
                    X = n.X,
                    Y = n.Y,
                    Theta = n.Theta,
                    Type = (int)n.Type,
                    Active = n.Active,
                    IsReverseParking = n.IsReverseParking,
                    AllowRotate = n.AllowRotate,
                    MaxCoordinateOffset = n.MaxCoordinateOffset
                }).ToList(),
                Edges = edges.Select(e => new MapEdgeCache
                {
                    EdgeId = e.EdgeId,
                    EdgeCode = e.EdgeCode,
                    FromNode = e.FromNode,
                    ToNode = e.ToNode,
                    Length = e.Length,
                    Cost = e.Cost,
                    Active = e.Active,
                    OrientationRads = e.OrientationRads,
                    MaxSpeed = e.MaxSpeed,
                    MaxRadDeviation = e.MaxRadDeviation,
                    IsCurve = e.IsCurve,
                    ControlPoints = e.ControlPoints?
                        .Select(p => new PointCache { X = p.X, Y = p.Y })
                        .ToList()
                }).ToList(),
                Resources = resources.Select(r => new MapResourceCache
                {
                    ResourceId = r.ResourceId,
                    ResourceCode = r.ResourceCode,
                    Type = (int)r.Type,
                    Capacity = r.Capacity,
                    LocationCoordinates = r.LocationCoordinates?.Coordinates
                        .Select(c => new PointCache { X = c.X, Y = c.Y })
                        .ToList(),
                    MaxSpeed = r.MaxSpeed,
                    CanRotate = r.CanRotate,
                    PreAction1Type = r.PreAction1Type,
                    PreNetActions1 = r.PreNetActions1,
                    PostAction1Type = r.PostAction1Type,
                    PostNetActions1 = r.PostNetActions1,
                    PreAction2Type = r.PreAction2Type,
                    PreNetActions2 = r.PreNetActions2,
                    PostAction2Type = r.PostAction2Type,
                    PostNetActions2 = r.PostNetActions2
                }).ToList()
            };
        }

        /// <summary>
        /// 同步所有机器人数据到Redis（使用Hash结构分离存储基础/状态/位置数据）
        /// @author zzy
        /// </summary>
        public async Task SyncRobotsAsync(CancellationToken cancellationToken = default)
        {
            using var scope = _serviceProvider.CreateScope();
            var robotRepo = scope.ServiceProvider.GetRequiredService<IRobotRepository>();
            var db = _redis.GetDatabase();

            var robots = await robotRepo.GetAllAsync(cancellationToken);

            foreach (var robot in robots)
            {
                await WriteRobotToRedisAsync(db, robot);
            }

            _logger.LogInformation("[数据同步] 已同步 {Count} 个机器人数据到Redis（Hash结构）", robots.Count());
        }

        /// <summary>
        /// 同步单个机器人数据到Redis（用于机器人数据修改后的热加载）
        /// @author zzy
        /// </summary>
        /// <param name="robotId">机器人ID</param>
        /// <param name="cancellationToken">取消令牌</param>
        public async Task SyncRobotAsync(Guid robotId, CancellationToken cancellationToken = default)
        {
            using var scope = _serviceProvider.CreateScope();
            var robotRepo = scope.ServiceProvider.GetRequiredService<IRobotRepository>();
            var db = _redis.GetDatabase();

            var robot = await robotRepo.GetByIdFullDataAsync(robotId, cancellationToken);
            if (robot == null)
            {
                _logger.LogWarning("[数据同步] 机器人 {RobotId} 不存在，跳过同步", robotId);
                return;
            }

            await WriteRobotToRedisAsync(db, robot);

            _logger.LogInformation("[数据同步] 已同步机器人 {RobotId}({RobotCode}) 到Redis", robot.RobotId, robot.RobotCode);
        }

        /// <summary>
        /// 直接将机器人实体同步到Redis（不查库，适用于数据尚未持久化的场景）
        /// @author zzy
        /// </summary>
        /// <param name="robot">机器人实体</param>
        public async Task SyncRobotAsync(Robot robot)
        {
            var db = _redis.GetDatabase();
            await WriteRobotToRedisAsync(db, robot);
            _logger.LogInformation("[数据同步] 已通过实体直接同步机器人 {RobotId}({RobotCode}) 到Redis", robot.RobotId, robot.RobotCode);
        }

        /// <summary>
        /// 将单个机器人数据写入Redis（Hash结构：基础/状态/位置 + 集合维护）
        /// @author zzy
        /// </summary>
        /// <param name="db">Redis数据库实例</param>
        /// <param name="robot">机器人实体</param>
        private async Task WriteRobotToRedisAsync(IDatabase db, Robot robot)
        {
            await DeleteRobotCacheByRobotIdAsync(db, robot.RobotId);

            var robotKey = $"{robot.RobotManufacturer}:{robot.RobotSerialNumber}";

            // 基础数据 Hash（使用制造商+序列号作为唯一标识）
            var basicKey = $"{_settings.Redis.KeyPrefixes.Robot}:{robotKey}:basic";
            await db.HashSetAsync(basicKey, new HashEntry[]
            {
                new("RobotId", robot.RobotId.ToString()),
                new("RobotCode", robot.RobotCode),
                new("RobotName", robot.RobotName),
                new("RobotModel", robot.RobotModel),
                new("RobotVersion", robot.RobotVersion),
                new("ProtocolName", robot.ProtocolName),
                new("ProtocolVersion", robot.ProtocolVersion),
                new("ProtocolType", (int)robot.ProtocolType),
                new("RobotManufacturer", robot.RobotManufacturer ?? ""),
                new("RobotSerialNumber", robot.RobotSerialNumber),
                new("RobotType", (int)robot.RobotType),
                new("IpAddress", robot.IpAddress),
                new("CoordinateScale", robot.CoordinateScale),
                new("LastNode", ""),// 最后经过的节点
                new("Active", robot.Active)
            });

            // 状态数据 Hash（使用制造商+序列号作为唯一标识）
            var statusKey = $"{_settings.Redis.KeyPrefixes.Robot}:{robotKey}:status";
            await db.HashSetAsync(statusKey, new HashEntry[]
            {
                new("Status", (int)robot.Status),
                new("Online", (int)robot.Online),
                new("BatteryLevel", robot.BatteryLevel ?? 0),
                new("Driving", robot.Driving),
                new("Paused", robot.Paused),
                new("Charging", robot.Charging),
                new("OperatingMode", (int)robot.OperatingMode),
                new("Errors", robot.Errors ?? ""),
                new("UpdatedAt", DateTime.Now.ToString("O"))
            });

            // 位置数据 Hash（使用制造商+序列号作为唯一标识）
            var locationKey = $"{_settings.Redis.KeyPrefixes.Robot}:{robotKey}:location";
            await db.HashSetAsync(locationKey, new HashEntry[]
            {
                new("MapId", robot.CurrentMapCodeId?.ToString() ?? ""),
                new("NodeId", robot.CurrentNodeId?.ToString() ?? ""),
                new("X", robot.CurrentX?.ToString(System.Globalization.CultureInfo.InvariantCulture) ?? ""),
                new("Y", robot.CurrentY?.ToString(System.Globalization.CultureInfo.InvariantCulture) ?? ""),
                new("Theta", robot.CurrentTheta?.ToString(System.Globalization.CultureInfo.InvariantCulture) ?? ""),
                new("Path", ""),
                new("UpdatedAt", DateTime.Now.ToString("O"))
            });

            // 添加到机器人集合（使用制造商:序列号作为标识）
            await db.SetAddAsync(_settings.Redis.KeyPrefixes.RobotsSet, robotKey);

            // 更新在线/空闲集合
            if (robot.Online == OnlineStatus.Online)
                await db.SetAddAsync(_settings.Redis.KeyPrefixes.RobotsOnlineSet, robotKey);
            else
                await db.SetRemoveAsync(_settings.Redis.KeyPrefixes.RobotsOnlineSet, robotKey);

            if (robot.Status == RobotStatus.Idle)
                await db.SetAddAsync(_settings.Redis.KeyPrefixes.RobotsIdleSet, robotKey);
            else
                await db.SetRemoveAsync(_settings.Redis.KeyPrefixes.RobotsIdleSet, robotKey);
        }

        private async Task DeleteRobotCacheByRobotIdAsync(IDatabase db, Guid robotId)
        {
            var robotMembers = await db.SetMembersAsync(_settings.Redis.KeyPrefixes.RobotsSet);

            foreach (var member in robotMembers)
            {
                var cachedRobotKey = member.ToString();
                if (string.IsNullOrWhiteSpace(cachedRobotKey))
                {
                    continue;
                }

                var basicKey = $"{_settings.Redis.KeyPrefixes.Robot}:{cachedRobotKey}:basic";
                var cachedRobotId = await db.HashGetAsync(basicKey, "RobotId");
                if (cachedRobotId.IsNullOrEmpty || !Guid.TryParse(cachedRobotId.ToString(), out var parsedRobotId) || parsedRobotId != robotId)
                {
                    continue;
                }

                var statusKey = $"{_settings.Redis.KeyPrefixes.Robot}:{cachedRobotKey}:status";
                var locationKey = $"{_settings.Redis.KeyPrefixes.Robot}:{cachedRobotKey}:location";

                await db.KeyDeleteAsync(new RedisKey[] { basicKey, statusKey, locationKey });
                await db.SetRemoveAsync(_settings.Redis.KeyPrefixes.RobotsSet, cachedRobotKey);
                await db.SetRemoveAsync(_settings.Redis.KeyPrefixes.RobotsOnlineSet, cachedRobotKey);
                await db.SetRemoveAsync(_settings.Redis.KeyPrefixes.RobotsIdleSet, cachedRobotKey);

                _logger.LogInformation("[数据同步] 已按 RobotId 清理旧缓存: {RobotId}, Key: {RobotKey}", robotId, cachedRobotKey);
            }
        }
    }
}