AiDOPWarehouse/server/Plugins/Admin.NET.Plugin.AiDOP/Service/S8/S8WatchRulePreviewService.cs

using Admin.NET.Plugin.AiDOP.Entity.S8;
using Admin.NET.Plugin.AiDOP.Infrastructure;
using Admin.NET.Plugin.AiDOP.Service.S8.Rules;
using Admin.NET.Plugin.AiDOP.Service.S8.Rules.DataAccess;
using Admin.NET.Plugin.AiDOP.Service.S8.Rules.Definitions;

namespace Admin.NET.Plugin.AiDOP.Service.S8;

/// <summary>
/// S8-RULE01-INTEGRATION-PREVIEW-1：监控规则的**只读预演**。
///
/// <b>解决的问题</b>：在此之前，想知道「一条规则启用后会命中什么」只有一条路 ——
/// 把它 enabled=true 然后等调度器跑。对 Rule 01 而言那意味着一次性生成 28 条真实异常单，
/// 而验证只需要 1 条。没有中间档位，等于逼着人拿异常中心当试验场。
///
/// <b>本服务走的是与生产完全相同的取数与判定链</b>：
/// <code>
///   rule.DatasetCode → S8MonitoringDataGateway → Catalog → Provider → canonical
///                    → 对应 evaluator（按 rule_type 分派） → hits
/// </code>
/// 不是另写一份预估 SQL —— 那样预演结果与真实运行必然漂移，预演也就失去意义。
///
/// <b>写入边界（本服务的全部价值都建立在这条上）</b>：
///   · 不写 ado_s8_detection_log
///   · 不写 ado_s8_exception / timeline / notification_log
///   · 不写 ado_s8_rule_detection_state（不推进抗抖计数）
///   · 不改规则自身的任何列（不动 enabled / next_run_at / last_run_at / lock_*）
///   · 不发通知
/// 只读既有 exception 用于回答「这条命中现在是否已有活动异常」。
///
/// <b>enabled=false 的规则同样可预演</b>——这正是本服务存在的理由：先看清楚再决定启不启用。
/// </summary>
public class S8WatchRulePreviewService : ITransient
{
    private readonly SqlSugarRepository<AdoS8WatchRule> _ruleRep;
    private readonly SqlSugarRepository<AdoS8Exception> _exceptionRep;
    private readonly S8MonitoringDataGateway _gateway;
    private readonly IS8RuleCatalog _ruleCatalog;
    private readonly S8TimeoutRuleEvaluator _timeoutEvaluator;
    private readonly S8ShortageRuleEvaluator _shortageEvaluator;
    private readonly S8OutOfRangeRuleEvaluator _outOfRangeEvaluator;

    public S8WatchRulePreviewService(
        SqlSugarRepository<AdoS8WatchRule> ruleRep,
        SqlSugarRepository<AdoS8Exception> exceptionRep,
        S8MonitoringDataGateway gateway,
        IS8RuleCatalog ruleCatalog,
        S8TimeoutRuleEvaluator timeoutEvaluator,
        S8ShortageRuleEvaluator shortageEvaluator,
        S8OutOfRangeRuleEvaluator outOfRangeEvaluator)
    {
        _ruleRep = ruleRep;
        _exceptionRep = exceptionRep;
        _gateway = gateway;
        _ruleCatalog = ruleCatalog;
        _timeoutEvaluator = timeoutEvaluator;
        _shortageEvaluator = shortageEvaluator;
        _outOfRangeEvaluator = outOfRangeEvaluator;
    }

    /// <summary>
    /// 预演一条规则。<paramref name="scope"/> 由 Controller 用服务端可信作用域盖章，
    /// 规则按 (id, tenant, factory) 绑行 —— 越权 id 一律按不存在处理，不泄露他租户规则是否存在。
    /// </summary>
    public async Task<S8WatchRulePreviewResult> PreviewAsync(long id, S8TrustedScope scope)
    {
        var rule = await _ruleRep.AsQueryable()
            .Where(x => x.Id == id && x.TenantId == scope.TenantId)
            .FirstAsync() ?? throw new S8NotFoundException();

        // S8-RULE-GOVERNANCE-BATCH1：预演必须与真实运行走同一份语义来源。
        // 若这里读 rule.RuleType（DB 投影列）而 evaluator 读定义，两者一旦不一致，
        // 预演结果就会与真跑结果不同 —— 而预演的全部价值就建立在"两者相同"上。
        var definition = _ruleCatalog.GetRequired(rule.RuleCode);
        var ruleType = definition.RuleType;

        IS8RuleEvaluator evaluator = ruleType switch
        {
            S8TimeoutRuleEvaluator.RuleTypeCode => _timeoutEvaluator,
            S8ShortageRuleEvaluator.RuleTypeCode => _shortageEvaluator,
            S8OutOfRangeRuleEvaluator.RuleTypeCode => _outOfRangeEvaluator,
            _ => throw new S8BizException($"不支持的规则类型：{ruleType}")
        };

        // 与生产同一条取数链。evaluator 内部会再次经 Gateway 取数，
        // 这里先单独取一次仅为拿到 candidateRows（判定前的行数），用于解释「筛掉了多少」。
        var maxRows = S8EvaluatorGuard.ResolveMaxRows(null);
        var data = await _gateway.LoadAsync(scope.TenantId, rule, ruleType, maxRows);
        var candidateRows = data.RowSet.Rows.Count;

        var hits = await evaluator.EvaluateAsync(scope.TenantId, rule);

        // 逐条回答「若真的建单，是新建还是命中既有活动异常」。
        // 与 S8WatchSchedulerService 的去重口径一致：同 dedup_key 且未 CLOSED 未删即视为活动。
        var dedupKeys = hits.Select(h => h.DedupKey).Where(k => !string.IsNullOrWhiteSpace(k)).Distinct().ToList();
        var activeByDedupKey = dedupKeys.Count == 0
            ? new Dictionary<string, long>(StringComparer.Ordinal)
            : (await _exceptionRep.AsQueryable()
                // S8-TENANT-ONLY-BATCH5：活动异常按 Tenant + dedup_key 查，不再按工厂切。
                // 预演必须与真跑同源：调度器侧的 FindOpenExceptionByDedupKeyAsync 也已只认 Tenant，
                // 两边一旦分叉，预演给出的"会新建还是会刷新"就不再可信。
                .Where(x => x.TenantId == scope.TenantId
                            && !x.IsDeleted && x.Status != "CLOSED"
                            && x.DedupKey != null && dedupKeys.Contains(x.DedupKey))
                .Select(x => new { x.DedupKey, x.Id })
                .ToListAsync())
              .GroupBy(x => x.DedupKey!, StringComparer.Ordinal)
              .ToDictionary(g => g.Key, g => g.First().Id, StringComparer.Ordinal);

        return new S8WatchRulePreviewResult
        {
            RuleId = rule.Id,
            RuleCode = rule.RuleCode,
            RuleType = ruleType,
            DatasetCode = definition.DatasetCode,
            Enabled = rule.Enabled,
            TenantId = scope.TenantId,
            EvaluatedAt = DateTime.Now,
            CandidateRows = candidateRows,
            HitCount = hits.Count,
            // 未命中数 = 候选 - 命中。刻意不细分「已完成」与「未到期」：
            // 那需要 preview 自己复刻一遍 evaluator 的判定分支，一旦两边逻辑漂移，
            // 预演就会给出与真实运行不同的解释。宁可少报，不可假报。
            NoHitRows = Math.Max(0, candidateRows - hits.Count),
            WouldCreateCount = CountWouldCreate(hits, activeByDedupKey),
            WouldMatchExistingCount = CountWouldMatchExisting(hits, activeByDedupKey),
            Hits = hits.Select(h => new S8WatchRulePreviewHit
            {
                SourceObjectType = h.SourceObjectType,
                SourceObjectId = h.SourceObjectId,
                RelatedObjectCode = h.RelatedObjectCode,
                RelatedObjectName = h.Title,
                ExceptionTypeCode = h.ExceptionTypeCode,
                Severity = h.Severity,
                DedupKey = h.DedupKey,
                DetectedAt = h.DetectedAt,
                ExistingActiveExceptionId =
                    activeByDedupKey.TryGetValue(h.DedupKey ?? string.Empty, out var exId) ? exId : null
            }).ToList()
        };
    }

    /// <summary>
    /// S8-RULE-LIFECYCLE-CREATE-GATE-1：「若此刻真的执行，会<b>新建</b>几条」。
    ///
    /// <para>判据必须与调度器 <c>ProcessSingleRuleAsync</c> 的建单条件<b>同源</b> ——
    /// 那里除了去重，还有一道 <see cref="S8RuleHit.CreateEligible"/> 闸门。
    /// 少判这一项，预演就会系统性高估：Rule 02 本地实测中预演报「将新建 3」，
    /// 而真跑 <c>created=2</c>，差的正是那条已过交期、风险已兑现的历史行。
    /// 管理员正是拿这个数字决定要不要启用，<b>报大了比不报更糟</b>。</para>
    ///
    /// <para>抽成纯函数只为一件事：让这条口径能被直接断言。原先它是
    /// <c>RunAsync</c> 里的一个内联 lambda，而 <c>RunAsync</c> 需要 DB + Gateway，
    /// 于是这条最容易悄悄漂移的算术反而是整个服务里唯一测不到的部分。</para>
    /// </summary>
    internal static int CountWouldCreate(
        IReadOnlyCollection<S8RuleHit> hits, IReadOnlyDictionary<string, long> activeByDedupKey) =>
        hits.Count(h => h.CreateEligible && !activeByDedupKey.ContainsKey(h.DedupKey ?? string.Empty));

    /// <summary>
    /// 「若此刻真的执行，会<b>刷新既有</b>几条」。
    ///
    /// <para><b>刻意不加 <see cref="S8RuleHit.CreateEligible"/> 过滤</b>：闸门在调度器里位于
    /// 「既有异常刷新」<b>之后</b>。一条跨过到期日的既有预警 <c>CreateEligible</c> 已经是 false，
    /// 但它照样会被刷新以保持 active —— 这正是假恢复修复的核心。这里跟着加过滤，
    /// 预演就会把「保持 active」误报成「什么都不会发生」，等于用另一种方式
    /// 把那条风险从管理员视野里抹掉。</para>
    /// </summary>
    internal static int CountWouldMatchExisting(
        IReadOnlyCollection<S8RuleHit> hits, IReadOnlyDictionary<string, long> activeByDedupKey) =>
        hits.Count(h => activeByDedupKey.ContainsKey(h.DedupKey ?? string.Empty));
}

/// <summary>预演结果。纯读，不代表任何已发生的副作用。</summary>
public sealed class S8WatchRulePreviewResult
{
    public long RuleId { get; init; }
    public string RuleCode { get; init; } = string.Empty;
    public string RuleType { get; init; } = string.Empty;
    public string? DatasetCode { get; init; }

    /// <summary>规则当前是否启用。预演**不受此值影响**，也不修改它。</summary>
    public bool Enabled { get; init; }

    public long TenantId { get; init; }
    public long FactoryId { get; init; }
    public DateTime EvaluatedAt { get; init; }

    /// <summary>Provider 返回的候选行数（判定之前）。</summary>
    public int CandidateRows { get; init; }

    public int HitCount { get; init; }
    public int NoHitRows { get; init; }

    /// <summary>若此刻真的执行，会新建的异常数。</summary>
    public int WouldCreateCount { get; init; }

    /// <summary>若此刻真的执行，会命中既有活动异常（即刷新而非新建）的数量。</summary>
    public int WouldMatchExistingCount { get; init; }

    public List<S8WatchRulePreviewHit> Hits { get; init; } = new();
}

/// <summary>单条预演命中。</summary>
public sealed class S8WatchRulePreviewHit
{
    public string SourceObjectType { get; init; } = string.Empty;
    public string SourceObjectId { get; init; } = string.Empty;
    public string RelatedObjectCode { get; init; } = string.Empty;
    public string RelatedObjectName { get; init; } = string.Empty;
    public string ExceptionTypeCode { get; init; } = string.Empty;
    public string Severity { get; init; } = string.Empty;
    public string DedupKey { get; init; } = string.Empty;
    public DateTime DetectedAt { get; init; }

    /// <summary>非空表示该命中已有活动异常，真实执行时是刷新而不是新建。</summary>
    public long? ExistingActiveExceptionId { get; init; }
}