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

using Admin.NET.Plugin.AiDOP.Entity.S8;
using Admin.NET.Plugin.AiDOP.Infrastructure;
using Admin.NET.Plugin.AiDOP.Infrastructure.S8;
using Admin.NET.Plugin.ApprovalFlow.Service;
using Microsoft.Extensions.Logging;

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

/// <summary>
/// S8 通知分层路由解析器（S8-NOTIFY-LAYER-RESOLVE-1）
///
/// 职责链：
///   (tenantId, factoryId, sceneCode, severity)
///     → 命中 ado_s8_notification_layer 行（多行 OK）
///     → 解析 target_role_ids（dual-format）
///     → 解析 notify_channel（IgnoreCase, ',' / ';' 分隔）
///     → S8RoleResolver → userIds
///     → S8NotificationPushAdapter.PushAsync
///     → 由 PushAdapter 落 AdoS8NotificationLog（**每个「已注册且被选中」的渠道**一条）
///
/// 不接入 watch / scheduler / task 主链路；不写 ApprovalFlowNotifyLog；
/// 不修改任何 schema；任何分支异常仅 LogWarning，不向上抛。
///
/// S8-STEP6C-CFG-NOTIFY-FIX-AND-CERT-1：平台默认回落粒度 = **(scene, severity, level) 逐层**。
/// 一次 OR 查询取回「平台默认 (0,0) ∪ 本工厂」的同 scene+severity 行，再交
/// <see cref="S8NotificationLayerMerge.Effective"/> 逐 level 取工厂优先。
/// 修正前是整键 fallback（精确租户查到任意一行即完全不读 (0,0)），会导致工厂补一层就丢掉平台其余层级。
/// merge 与配置页 ListAsync 共用同一实现，禁止各自复制。
/// </summary>
public class S8NotificationLayerResolver : ITransient
{
	private readonly SqlSugarRepository<AdoS8NotificationLayer> _layerRep;
	private readonly S8RoleResolver _roleResolver;
	private readonly IS8NotificationRecipientResolver _recipientResolver;
	private readonly Admin.NET.Core.Service.SysNoticeService _noticeService;
	private readonly S8NotificationPushAdapter _pushAdapter;
	private readonly ILogger<S8NotificationLayerResolver> _logger;

	public S8NotificationLayerResolver(
		SqlSugarRepository<AdoS8NotificationLayer> layerRep,
		S8RoleResolver roleResolver,
		IS8NotificationRecipientResolver recipientResolver,
		Admin.NET.Core.Service.SysNoticeService noticeService,
		S8NotificationPushAdapter pushAdapter,
		ILogger<S8NotificationLayerResolver> logger)
	{
		_layerRep = layerRep;
		_roleResolver = roleResolver;
		_recipientResolver = recipientResolver;
		_noticeService = noticeService;
		_pushAdapter = pushAdapter;
		_logger = logger;
	}

	public class DispatchByLayerInput
	{
		public long TenantId { get; set; }
		public long? ExceptionId { get; set; }
		public string? ExceptionNo { get; set; }
		public string SceneCode { get; set; } = string.Empty;
		public string Severity { get; set; } = string.Empty;
		public string Title { get; set; } = string.Empty;
		public string Content { get; set; } = string.Empty;
		public string? Status { get; set; }
		public string? SourceRuleCode { get; set; }

		/// <summary>
		/// S8-NOTIFY-RECIPIENT-1：本次派发对应的事件码（<c>S8NotifyEventCode</c>）。
		/// <para>为空表示调用方尚未接入新收件人模型，本次直接走 LEGACY 分层。</para>
		/// </summary>
		public string? EventCode { get; set; }

		/// <summary>
		/// 触发本次派发的异常单本体。新模型要靠它解析 ASSIGNEE / REVIEWER / HANDLER_POOL。
		/// 为 null 时同样退回 LEGACY 分层。
		/// </summary>
		public Admin.NET.Plugin.AiDOP.Entity.S8.AdoS8Exception? ExceptionRef { get; set; }
		public string? JumpUrl { get; set; }
		/// <summary>
		/// S8-NOTIFY-WIRE-RECOVERED-1：true 表示恢复事件，BuildNotification 会在 Context 中追加
		/// "recovered"="true"。默认 false，保持 CREATED 路径载荷向后兼容。
		/// </summary>
		public bool Recovered { get; set; }

		// ============================================================
		// S8-DEMO-IMPACT-SORT-NOTICE-1：影响统计字段（可选；CREATED 路径透传，RECOVERED 路径置空）。
		// 由 S8WatchSchedulerService.TryDispatchLayerNotificationAsync 调 S8ImpactMetricsService 计算后传入。
		// ============================================================
		public int? RepeatCount30d { get; set; }
		public decimal? CumulativeLossHours30d { get; set; }
		public string? SuggestedAttentionLevel { get; set; }
		public string? SuggestedAttentionLabel { get; set; }
		public string? ImpactReason { get; set; }

		// ============================================================
		// S8-R03-OVERDUE-CLOSE-NOTICE-1：关闭超时独立预警字段（可选；仅 CloseAsync 命中 closedAt > slaDeadline 时传入）。
		// 语义与 TimeoutFlag 运行时口径分离：TimeoutFlag 仅看未关闭超时；OverdueClosed 是已关闭后的闭环及时性提醒。
		// ============================================================
		public bool? OverdueClosed { get; set; }
		public DateTime? ClosedAt { get; set; }
		public DateTime? SlaDeadlineRef { get; set; }
		public decimal? OverdueCloseHours { get; set; }
	}

	/// <summary>
	/// 调用方：watch/scheduler/task 在拿到 sceneCode + severity 后调用本方法（本轮不接入主链路）。
	/// </summary>
	public async Task DispatchByLayerAsync(DispatchByLayerInput input)
	{
		if (input == null)
		{
			_logger.LogWarning("S8LayerDispatch: input null");
			return;
		}
		if (string.IsNullOrWhiteSpace(input.SceneCode) || string.IsNullOrWhiteSpace(input.Severity))
		{
			_logger.LogInformation("S8LayerDispatch skip: empty sceneCode or severity (exceptionId={ExceptionId})", input.ExceptionId);
			return;
		}

		// ── S8-NOTIFY-RECIPIENT-1：新收件人模型是 CURRENT AUTHORITY ──
		//
		// 新模型对该 (租户, 规则, 事件) 一旦有任何配置，旧分层表就**完全不参与**本次派发。
		// 不做"两者合并"：合并会让管理员删掉收件人之后通知照发，而他在新页面上
		// 已经看不到那些人了 —— 那是最难自查的一类配置故障。
		//
		// 只有新模型没有配置时才回落 LEGACY 分层，保证现网既有通知不被这批改动打断。
		if (!string.IsNullOrWhiteSpace(input.EventCode) && input.ExceptionRef != null)
		{
			var resolution = await _recipientResolver.ResolveAsync(input.TenantId, input.EventCode!, input.ExceptionRef);
			if (resolution.Source != "NONE")
			{
				await DispatchToUsersAsync(input, resolution);
				return;
			}
		}

		// S8-STEP6C-CFG-NOTIFY-FIX-AND-CERT-1：覆盖粒度由「整个 (scene, severity) 键」收敛为**逐 level 覆盖**。
		//
		// 原实现是两次往返 + 整键 fallback（精确租户查到任意一行 → 完全不读 (0,0)）。
		// 那意味着工厂只要为某一层建一行，平台默认在该 scene+severity 下的其余层级会整体消失——
		// 工厂本意是「补一层」，实际是「换掉整组」，且该副作用在配置页上不可见。
		//
		// 现在一次 OR 查询同时取回平台默认与本工厂行，再由 S8NotificationLayerMerge 逐 level 取舍。
		// merge 与配置页 ListAsync 共用同一函数，杜绝「页面显示一种、运行时派发另一种」。
		List<AdoS8NotificationLayer> layers;
		var severity = S8SeverityCode.Normalize(input.Severity);
		try
		{
			var candidates = await _layerRep.AsQueryable()
				.Where(x => x.SceneCode == input.SceneCode && x.Severity == severity)
				// S8-TENANT-ONLY-BATCH6：候选判据去掉 factory 等值，保留 (0,0) 平台默认哨兵。
				// 不去掉是必然断链：本批之后异常 factory_id 恒为 0，而库里的 notification_layer
				// 租户行 factory_id ≠ 0，租户那一支永远命中不了 —— 分层通知会静默退化成"只有平台默认"。
				.Where(x => x.TenantId == input.TenantId
					|| (x.TenantId == S8ConfigScope.GlobalTenantId && x.FactoryId == S8ConfigScope.GlobalFactoryId))
				.ToListAsync();

			layers = S8NotificationLayerMerge.Effective(candidates);
		}
		catch (Exception ex)
		{
			_logger.LogWarning(ex, "S8LayerDispatch: query AdoS8NotificationLayer failed (scene={Scene}, sev={Sev})", input.SceneCode, input.Severity);
			return;
		}

		if (layers.Count > 0)
			_logger.LogInformation(
				"S8LayerDispatch: {Total} effective layer rows across {Levels} level(s) for scene={Scene} sev={Sev}; {G} from platform default (tenant=0/factory=0)",
				layers.Count,
				layers.Select(x => S8NotificationLayerMerge.NormalizeLevel(x.LevelCode)).Distinct().Count(),
				input.SceneCode, severity,
				layers.Count(x => S8ConfigScope.IsGlobal(x.TenantId, x.FactoryId)));

		if (layers.Count == 0)
		{
			_logger.LogInformation("S8LayerDispatch: no layer matched (tenant={Tenant}, factory={Factory}, scene={Scene}, sev={Sev})",
				input.TenantId, input.SceneCode, input.Severity);
			return;
		}

		var notification = BuildNotification(input);

		foreach (var layer in layers)
		{
			List<long> userIds;
			try
			{
				var tokens = S8RoleResolver.SplitTokens(layer.TargetRoleIds);
				if (tokens.Count == 0)
				{
					_logger.LogWarning("S8LayerDispatch: layer id={LayerId} target_role_ids empty, skip row", layer.Id);
					continue;
				}
				// S8-ROLE-TENANT-SCOPE-1：显式透传租户作为安全边界。
				// 注意用 input.TenantId 而非 layer.TenantId —— 全局层（tenant_id=0）也必须
				// 按**触发异常的租户**解析收件人，否则全局层会解析不到任何角色。
				userIds = await _roleResolver.ResolveUserIdsAsync(input.TenantId, tokens);
			}
			catch (Exception ex)
			{
				_logger.LogWarning(ex, "S8LayerDispatch: resolve roles failed for layer id={LayerId}", layer.Id);
				continue;
			}

			if (userIds.Count == 0)
			{
				_logger.LogWarning("S8LayerDispatch: layer id={LayerId} resolved 0 users from target_role_ids='{Roles}'",
					layer.Id, layer.TargetRoleIds);
				continue;
			}

			var channels = ParseChannels(layer.NotifyChannel);
			try
			{
				await _pushAdapter.PushAsync(
					tenantId: input.TenantId,
					// 通知日志的 factory 列写兼容值 0：归属只由 tenant 决定。
					factoryId: S8ConfigScope.GlobalFactoryId,
					exceptionId: input.ExceptionId,
					userIds: userIds,
					notification: notification,
					channels: channels);
			}
			catch (Exception ex)
			{
				// PushAdapter 自身已对内部错误做了捕获；这里再兜一层保证主流程不被打断。
				_logger.LogWarning(ex, "S8LayerDispatch: push throw (layer id={LayerId})", layer.Id);
			}
		}
	}

	/// <summary>
	/// 新收件人模型的投递。复用与 LEGACY 完全相同的 <see cref="BuildNotification"/> 与
	/// PushAdapter —— 两条路径只在"收件人怎么来"上不同，通知内容与投递方式必须一致，
	/// 否则同一条异常会因为配置来源不同而呈现出不同的消息。
	/// </summary>
	private async Task DispatchToUsersAsync(DispatchByLayerInput input, S8RecipientResolution resolution)
	{
		if (resolution.UserIds.Count == 0)
		{
			// 0 收件人必须可观测：配了却发不出去，与"没配置"是两回事。
			// 绝不静默返回让调用方以为发送成功 —— 那正是本模块反复出现的失败形态。
			_logger.LogWarning(
				"S8RecipientDispatch: resolved 0 recipients (tenant={Tenant} event={Event} exceptionId={ExceptionId} perType={PerType})",
				input.TenantId, input.EventCode, input.ExceptionId,
				string.Join(',', resolution.PerType.Select(kv => $"{kv.Key}={kv.Value}")));
			return;
		}

		_logger.LogInformation(
			"S8RecipientDispatch: source={Source} recipients={Count} (tenant={Tenant} event={Event} exceptionId={ExceptionId} perType={PerType})",
			resolution.Source, resolution.UserIds.Count, input.TenantId, input.EventCode, input.ExceptionId,
			string.Join(',', resolution.PerType.Select(kv => $"{kv.Key}={kv.Value}")));

		// ① 站内信：这是本部署里**唯一会为用户留下一条可见消息**的通道。
		//
		//    已注册的 pusher 只有 DingTalk / WorkWeixin / SignalR / Sms —— 没有站内信。
		//    旧的分层派发因此从来只推 SignalR（用户不在线就等于没发过），
		//    而认领 / 转派的站内信是靠一段写死收件人的代码单独发的。
		//    新模型把两者合并：所有事件都先落站内信，再推实时通道。
		//    少了这一步，本次重构会静默丢掉认领 / 转派原本有的站内信（本地实测已发生）。
		try
		{
			await _noticeService.PublishToUsersAsync(
				input.Title,
				BuildNoticeContent(input),
				resolution.UserIds.ToArray(),
				0,
				"S8异常监控");
		}
		catch (Exception ex)
		{
			_logger.LogWarning(ex, "S8RecipientDispatch: notice publish throw (event={Event})", input.EventCode);
		}

		// ② 实时通道：在线用户即时可见；不在线也不影响①已经留下的站内信。
		try
		{
			await _pushAdapter.PushAsync(
				tenantId: input.TenantId,
				factoryId: S8ConfigScope.GlobalFactoryId,
				exceptionId: input.ExceptionId,
				userIds: resolution.UserIds,
				notification: BuildNotification(input),
				channels: DefaultChannels);
		}
		catch (Exception ex)
		{
			_logger.LogWarning(ex, "S8RecipientDispatch: push throw (event={Event})", input.EventCode);
		}
	}

	/// <summary>站内信正文：内容 + 一个能点回异常详情的链接。</summary>
	private static string BuildNoticeContent(DispatchByLayerInput input)
	{
		var jump = string.IsNullOrWhiteSpace(input.JumpUrl) ? null : $"/#{input.JumpUrl}";
		return $"<p>{input.ExceptionNo} {input.Content}</p>"
			+ (jump == null ? string.Empty : $"<p><a href=\"{jump}\">查看异常详情</a></p>");
	}

	/// <summary>
	/// 新模型的投递渠道。只列<b>真实可用</b>的两个 —— 站内信与 SignalR，
	/// 与旧分层表里实际在用的 <c>notify_channel='log,SignalR'</c> 同源。
	/// 不为了 UI 看起来完整而虚构短信 / 邮件之类当前根本没有实现的渠道。
	/// </summary>
	private static readonly List<string> DefaultChannels = new() { "log", "SignalR" };

	private static FlowNotification BuildNotification(DispatchByLayerInput input)
	{
		// 注意：FlowNotificationTypeEnum 不含 S8_EXCEPTION 值；BizType 字段承载 "S8_EXCEPTION" 语义。
		// InstanceId 仅作为载荷字段（PushAdapter 不写 ApprovalFlowNotifyLog，不会脏写该列）。
		var ctx = new Dictionary<string, string?>
		{
			["exceptionId"] = input.ExceptionId?.ToString(),
			["exceptionNo"] = input.ExceptionNo,
			["sceneCode"] = input.SceneCode,
			["severity"] = input.Severity,
			["status"] = input.Status,
			["sourceRuleCode"] = input.SourceRuleCode,
			["jumpUrl"] = input.JumpUrl,
		};
		if (input.Recovered) ctx["recovered"] = "true";
		// S8-DEMO-IMPACT-SORT-NOTICE-1：影响统计 5 字段，仅 CREATED 路径携带，RECOVERED 路径不传入。
		if (input.RepeatCount30d.HasValue)
			ctx["repeatCount30d"] = input.RepeatCount30d.Value.ToString(System.Globalization.CultureInfo.InvariantCulture);
		if (input.CumulativeLossHours30d.HasValue)
			ctx["cumulativeLossHours30d"] = input.CumulativeLossHours30d.Value.ToString("0.#", System.Globalization.CultureInfo.InvariantCulture);
		if (!string.IsNullOrWhiteSpace(input.SuggestedAttentionLevel))
			ctx["suggestedAttentionLevel"] = input.SuggestedAttentionLevel;
		if (!string.IsNullOrWhiteSpace(input.SuggestedAttentionLabel))
			ctx["suggestedAttentionLabel"] = input.SuggestedAttentionLabel;
		if (!string.IsNullOrWhiteSpace(input.ImpactReason))
			ctx["impactReason"] = input.ImpactReason;
		// S8-R03-OVERDUE-CLOSE-NOTICE-1：关闭超时独立预警 4 字段，仅 CloseAsync 命中 closedAt > slaDeadline 时携带。
		if (input.OverdueClosed == true)
			ctx["overdueClosed"] = "true";
		if (input.ClosedAt.HasValue)
			ctx["closedAt"] = input.ClosedAt.Value.ToString("yyyy-MM-dd HH:mm:ss", System.Globalization.CultureInfo.InvariantCulture);
		if (input.SlaDeadlineRef.HasValue)
			ctx["slaDeadline"] = input.SlaDeadlineRef.Value.ToString("yyyy-MM-dd HH:mm:ss", System.Globalization.CultureInfo.InvariantCulture);
		if (input.OverdueCloseHours.HasValue)
			ctx["overdueCloseHours"] = input.OverdueCloseHours.Value.ToString("0.#", System.Globalization.CultureInfo.InvariantCulture);
		return new FlowNotification
		{
			Type = FlowNotificationTypeEnum.NewTask,
			BizType = "S8_EXCEPTION",
			InstanceId = input.ExceptionId ?? 0,
			Title = input.Title ?? string.Empty,
			Content = input.Content ?? string.Empty,
			Context = ctx,
		};
	}

	public static List<string> ParseChannels(string? csv)
	{
		if (string.IsNullOrWhiteSpace(csv)) return new List<string>();
		return csv.Split(new[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries).ToList();
	}
}