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

using Admin.NET.Core;
using Admin.NET.Plugin.AiDOP.Const.S8;
using Admin.NET.Plugin.AiDOP.Entity.S8;
using Admin.NET.Plugin.AiDOP.Infrastructure.S8;
using Microsoft.Extensions.Logging;

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

/// <summary>一次收件人解析的结果。</summary>
public sealed class S8RecipientResolution
{
    /// <summary>去重后的收件账号。<b>只可能是 <c>SysUser.Id</c>。</b></summary>
    public List<long> UserIds { get; set; } = new();

    /// <summary>本次实际使用的配置来源：<c>RECIPIENT_MODEL</c> / <c>LEGACY_LAYER</c> / <c>NONE</c>。</summary>
    public string Source { get; set; } = "NONE";

    /// <summary>每个收件人类型解析出多少人 —— 0 人的必须能被看见，不能混在总数里被抹平。</summary>
    public Dictionary<string, int> PerType { get; set; } = new();

    /// <summary>配置存在但一个人都解析不出来。<b>这不是"没配置"，是"配了但发不出去"。</b></summary>
    public bool ConfiguredButEmpty => Source != "NONE" && UserIds.Count == 0;
}

/// <summary>
/// S8-NOTIFY-RECIPIENT-1：「这个事件该通知谁」的<b>唯一</b>解析实现。
///
/// <para><b>输出只认 <c>SysUserId</c></b>。所有个人通知最终都投递到系统账号 ——
/// 不存在"通知某个员工"这条路径（S8-SYSUSER-ONLY-1 已把 EmployeeMaster 移出人员主链）。</para>
///
/// <para><b>Authority 优先级（单一链路，不是两个平级来源）</b>：
/// ① 新收件人模型的规则级配置 → ② 新模型的租户级默认（<c>rule_code = '*'</c>）
/// → ③ 旧 <c>ado_s8_notification_layer</c>（LEGACY fallback）。
/// 一旦新模型对该 (租户, 规则, 事件) 有任何配置，旧表就<b>完全不参与</b> ——
/// 否则会出现"我明明删掉了收件人，怎么还在发"。</para>
///
/// <para><b>HANDLER_POOL 直接复用 P1-C 的责任池</b>，不复制第二份人员配置：
/// 两份人员名单迟早不一致，而不一致的那一刻没有任何报错。</para>
///
/// <para><b>REVIEWER 不是新建的 Reviewer Pool</b>：它解析当前事实 ——
/// 优先取单据上的 <c>verifier_user_id</c>（提交复核时手选、真正能点通过/退回的人），
/// 尚未提交复核时回落审批流节点解析出的审批人。本批不发明 Rule 级审核池。</para>
///
/// <para><b>0 收件人必须可观测</b>：解析结果为空时返回 <c>ConfiguredButEmpty</c>，
/// 由调用方落日志。绝不静默当作"发送成功"—— 那正是本模块反复出现的失败形态。</para>
/// </summary>
public interface IS8NotificationRecipientResolver
{
    Task<S8RecipientResolution> ResolveAsync(long tenantId, string eventCode, AdoS8Exception exception);
}

/// <summary>正式实现。生产代码里只有这一份；接口只为测试留 seam。</summary>
public sealed class S8NotificationRecipientResolver : IS8NotificationRecipientResolver, ITransient
{
    private readonly SqlSugarRepository<AdoS8NotificationRecipient> _rep;
    private readonly IS8RuleHandlerPoolReader _handlerPool;
    private readonly IS8UserScopeValidator _userScope;
    private readonly S8ReviewSourceService _reviewSource;
    private readonly ILogger<S8NotificationRecipientResolver> _logger;

    public S8NotificationRecipientResolver(
        SqlSugarRepository<AdoS8NotificationRecipient> rep,
        IS8RuleHandlerPoolReader handlerPool,
        IS8UserScopeValidator userScope,
        S8ReviewSourceService reviewSource,
        ILogger<S8NotificationRecipientResolver> logger)
    {
        _rep = rep;
        _handlerPool = handlerPool;
        _userScope = userScope;
        _reviewSource = reviewSource;
        _logger = logger;
    }

    public async Task<S8RecipientResolution> ResolveAsync(long tenantId, string eventCode, AdoS8Exception exception)
    {
        var result = new S8RecipientResolution();

        if (!S8NotificationCatalog.IsKnownEvent(eventCode) || tenantId <= 0 || exception == null)
            return result;

        var ruleCode = string.IsNullOrWhiteSpace(exception.SourceRuleCode)
            ? S8NotificationCatalog.TenantDefaultRuleCode
            : exception.SourceRuleCode!;

        // ① 规则级配置优先；② 没有才回落租户级默认。
        //    刻意**不合并**两者：合并会让"我给这条规则单独配了收件人"变成"在默认之上又加了几个"，
        //    管理员想缩小范围时会发现怎么也去不掉默认里的那些人。
        var rows = await LoadAsync(tenantId, ruleCode, eventCode);
        if (rows.Count == 0 && ruleCode != S8NotificationCatalog.TenantDefaultRuleCode)
            rows = await LoadAsync(tenantId, S8NotificationCatalog.TenantDefaultRuleCode, eventCode);

        if (rows.Count == 0) return result;   // Source 保持 NONE，调用方回落 LEGACY

        result.Source = "RECIPIENT_MODEL";
        var ids = new HashSet<long>();

        foreach (var row in rows)
        {
            var resolved = await ResolveOneAsync(tenantId, row, exception);
            result.PerType[row.RecipientType] = resolved.Count;
            foreach (var id in resolved) ids.Add(id);
        }

        // 最终统一过一遍账号有效性：配置可能是几个月前配的，人可能已经停用或换了租户。
        var valid = await _userScope.ValidateUsersAsync(tenantId, ids);
        result.UserIds = valid.Select(u => u.UserId).ToList();

        if (result.ConfiguredButEmpty)
            _logger.LogWarning(
                "s8_notify_recipients_empty tenant={Tenant} rule={Rule} event={Event} perType={PerType}"
                + "；配置存在但解析不出任何有效账号，本次通知不会发给任何人",
                tenantId, ruleCode, eventCode, string.Join(',', result.PerType.Select(kv => $"{kv.Key}={kv.Value}")));

        return result;
    }

    private async Task<List<AdoS8NotificationRecipient>> LoadAsync(long tenantId, string ruleCode, string eventCode) =>
        await _rep.AsQueryable().ClearFilter()
            .Where(x => x.TenantId == tenantId && x.RuleCode == ruleCode && x.EventCode == eventCode)
            .ToListAsync();

    private async Task<List<long>> ResolveOneAsync(long tenantId, AdoS8NotificationRecipient row, AdoS8Exception e)
    {
        switch (row.RecipientType)
        {
            case S8RecipientType.HandlerPool:
                if (string.IsNullOrWhiteSpace(e.SourceRuleCode)) return new List<long>();
                return (await _handlerPool.GetMemberIdsAsync(tenantId, e.SourceRuleCode!)).ToList();

            case S8RecipientType.Assignee:
                return e.AssigneeUserId is > 0 ? new List<long> { e.AssigneeUserId.Value } : new List<long>();

            case S8RecipientType.Reviewer:
                // 单据上已有检验人 = 真正能点通过/退回的那个人，最准确。
                if (e.VerifierUserId is > 0) return new List<long> { e.VerifierUserId.Value };
                // 尚未提交复核 → 回落审批流节点解析出的审批人（解析当前事实，不发明 pool）。
                return await ResolveFlowApproversAsync(tenantId);

            case S8RecipientType.SpecificUser:
                return S8RoleResolver.SplitTokens(row.RecipientUserIds)
                    .Select(t => long.TryParse(t, out var v) ? v : 0)
                    .Where(v => v > 0)
                    .ToList();

            default:
                // 未知类型不猜、不放行 —— 配置里出现它本身就说明有人绕过了目录校验。
                _logger.LogWarning("s8_notify_unknown_recipient_type type={Type} rowId={Id}", row.RecipientType, row.Id);
                return new List<long>();
        }
    }

    /// <summary>从复核审批流节点解析实际审批人。解析不出就是解析不出，不回落到任何"兜底人"。</summary>
    private async Task<List<long>> ResolveFlowApproversAsync(long tenantId)
    {
        var stages = await _reviewSource.DescribeAsync(tenantId);
        var verify = stages.FirstOrDefault(s => s.Stage == "复核");
        if (verify == null) return new List<long>();

        // DescribeAsync 输出的是展示名，这里需要 Id —— 复用同一份租户账号集合做反查，
        // 保证"页面上看到的审核人"与"实际收到通知的人"是同一批。
        var tenantUsers = await _userScope.ValidateUsersAsync(tenantId,
            await _rep.Context.Queryable<SysUser>().ClearFilter()
                .Where(u => u.TenantId == tenantId)
                .Select(u => u.Id).ToListAsync());

        var display = verify.Nodes.SelectMany(n => n.ResolvedUsers).ToHashSet();
        return tenantUsers
            .Where(u => display.Contains($"{u.DisplayName} ({u.Account})"))
            .Select(u => u.UserId)
            .ToList();
    }
}