HealthMonitor/HealthMonitor.WebApi/Worker.cs

using dotnet_etcd;
using Etcdserverpb;
using Google.Protobuf.WellKnownTypes;
using HealthMonitor.Common;
using HealthMonitor.Common.helper;
using HealthMonitor.Core.Common.Extensions;
using HealthMonitor.Core.Pipeline;
using HealthMonitor.Model.Config;
using HealthMonitor.Model.Service;
using HealthMonitor.Model.Service.Mapper;
using HealthMonitor.Service.Biz;
using HealthMonitor.Service.Biz.db;
using HealthMonitor.Service.Cache;
using HealthMonitor.Service.Etcd;
using HealthMonitor.Service.MessageQueue;
using HealthMonitor.Service.Sub;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using Microsoft.Extensions.Options;
using NetTaste;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Reflection;
using System.Threading.Channels;
using TDengineDriver;
using TDengineTMQ;
using TelpoDataService.Util.Clients;
using TelpoDataService.Util.Entities.GpsCard;
using TelpoDataService.Util.Entities.GpsLocationHistory;
using TelpoDataService.Util.Models;
using TelpoDataService.Util.QueryObjects;

namespace HealthMonitor.WebApi
{
    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;
        private readonly IServiceProvider _services;
        private readonly TDengineDataSubcribe _tdEngineDataSubcribe;
        private readonly PackageProcess _processor;
        private readonly TDengineService _serviceTDengine;
        private readonly EtcdService _serviceEtcd;
        private readonly HttpHelper _httpHelper = default!;
        private readonly IotApiService _serviceIotApi;
        private readonly BoodPressResolverConfig _configBoodPressResolver;
        private readonly BloodPressReferenceValueCacheManager _bpRefValCacheManager;
        private readonly PersonCacheManager _personCacheMgr;
        private readonly DeviceCacheManager _deviceCacheMgr;
        private readonly FetalMovementNormalValueRangeCacheManager _mgrFetalMovementNormalValueRangeCache;

        private readonly GpsLocationHistoryAccessorClient<HisGpsFetalHeartRate> _hisFetalHeartApiClient;
        private readonly GpsLocationHistoryAccessorClient<HisGpsFetalMovement> _hisFetalMovementApiClient;

        private readonly MqProcessLogic _serviceMqProcess;

        private CancellationTokenSource _tokenSource = default!;

        public Worker(ILogger<Worker> logger, IServiceProvider services, PersonCacheManager personCacheMgr, 
            BloodPressReferenceValueCacheManager bpRefValCacheManager, IotApiService IotApiService, 
            IOptions<BoodPressResolverConfig> optionBoodPressResolver, PackageProcess processor, 
            TDengineDataSubcribe tdEngineDataSubcribe, TDengineService serviceDengine,
            GpsLocationHistoryAccessorClient<HisGpsFetalHeartRate> hisFetalHeartApiClient,
            GpsLocationHistoryAccessorClient<HisGpsFetalMovement> hisFetalMovementApiClient,
            FetalMovementNormalValueRangeCacheManager fetalMovementNormalValueRangeCacheMgr, MqProcessLogic serviceMqProcess,
            HttpHelper httpHelper, EtcdService serviceEtcd, DeviceCacheManager deviceCacheMgr)
        {
            _logger = logger;
            _tdEngineDataSubcribe = tdEngineDataSubcribe;
            _services = services;
            _serviceIotApi = IotApiService;
            _processor = processor;
            _serviceEtcd = serviceEtcd;
            _serviceTDengine = serviceDengine;
            _httpHelper = httpHelper;
            _configBoodPressResolver = optionBoodPressResolver.Value;
            _bpRefValCacheManager = bpRefValCacheManager;
            _personCacheMgr = personCacheMgr;
            _deviceCacheMgr = deviceCacheMgr;
            _hisFetalHeartApiClient = hisFetalHeartApiClient;
            _hisFetalMovementApiClient = hisFetalMovementApiClient;
            _serviceMqProcess = serviceMqProcess;
            _mgrFetalMovementNormalValueRangeCache = fetalMovementNormalValueRangeCacheMgr;
        }

        public override Task StartAsync(CancellationToken cancellationToken)
        {
            //_logger.LogInformation("------StartAsync");
            _tokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
            return base.StartAsync(cancellationToken);
        }

        public override Task StopAsync(CancellationToken cancellationToken)
        {
            //_logger.LogInformation("------StopAsync");
            _tokenSource.Cancel();  //停止工作线程
            return base.StopAsync(cancellationToken);
        }
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            var tasks = new[]
            {
                Task.Run(async () =>
                {
                    _logger.LogInformation("解析器启动");
                    while (!stoppingToken.IsCancellationRequested)
                    {
                        await _processor.ResolveAsync().ConfigureAwait(false);
                    }
                }, stoppingToken),

                Task.Run(() =>
                {
                    _logger.LogInformation("TDengine 订阅启动");
                    while (!stoppingToken.IsCancellationRequested)
                    {
                        _tdEngineDataSubcribe.BeginListen(stoppingToken);
                    }
                }, stoppingToken),

                Task.Run(() =>
                    _serviceEtcd.WacthKeysWithPrefixResponseAsync("health_monitor/schedule_push", WatchEvents),
                    stoppingToken)
            };

            await Task.WhenAll(tasks);
        }

        private void WatchEvents(WatchResponse response)
        {

            response.Events.ToList<Mvccpb.Event>().ForEach(async e =>
            {
                try
                {
                    switch (e.Type.ToString())
                    {
                        case "Put":
                            // 获取时间点计算TTL
                            Console.BackgroundColor = ConsoleColor.Blue;
                            Console.WriteLine($"--- {e.Type}--{e.Kv.Key.ToStringUtf8()}--{e.Kv.Value.ToStringUtf8()}---{DateTime.Now}");
                            Console.BackgroundColor = ConsoleColor.Black;
                            break;

                        case "Delete":
                            // TTL到了重新计算TTL，下发
                            //Console.BackgroundColor = ConsoleColor.Green;
                            //Console.WriteLine($"--- {e.Type}--{e.Kv.Key.ToStringUtf8()}--{e.Kv.Value.ToStringUtf8()}---{DateTime.Now}");

                            // var key = $"health_monitor/schedule_push/imei/{bp.Serialno}";
                            var key = e.Kv.Key.ToStringUtf8();
                            var imeiDel = key.Split('/')[^1];
                            var schedule_push = await _serviceEtcd.GetValAsync(key).ConfigureAwait(false);
                            if (string.IsNullOrWhiteSpace(schedule_push))
                            {
                                if (key.Contains("pregnancy_heart_rate"))
                                {
                                    var watchConfig = await _deviceCacheMgr.GetGpsDeviceWatchConfigCacheObjectBySerialNoAsync(imeiDel, "0067");
                                    var isFetalHeartEnable = watchConfig != null && (int)watchConfig["enabled"]! == 1;

                                    if (isFetalHeartEnable)
                                    {
                                        // 高频心率采样间隔 highFreqSampleInterval = highFreqSampleInterval+5,增加5秒兼容
                                        //var highFreqSampleInterval = (int)watchConfig!["highFreqSampleInterval"]! + 5;
                                        // 高频心率采样间隔 highFreqSampleInterval = highFreqSampleInterval+5,增加5秒兼容(最小highFreqSampleInterval=60)
                                        var highFreqSampleInterval = (int)watchConfig!["highFreqSampleInterval"]! >= 60 ? (int)watchConfig!["highFreqSampleInterval"]! + 5 : 60;
                                        // 处理孕妇业务，计算一般心率并下发
                                        var commonPHR = await _serviceTDengine.InitPregnancyCommonHeartRateModeAsync(imeiDel, highFreqSampleInterval: highFreqSampleInterval);
                                        if (commonPHR == null)
                                        {
                                            // 建模中
                                            var flag = await _serviceIotApi.SetFetalConfig(imeiDel);
                                            _logger.LogInformation($"{imeiDel} 建模建模中");
                                        }
                                        else
                                        {
                                            // 建模完成
                                            var flag = await _serviceIotApi.SetFetalConfig(imeiDel, 1, commonPHR.MaxValue, commonPHR.MinValue);
                                            _logger.LogInformation($"{imeiDel} 建模完成");
                                            // 保存到TDengine数据库
                                            await _serviceTDengine.InsertAsync<PregnancyCommonHeartRateModel>("hm_pchr", commonPHR);
                                            _logger.LogInformation($"保存TDengine完成");

                                            //
                                        }
                                    }




                                    #region 注册定时下发
                                    var startTime = DateTime.Now;
                                    // 注册下次下推
                                    var endTime = DateTime.Now;

#if DEBUG


                                    //long ttl = (long)((60 * 1000-(endTime-startTime).TotalMilliseconds)/1000);
                                    //await _serviceEtcd.PutValAsync(key, imeiDel,ttl, false).ConfigureAwait(false);

                                    var interval = 0;
                                    // 获取当前时间
                                    DateTime now = DateTime.Now;

                                    // 计算距离下一个$interval天后的8点的时间间隔
                                    DateTime nextRunTime = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute + 2, 0).AddDays(interval);
                                    TimeSpan timeUntilNextRun = nextRunTime - now;

                                    // 如果当前时间已经超过了8点，将等待到明天后的8点
                                    if (timeUntilNextRun < TimeSpan.Zero)
                                    {
                                        timeUntilNextRun = timeUntilNextRun.Add(TimeSpan.FromMinutes(1));
                                        nextRunTime += timeUntilNextRun;
                                    }

                                    //long ttl = timeUntilNextRun.Milliseconds/1000;
                                    long ttl = (long)((timeUntilNextRun.TotalMilliseconds - (endTime - startTime).TotalMilliseconds) / 1000);
                                    var data = new
                                    {
                                        imei = imeiDel,
                                        create_time = now.ToString("yyyy-MM-dd HH:mm:ss"),
                                        ttl,
                                        next_run_time = nextRunTime.ToString("yyyy-MM-dd HH:mm:ss")
                                    };
                                    var result = JsonConvert.SerializeObject(data);

                                    await _serviceEtcd.PutValAsync(key, result, ttl, false).ConfigureAwait(false);


#else
                                        // 每$interval天,晚上8点
                                        var interval = 1;
                                        // 获取当前时间
                                        DateTime now = DateTime.Now;
                                        var rand = new Random();

                                        var pushSec = rand.Next(59);
                                        int pushMin = int.TryParse(imeiDel.AsSpan(imeiDel.Length - 1), out pushMin) ? pushMin : 10;
                                        // 计算距离下一个$interval天后的0点的时间间隔
                                         DateTime nextRunTime = new DateTime(now.Year, now.Month, now.Day, 6, pushMin, pushSec).AddDays(interval);
                                        TimeSpan timeUntilNextRun = nextRunTime - now;

                                        // 如果当前时间已经超过了8点，将等待到明天后的8点
                                        if (timeUntilNextRun < TimeSpan.Zero)
                                        {
                                            timeUntilNextRun = timeUntilNextRun.Add(TimeSpan.FromDays(1));
                                            nextRunTime += timeUntilNextRun;
                                        }

                                        // var ttl = timeUntilNextRun.TotalMilliseconds;
                                        long ttl = (long)((timeUntilNextRun.TotalMilliseconds-(endTime-startTime).TotalMilliseconds)/1000);
                                        var data = new
                                        {
                                            imei = imeiDel,
                                            create_time = now.ToString("yyyy-MM-dd HH:mm:ss"),
                                            ttl,
                                            next_run_time = nextRunTime.ToString("yyyy-MM-dd HH:mm:ss")
                                        };
                                        var result = JsonConvert.SerializeObject(data);
                                        await _serviceEtcd.PutValAsync(key, result, ttl, false).ConfigureAwait(false);
#endif
                                    #endregion
                                }
                                // health_monitor/schedule_push/cal_fetal_heart_rate/imei/
                                else if (key.Contains("health_monitor/schedule_push/cal_fetal_heart_rate/imei/"))
                                {
                                   /**
                                    var triggerValue= (JObject)JsonConvert.DeserializeObject(e.PrevKv.Value.ToStringUtf8())!;
                                    var trigger = triggerValue["trigger"]?.ToString();
                                    if (!string.IsNullOrEmpty(trigger))
                                    {
                                        var triggerHeartRate= JsonConvert.DeserializeObject<HisGpsHeartRate>(trigger);
                                        using (_logger.BeginScope(new Dictionary<string, object> { ["RequestId"] = triggerHeartRate?.MessageId! }))
                                        {
                                            var watchConfig = await _deviceCacheMgr.GetGpsDeviceWatchConfigCacheObjectBySerialNoAsync(imeiDel, "0067");
                                            _logger.LogInformation($"触发常规心率计算胎心");
                                            var isFetalHeartEnable = watchConfig != null && (int)watchConfig["enabled"]! == 1;

                                            if (isFetalHeartEnable)
                                            {
                                                // 告警上限阀值
                                                var upperAlarmThreshold = (int)watchConfig!["upperAlarmThreshold"]!;
                                                // 告警下限阀值
                                                var lowerAlarmThreshold = (int)watchConfig["lowerAlarmThreshold"]!;

                                                // 高频心率采样间隔 highFreqSampleInterval = highFreqSampleInterval+5,增加5秒兼容(最小highFreqSampleInterval=60)
                                                var highFreqSampleInterval = (int)watchConfig!["highFreqSampleInterval"]! >= 60 ? (int)watchConfig!["highFreqSampleInterval"]! + 5 : 60;

                                                var commonPHR = await _serviceTDengine.GetLastAsync<PregnancyCommonHeartRateModel>(imeiDel);

                                                // 最后一条孕妇心率
                                                var lastPhr = await _serviceTDengine.GetLastAsync<PregnancyHeartRateModel>(imeiDel);
                                                var isNormalHeartRate = triggerHeartRate?.MessageId == lastPhr.MessageId;
                                                // 判断最后一条孕妇心率与解析器的触发心率是否一致
                                                if (isNormalHeartRate)
                                                {
                                                    //最后一条孕妇心率与解析器的触发心率一致
                                                    HisGpsHeartRate heartRate = new()
                                                    {
                                                        CreateTime = lastPhr.CreateTime,
                                                        DeviceKey = lastPhr.DeviceKey,
                                                        HeartRate = lastPhr.PregnancyHeartRate,
                                                        HeartRateId = lastPhr.PregnancyHeartRateId,
                                                        IsDisplay = lastPhr.IsDisplay ? 1 : 0,
                                                        MessageId = lastPhr.MessageId,
                                                        LastUpdate = lastPhr.LastUpdate,
                                                        Method = lastPhr.Method,
                                                        PersonId = lastPhr.PersonId,
                                                        Serialno = lastPhr.SerialNumber
                                                    };
                                                    var intervalFHR = 15;
                                                    await CalculateNormalFetalHeartRateAsync(heartRate, upperAlarmThreshold, lowerAlarmThreshold, intervalFHR, commonPHR);
                                                }
                                                // 最后一条孕妇心率与解析器的触发心率不一致,触发心率是高频心率的首条
                                                else
                                                {
                                                    var phr = await _serviceTDengine.GetBySerialNoAsync<PregnancyHeartRateModel>(imeiDel, 7);
                                                    var phrFreqstatus = await _deviceCacheMgr.GetPregnancyHeartRateFreqStatusAsync(imeiDel);
                                                    
                                                    if (phrFreqstatus != null)
                                                    {

                                                        #region 高频缓存
                                                        // 高频首条是触发心率，30秒后，高频第二条已经写入首条高频缓存
                                                        var diffCount = phr.Where(i => i.CreateTime >= phrFreqstatus.CreateTime && i.CreateTime <= lastPhr.CreateTime)
                                                        .OrderByDescending(i => i.CreateTime);
                                                        _logger.LogInformation($"{imeiDel} 存在高频缓存，高频心率首条记录${phrFreqstatus.MessageId},高频首条到当前的MSG ID{string.Join(",",diffCount.Select(i=>i.MessageId))}");
                                                        #endregion
                                                    }
                                                    // 不在高频状态状态,但触发孕妇心率与最后一条孕妇心率不一致,
                                                    // 常规心率数据是批量上报,需要计算每条心率对应的胎心数据
                                                    else
                                                    {
                                                        _logger.LogInformation($"{imeiDel} 常规心率数据是批量上报,需要计算每条心率对应的胎心数据");

                                                        #region 计算每条心率对应的胎心数据
                                                        phr = phr.OrderByDescending(i => i.LastUpdate).ToList();
                                                        // 获取高频数据
                                                        var freqCollection = new List<PregnancyHeartRateModel>();
                                                        PregnancyHeartRateModel? previousItem = null;
                                                        foreach (var item in phr)
                                                        {
                                                            if (previousItem != null)
                                                            {
                                                                var timeNextDiff = (previousItem!.LastUpdate - item.LastUpdate).TotalSeconds;
                                                                if (timeNextDiff <= highFreqSampleInterval)
                                                                {
                                                                    freqCollection.Add(item);
                                                                }
                                                            }
                                                            previousItem = item;
                                                        }
                                                        //去除高频
                                                        foreach (var item in freqCollection)
                                                        {
                                                            phr.Remove(item);
                                                        }


                                                        // 排序并过滤高频数据
                                                        //var previousItem = phr.OrderByDescending(i => i.LastUpdate).ToList().First();
                                                        //phr = phr.Skip(1)
                                                        //         .Where(item =>
                                                        //         {
                                                        //             var timeNextDiff = (previousItem!.LastUpdate - item.LastUpdate).TotalSeconds;
                                                        //             previousItem = item;
                                                        //             return timeNextDiff > highFreqSampleInterval;
                                                        //         })
                                                        //         .Prepend(previousItem)
                                                        //         .OrderByDescending(i => i.LastUpdate)
                                                        //         .ToList();

                                                        var calFhrTasks = phr.Where(p => p.LastUpdate >= triggerHeartRate!.LastUpdate)
                                                        .Select( async p =>
                                                        {
                                                            HisGpsHeartRate heartRate = new()
                                                            {
                                                                CreateTime = p.CreateTime,
                                                                DeviceKey = p.DeviceKey,
                                                                HeartRate = p.PregnancyHeartRate,
                                                                HeartRateId = p.PregnancyHeartRateId,
                                                                IsDisplay = p.IsDisplay ? 1 : 0,
                                                                MessageId = p.MessageId,
                                                                LastUpdate = p.LastUpdate,
                                                                Method = p.Method,
                                                                PersonId = p.PersonId,
                                                                Serialno = p.SerialNumber
                                                            };
                                                            var intervalFHR = 15;
                                                            await CalculateNormalFetalHeartRateAsync(heartRate, upperAlarmThreshold, lowerAlarmThreshold, intervalFHR, commonPHR);
                                                        });
                                                        await Task.WhenAll(calFhrTasks);
                                                        #endregion
                                                    }
                                                }
                                            }
                                            else
                                            {
                                                _logger.LogWarning($"{imeiDel} 胎心监测功能没有开启");
                                            }
                                        }
                                    }
                                    else
                                    {
                                        _logger.LogWarning($"{imeiDel} trigger is not set");
                                    }

                                    */

                                    

                                    
                                }
                                //health_monitor/schedule_push/cal_fetal_movement/imei/
                                else if (key.Contains("health_monitor/schedule_push/cal_fetal_movement/imei/"))
                                {
                                    #region 胎动延时计算
                                    var watchConfig = await _deviceCacheMgr.GetGpsDeviceWatchConfigCacheObjectBySerialNoAsync(imeiDel, "0067");
                                    _logger.LogInformation($"触发胎动计算，设备配置{JsonConvert.SerializeObject(watchConfig)}");
                                    var isFetalHeartEnable = watchConfig != null && (int)watchConfig["enabled"]! == 1;
                                    if (isFetalHeartEnable) 
                                    {
                                        var edoc = DateTimeUtil.ToDateTime(watchConfig!["EDOC"]!.ToString());
                                        // 已经建模
                                        var commonPHR = await _serviceTDengine.GetLastAsync<PregnancyCommonHeartRateModel>(imeiDel);
                                        if (commonPHR != null)
                                        {
                                            var phr = await _serviceTDengine.GetBySerialNoAsync<PregnancyHeartRateModel>(imeiDel, 7);
                                            _logger.LogInformation($"{imeiDel} 计算胎动数据 ");

                                            var fmNow = DateTime.Now;
                                            // 两小时前
                                            var fmNowSubtract = fmNow.AddMinutes(-fmNow.Minute).AddSeconds(-fmNow.Second).AddMilliseconds(-fmNow.Millisecond);
                                            
                                            var fetalMovementSampleTime = DateTimeUtil.ConvertToTimeStamp(fmNowSubtract).ToString()[..10];

                                            // 统计开始时间
                                            var statStartTime = fmNowSubtract.AddHours(-2);
                                            // 统计结束时间
                                            var statEndTime = fmNowSubtract;

                                            var isFetalMovementExisted = await _deviceCacheMgr.FetalMovementIsExistedAsync(imeiDel, fetalMovementSampleTime);
                                            _logger.LogInformation($"{imeiDel} 胎动记录{isFetalMovementExisted},数据采样时间:{fetalMovementSampleTime}|{fmNowSubtract.ToString("yyyy-MM-dd HH:mm:ss")}, 周期:{statStartTime}-{statEndTime} 开始");

                                            if (!isFetalMovementExisted)
                                            {
                                                /// 开始计算
                                                var phrRange = phr.Where(i => i.LastUpdate >= statStartTime && i.LastUpdate <= statEndTime)
                                                .OrderByDescending(i => i.LastUpdate)
                                                .Select(i => i.LastUpdate)
                                                .ToList();
                                                // 判断是否有持续佩戴
                                                if (phrRange.Count >= 2)
                                                {
                                                    // 读取胎心数据
                                                    GeneralParam param = new()
                                                    {
                                                        Filters = new List<QueryFilterCondition>
                                                            {
                                                                new ()
                                                                {
                                                                    Key=nameof(HisGpsFetalHeartRate.Serialno),
                                                                    Value=imeiDel,
                                                                    ValueType=QueryValueTypeEnum.String,
                                                                    Operator=QueryOperatorEnum.Equal
                                                                },
                                                                //new ()
                                                                //{
                                                                //    Key=nameof(HisGpsFetalHeartRate.SampleTime),
                                                                //    Value=sampleTime,
                                                                //    ValueType=QueryValueTypeEnum.String,
                                                                //    Operator=QueryOperatorEnum.GreaterEqual
                                                                //},
                                                            },
                                                        OrderBys = new List<OrderByCondition>
                                                            {
                                                                new (){
                                                                   IsDesc=true,
                                                                   Key=nameof(HisGpsFetalHeartRate.SampleTime)
                                                                }
                                                            }
                                                    };
                                                    var fetalHeartRateIsAbnormal = 0;
                                                    var fhr = await _hisFetalHeartApiClient.GetFirstAsync(param, imeiDel[^2..], null, new RequestHeader { RequestId = Guid.NewGuid().ToString("D") });

                                                    // 胎心数据时间与胎动时间一致
                                                    var time = long.Parse(fhr.SampleTime.Length < 13 ? fhr.SampleTime.PadRight(13, '0') : fhr.SampleTime);
                                                    var fhrSampleTime = DateTimeUtil.GetDateTimeFromUnixTimeMilliseconds(time);

                                                    // 胎心数据时间与胎动时间一致，最后一条胎心数据与胎动数据的小时差不大于2
                                                    if ((DateTime.Now.Hour - fhrSampleTime.Hour) <= 2)
                                                    {
                                                        var duringMins = Math.Abs((phrRange.First() - phrRange.Last()).TotalMinutes);
                                                        //在餐后时间段（8:00~10:00，12:00~14:00，18:00~20:00，22:00~24:00）取中间值。其他时间段取正常起始值
                                                        bool isInTimeRanges = IsLastUpdateInTimeRanges(phrRange.First());

                                                        int pregnancyWeeks = (DateTime.Now - edoc.AddDays(-280)).Days / 7;
                                                        if (pregnancyWeeks >= 12 && pregnancyWeeks <= 50)
                                                        {
                                                            var fetalMovementMap = _mgrFetalMovementNormalValueRangeCache.GetFetalMovements();

                                                            var fetalMovementMapValue = isInTimeRanges ? fetalMovementMap
                                                                    .Where(i =>
                                                                    i.PregnancyPeriod![0] <= pregnancyWeeks &&
                                                                    i.PregnancyPeriod[1] >= pregnancyWeeks)
                                                                    .Select(i => i.MedianMovement)
                                                                    .FirstOrDefault()
                                                                    :
                                                                    fetalMovementMap
                                                                    .Where(i =>
                                                                    i.PregnancyPeriod![0] <= pregnancyWeeks &&
                                                                    i.PregnancyPeriod[1] >= pregnancyWeeks)
                                                                    .Select(i => i.InitialMovement)
                                                                    .FirstOrDefault()
                                                            ;

                                                            var fetalMovementValue = (fetalMovementMapValue * duringMins * 2) / 120;
                                                            // 四舍五入
                                                            var fetalMovement = (int)Math.Round(fetalMovementValue, 0, MidpointRounding.AwayFromZero);
                                                            // _logger.LogInformation($"{imeiDel} segmentCountFMIndex: {i} -- fetalMovementSampleTime:{fetalMovementSampleTime}|{midNight.AddHours(2 * i).ToString("yyyy-MM-dd HH:mm:ss")} -- statStartTime: {statStartTime} -- statEndTime: {statEndTime}-- isFetalMovementExisted: {isFetalMovementExisted} ");

                                                            _logger.LogInformation($"{imeiDel} 孕周：{pregnancyWeeks}，胎动数据采样时间:{fetalMovementSampleTime}|{fmNowSubtract.ToString("yyyy-MM-dd HH:mm:ss")}, 采样周期:{statStartTime}-{statEndTime}, 原始胎动值:{fetalMovementMapValue}, 佩戴时间 :{duringMins}|{phrRange.Last()}-{phrRange.First()}, 胎动计算值:{fetalMovementValue}, 胎动最终值:{fetalMovement} 已完成.");

                                                            // 获取胎心数据状态与胎动数据状态一致
                                                            //etalHeartRateIsAbnormal= fhr.IsAbnormal;
                                                            var feltalMovementIsAbnormal = fetalHeartRateIsAbnormal;

                                                            await _serviceIotApi.SetFetalMovementConfig(imeiDel, fetalMovement, fetalMovementSampleTime, feltalMovementIsAbnormal);

                                                            // 保存到MySQL数据库
                                                            HisGpsFetalMovement fm = new()
                                                            {
                                                                FetalMovementId = Guid.NewGuid().ToString("D"),
                                                                PersonId = commonPHR!.PersonId,
                                                                Serialno = imeiDel,
                                                                CreateTime = DateTime.Now,
                                                                IsAbnormal = feltalMovementIsAbnormal,
                                                                FetalMovementValue = fetalMovement,
                                                                SampleTime = fetalMovementSampleTime,
                                                                Method = 1,
                                                                IsDisplay = 1,
                                                                DeviceKey = commonPHR!.DeviceKey
                                                            };
                                                            await _hisFetalMovementApiClient.AddAsync(fm).ConfigureAwait(false);

                                                            var device = await _deviceCacheMgr.GetDeviceBySerialNoAsync(imeiDel).ConfigureAwait(false);
                                                            var fmMsgId = $"{imeiDel}-{fetalMovementSampleTime}-{Guid.NewGuid().ToString("D")[^3..]}";
                                                            var fmMsgTime = DateTimeUtil.GetDateTimeFromUnixTimeMilliseconds(long.Parse(fetalMovementSampleTime.Length < 13 ? fetalMovementSampleTime.PadRight(13, '0') : fetalMovementSampleTime)).ToString("yyyy-MM-dd HH:mm:ss");
                                                            // 胎动数据推送到第三方
                                                            var topic = "topic.push.third";
                                                            var fmThridMsg = new
                                                            {
                                                                messageId = fmMsgId,
                                                                topic = topic,
                                                                time = fmMsgTime,
                                                                data = new
                                                                {
                                                                    imei = imeiDel,
                                                                    value = fetalMovement,
                                                                    isAbnormal = feltalMovementIsAbnormal,
                                                                    type = "fetalMovement"
                                                                }
                                                            };
                                                            await _serviceMqProcess.ProcessIMEIEventMessageAsync(fmMsgId, topic, 31, fmThridMsg).ConfigureAwait(false);

                                                            // 胎动数据推送到微信
                                                            if (feltalMovementIsAbnormal != 0)
                                                            {
                                                                topic = "topic.push.wx";
                                                                var fmMsg = new
                                                                {
                                                                    messageId = Guid.NewGuid().ToString("D"),
                                                                    topic = topic,
                                                                    time = DateTimeUtil.GetDateTimeFromUnixTimeMilliseconds(long.Parse(fetalMovementSampleTime.Length < 13 ? fetalMovementSampleTime.PadRight(13, '0') : fetalMovementSampleTime)).ToString("yyyy-MM-dd HH:mm:ss"),
                                                                    data = new
                                                                    {
                                                                        deviceId = device?.DeviceId,
                                                                        imei = imeiDel,
                                                                        alarmTypeId = 12,
                                                                        alarmDeviceName = imeiDel,
                                                                        alarmRemarks = JsonConvert.SerializeObject(new { fetalMovementValue = fetalMovement, isAbnormal = feltalMovementIsAbnormal }),
                                                                        address = string.Empty,
                                                                        deviceKey = device?.DeviceId
                                                                    }
                                                                };
                                                                await _serviceMqProcess.ProcessIMEIEventMessageAsync(fmMsgId, topic, fmMsg).ConfigureAwait(false);
                                                            }
                                                            // 设置入库缓存记录
                                                            await _deviceCacheMgr.SetFetalMovementAsync(imeiDel, fetalMovementSampleTime, fm);


                                                        }
                                                        else
                                                        {
                                                            _logger.LogWarning($"{imeiDel} 孕周 {pregnancyWeeks},超出胎动计算范围");
                                                        }
                                                    }
                                                    else
                                                    {
                                                        _logger.LogWarning($"{imeiDel} 最后一条胎心数据与胎动数据的小时差大于2,不计算胎动数据");
                                                    }
                                                }
                                                else
                                                {
                                                    _logger.LogInformation($"{imeiDel} 胎动记录{isFetalMovementExisted},数据采样时间:{fetalMovementSampleTime}|{fmNowSubtract.ToString("yyyy-MM-dd HH:mm:ss")}, 周期:{statStartTime}-{statEndTime} 不足两条,不能判断是否持续佩戴");

                                                }
                                            }
                                            else
                                            {
                                                _logger.LogInformation($"{imeiDel} 胎动记录{isFetalMovementExisted},数据采样时间:{fetalMovementSampleTime}|{fmNowSubtract.ToString("yyyy-MM-dd HH:mm:ss")}, 周期:{statStartTime}-{statEndTime} 已处理");
                                            }
                                        }

                                        
                                    }
                                    #endregion
                                }
                                else
                                {
                                    // 处理血压业务
                                    int systolicInc;
                                    int diastolicInc;

                                    int systolicRefValue;
                                    int diastolicRefValue;

                                    decimal systolicAvg;
                                    decimal diastolicAvg;

                                    int systolicMax = 0;
                                    int diastolicMax = 0;

                                    // 统计时间
                                    //DateTime endTime = DateTime.Now; //测试
                                    DateTime statStartTime = DateTime.Now;


                                    // 最小值
                                    int systolicMin = 0;
                                    int diastolicMin = 0;

                                    // 偏移参数
                                    var avgOffset = 0.25M;
                                    var systolicAvgOffset = avgOffset;
                                    var diastolicAvgOffset = avgOffset;

                                    // 最后一次下发值
                                    int lastPushSystolicInc = 0;
                                    int lastPushDiastolicInc = 0;


                                    var startTime = DateTime.Now;
                                    // 下发增量值
                                    #region 统计定时下发增量值
                                    //var last = await _serviceTDengine.GetLastAsync("stb_hm_bloodpress_stats_inc", $"serialno='{imeiDel}' order by last_update desc");
                                    //var ts = last?[0];

                                    // 最后一条血压数据
                                    var condition = $"serialno='{imeiDel}' order by last_update desc";
                                    var field = "last_row(*)";
                                    var lastHmBpResponse = await _serviceTDengine.ExecuteSelectRestResponseAsync("stb_hm_bloodpress", condition, field);
                                    var lastHmBpParser = JsonConvert.DeserializeObject<ParseTDengineRestResponse<BloodPressureModel>>(lastHmBpResponse!);
                                    var lastHmBp = lastHmBpParser?.Select().FirstOrDefault();
                                    //if (lastHmBpParser?.Select()?.ToList().Count < 2)
                                    //{
                                    //    _logger.LogInformation($"{imeiDel} -- {nameof(Worker)} --{nameof(WatchEvents)} -- 血压数据条目不足");
                                    //    break;
                                    //}

                                    // 7 天有效数据
                                    if (lastHmBp?.Timestamp.AddDays(7) > DateTime.Now)
                                    {
                                        // 计算增量值
                                        condition = $"serialno='{imeiDel}' order by ts desc";
                                        var lastPushResponse = await _serviceTDengine.ExecuteSelectRestResponseAsync("stb_hm_bp_push_ref_inc_value", condition, field);
                                        if (lastPushResponse == null)
                                        {
                                            _logger.LogInformation($"{imeiDel}--没有下发记录");
                                            break;
                                        }
                                        var lastPushParser = JsonConvert.DeserializeObject<ParseTDengineRestResponse<BloodPressurePushRefIncModel>>(lastPushResponse);
                                        var lastPush = lastPushParser!.Select().FirstOrDefault();
                                        // 有下推记录
                                        if (lastPush != null)
                                        {
                                            systolicRefValue = lastPush!.SystolicRefValue;
                                            diastolicRefValue = lastPush!.DiastolicRefValue;
                                            lastPushSystolicInc = lastPush!.SystolicIncValue;
                                            lastPushDiastolicInc = lastPush!.DiastolicIncValue;
                                            condition = $"ts between '{lastPush?.Timestamp:yyyy-MM-dd HH:mm:ss.fff}' and '{startTime:yyyy-MM-dd HH:mm:ss.fff}' " +
                                            $"and serialno='{imeiDel}' " +
                                            $"and is_display = true";
                                            // 使用最近一次的下推时间作为统计的开始时间
                                            statStartTime = lastPush!.Timestamp;
                                        }
                                        // 没有下推记录(历史遗留数据),没有初始的测量值产生的平均值（测量值=平均值）
                                        else
                                        {
                                            #region 获取个人信息

                                            var person = await _personCacheMgr.GetDeviceGpsPersonCacheBySerialNoAsync(Guid.NewGuid().ToString(), imeiDel).ConfigureAwait(false);
                                            //验证这个信息是否存在
                                            if (person == null || person?.Person.BornDate == null)
                                            {
                                                _logger.LogWarning($"{nameof(Worker)}--{imeiDel} 验证个人信息，找不到个人信息，跳过此消息");
                                                break;
                                            }
                                            // 验证年龄是否在范围 （2 - 120）
                                            var age = SafeType.SafeInt(DateTime.Today.Year - person?.Person.BornDate!.Value.Year!);
                                            if (age < 2 || age > 120)
                                            {
                                                _logger.LogWarning($"{nameof(Worker)}--{imeiDel} 验证年龄，不在范围 （2 - 120）岁，跳过此消息");
                                                break;
                                            }

                                            var gender = person?.Person.Gender == true ? 1 : 2;
                                            var isHypertension = SafeType.SafeBool(person?.Person.Ishypertension!);
                                            var height = SafeType.SafeDouble(person?.Person.Height!);
                                            var weight = SafeType.SafeDouble(person?.Person.Weight!);

                                            #endregion

                                            #region 初始化常规血压标定值标定值
                                            var bpRef = await _bpRefValCacheManager.GetBloodPressReferenceValueAsync(age, gender, isHypertension);
                                            //systolicRefValue = bpRef!.Systolic;//?
                                            //diastolicRefValue = bpRef!.Diastolic;//?
                                            #endregion

                                            systolicRefValue = bpRef!.Systolic;
                                            diastolicRefValue = bpRef!.Diastolic;
                                            lastPushSystolicInc = 0;
                                            lastPushDiastolicInc = 0;
                                            condition = $"ts <= '{startTime:yyyy-MM-dd HH:mm:ss.fff}' " +
                                            $"and serialno='{imeiDel}' " +
                                            $"and is_display = true";
                                        }



                                        var hmBpResponse = await _serviceTDengine.ExecuteSelectRestResponseAsync("stb_hm_bloodpress", condition);
                                        var hmBpParser = JsonConvert.DeserializeObject<ParseTDengineRestResponse<BloodPressureModel>>(hmBpResponse!);
                                        var hmBp = hmBpParser?.Select();
                                        //if (hmBp?.ToList().Count < 2)
                                        // 1. 判断数据样本数量
                                        if (hmBpParser!.Rows < 5)
                                        {
                                            _logger.LogInformation($"{imeiDel} -- {nameof(Worker)} --{nameof(WatchEvents)} -- 统计定时下发，计算增量值的数据条目不足:{hmBpParser!.Rows} < 5");
                                            _logger.LogInformation($"{imeiDel} -- {nameof(Worker)} --{nameof(WatchEvents)} 没有足够的数据样本，不会定时下发");
                                            break;
                                        }
                                        // 没有下推记录重新计算统计时间
                                        if (lastPush == null)
                                        {
                                            var firstHmBp = hmBpParser?.Select(i => i).OrderBy(i => i.Timestamp).FirstOrDefault();
                                            statStartTime = firstHmBp!.Timestamp;
                                        }

                                        // NewMethod(systolicRefValue, hmBpParser);

                                        // 最大值
                                        //systolicMax = (int)hmBpParser?.Select(i => i.SystolicValue).Max()!;
                                        //diastolicMax = (int)hmBpParser?.Select(i => i.DiastolicValue).Max()!;
                                        //// 最小值
                                        //systolicMin = (int)hmBpParser?.Select(i => i.SystolicValue).Min()!;
                                        //diastolicMin = (int)hmBpParser?.Select(i => i.DiastolicValue).Min()!;

                                        //systolicAvg = (int)(hmBpParser?.AverageAfterRemovingOneMinMaxRef(i => i.SystolicValue, SafeType.SafeInt(systolicRefValue!)))!;
                                        //diastolicAvg = (int)(hmBpParser?.AverageAfterRemovingOneMinMaxRef(i => i.DiastolicValue, SafeType.SafeInt(diastolicRefValue!)))!;

                                        var avgs = _serviceTDengine.AverageAfterRemovingOneMinMaxRef(hmBpParser!);
                                        systolicAvg = avgs[0];
                                        diastolicAvg = avgs[1];


                                        // 2. 判断能否计算增量值
                                        if (systolicAvg.Equals(0))
                                        {
                                            _logger.LogInformation($"{imeiDel}--{nameof(Worker)}--计算平均值" +
                                            $"\n currentSystolicAvg:{systolicAvg}  -- lastPushSystolicInc:{lastPushSystolicInc}" +
                                            $"\n currentDiastolicInc:{diastolicAvg}  -- lastPushDiastolicInc:{lastPushDiastolicInc}");
                                            _logger.LogInformation($"{imeiDel}--{nameof(Worker)} 没有足够的数据样本计算平均值，不会定时下发");
                                            break;
                                        }
                                        // 除最大值和最小值后的平均值与标定值差值少于4后（当天计算出该结果则也不产生增量调整），就不再进行增量值调整了。
                                        if (systolicRefValue - systolicAvg < 4)
                                        {
                                            _logger.LogInformation($"diastolic 舒张压 {imeiDel}除最大值和最小值后的平均值:{diastolicAvg}与标定值:{diastolicRefValue}\n systolic 收缩压 {imeiDel}除最大值和最小值后的平均值:{systolicAvg}与标定值:{systolicRefValue}的差值(标定值-平均值)少于4后，systolic 收缩压 不再进行增量值调整");
                                            break;
                                        }

                                        if (diastolicRefValue - diastolicAvg < 4)
                                        {
                                            _logger.LogInformation($"systolic 收缩压 {imeiDel}除最大值和最小值后的平均值:{systolicAvg}与标定值:{systolicRefValue}\n diastolic 舒张压 {imeiDel}除最大值和最小值后的平均值:{diastolicAvg}与标定值:{diastolicRefValue}的差值(标定值-平均值)少于4后，diastolic 舒张压 不再进行增量值调整");
                                            break;
                                        }

                                        // 增量值=（标定值-平均值）* 0.25
                                        var currentSystolicInc = (int)((systolicRefValue - systolicAvg) * systolicAvgOffset)!;
                                        var currentDiastolicInc = (int)((diastolicRefValue - diastolicAvg) * diastolicAvgOffset)!;


                                        // 累计增量
                                        systolicInc = currentSystolicInc + lastPushSystolicInc;
                                        diastolicInc = currentDiastolicInc + lastPushDiastolicInc;

                                        _logger.LogInformation($"{imeiDel}--{nameof(Worker)}--计算增量值" +
                                                $"\n {imeiDel} -- systolicAvg:{systolicAvg}-- systolicInc:{systolicInc}-- currentSystolicInc:{currentSystolicInc} -- lastPushSystolicInc:{lastPushSystolicInc}" +
                                                $"\n {imeiDel} -- diastolicAvg:{diastolicAvg}-- diastolicInc:{diastolicInc} --currentDiastolicInc:{currentDiastolicInc} -- lastPushDiastolicInc:{lastPushDiastolicInc}");
                                        _logger.LogInformation($"{imeiDel}--{nameof(Worker)}-- 定时校准,发给设备的绝对增量值=（上次绝对增量值+新数据的增量值）");


                                        _logger.LogInformation($"{nameof(Worker)} 开启血压标定值下发: {_configBoodPressResolver.EnableBPRefPush}");
                                        if (_configBoodPressResolver.EnableBPRefPush)
                                        // if (false) // 临时关闭
                                        {
                                            BloodPressCalibrationConfigModel bpIncData = new()
                                            {

                                                Imei = imeiDel,
                                                SystolicRefValue = SafeType.SafeInt(((int)systolicRefValue!)),  //收缩压标定值，值为0 表示不生效
                                                DiastolicRefValue = SafeType.SafeInt(((int)diastolicRefValue!)), //舒张压标定值，值为0表示不生效
                                                SystolicIncValue = SafeType.SafeInt(((int)systolicInc!)), //收缩压显示增量，值为0 表示不生效
                                                DiastolicIncValue = SafeType.SafeInt(((int)diastolicInc!))   //舒张压显示增量，值为0 表示不生效
                                            };
                                            //var pushedBP = await _serviceIotApi.SetBloodPressCalibrationConfigAsync(bpIncData).ConfigureAwait(false);
                                            var response = await _serviceIotApi.SetBloodPressCalibrationConfig2Async(bpIncData).ConfigureAwait(false);
                                            var pushedBP = response.Flag;
                                            if (pushedBP)
                                            {
                                                #region 保存下推记录 stb_hm_bp_push_ref_inc_value
                                                var sql = $"INSERT INTO health_monitor.hm_bp_push_ref_inc_value_{imeiDel.Substring(imeiDel.Length - 2)} " +
                                                        $"USING health_monitor.stb_hm_bp_push_ref_inc_value " +
                                                        $"TAGS ('{imeiDel.Substring(imeiDel.Length - 2)}')  " +
                                                        $"VALUES(" +
                                                            $"'{startTime:yyyy-MM-dd HH:mm:ss.fff}'," +
                                                            $"'{imeiDel}'," +
                                                            $"{bpIncData.SystolicRefValue}," +
                                                            $"{bpIncData.DiastolicRefValue}," +
                                                            $"{bpIncData.SystolicIncValue}," +
                                                            $"{bpIncData.DiastolicIncValue}," +
                                                            $"{false}," +
                                                            $"{systolicAvg}," +
                                                            $"{diastolicAvg}," +
                                                            $"{systolicAvgOffset}," +
                                                            $"{diastolicAvgOffset}," +
                                                            $"'{statStartTime:yyyy-MM-dd HH:mm:ss.fff}'," +
                                                            $"'{startTime:yyyy-MM-dd HH:mm:ss.fff}'" +
                                                            $")";
                                                _serviceTDengine.ExecuteInsertSQL(sql);
                                                #endregion

                                                #region 注册定时下发
                                                // 注册下次下推
                                                var endTime = DateTime.Now;

#if DEBUG


                                                //long ttl = (long)((60 * 1000-(endTime-startTime).TotalMilliseconds)/1000);
                                                //await _serviceEtcd.PutValAsync(key, imeiDel,ttl, false).ConfigureAwait(false);

                                                var interval = 0;
                                                // 获取当前时间
                                                DateTime now = DateTime.Now;

                                                // 计算距离下一个$interval天后的8点的时间间隔
                                                DateTime nextRunTime = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute + 2, 0).AddDays(interval);
                                                TimeSpan timeUntilNextRun = nextRunTime - now;

                                                // 如果当前时间已经超过了8点，将等待到明天后的8点
                                                if (timeUntilNextRun < TimeSpan.Zero)
                                                {
                                                    timeUntilNextRun = timeUntilNextRun.Add(TimeSpan.FromMinutes(1));
                                                    nextRunTime += timeUntilNextRun;
                                                }

                                                // var ttl = timeUntilNextRun.TotalMilliseconds;
                                                long ttl = (long)((timeUntilNextRun.TotalMilliseconds - (endTime - startTime).TotalMilliseconds) / 1000);
                                                var data = new
                                                {
                                                    imei = imeiDel,
                                                    create_time = now.ToString("yyyy-MM-dd HH:mm:ss"),
                                                    ttl,
                                                    next_run_time = nextRunTime.ToString("yyyy-MM-dd HH:mm:ss")
                                                };
                                                var result = JsonConvert.SerializeObject(data);

                                                await _serviceEtcd.PutValAsync(key, result, ttl, false).ConfigureAwait(false);


#else
                                        // 每$interval天,晚上8点
                                        var interval = 1;
                                        // 获取当前时间
                                        DateTime now = DateTime.Now;

                                        // 计算距离下一个$interval天后的8点的时间间隔
                                        DateTime nextRunTime = new DateTime(now.Year, now.Month, now.Day, 20, 0, 0).AddDays(interval);
                                        TimeSpan timeUntilNextRun = nextRunTime - now;

                                        // 如果当前时间已经超过了8点，将等待到明天后的8点
                                        if (timeUntilNextRun < TimeSpan.Zero)
                                        {
                                            timeUntilNextRun = timeUntilNextRun.Add(TimeSpan.FromDays(1));
                                            nextRunTime += timeUntilNextRun;
                                        }

                                        // var ttl = timeUntilNextRun.TotalMilliseconds;
                                        long ttl = (long)((timeUntilNextRun.TotalMilliseconds-(endTime-startTime).TotalMilliseconds)/1000);
                                        var data = new
                                        {
                                            imei = imeiDel,
                                            create_time = now.ToString("yyyy-MM-dd HH:mm:ss"),
                                            ttl,
                                            next_run_time = nextRunTime.ToString("yyyy-MM-dd HH:mm:ss")
                                        };
                                        var result = JsonConvert.SerializeObject(data);
                                        await _serviceEtcd.PutValAsync(key, result, ttl, false).ConfigureAwait(false);
#endif
                                                #endregion

                                            }
                                            else
                                            {
                                                _logger.LogInformation($"错误响应，没有下推数据:{response.Message}");
                                            }
                                        }
                                    }
                                    else
                                    {
                                        _logger.LogInformation($"向{imeiDel}统计数据已经失效");
                                    }
                                    #endregion

                                }

                            }
                            break;
                    }
                }
                catch (Exception ex)
                {
                    _logger.LogInformation($"{nameof(WatchEvents)},出错: |{ex.Message}|{ex.StackTrace}");
                }


            });

        }


        private async Task SetIntervalTriggerAsync(string key, string imei, long interval)

        {
            // var key = $"health_monitor/schedule_push/{type}/imei/{imei}";
            var schedulePush = await _serviceEtcd.GetValAsync(key).ConfigureAwait(false);
            if (string.IsNullOrWhiteSpace(schedulePush))
            {
                var now = DateTime.Now;
                var timeNextRun = now.Add(TimeSpan.FromSeconds(interval));
                var data = new
                {
                    imei,
                    create_time = now.ToString("yyyy-MM-dd HH:mm:ss"),
                    ttl = interval,
                    next_run_time = timeNextRun.ToString("yyyy-MM-dd HH:mm:ss")
                };
                var result = JsonConvert.SerializeObject(data);
                await _serviceEtcd.PutValAsync(key, result, interval, false).ConfigureAwait(false);
            }
        }

        public static bool IsNowInTimeRanges()
        {
            var now = DateTime.Now.TimeOfDay;

            var timeRanges = new List<(TimeSpan Start, TimeSpan End)>
            {
                // 8:00~10:00，12:00~14:00，18:00~20:00，22:00~24:00
                (new TimeSpan(8, 0, 0), new TimeSpan(10, 0, 0)),
                (new TimeSpan(12, 0, 0), new TimeSpan(14, 0, 0)),
                (new TimeSpan(18, 0, 0), new TimeSpan(20, 0, 0)),
                (new TimeSpan(22, 0, 0), new TimeSpan(24, 0, 0))
            };

            return timeRanges.Any(range => now >= range.Start && now <= range.End);
        }
        public static bool IsLastUpdateInTimeRanges(DateTime lastUpdate)
        {
            var now = lastUpdate.TimeOfDay;

            var timeRanges = new List<(TimeSpan Start, TimeSpan End)>
            {
                // 8:00~10:00，12:00~14:00，18:00~20:00，22:00~24:00
                (new TimeSpan(8, 0, 0), new TimeSpan(10, 0, 0)),
                (new TimeSpan(12, 0, 0), new TimeSpan(14, 0, 0)),
                (new TimeSpan(18, 0, 0), new TimeSpan(20, 0, 0)),
                (new TimeSpan(22, 0, 0), new TimeSpan(24, 0, 0))
            };

            return timeRanges.Any(range => now >= range.Start && now <= range.End);
        }

        private async Task CalculateNormalFetalHeartRateAsync(HisGpsHeartRate heartRate, int upperAlarmThreshold, int lowerAlarmThreshold, int intervalFHR, PregnancyCommonHeartRateModel? commonPHR)
        {
            // 上15分钟的数据
            // 获取当前时间
            DateTime nowInterval = (DateTime)heartRate.LastUpdate!;

            if (nowInterval.Second > 0)
            {
                nowInterval = nowInterval.AddMinutes(1);
            }
            // 计算last_update到上一间隔的分钟数
            int minutesToSubtract = nowInterval.Minute % intervalFHR;

            // 计算上一间隔的时间
            DateTime previousInterval = nowInterval.AddMinutes(-minutesToSubtract).AddSeconds(-nowInterval.Second).AddMilliseconds(-nowInterval.Millisecond);

            // 使用 last_update 上一刻
            var sampleTimeFHR = DateTimeUtil.ConvertToTimeStamp(previousInterval).ToString();

            // 计算last_update到下一间隔的分钟数
            int minutesToAdd = intervalFHR - (nowInterval.Minute % intervalFHR);
            if (minutesToAdd == intervalFHR)
            {
                minutesToAdd = 0; // 如果已经是间隔，则不需要增加分钟
            }

            // 计算下一间隔的时间
            DateTime nextInterval = nowInterval.AddMinutes(minutesToAdd)
                                            .AddSeconds(-nowInterval.Second)
                                            .AddMilliseconds(-nowInterval.Millisecond);


            var daysPhr = await _serviceTDengine.GetBySerialNoAsync<PregnancyHeartRateModel>(heartRate.Serialno, 7);

            var normalPhrStatStartTime = nextInterval.AddMinutes(-intervalFHR);

            var normalPhrStatEndTime = nextInterval;

            _logger.LogInformation($" {heartRate.MessageId} -- {heartRate.Serialno} 计算胎心数据, 周期:{normalPhrStatStartTime}-{normalPhrStatEndTime} ");
            var filteredPhr = daysPhr
                // 使用 last_update 下一刻
                .Where(i => i.LastUpdate <= normalPhrStatEndTime && i.LastUpdate >= normalPhrStatStartTime)
                .ToList();
            if (filteredPhr.Count == 0)
            {
                _logger.LogWarning($"{heartRate.MessageId} -- {heartRate.Serialno}  周期:{normalPhrStatStartTime}-{normalPhrStatEndTime} 孕妇心率数据不足,{filteredPhr.Count}条记录");
                return;
            }
            var phrValue = filteredPhr.Count == 1
                ? filteredPhr.First().PregnancyHeartRate
                : filteredPhr.Average(i => i.PregnancyHeartRate);
            
            //await SaveAndPushFreqFetalHeartRateAsync(heartRate, commonPHR!, upperAlarmThreshold, lowerAlarmThreshold, phrValue, sampleTimeFHR);
            await SaveAndPushFetalHeartRateAsync(heartRate, commonPHR!, upperAlarmThreshold, lowerAlarmThreshold, phrValue, sampleTimeFHR, normalPhrStatStartTime, normalPhrStatEndTime);
        }

        private async Task SaveAndPushFetalHeartRateAsync(HisGpsHeartRate heartRate, PregnancyCommonHeartRateModel commonPHR, int upperAlarmThreshold, int lowerAlarmThreshold, double phrValue, string sampleTime, DateTime statStartTime, DateTime statEndTime)
        {
            // 计算胎心=孕妇心率*系数
            var fetalHeartRate = SafeType.SafeInt(phrValue * commonPHR?.StatModeAvgFprCoefficient!);
            //fetalHeartRate = fetalHeartRate > 220 ? 220 : fetalHeartRate; // 胎心的最大值调整为220，超过都按该值220输出
            if (fetalHeartRate >= 220)
            {
                // 先使用最小系数计算
                var statMaxValueFprCoefficient = commonPHR?.StatMaxValueFprCoefficient!;
                var statMinValueFprCoefficient = commonPHR?.StatMinValueFprCoefficient!;
                var coefficient = statMaxValueFprCoefficient < statMinValueFprCoefficient ? statMaxValueFprCoefficient : statMinValueFprCoefficient;
                fetalHeartRate = SafeType.SafeInt(phrValue * coefficient);
                if (fetalHeartRate < 220)
                {
                    _logger.LogWarning($"{heartRate.Serialno} 使用极值系数 {coefficient} ,建模数据可能出现异常,请检查");
                }
                else
                {
                    fetalHeartRate = 220;
                    _logger.LogWarning($"{heartRate.Serialno} 使用所有系数都不能放映实际,建模数据可能出现异常,请检查");
                }
            }

            var isAbnormal = fetalHeartRate > upperAlarmThreshold ? 1 : (fetalHeartRate < lowerAlarmThreshold ? 2 : 0);
            var phrFreqstatus = await _deviceCacheMgr.GetPregnancyHeartRateFreqStatusAsync(heartRate.Serialno);
            if (phrFreqstatus == null) isAbnormal = 0;
            var statsusDesc = (phrFreqstatus == null) ? $"MSG ID: {heartRate.MessageId} 常规" : "高频";
            _logger.LogInformation($"{heartRate.Serialno} 在 {statsusDesc} 状态,心率值{heartRate.HeartRate},生成胎心值:{fetalHeartRate},统计周期:{statStartTime.ToString("yyyy-MM-dd HH:mm:ss")}----{statEndTime.ToString("yyyy-MM-dd HH:mm:ss")}");
            //if (!isFreq)
            //{
            //    statStartTime = heartRate.LastUpdate;
            //    
            //} 
            // 保存到 数据服务 MySQL 数据库
            HisGpsFetalHeartRate gpsFetalHeartRate = new()
            {
                FetalHeartRateId = Guid.NewGuid().ToString("D"),
                PersonId = commonPHR!.PersonId,
                Serialno = heartRate.Serialno,
                HeartRate = fetalHeartRate,
                SampleTime = sampleTime.Length > 10 ? sampleTime.Substring(0, 10) : sampleTime,
                IsAbnormal = isAbnormal,
                StatStartTime = statStartTime,
                StatEndTime = statEndTime,//commonPHR.StatEndTime,
                CreateTime = DateTime.Now,
                Method = 1,
                IsDisplay = 1,
                DeviceKey = commonPHR!.DeviceKey
            };
            await _hisFetalHeartApiClient.AddAsync(gpsFetalHeartRate).ConfigureAwait(false);

            // 推送到api/v1/open/OpenIot/SetFetalHeartRateConfig
            // 推送最后一条常规心率计算的胎心数据到iot设备
            var lastPhr = await _serviceTDengine.GetLastAsync<PregnancyHeartRateModel>(heartRate.Serialno);
            if (lastPhr.MessageId== heartRate.MessageId)
            {
                await _serviceIotApi.SetFetalHeartRateConfig(heartRate.Serialno, fetalHeartRate, sampleTime, isAbnormal);
                _logger.LogInformation($"{heartRate.Serialno} 推送最后一条常规心率计算的胎心数据到iot设备");
            }

            var device = await _deviceCacheMgr.GetDeviceBySerialNoAsync(heartRate.Serialno).ConfigureAwait(false);
            var fhrMsgId = $"{heartRate.Serialno}-{sampleTime}-{Guid.NewGuid().ToString("D")[^3..]}";
            var fhrMsgTime = DateTimeUtil.GetDateTimeFromUnixTimeMilliseconds(long.Parse(sampleTime.Length < 13 ? sampleTime.PadRight(13, '0') : sampleTime)).ToString("yyyy-MM-dd HH:mm:ss");
            // 胎心数据推送到第三方
            var topic = "topic.push.third";
            var fhrThridMsg = new
            {
                messageId = fhrMsgId,
                topic = topic,
                time = fhrMsgTime,
                data = new
                {
                    imei = heartRate.Serialno,
                    value = fetalHeartRate,
                    isAbnormal,
                    type = "fetalHeart"
                }
            };
            await _serviceMqProcess.ProcessIMEIEventMessageAsync(fhrMsgId, topic, 31, fhrThridMsg).ConfigureAwait(false);

            // 胎心数据推送到微信
            if (isAbnormal != 0)
            {

                topic = "topic.push.wx";
                var fhrMsg = new
                {
                    messageId = fhrMsgId,
                    topic = topic,
                    time = fhrMsgTime,
                    data = new
                    {
                        deviceId = device?.DeviceId,
                        imei = heartRate.Serialno,
                        alarmTypeId = 12,
                        alarmDeviceName = heartRate.Serialno,
                        alarmRemarks = JsonConvert.SerializeObject(new { fetalHeartValue = fetalHeartRate, isAbnormal = isAbnormal }),
                        address = string.Empty,
                        deviceKey = device?.DeviceId
                    }
                };
                await _serviceMqProcess.ProcessIMEIEventMessageAsync(fhrMsgId, topic, fhrMsg).ConfigureAwait(false);

            }
        }

    }
}