YZWater3/src/YZWater.Core/Services/AutoControlService.cs

using Serilog;
using YZWater.Core.Models;

namespace YZWater.Core.Services;

/// <summary>
/// 自动控制系统 — 根据液位阈值自动启停泵
/// 订阅 PlcPollingService.DataUpdated，每次数据更新时检查液位并控制泵
/// </summary>
public class AutoControlService : IDisposable
{
    private static AutoControlService? _instance;
    private static readonly object _lock = new();
    public static AutoControlService Instance
    {
        get
        {
            lock (_lock)
            {
                return _instance ??= new AutoControlService();
            }
        }
    }

    public static void ResetInstance()
    {
        lock (_lock)
        {
            var old = _instance;
            _instance = null;
            old?.Dispose();
        }
    }

    private bool _disposed;
    private bool _isEnabled = true;
    private bool _subscribed;
    private bool _projectSubscribed;

    /// <summary>是否启用自动控制</summary>
    public bool IsEnabled
    {
        get => _isEnabled;
        set
        {
            _isEnabled = value;
            Log.Information("自动控制已{Status}", value ? "启用" : "禁用");
        }
    }

    /// <summary>当前需要的泵数量（由液位决定）</summary>
    public int RequiredPumpCount { get; private set; }

    /// <summary>最后一次自动控制时间</summary>
    public DateTime LastControlTime { get; private set; }

    /// <summary>防频繁启停：同一台泵两次操作最小间隔（秒）</summary>
    public int MinIntervalSeconds { get; set; } = 60;

    /// <summary>启泵延迟（液位持续低于阈值的时间，秒）</summary>
    public int StartDelaySeconds { get; set; } = 3;

    /// <summary>停泵延迟（液位持续高于阈值的时间，秒）</summary>
    public int StopDelaySeconds { get; set; } = 5;

    /// <summary>是否启用泵轮换（均衡磨损）</summary>
    public bool EnablePumpRotation { get; set; } = true;

    // 防频繁启停跟踪
    private readonly Dictionary<string, DateTime> _lastStartTimes = new();
    private readonly Dictionary<string, DateTime> _lastStopTimes = new();

    // PLC 拒写后的重试退避：不能用轮询频率反复写（读正常、写被拒时 HasValidData 仍为 true）
    private readonly Dictionary<string, DateTime> _controlRetryAt = new();
    private const int ControlRetrySeconds = 15;

    // 控制执行重入闸：脉冲含 Task.Delay，上一轮未结束时新轮询不得并发写同一泵
    private int _controlInFlight;

    // 泵轮换跟踪：记录每台泵的累计运行时间
    private readonly Dictionary<string, float> _pumpRunningHours = new();
    private int _rotationIndex = 0;

    // 延迟触发跟踪
    private DateTime _startConditionSince = DateTime.MinValue;
    private DateTime _stopConditionSince = DateTime.MinValue;
    private int _lastRequiredCount = -1;

    private AutoControlService() { }

    /// <summary>
    /// 启动自动控制（订阅 PLC 数据更新）
    /// 根据项目配置决定是否实际激活
    /// </summary>
    public void Start()
    {
        // 订阅项目切换事件（防重复订阅）
        if (!_projectSubscribed)
        {
            ProjectService.ProjectChanged += OnProjectChanged;
            _projectSubscribed = true;
        }

        // 检查项目级自动控制开关
        var profile = ProjectService.Current;
        if (profile != null && !profile.Control.EnableAutoControl)
        {
            _isEnabled = false;
            Log.Information("自动控制未启用: 项目 [{Project}] 配置为 PLC 自动控制", profile.Name);
            return;
        }

        PlcPollingService.Instance.DataUpdated += OnDataUpdated;
        _subscribed = true;
        Log.Information("自动控制系统已启动");
    }

    /// <summary>
    /// 停止自动控制
    /// </summary>
    public void Stop()
    {
        if (_projectSubscribed)
        {
            ProjectService.ProjectChanged -= OnProjectChanged;
            _projectSubscribed = false;
        }

        if (_subscribed)
        {
            PlcPollingService.Instance.DataUpdated -= OnDataUpdated;
            _subscribed = false;
        }
        Log.Information("自动控制系统已停止");
    }

    /// <summary>
    /// 项目切换时重新评估自动控制状态
    /// </summary>
    private void OnProjectChanged(ProjectProfile? profile)
    {
        bool shouldBeEnabled = profile?.Control.EnableAutoControl ?? false;

        if (shouldBeEnabled && !_subscribed)
        {
            PlcPollingService.Instance.DataUpdated += OnDataUpdated;
            _subscribed = true;
            _isEnabled = true;
            Log.Information("项目切换: 自动控制已启用");
        }
        else if (!shouldBeEnabled && _subscribed)
        {
            PlcPollingService.Instance.DataUpdated -= OnDataUpdated;
            _subscribed = false;
            _isEnabled = false;
            Log.Information("项目切换: 自动控制已禁用");
        }
    }

    /// <summary>
    /// PLC 数据更新回调 — 核心控制逻辑
    /// </summary>
    private void OnDataUpdated(PlcDataModel data)
    {
        if (!_isEnabled) return;

        // PLC 未连接时不执行自动控制（Mock 模式除外，因为本来就没有真实 PLC）
        if (!data.HasValidData) return;

        var profile = ProjectService.Current;
        if (profile == null || profile.Tanks.Count == 0 || profile.Pumps.Count == 0)
            return;

        try
        {
            var tank = profile.Tanks[0]; // 取第一个水池
            var levelKey = $"{tank.Name}.Level";
            var currentLevel = data.GetAnalogRegister(levelKey);
            var startPump1 = data.GetAnalogRegister($"{tank.Name}.StartPump1Level");
            var startPump2 = data.GetAnalogRegister($"{tank.Name}.StartPump2Level");
            var startPump3 = data.GetAnalogRegister($"{tank.Name}.StartPump3Level");
            var stopLevel = data.GetAnalogRegister($"{tank.Name}.StopLevel");
            var protectionLevel = data.GetAnalogRegister($"{tank.Name}.ProtectionLevel");

            // 液位或任一启停阈值读取失败就不作决策：坏点里存的是最后一次有效值，
            // 拿它启停泵可能踩在几分钟前的液位上（改动前读失败返回 0，会被当成"液位极低"直接启 3 台泵）
            var unreadable = new[]
            {
                levelKey,
                $"{tank.Name}.StopLevel",
                $"{tank.Name}.ProtectionLevel",
                $"{tank.Name}.StartPump1Level",
                $"{tank.Name}.StartPump2Level",
                $"{tank.Name}.StartPump3Level"
            }.Where(data.IsTagBad).ToList();
            if (unreadable.Count > 0)
            {
                // 质量跳变时轮询服务已经告警过，这里只留痕不打扰操作员
                Log.Debug("自动控制: 测点数据质量 Bad，本轮不做泵组决策: {Keys}", string.Join(", ", unreadable));
                return;
            }

            // 计算需要的泵数量
            int requiredCount;
            if (protectionLevel > 0 && currentLevel > protectionLevel)
            {
                // 超保护液位：紧急全启
                requiredCount = profile.Pumps.Count;
                Log.Warning("自动控制: 液位 {Level:F2} 超过保护液位 {Protection:F2}，紧急全启",
                    currentLevel, protectionLevel);
            }
            else if (currentLevel > stopLevel && stopLevel > 0)
            {
                requiredCount = 0;
            }
            else if (currentLevel < startPump3 && startPump3 > 0)
            {
                requiredCount = 3;
            }
            else if (currentLevel < startPump2 && startPump2 > 0)
            {
                requiredCount = 2;
            }
            else if (currentLevel < startPump1 && startPump1 > 0)
            {
                requiredCount = 1;
            }
            else
            {
                requiredCount = 0;
            }

            // 延迟触发（防抖动）
            if (requiredCount != _lastRequiredCount)
            {
                if (requiredCount > _lastRequiredCount || _lastRequiredCount < 0)
                    _startConditionSince = DateTime.Now;
                else
                    _stopConditionSince = DateTime.Now;
                _lastRequiredCount = requiredCount;
            }

            // 判断是否满足延迟条件
            bool shouldApply;
            if (requiredCount > 0)
                shouldApply = (DateTime.Now - _startConditionSince).TotalSeconds >= StartDelaySeconds;
            else
                shouldApply = (DateTime.Now - _stopConditionSince).TotalSeconds >= StopDelaySeconds;

            if (!shouldApply) return;

            RequiredPumpCount = requiredCount;
            LastControlTime = DateTime.Now;

            // 执行泵启停
            ExecutePumpControl(profile, requiredCount, data);
        }
        catch (Exception ex)
        {
            Log.Error(ex, "自动控制异常");
        }
    }

    /// <summary>
    /// 执行泵启停控制
    /// </summary>
    private async void ExecutePumpControl(ProjectProfile profile, int requiredCount, PlcDataModel data)
    {
        // 防重入：脉冲写入含 Task.Delay，前一轮未完成时新轮询直接跳过（下轮会重新评估）
        if (Interlocked.CompareExchange(ref _controlInFlight, 1, 0) != 0)
        {
            Log.Debug("自动控制: 上一轮泵指令尚未完成，本轮跳过");
            return;
        }

        try
        {
            var now = DateTime.Now;

            // 确定应该运行的泵（考虑轮换）
            var pumpsToRun = SelectPumpsToRun(profile, requiredCount, data);

            for (int i = 0; i < profile.Pumps.Count; i++)
            {
                var pump = profile.Pumps[i];
                var pumpKey = pump.Name;
                var isRunning = data.GetDigitalRegister($"{pump.Name}.Run");
                var hasFault = data.GetDigitalRegister($"{pump.Name}.Fault");

                // 运行/故障状态读不到时不下发指令：无法确认设备现状就不该动它
                if (data.IsTagBad($"{pump.Name}.Run") || data.IsTagBad($"{pump.Name}.Fault"))
                {
                    Log.Debug("自动控制: {Name} 运行/故障状态数据质量 Bad，本轮跳过", pump.Name);
                    continue;
                }

                // 故障泵跳过
                if (hasFault)
                {
                    if (isRunning)
                        Log.Warning("自动控制: {Name} 有故障但仍在运行，跳过", pump.Name);
                    continue;
                }

                var shouldRun = pumpsToRun.Contains(pump);

                if (shouldRun && !isRunning)
                {
                    // 需要启动但没在运行
                    if (_lastStartTimes.TryGetValue(pumpKey, out var lastStart) &&
                        (now - lastStart).TotalSeconds < MinIntervalSeconds)
                        continue; // 防频繁启动
                    if (IsInRetryBackoff(pumpKey, now))
                        continue; // 上次写入被拒，退避期内不重复下发

                    Log.Information("自动控制: 启动 {Name} (需要 {Required} 台)", pump.Name, requiredCount);
                    // 成功才记防频繁退避；失败只按较短的重试退避，避免按轮询频率反复写
                    if (await PulseAddressAsync(pump.StartAddress))
                        _lastStartTimes[pumpKey] = now;
                    else
                    {
                        SetRetryBackoff(pumpKey, now);
                        Log.Error("自动控制: 启动 {Name} 写入 PLC 失败，{Sec}s 后重试", pump.Name, ControlRetrySeconds);
                    }
                }
                else if (!shouldRun && isRunning)
                {
                    // 需要停止但在运行
                    if (_lastStopTimes.TryGetValue(pumpKey, out var lastStop) &&
                        (now - lastStop).TotalSeconds < MinIntervalSeconds)
                        continue; // 防频繁停止
                    if (IsInRetryBackoff(pumpKey, now))
                        continue; // 上次写入被拒，退避期内不重复下发

                    Log.Information("自动控制: 停止 {Name} (需要 {Required} 台)", pump.Name, requiredCount);
                    if (await PulseAddressAsync(pump.StopAddress))
                        _lastStopTimes[pumpKey] = now;
                    else
                    {
                        SetRetryBackoff(pumpKey, now);
                        Log.Error("自动控制: 停止 {Name} 写入 PLC 失败，{Sec}s 后重试", pump.Name, ControlRetrySeconds);
                    }
                }
            }
        }
        catch (Exception ex)
        {
            Log.Error(ex, "自动控制执行异常");
        }
        finally
        {
            Interlocked.Exchange(ref _controlInFlight, 0);
        }
    }

    private bool IsInRetryBackoff(string pumpKey, DateTime now) =>
        _controlRetryAt.TryGetValue(pumpKey, out var retryAt) && (now - retryAt).TotalSeconds < ControlRetrySeconds;

    private void SetRetryBackoff(string pumpKey, DateTime now) => _controlRetryAt[pumpKey] = now;

    /// <summary>
    /// 选择应该运行的泵（考虑轮换和故障）
    /// </summary>
    private List<PumpConfig> SelectPumpsToRun(ProjectProfile profile, int requiredCount, PlcDataModel data)
    {
        // 故障状态读不到的泵不参与选择（质量 Bad 时寄存器里留的是最后一次有效值，不能当"无故障"用）
        var availablePumps = profile.Pumps
            .Where(p => !data.IsTagBad($"{p.Name}.Fault") && !data.GetDigitalRegister($"{p.Name}.Fault"))
            .ToList();

        if (requiredCount >= availablePumps.Count)
            return availablePumps;

        if (!EnablePumpRotation)
        {
            // 不启用轮换，按顺序选择
            return availablePumps.Take(requiredCount).ToList();
        }

        // 启用轮换：优先选择运行时间最短的泵
        // 更新运行时间
        foreach (var pump in availablePumps)
        {
            var hours = data.GetAnalogRegister($"{pump.Name}.DailyHours");
            _pumpRunningHours[pump.Name] = hours;
        }

        // 按运行时间排序，选择时间最短的 N 台
        var selected = availablePumps
            .OrderBy(p => _pumpRunningHours.GetValueOrDefault(p.Name, 0))
            .Take(requiredCount)
            .ToList();

        // 如果运行时间相同，使用轮换索引打破平局
        if (selected.Count > 0 && selected.Count < availablePumps.Count)
        {
            var minHours = _pumpRunningHours.GetValueOrDefault(selected[0].Name, 0);
            var tiedPumps = availablePumps
                .Where(p => Math.Abs(_pumpRunningHours.GetValueOrDefault(p.Name, 0) - minHours) < 0.1)
                .ToList();

            if (tiedPumps.Count > requiredCount)
            {
                // 多台泵运行时间相同，使用轮换索引
                _rotationIndex = (_rotationIndex + 1) % tiedPumps.Count;
                selected = tiedPumps
                    .Skip(_rotationIndex)
                    .Take(requiredCount)
                    .ToList();

                if (selected.Count < requiredCount)
                {
                    // 补齐
                    selected = selected
                        .Concat(tiedPumps.Take(requiredCount - selected.Count))
                        .ToList();
                }
            }
        }

        return selected;
    }

    /// <summary>
    /// 点动写入（短暂置位后复位）
    /// </summary>
    private static async Task<bool> PulseAddressAsync(string? address)
    {
        if (string.IsNullOrEmpty(address)) return false;
        try
        {
            var on = await PlcService.WriteBoolAsync(address, true);
            await Task.Delay(200);
            var off = await PlcService.WriteBoolAsync(address, false);
            if (!off)
            {
                // 复位写失败会把启动/停止位留在置位状态，必须再试一次并显式报错
                off = await PlcService.WriteBoolAsync(address, false);
                if (!off)
                    Log.Error("PLC 点动复位失败，输出位可能仍置位: {Address}", address);
            }
            return on && off;
        }
        catch (Exception ex)
        {
            Log.Error(ex, "点动写入失败: {Address}", address);
            return false;
        }
    }

    public void Dispose()
    {
        if (_disposed) return;
        _disposed = true;
        Stop();
    }
}