BuYuHouDuan/AdminSrc/AdminService/GameConfigs/ActivityConfigService.cs

using CommonDomain;
using DotNetCore.CAP;
using Microsoft.Extensions.Logging;
using MongoRepository;
using RedisService;

namespace AdminService.GameConfigs
{
    public class ActivityConfigService : IActivityConfigService
    {
        private readonly IMongoBaseRepository<ActivityConfig> _mongo;
        private readonly IRedisService _redis;
        private readonly ICapPublisher _capPublisher;
        private readonly ILogger<ActivityConfigService> _logger;

        public ActivityConfigService(
            IMongoBaseRepository<ActivityConfig> mongo,
            IRedisService redis,
            ICapPublisher capPublisher,
            ILogger<ActivityConfigService> logger)
        {
            _mongo = mongo;
            _redis = redis;
            _capPublisher = capPublisher;
            _logger = logger;
        }

        public async Task<ActivityConfig> Get()
        {
            var config = _redis.GetActivityConfig();
            if (config == null)
            {
                config = await _mongo.FindOneAsync(c => true);
                if (config != null)
                    _redis.SetActivityConfig(config);
            }

            if (config != null && config.AutoStopExpired(DateTimeOffset.UtcNow.ToUnixTimeSeconds()))
            {
                _redis.SetActivityConfig(config);
                var result = await _mongo.ReplaceOneAsync(config);
                
            }
            return config;
        }

        public async Task<(bool isok, string msg)> Update(ActivityConfig config)
        {
            var operationId = Guid.NewGuid().ToString("N");
            var startedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
            bool isadd = false;
            var model = await Get();
            if (model == null)
            {
                isadd = true;
                config.Id = Guid.NewGuid().ToString("N");
            }
            else
            {
                config.Id = model.Id;
            }

            var saveResult = isadd
                ? await _mongo.InsertOneAsync(config)
                : await _mongo.ReplaceOneAsync(config);
            if (!saveResult.ok)
            {
                
                return (false, saveResult.message);
            }

            _redis.SetActivityConfig(config);

            var existing = _redis.GetFishingKillConfig();
            if (existing != null)
            {
                existing.BattleOrderIsOpen = config.BattleOrderConfig?.IsOpen ?? false;
                _redis.SetFishingKillConfig(existing);
            }

            

            try
            {
                var publishedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                _capPublisher.Publish(TopicKeys.配置变更, new ConfigChangedMessage
                {
                    ConfigType = "ActivityConfig",
                    OperationId = operationId,
                    PublishedAtUnixMs = publishedAt
                });
                
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "[ActivityConfig] CAP发布失败 operationId={OperationId} topic={Topic}", operationId, TopicKeys.配置变更);
                return (false, $"数据已保存，但刷新通知发布失败，操作编号：{operationId}");
            }

            return saveResult;
        }

        public async Task<(bool isok, string msg)> Delete()
        {
            _redis.RemoveActivityConfig();
            return await _mongo.DeleteOneAsync(c => true);
        }
    }
}