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

using Admin.NET.Plugin.AiDOP.Dto.S8;
using Admin.NET.Plugin.AiDOP.Entity.S0.Warehouse;
using Admin.NET.Plugin.AiDOP.Entity.S8;
using Admin.NET.Plugin.AiDOP.Entity.S8.OrderFlow;
using Admin.NET.Plugin.AiDOP.Infrastructure;
using Admin.NET.Plugin.AiDOP.Infrastructure.S8;

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

public class S8MonitoringService : ITransient
{
    private readonly SqlSugarRepository<AdoS8Exception> _rep;
    private readonly SqlSugarRepository<AdoS8ExceptionType> _typeRep;
    // S8-OVERVIEW-DEPT-LABEL-HYDRATION-1：部门名称水合改用 AdoS0DepartmentMaster（DepartmentMaster 表，
    // RecID=1/2 映射真实部门），与 S8DashboardService / S8ExceptionService 主数据水合口径一致。
    // SysOrg 的 Id 为雪花，不与 ado_s8_exception.responsible_dept_id (1/2) 匹配，不能作部门名来源。
    private readonly SqlSugarRepository<AdoS0DepartmentMaster> _deptRep;
    // TASK-012-S9-QDC-RATIO-MIGRATION-2：result KPI summary 读取 RATIO 指标字典
    private readonly SqlSugarRepository<AdoS8MonitorMetric> _metricRep;
    // S8-REAL-DATA-PRESENTATION-1：原先这里注入了 ado_s8_order_flow_order / _procurement_pivot /
    // _manufacturing_process / _stage 四个 SEED 仓储，用于把种子数据算成「当前 KPI」。
    // 四项 KPI 已改为如实 PENDING_REAL（见 ComputeResultKpiCurrentAsync），依赖随之移除 ——
    // 本服务从此与 ado_s8_order_flow_* **无任何运行期事实依赖**。

    public S8MonitoringService(
        SqlSugarRepository<AdoS8Exception> rep,
        SqlSugarRepository<AdoS8ExceptionType> typeRep,
        SqlSugarRepository<AdoS0DepartmentMaster> deptRep,
        SqlSugarRepository<AdoS8MonitorMetric> metricRep)
    {
        _rep = rep;
        _typeRep = typeRep;
        _deptRep = deptRep;
        _metricRep = metricRep;
    }

    /// <summary>
    /// 9宫格数据：S1-S7 订单健康分布 + S8业务类别汇总 + S9部门汇总。
    /// 数据来源 ado_s8_exception 聚合；异常表为空时返回全 0（不再返回 Demo 数据）。
    /// </summary>
    public async Task<AdoS8OrderGridDto> GetOrderGridAsync(long tenantId, string? period = null)
    {
        var (periodFrom, periodTo) = S8PeriodHelper.Resolve(period);

        // TASK-002-RESET-DIMENSION-MODEL-DEV-4A：聚合源切到 stage_code（DEV-2A 已与 module_code 对齐）；
        // DTO 字段名保持 ModuleCode 以兼容前端，仅来源字段改为 StageCode。
        var events = await _rep.AsQueryable()
            .Where(e => e.TenantId == tenantId && !e.IsDeleted)
            .Where(e => S8ModuleCode.All.Contains(e.StageCode))
            .WhereIF(periodFrom.HasValue, e => e.CreatedAt >= periodFrom!.Value)
            .WhereIF(periodTo.HasValue,   e => e.CreatedAt < periodTo!.Value)
            .Select(e => new
            {
                ModuleCode = e.StageCode,
                e.Severity,
                e.Status,
                e.TimeoutFlag,
                e.ExceptionTypeCode,
                e.SceneCode,
                e.ResponsibleDeptId,
                e.CreatedAt,
                e.ClosedAt
            })
            .ToListAsync();

        // ── Modules：按 module_code 聚合 ──
        var modules = S8ModuleCode.All.Select(mc =>
        {
            var rows = events.Where(e => e.ModuleCode == mc).ToList();
            var unclosed = rows.Where(e => e.Status != "CLOSED").ToList();
            // S8-SEVERITY-FOLLOW-SERIOUS-STANDARDIZE-EXEC-1：red=SERIOUS / yellow=FOLLOW；
            // green 不再来自异常 severity（异常表无「正常」桶），保留 0 兜底，绿色由 useS8StageConfig 兜底。
            var red    = unclosed.Count(e => S8SeverityCode.IsSerious(e.Severity));
            var yellow = unclosed.Count(e => S8SeverityCode.IsFollow(e.Severity));
            var green  = 0;
            var closed = rows.Count(e => e.Status == "CLOSED");
            var total  = rows.Count;
            return new AdoS8ModuleOrderSummary
            {
                ModuleCode      = mc,
                ModuleLabel     = S8ModuleCode.Label(mc),
                Green           = green,
                Yellow          = yellow,
                Red             = red,
                Total           = total,
                // S8-DASHBOARD-P2-SEMANTICS-1（P2-D）：原为 `Frequency = total`，
                // 把「异常绝对数」冒充成 DTO 注释所写的「每百订单异常数」。
                // 每百订单需要「该阶段的订单分母」，而 S8 没有任何 Authority 能提供：
                // 各 stage 的异常对象类型不同（S4 的对象是采购单），mdp_std_so 只是 S1 的
                // 销售订单行，充当全阶段公共分母属于自造口径。按 NO_DATA ≠ 0 返回 null。
                Frequency       = null,
                AvgProcessHours = AvgHours(rows.Select(r => (r.CreatedAt, r.ClosedAt))),
                CloseRate       = total == 0 ? 0 : Math.Round(closed * 100.0 / total, 1),
            };
        }).ToList();

        // ── ByCategory：按异常类型的 type_code 聚合为 5 大业务类别（CategoryOf） ──
        var typeMap = (await _typeRep.AsQueryable()
                .Where(t => t.TenantId == S8ConfigScope.GlobalTenantId || t.TenantId == tenantId)
                .ToListAsync())
            .GroupBy(t => t.TypeCode)
            // S8-TENANT-ONLY-BATCH6：precedence 判据由 FactoryId 降序改为「租户行优先」；
            // 本批之后租户覆盖行的 factory_id 恒为 0，按 FactoryId 排序会反过来选中平台默认。
            .ToDictionary(g => g.Key, g => g.OrderByDescending(x => x.TenantId != S8ConfigScope.GlobalTenantId).First());

        var byCategory = events
            .Where(e => !string.IsNullOrEmpty(e.ExceptionTypeCode) && typeMap.ContainsKey(e.ExceptionTypeCode!))
            .GroupBy(e => CategoryOf(typeMap[e.ExceptionTypeCode!]))
            .Where(g => !string.IsNullOrEmpty(g.Key))
            .Select(g =>
            {
                var total  = g.Count();
                var closed = g.Count(e => e.Status == "CLOSED");
                return new AdoS8CategorySummary
                {
                    Category        = g.Key!,
                    Total           = total,
                    AvgProcessHours = AvgHours(g.Select(e => (e.CreatedAt, e.ClosedAt))),
                    CloseRate       = total == 0 ? 0 : Math.Round(closed * 100.0 / total, 1),
                };
            })
            .OrderBy(c => CategoryOrder(c.Category))
            .ToList();

        // ── ByDept：按 ResponsibleDeptId 聚合，JOIN AdoS0DepartmentMaster（DepartmentMaster）取部门名称 ──
        // S8-OVERVIEW-DEPT-LABEL-HYDRATION-1：原使用 SysOrg 但其 Id 是雪花，与 dept_id=1/2 不匹配 → 100% fallback；
        // 改用 DepartmentMaster（RecID=1=质量部 / RecID=2=生产部），与 dashboard 部门口径对齐。
        var deptIds = events.Select(e => e.ResponsibleDeptId).Where(id => id > 0).Distinct().ToList();
        // S8-DEPT-DISPLAY-CONSISTENCY-1（P0-A-3）：部门水合加 factory_ref_id 约束。
        var deptNameMap = deptIds.Count == 0
            ? new Dictionary<long, string>()
            : (await _deptRep.AsQueryable()
                    .Where(d => deptIds.Contains(d.Id) && d.TenantId == tenantId)
                    .Select(d => new { d.Id, Name = d.Descr ?? d.Department })
                    .ToListAsync())
                .ToDictionary(d => d.Id, d => d.Name ?? string.Empty);

        var byDept = events
            .Where(e => e.ResponsibleDeptId > 0)
            .GroupBy(e => e.ResponsibleDeptId)
            .Select(g =>
            {
                var total  = g.Count();
                var closed = g.Count(e => e.Status == "CLOSED");
                return new AdoS8DeptSummary
                {
                    DeptName        = deptNameMap.TryGetValue(g.Key, out var n) && !string.IsNullOrEmpty(n) ? n : $"部门{g.Key}",
                    Total           = total,
                    AvgProcessHours = AvgHours(g.Select(e => (e.CreatedAt, e.ClosedAt))),
                    CloseRate       = total == 0 ? 0 : Math.Round(closed * 100.0 / total, 1),
                };
            })
            .OrderByDescending(d => d.Total)
            .ToList();

        return new AdoS8OrderGridDto
        {
            Modules    = modules,
            ByCategory = byCategory,
            ByDept     = byDept,
        };
    }

    private static double AvgHours(IEnumerable<(DateTime createdAt, DateTime? closedAt)> items)
    {
        var closed = items.Where(x => x.closedAt.HasValue).ToList();
        if (closed.Count == 0) return 0;
        var avg = closed.Average(x => (x.closedAt!.Value - x.createdAt).TotalHours);
        return Math.Round(avg, 1);
    }

    /// <summary>异常类型 → 业务类别（与 Overview 页 5 张类别卡对应）。
    /// 优先级：配置 (AdoS8ExceptionType.MonitoringCategoryKey → KeyToLabel) → legacy hardcode fallback → string.Empty。
    /// 配置缺失或非法 key 时由 CategoryOfLegacy 兜底，保证演示链路不丢类别卡。</summary>
    private static string CategoryOf(AdoS8ExceptionType? t)
    {
        if (t is null) return string.Empty;
        var configured = S8MonitoringCategory.KeyToLabel(t.MonitoringCategoryKey);
        if (!string.IsNullOrEmpty(configured)) return configured;
        return CategoryOfLegacy(t.TypeCode);
    }

    /// <summary>Legacy hardcode 映射，保留现有 15 条 enabled + 7 条 deprecated 兼容分支。
    /// 不在此处补新映射；新 type_code 通过 monitoring_category_key 配置驱动。</summary>
    private static string CategoryOfLegacy(string? typeCode) => typeCode switch
    {
        // 订单评审
        "ORDER_CHANGE"                              => "订单评审",
        // 总装发货
        "DELIVERY_DELAY"                            => "总装发货",
        "PENDING_SHIPMENT"                          => "总装发货",
        // 本体生产（新基线）
        "EQUIP_FAULT"                               => "本体生产",
        "MFG_MATERIAL_ABNORMAL"                     => "本体生产",
        "MFG_QUALITY_ABNORMAL"                      => "本体生产",
        "PRODUCTION_MATERIAL_ABNORMAL"              => "本体生产",
        "PRODUCTION_QUALITY_ABNORMAL"               => "本体生产",
        "WORK_ORDER_KITTING_ABNORMAL"               => "本体生产",
        "WORK_ORDER_ISSUE_ABNORMAL"                 => "本体生产",
        // 材料采购（新基线）
        "SUPPLIER_ETA_ISSUE"                        => "材料采购",
        "SUPPLIER_SHIP_ISSUE"                       => "材料采购",
        "IQC_ISSUE"                                 => "材料采购",
        "WH_PUTAWAY_ISSUE"                          => "材料采购",
        "WAREHOUSE_RECEIPT_ABNORMAL"                => "材料采购",
        // 旧 7 条 deprecated 仍保留兼容（DB 已迁移；此分支防 Overview 临时回放历史 active）
        "MATERIAL_SHORTAGE"                         => "本体生产",
        "QUALITY_DEFECT"                            => "本体生产",
        "DIMENSION_DEVIATION"                       => "本体生产",
        "WH_KIT_ISSUE"                              => "本体生产",
        "WH_ISSUE_OUT_ISSUE"                        => "本体生产",
        "WH_INBOUND_ISSUE"                          => "材料采购",
        _                                           => string.Empty,
    };

    private static int CategoryOrder(string category) => category switch
    {
        "订单评审" => 1,
        "产品设计" => 2,
        "材料采购" => 3,
        "本体生产" => 4,
        "总装发货" => 5,
        _         => 99,
    };

    // ── QDC 常量映射（不建表，后端常量驱动） ──────────────────────────────────────
    private static readonly (string Code, string Title, string[] Types, string? Remark)[] QdcGroups =
    {
        ("QUALITY",   "质量异常", new[] { "PURCHASE_QUALITY_ABNORMAL", "MFG_QUALITY_ABNORMAL", "PRODUCTION_QUALITY_ABNORMAL" }, null),
        ("DELIVERY",  "交付异常", new[] { "ORDER_DELIVERY_DELAY_WARNING", "SUPPLIER_DELIVERY_DELAY_WARNING", "ORDER_CHANGE", "DELIVERY_DELAY", "PENDING_SHIPMENT" }, null),
        ("INVENTORY", "库存异常", new[] { "MATERIAL_STOCK_ABNORMAL", "INVENTORY_TURNOVER_ABNORMAL", "INVENTORY_AMOUNT_LEVEL_ABNORMAL" }, null),
        ("COST",      "成本异常", Array.Empty<string>(), "待定义成本异常口径"),
    };

    /// <summary>
    /// S9 QDC 四主线运营聚合：质量 / 交付 / 成本 / 库存。
    /// 成本异常当前无 enabled exception_type，返回空桶。
    /// 及时关闭率依赖 sla_deadline，无 SLA 数据时返回 null。
    /// </summary>
    public async Task<AdoS8QdcSummaryDto> GetQdcSummaryAsync(long tenantId, string? period = null)
    {
        var (periodFrom, periodTo) = S8PeriodHelper.Resolve(period);

        var events = await _rep.AsQueryable()
            .Where(e => e.TenantId == tenantId && !e.IsDeleted)
            .WhereIF(periodFrom.HasValue, e => e.CreatedAt >= periodFrom!.Value)
            .WhereIF(periodTo.HasValue,   e => e.CreatedAt < periodTo!.Value)
            .Select(e => new
            {
                e.ExceptionTypeCode,
                e.Status,
                e.CreatedAt,
                e.ClosedAt,
                e.SlaDeadline,
            })
            .ToListAsync();

        var items = new List<AdoS8QdcSummaryItemDto>();
        foreach (var (code, title, types, remark) in QdcGroups)
        {
            if (types.Length == 0)
            {
                items.Add(new AdoS8QdcSummaryItemDto { Code = code, Title = title, Total = 0, Remark = remark });
                continue;
            }

            var rows = events
                .Where(e => e.ExceptionTypeCode != null && types.Contains(e.ExceptionTypeCode))
                .ToList();
            var total      = rows.Count;
            var closedRows = rows.Where(e => e.Status == "CLOSED" && e.ClosedAt.HasValue).ToList();

            double? avgHours = closedRows.Count == 0
                ? null
                : Math.Round(closedRows.Average(e => (e.ClosedAt!.Value - e.CreatedAt).TotalHours), 1);

            double? closeRate = total == 0
                ? null
                : Math.Round(closedRows.Count * 100.0 / total, 1);

            double? onTimeCloseRate = null;
            if (closedRows.Count > 0)
            {
                var closedWithSla = closedRows.Where(e => e.SlaDeadline.HasValue).ToList();
                if (closedWithSla.Count > 0)
                    onTimeCloseRate = Math.Round(
                        closedWithSla.Count(e => e.ClosedAt!.Value <= e.SlaDeadline!.Value) * 100.0 / closedRows.Count, 1);
            }

            items.Add(new AdoS8QdcSummaryItemDto
            {
                Code            = code,
                Title           = title,
                Total           = total,
                AvgProcessHours = avgHours,
                OnTimeCloseRate = onTimeCloseRate,
                CloseRate       = closeRate,
                Remark          = remark,
            });
        }
        return new AdoS8QdcSummaryDto { Items = items };
    }

    /// <summary>
    /// 异常监控汇总：按 module_code 分组统计红/黄/绿/超时数。
    /// 供综合全景页顶部徽标和模块汇总表使用。
    /// </summary>
    public async Task<AdoS8MonitoringSummaryDto> GetSummaryAsync(AdoS8MonitoringSummaryQueryDto q)
    {
        // 显式日期范围优先；未传显式范围时尝试从 period 解析。
        var (periodFrom, periodTo) = (!q.BizDateFrom.HasValue && !q.BizDateTo.HasValue)
            ? S8PeriodHelper.Resolve(q.Period)
            : (q.BizDateFrom, q.BizDateTo);
        var effectiveFrom = q.BizDateFrom ?? periodFrom;
        var effectiveTo   = q.BizDateTo   ?? periodTo;

        // 前端三专题页传入逗号分隔模块码（"S1,S7" / "S2,S6" / "S3,S4,S5"），按 IN 过滤；空值/单值保持原语义。
        var moduleCodes = (q.ModuleCode ?? string.Empty)
            .Split(',', StringSplitOptions.RemoveEmptyEntries)
            .Select(s => s.Trim())
            .Where(s => s.Length > 0)
            .Distinct()
            .ToList();

        var query = _rep.AsQueryable()
            .Where(e => e.TenantId == q.TenantId && !e.IsDeleted)
            // TASK-002-RESET-DIMENSION-MODEL-DEV-4A：聚合源 module_code → stage_code。
            .Where(e => S8ModuleCode.All.Contains(e.StageCode))
            .WhereIF(!string.IsNullOrWhiteSpace(q.SceneCode), e => e.SceneCode == q.SceneCode)
            .WhereIF(moduleCodes.Count > 0, e => moduleCodes.Contains(e.StageCode))
            .WhereIF(effectiveFrom.HasValue, e => e.CreatedAt >= effectiveFrom!.Value)
            .WhereIF(effectiveTo.HasValue,   e => e.CreatedAt < effectiveTo!.Value);

        // 聚合到内存（数据量在可控范围内，避免复杂 GROUP BY 兼容性问题）
        // S8-SLA-TIMEOUT-RUNTIME-1（P3）：投影 SlaDeadline 替代 TimeoutFlag，timeout 改为运行时计算。
        var raw = await query
            .Select(e => new
            {
                ModuleCode = e.StageCode,
                e.SceneCode,
                e.Severity,
                e.SlaDeadline,
                e.Status
            })
            .ToListAsync();
        var nowForTimeout = DateTime.Now;

        // S8-OVERVIEW-STAGE-CARD-LIFECYCLE-COPY-AND-METRIC-FIX-1：超时口径 = SlaDeadline < now AND status NOT IN (CLOSED, RECOVERED)。
        // 按 severity 拆桶用于 stage card 「严重 N / 延误 M」「关注 N / 延误 M」展示。
        bool IsTimeout(DateTime? sla, string? status) =>
            sla != null && sla < nowForTimeout && status != "CLOSED" && status != "RECOVERED";

        var byModule = raw
            .GroupBy(e => new { mc = e.ModuleCode ?? string.Empty, sc = e.SceneCode ?? string.Empty })
            .Select(g => new AdoS8ModuleSummaryItem
            {
                ModuleCode  = g.Key.mc,
                ModuleLabel = S8ModuleCode.Label(g.Key.mc),
                SceneCode   = g.Key.sc,
                SceneLabel  = S8SceneCode.Label(g.Key.sc),
                Total   = g.Count(),
                // S8-SEVERITY-FOLLOW-SERIOUS-STANDARDIZE-EXEC-1：red=SERIOUS / yellow=FOLLOW；green=0（异常表无正常桶）。
                Red     = g.Count(e => S8SeverityCode.IsSerious(e.Severity)),
                Yellow  = g.Count(e => S8SeverityCode.IsFollow(e.Severity)),
                Green   = 0,
                Timeout = g.Count(e => IsTimeout(e.SlaDeadline, e.Status)),
                SeriousTimeout = g.Count(e => S8SeverityCode.IsSerious(e.Severity) && IsTimeout(e.SlaDeadline, e.Status)),
                FollowTimeout  = g.Count(e => S8SeverityCode.IsFollow(e.Severity)  && IsTimeout(e.SlaDeadline, e.Status)),
            })
            // 按 S8ModuleCode.All 顺序排列
            .OrderBy(r => Array.IndexOf(S8ModuleCode.All, r.ModuleCode))
            .ToList();

        return new AdoS8MonitoringSummaryDto
        {
            Total   = raw.Count,
            // S8-SEVERITY-FOLLOW-SERIOUS-STANDARDIZE-EXEC-1：red=SERIOUS / yellow=FOLLOW；green=0。
            Red     = raw.Count(e => S8SeverityCode.IsSerious(e.Severity)),
            Yellow  = raw.Count(e => S8SeverityCode.IsFollow(e.Severity)),
            Green   = 0,
            Timeout = raw.Count(e => IsTimeout(e.SlaDeadline, e.Status)),
            SeriousTimeout = raw.Count(e => S8SeverityCode.IsSerious(e.Severity) && IsTimeout(e.SlaDeadline, e.Status)),
            FollowTimeout  = raw.Count(e => S8SeverityCode.IsFollow(e.Severity)  && IsTimeout(e.SlaDeadline, e.Status)),
            ByModule = byModule
        };
    }

    /// <summary>
    /// S8-DELIVERY-PAGE-TYPE-TOTAL-ALIGN-1：Delivery 页近 N 日交付异常趋势。
    /// 口径：module_code IN (S1,S7) AND exception_type_code IN
    /// (ORDER_DUE_DATE_DELAY / PRODUCT_DESIGN_DELAY / DELIVERY_DELAY_WARNING)；
    /// 时间字段 created_at；不排除 CLOSED；按日聚合，缺失日期补 0；days 限 1-30；
    /// Total = OrderDueDateDelay + ProductDesignDelay + DeliveryDelayWarning，
    /// 与左侧 S1/S7 summary 总数对齐（PRODUCT_DESIGN_DELAY 属于 S1 stage）。
    /// </summary>
    public async Task<AdoS8DeliveryTrendDto> GetDeliveryTrendAsync(long tenantId, int days = 7, string? period = null)
    {
        var plan = ResolveTrendWindow(period, days);
        var from = plan.QueryFrom;
        var toExclusive = plan.QueryToExclusive;
        var effectiveDays = plan.Buckets.Count;

        var deliveryModules = new[] { "S1", "S7" };
        var deliveryTypes = new[] { "ORDER_DUE_DATE_DELAY", "PRODUCT_DESIGN_DELAY", "DELIVERY_DELAY_WARNING", "SHIPMENT_ABNORMAL" };

        var rows = await _rep.AsQueryable()
            .Where(e => e.TenantId == tenantId && !e.IsDeleted)
            .Where(e => deliveryModules.Contains(e.StageCode))
            .Where(e => e.ExceptionTypeCode != null && deliveryTypes.Contains(e.ExceptionTypeCode))
            .Where(e => e.CreatedAt >= from && e.CreatedAt < toExclusive)
            .Select(e => new { e.ExceptionTypeCode, e.CreatedAt })
            .ToListAsync();

        var byDate = rows
            .GroupBy(r => r.CreatedAt.Date)
            .ToDictionary(g => g.Key, g => g.ToList());

        var dayList = new List<AdoS8DeliveryTrendDayDto>(effectiveDays);
        foreach (var d in plan.Buckets)
        {
            var bucket = byDate.TryGetValue(d, out var list) ? list : new();
            var orderDueDateDelay    = bucket.Count(r => r.ExceptionTypeCode == "ORDER_DUE_DATE_DELAY");
            var productDesignDelay   = bucket.Count(r => r.ExceptionTypeCode == "PRODUCT_DESIGN_DELAY");
            var deliveryDelayWarning = bucket.Count(r => r.ExceptionTypeCode == "DELIVERY_DELAY_WARNING");
            var shipmentAbnormal     = bucket.Count(r => r.ExceptionTypeCode == "SHIPMENT_ABNORMAL");
            dayList.Add(new AdoS8DeliveryTrendDayDto
            {
                Date                 = d.ToString("MM/dd"),
                RawDate              = d.ToString("yyyy-MM-dd"),
                OrderDueDateDelay    = orderDueDateDelay,
                ProductDesignDelay   = productDesignDelay,
                DeliveryDelayWarning = deliveryDelayWarning,
                ShipmentAbnormal     = shipmentAbnormal,
                Total                = orderDueDateDelay + productDesignDelay + deliveryDelayWarning + shipmentAbnormal,
            });
        }

        return new AdoS8DeliveryTrendDto
        {
            Days = dayList,
            Summary = BuildTrendSummary(plan, dayList.Select(d => (d.Total, d.RawDate)).ToList()),
        };
    }

    /// <summary>
    /// S8-PRODUCTION-PAGE-TYPE-TITLE-AND-TREND-ALIGN-1：Production 页近 N 日生产异常趋势。
    /// 口径：module_code IN (S2,S6) AND exception_type_code IN
    /// (EQUIP_FAULT / MFG_MATERIAL_ABNORMAL / MFG_QUALITY_ABNORMAL / BODY_PRODUCTION_DELAY_WARNING)；
    /// 时间字段 created_at；不排除 CLOSED；按日聚合，缺失日期补 0；days 限 1-30；
    /// Total = EquipmentFault + MaterialFault + QualityFault + BodyProductionDelay，与右侧明细对齐。
    /// </summary>
    public async Task<AdoS8ProductionTrendDto> GetProductionTrendAsync(long tenantId, int days = 7, string? period = null)
    {
        var plan = ResolveTrendWindow(period, days);
        var from = plan.QueryFrom;
        var toExclusive = plan.QueryToExclusive;
        var effectiveDays = plan.Buckets.Count;

        var prodModules = new[] { "S2", "S6" };
        var prodTypes = new[]
        {
            "EQUIP_FAULT", "MFG_MATERIAL_ABNORMAL", "MFG_QUALITY_ABNORMAL",
            "BODY_PRODUCTION_DELAY_WARNING", "PRODUCTION_WORK_ORDER_COMPLETION_DELAY"
        };

        var rows = await _rep.AsQueryable()
            .Where(e => e.TenantId == tenantId && !e.IsDeleted)
            .Where(e => prodModules.Contains(e.StageCode))
            .Where(e => e.ExceptionTypeCode != null && prodTypes.Contains(e.ExceptionTypeCode))
            .Where(e => e.CreatedAt >= from && e.CreatedAt < toExclusive)
            .Select(e => new { e.ExceptionTypeCode, e.CreatedAt })
            .ToListAsync();

        var byDate = rows.GroupBy(r => r.CreatedAt.Date).ToDictionary(g => g.Key, g => g.ToList());

        var dayList = new List<AdoS8ProductionTrendDayDto>(effectiveDays);
        foreach (var d in plan.Buckets)
        {
            var bucket = byDate.TryGetValue(d, out var list) ? list : new();
            var ef  = bucket.Count(r => r.ExceptionTypeCode == "EQUIP_FAULT");
            var mf  = bucket.Count(r => r.ExceptionTypeCode == "MFG_MATERIAL_ABNORMAL");
            var qf  = bucket.Count(r => r.ExceptionTypeCode == "MFG_QUALITY_ABNORMAL");
            var bpd = bucket.Count(r => r.ExceptionTypeCode == "BODY_PRODUCTION_DELAY_WARNING");
            var pwo = bucket.Count(r => r.ExceptionTypeCode == "PRODUCTION_WORK_ORDER_COMPLETION_DELAY");
            dayList.Add(new AdoS8ProductionTrendDayDto
            {
                Date                                = d.ToString("MM/dd"),
                RawDate                             = d.ToString("yyyy-MM-dd"),
                EquipmentFault                      = ef,
                MaterialFault                       = mf,
                QualityFault                        = qf,
                BodyProductionDelay                 = bpd,
                ProductionWorkOrderCompletionDelay  = pwo,
                Total                               = ef + mf + qf + bpd + pwo,
            });
        }

        return new AdoS8ProductionTrendDto
        {
            Days = dayList,
            Summary = BuildTrendSummary(plan, dayList.Select(d => (d.Total, d.RawDate)).ToList()),
        };
    }

    /// <summary>
    /// S8-SUPPLY-PAGE-TYPE-TOTAL-ALIGN-1：Supply 页近 N 日供应异常趋势。
    /// 口径：module_code IN (S3,S4,S5) AND exception_type_code IN 11 类
    /// （SUPPLIER_ETA_ISSUE / SUPPLIER_SHIP_ISSUE / SUPPLIER_DELIVERY_DELAY_WARNING /
    /// WAREHOUSE_RECEIPT_ABNORMAL / IQC_ISSUE / WH_PUTAWAY_ISSUE /
    /// WORK_ORDER_KITTING_ABNORMAL / WORK_ORDER_ISSUE_ABNORMAL /
    /// PURCHASE_EXECUTION_DELAY / MATERIAL_STOCK_ABNORMAL / INVENTORY_TURNOVER_ABNORMAL）；
    /// 时间字段 created_at；不排除 CLOSED；按日聚合，缺失日期补 0；days 限 1-30；
    /// Total = 11 个字段之和（避免历史 bucket.Count 含未承载类型导致 total 与图线不一致）。
    /// </summary>
    public async Task<AdoS8SupplyTrendDto> GetSupplyTrendAsync(long tenantId, int days = 7, string? period = null)
    {
        var plan = ResolveTrendWindow(period, days);
        var from = plan.QueryFrom;
        var toExclusive = plan.QueryToExclusive;
        var effectiveDays = plan.Buckets.Count;

        var supplyModules = new[] { "S3", "S4", "S5" };
        var supplyTypes = new[]
        {
            "SUPPLIER_ETA_ISSUE", "SUPPLIER_SHIP_ISSUE", "SUPPLIER_DELIVERY_DELAY_WARNING",
            "WAREHOUSE_RECEIPT_ABNORMAL", "IQC_ISSUE", "WH_PUTAWAY_ISSUE",
            "WORK_ORDER_KITTING_ABNORMAL", "WORK_ORDER_ISSUE_ABNORMAL",
            "PURCHASE_EXECUTION_DELAY", "MATERIAL_STOCK_ABNORMAL", "INVENTORY_TURNOVER_ABNORMAL",
            "PURCHASE_DELIVERY_ABNORMAL"
        };

        var rows = await _rep.AsQueryable()
            .Where(e => e.TenantId == tenantId && !e.IsDeleted)
            .Where(e => supplyModules.Contains(e.StageCode))
            .Where(e => e.ExceptionTypeCode != null && supplyTypes.Contains(e.ExceptionTypeCode))
            .Where(e => e.CreatedAt >= from && e.CreatedAt < toExclusive)
            .Select(e => new { e.ExceptionTypeCode, e.CreatedAt })
            .ToListAsync();

        var byDate = rows.GroupBy(r => r.CreatedAt.Date).ToDictionary(g => g.Key, g => g.ToList());

        var dayList = new List<AdoS8SupplyTrendDayDto>(effectiveDays);
        foreach (var d in plan.Buckets)
        {
            var bucket = byDate.TryGetValue(d, out var list) ? list : new();
            var sEta  = bucket.Count(r => r.ExceptionTypeCode == "SUPPLIER_ETA_ISSUE");
            var sShip = bucket.Count(r => r.ExceptionTypeCode == "SUPPLIER_SHIP_ISSUE");
            var sDdw  = bucket.Count(r => r.ExceptionTypeCode == "SUPPLIER_DELIVERY_DELAY_WARNING");
            var whR   = bucket.Count(r => r.ExceptionTypeCode == "WAREHOUSE_RECEIPT_ABNORMAL");
            var iqc   = bucket.Count(r => r.ExceptionTypeCode == "IQC_ISSUE");
            var whP   = bucket.Count(r => r.ExceptionTypeCode == "WH_PUTAWAY_ISSUE");
            var woK   = bucket.Count(r => r.ExceptionTypeCode == "WORK_ORDER_KITTING_ABNORMAL");
            var woI   = bucket.Count(r => r.ExceptionTypeCode == "WORK_ORDER_ISSUE_ABNORMAL");
            var ped   = bucket.Count(r => r.ExceptionTypeCode == "PURCHASE_EXECUTION_DELAY");
            var msa   = bucket.Count(r => r.ExceptionTypeCode == "MATERIAL_STOCK_ABNORMAL");
            var ita   = bucket.Count(r => r.ExceptionTypeCode == "INVENTORY_TURNOVER_ABNORMAL");
            var pda   = bucket.Count(r => r.ExceptionTypeCode == "PURCHASE_DELIVERY_ABNORMAL");
            dayList.Add(new AdoS8SupplyTrendDayDto
            {
                Date                          = d.ToString("MM/dd"),
                RawDate                       = d.ToString("yyyy-MM-dd"),
                SupplierEtaIssue              = sEta,
                SupplierShipIssue             = sShip,
                SupplierDeliveryDelayWarning  = sDdw,
                WarehouseReceiptAbnormal      = whR,
                IqcIssue                      = iqc,
                WarehousePutawayIssue         = whP,
                WorkOrderKittingAbnormal      = woK,
                WorkOrderIssueAbnormal        = woI,
                PurchaseExecutionDelay        = ped,
                MaterialStockAbnormal         = msa,
                InventoryTurnoverAbnormal     = ita,
                PurchaseDeliveryAbnormal      = pda,
                Total                         = sEta + sShip + sDdw + whR + iqc + whP + woK + woI + ped + msa + ita + pda,
            });
        }

        return new AdoS8SupplyTrendDto
        {
            Days = dayList,
            Summary = BuildTrendSummary(plan, dayList.Select(d => (d.Total, d.RawDate)).ToList()),
        };
    }

    // ══════════════ S8-DASHBOARD-P2-SEMANTICS-1（P2-C）：趋势时间语义 ══════════════

    /// <summary>
    /// 解析日粒度趋势的统计窗口与日桶。
    ///
    /// <para>显式 period 优先；未给 period 时回落「最近 <paramref name="days"/> 天」
    /// （零点对齐，上限 30 天，与历史行为一致）。</para>
    ///
    /// <para>关键：<c>last_24h</c> 这类<b>非零点</b>窗口过去会被直接当成桶键，
    /// 与按 <c>CreatedAt.Date</c> 分组的字典永远对不上 ⇒ 趋势恒 0。桶枚举统一交给
    /// <see cref="S8TrendBucketHelper"/>，保证 Σ桶 == 窗口内行数。</para>
    /// </summary>
    private static S8TrendBucketHelper.DayBucketPlan ResolveTrendWindow(string? period, int days)
    {
        var (periodFrom, periodTo) = S8PeriodHelper.Resolve(period);
        if (periodFrom.HasValue && periodTo.HasValue)
            return S8TrendBucketHelper.Resolve(periodFrom.Value, periodTo.Value);

        var effectiveDays = Math.Clamp(days, 1, 30);
        var today = DateTime.Today;
        return S8TrendBucketHelper.Resolve(today.AddDays(-(effectiveDays - 1)), today.AddDays(1), 30);
    }

    /// <summary>
    /// 由日桶汇总出趋势摘要，并把统计窗口一并回传，供前端与独立 SQL 核对口径。
    ///
    /// <para>首尾桶不是完整自然日时（<c>HasPartialEdge</c>，如「过去 24h」），
    /// 「今日 vs 昨日」是半天比全天，<b>不可比</b> ⇒ 环比置 null，不给误导性的百分比。</para>
    /// </summary>
    private static AdoS8DeliveryTrendSummaryDto BuildTrendSummary(
        S8TrendBucketHelper.DayBucketPlan plan,
        IReadOnlyList<(int Total, string RawDate)> dayList)
    {
        var totalSum = dayList.Sum(d => d.Total);
        var peak = dayList.Count == 0 ? default : dayList.OrderByDescending(d => d.Total).First();
        var todayDay = dayList.Count == 0 ? default : dayList[^1];
        var yesterday = dayList.Count >= 2 ? dayList[^2] : default((int, string)?);

        double? changeRate = (plan.HasPartialEdge || yesterday is null || yesterday.Value.Item1 == 0)
            ? null
            : Math.Round((todayDay.Total - yesterday.Value.Item1) * 100.0 / yesterday.Value.Item1, 1);

        return new AdoS8DeliveryTrendSummaryDto
        {
            PeakValue         = peak.Total,
            PeakDate          = peak.Total == 0 ? null : peak.RawDate,
            AvgValue          = dayList.Count == 0 ? 0 : Math.Round(totalSum / (double)dayList.Count, 2),
            TodayValue        = todayDay.Total,
            TodayChangeRate   = changeRate,
            WindowFrom        = plan.QueryFrom.ToString("yyyy-MM-ddTHH:mm:ss"),
            WindowToExclusive = plan.QueryToExclusive.ToString("yyyy-MM-ddTHH:mm:ss"),
            WindowTruncated   = plan.IsTruncated,
            PartialEdgeDays   = plan.HasPartialEdge,
        };
    }

    /// <summary>
    /// S8-SIDEBAR-TYPE-CARD-WINDOW-TOGGLE-1：专题页右侧类型卡按 (domain, window) 统一聚合。
    /// 单一时间窗口下 total / open / closed / avgProcessHours / closeRate 共用同一分母。
    /// 公共过滤：tenant/factory + is_deleted=0 + module_code IN S1-S7 + exception_type_code IN domain 类型集 + created_at IN window。
    /// </summary>
    public async Task<AdoS8DomainTypeMetricsDto> GetDomainTypeMetricsAsync(string domain, string window, long tenantId, string? period = null)
    {
        var d = (domain ?? string.Empty).Trim().ToUpperInvariant();
        var w = (window ?? string.Empty).Trim().ToUpperInvariant();
        if (w != "LAST_24H" && w != "LAST_7D") w = "LAST_24H";

        (string key, string label, string typeCode)[] specs = d switch
        {
            // S8-DELIVERY-PAGE-TYPE-TOTAL-ALIGN-1：Delivery 页类型明细 3 类，与左侧 S1/S7 stage summary 对齐；
            // PRODUCT_DESIGN_DELAY 属于 S1 stage，须计入交付明细才能让左右合计一致。
            // 显示名「总装发货延期」仅作大屏展示，不改 ado_s8_exception_type.type_name。
            "DELIVERY" => new (string, string, string)[]
            {
                ("order-due-date-delay",    "订单交期延期", "ORDER_DUE_DATE_DELAY"),
                ("product-design-delay",    "产品设计延期", "PRODUCT_DESIGN_DELAY"),
                ("delivery-delay-warning",  "总装发货延期", "DELIVERY_DELAY_WARNING"),
                ("shipment-abnormal",       "发运异常",     "SHIPMENT_ABNORMAL"),
            },
            "PRODUCTION" => new (string, string, string)[]
            {
                ("equipment-fault",                          "设备异常",         "EQUIP_FAULT"),
                ("material-fault",                           "物料异常",         "MFG_MATERIAL_ABNORMAL"),
                ("quality-fault",                            "质量异常",         "MFG_QUALITY_ABNORMAL"),
                // S8-PRODUCTION-PAGE-TYPE-TITLE-AND-TREND-ALIGN-1：大屏显示「本体生产延期」（去预警），
                // typeCode 保持 BODY_PRODUCTION_DELAY_WARNING，不改 ado_s8_exception_type.type_name。
                ("body-production-delay-warning",            "本体生产延期",     "BODY_PRODUCTION_DELAY_WARNING"),
                ("production-work-order-completion-delay",   "工单完工延期",     "PRODUCTION_WORK_ORDER_COMPLETION_DELAY"),
            },
            "SUPPLY" => new (string, string, string)[]
            {
                // S8-SUPPLY-PAGE-TYPE-TOTAL-ALIGN-1：SUPPLY 大屏明细 11 类，与左侧 S3/S4/S5 stage summary 对齐。
                // 新增 SUPPLIER_DELIVERY_DELAY_WARNING (S3) / MATERIAL_STOCK_ABNORMAL (S5) / INVENTORY_TURNOVER_ABNORMAL (S5)，
                // 显示名沿用 DB type_name 既有命名，不改 ado_s8_exception_type.type_name。
                ("supplier-reply-delay",           "供应商回复交期异常",   "SUPPLIER_ETA_ISSUE"),
                ("supplier-ship-fault",            "供应商发货异常",       "SUPPLIER_SHIP_ISSUE"),
                ("supplier-delivery-delay-warning","供应商交付延期预警",   "SUPPLIER_DELIVERY_DELAY_WARNING"),
                ("warehouse-receipt",              "仓库收货异常",         "WAREHOUSE_RECEIPT_ABNORMAL"),
                ("iqc-inspection",                 "IQC 检验异常",         "IQC_ISSUE"),
                ("warehouse-shelving",             "仓库上架入库异常",     "WH_PUTAWAY_ISSUE"),
                ("work-order-prepare",             "仓库工单备料异常",     "WORK_ORDER_KITTING_ABNORMAL"),
                ("work-order-issue",               "仓库工单发料异常",     "WORK_ORDER_ISSUE_ABNORMAL"),
                ("purchase-execution-delay",       "采购执行延期",         "PURCHASE_EXECUTION_DELAY"),
                ("material-stock-abnormal",        "物料库存异常",         "MATERIAL_STOCK_ABNORMAL"),
                ("inventory-turnover-abnormal",    "库存周转异常",         "INVENTORY_TURNOVER_ABNORMAL"),
                ("purchase-delivery-abnormal",     "采购到货异常",         "PURCHASE_DELIVERY_ABNORMAL"),
            },
            _ => Array.Empty<(string, string, string)>(),
        };

        var typeCodes = specs.Select(s => s.typeCode).ToArray();
        if (typeCodes.Length == 0)
        {
            return new AdoS8DomainTypeMetricsDto { Domain = d, Window = w, Total = 0, Items = new() };
        }

        DateTime from, to;
        var (periodFrom, periodTo) = S8PeriodHelper.Resolve(period);
        if (periodFrom.HasValue && periodTo.HasValue)
        {
            from = periodFrom.Value;
            to   = periodTo.Value;
        }
        else if (w == "LAST_7D")
        {
            // 与 trend 接口保持一致：[today-6, today+1)
            var today = DateTime.Today;
            from = today.AddDays(-6);
            to   = today.AddDays(1);
        }
        else
        {
            // LAST_24H：滑动窗口 NOW()-24h ~ NOW()
            var now = DateTime.Now;
            from = now.AddHours(-24);
            to   = now.AddMinutes(1);
        }

        var rows = await _rep.AsQueryable()
            .Where(e => e.TenantId == tenantId && !e.IsDeleted)
            .Where(e => S8ModuleCode.All.Contains(e.StageCode))
            .Where(e => e.ExceptionTypeCode != null && typeCodes.Contains(e.ExceptionTypeCode))
            .Where(e => e.CreatedAt >= from && e.CreatedAt < to)
            .Select(e => new { e.ExceptionTypeCode, e.Status, e.CreatedAt, e.ClosedAt })
            .ToListAsync();

        var byType = rows.GroupBy(r => r.ExceptionTypeCode!).ToDictionary(g => g.Key, g => g.ToList());

        var items = specs.Select(s =>
        {
            var bucket = byType.TryGetValue(s.typeCode, out var list) ? list : new();
            var total       = bucket.Count;
            var closedCount = bucket.Count(r => r.Status == "CLOSED");
            var openCount   = total - closedCount;
            double? avgHours = null;
            var closedSamples = bucket.Where(r => r.ClosedAt.HasValue).ToList();
            if (closedSamples.Count > 0)
            {
                avgHours = Math.Round(closedSamples.Average(r => (r.ClosedAt!.Value - r.CreatedAt).TotalHours), 1);
            }
            double? closeRate = total == 0 ? null : Math.Round(closedCount * 100.0 / total, 1);
            return new AdoS8DomainTypeMetricItemDto
            {
                Key             = s.key,
                Label           = s.label,
                TypeCode        = s.typeCode,
                Total           = total,
                OpenCount       = openCount,
                ClosedCount     = closedCount,
                AvgProcessHours = avgHours,
                CloseRate       = closeRate,
            };
        }).ToList();

        return new AdoS8DomainTypeMetricsDto
        {
            Domain = d,
            Window = w,
            Total  = items.Sum(i => i.Total),
            Items  = items,
        };
    }

    /// <summary>
    /// 结果 KPI 汇总。来源：ado_s8_monitor_metric WHERE mechanism='RATIO' AND is_result_kpi=1
    /// （保留字典顺序与 metricName）。不写 DB / 不接 period / 不启用 watch_rule。
    ///
    /// <para>S8-REAL-DATA-PRESENTATION-1 当前口径：
    /// <c>IQC_PASS_RATE</c> → <c>DEMO_BASELINE</c>（常量，前端「当前基线」，如实标注）；
    /// 其余全部 → <c>PENDING_REAL</c>（无当前值，前端「待真实接入」）。
    /// 曾经的 <c>ORDER_FLOW_CALC</c> 一路已全部撤除——它算的是 seed，详见
    /// <see cref="ComputeResultKpiCurrentAsync"/>。</para>
    ///
    /// <para>⚠️ 本段历史注释曾写「4 个 KPI → DEMO_BASELINE / 1 个 → ORDER_FLOW_CALC」，
    /// 与其后的实现长期不符（实际是 4 个走 ORDER_FLOW_CALC、仅 IQC 走 DEMO_BASELINE）。
    /// 已按现行实现改写，勿再据旧文案推断行为。</para>
    /// </summary>
    /// <summary>
    /// S8-CONFIG-AUTHORITY-FIX-1：结果 KPI 的「覆盖解析 → 启用门禁」。
    ///
    /// <b>为什么门禁必须在覆盖解析之后</b>：候选行同时含平台全局行（tenant/factory=0）与租户覆盖行。
    /// 若把 <c>Enabled</c> 下推成 SQL 的 WHERE，租户停用某指标（override enabled=false）时该行会先被滤掉，
    /// 分组里只剩 enabled=true 的全局行，结果反而回落成「显示」——与用户的停用意图完全相反。
    /// 因此：先按 工厂行 &gt; 租户行 &gt; 全局行 定出唯一 EffectiveMetric，再判它的 Enabled。
    ///
    /// 本方法只做纳入与否的门禁，<b>不参与任何 KPI 数值计算</b>；
    /// 也只作用于结果 KPI 路径，不影响 Rule 向导消费的机制字典（mechanism = DATE / VALUE_RANGE）。
    /// internal 暴露供契约测试直接驱动（沿用 evaluator EvaluateRows 的既有范式）。
    /// </summary>
    internal static List<AdoS8MonitorMetric> ResolveEnabledEffectiveResultKpis(IEnumerable<AdoS8MonitorMetric> candidateRows) =>
        candidateRows
            .GroupBy(x => x.MetricCode)
            .Select(g => g.OrderByDescending(x => x.TenantId != S8ConfigScope.GlobalTenantId).First())
            .Where(m => m.Enabled)
            .OrderBy(x => x.SortNo)
            .ThenBy(x => x.MetricCode)
            .ToList();

    public async Task<AdoS8ResultKpiSummaryDto> GetResultKpiSummaryAsync(long tenantId)
    {
        var rows = await _metricRep.AsQueryable()
            .Where(x => x.Mechanism == "RATIO" && x.IsResultKpi
                && (x.TenantId == S8ConfigScope.GlobalTenantId || x.TenantId == tenantId))
            .ToListAsync();

        var resolved = ResolveEnabledEffectiveResultKpis(rows);

        var items = new List<AdoS8ResultKpiItemDto>(resolved.Count);
        foreach (var m in resolved)
        {
            var unit = string.IsNullOrWhiteSpace(m.Unit) ? "%" : m.Unit!;

            // S8-STEP4-KPI-CURRENT-VALUE-CLOSURE-1：CurrentValue 优先走订单链路真实聚合；
            // 仅 IQC_PASS_RATE 因 S8 无权威 IQC 源，保留 DEMO_BASELINE（provenance 由 Source 字段如实标注）。
            var computed = await ComputeResultKpiCurrentAsync(m.MetricCode, tenantId);
            if (computed != null)
            {
                items.Add(new AdoS8ResultKpiItemDto
                {
                    MetricCode = m.MetricCode,
                    MetricName = m.MetricName,
                    ObjectCode = m.ObjectCode,
                    Unit = unit,
                    CurrentValue = computed.Value.CurrentValue,
                    // S8-CONFIG-GLOBAL-ROW-SEMANTICS-AND-KPI-TARGET-1：目标值是 DB 唯一事实源
                    // （工厂覆盖 > 平台默认），与 CurrentValue 完全解耦；未配置时返回 null，
                    // 前端显示「目标 待配置」，不做 C# 常量兜底。
                    TargetRatio = ResolveEffectiveTarget(m),
                    DictionaryEnabled = true,
                    Remark = computed.Value.Remark,
                    Source = computed.Value.Source,
                });
            }
            else if (_demoBaselineMap.TryGetValue(m.MetricCode, out var baseline))
            {
                items.Add(new AdoS8ResultKpiItemDto
                {
                    MetricCode = m.MetricCode,
                    MetricName = m.MetricName,
                    ObjectCode = m.ObjectCode,
                    Unit = unit,
                    CurrentValue = baseline.CurrentValue,
                    TargetRatio = ResolveEffectiveTarget(m),
                    DictionaryEnabled = true,
                    Remark = baseline.Remark,
                    Source = "DEMO_BASELINE",
                });
            }
            else
            {
                items.Add(new AdoS8ResultKpiItemDto
                {
                    MetricCode = m.MetricCode,
                    MetricName = m.MetricName,
                    ObjectCode = m.ObjectCode,
                    Unit = unit,
                    CurrentValue = null,
                    TargetRatio = m.DefaultTargetRatio,
                    DictionaryEnabled = false,
                    Remark = m.Remark,
                    Source = "PENDING_REAL",
                });
            }
        }

        // S8-REAL-DATA-PRESENTATION-1：envelope 的 provenance 必须由 items 真实构成推出。
        // 旧实现无条件写死 "MIXED_BASELINE"，前端渲染「当前基线 · 部分订单链路计算」——
        // 在 items 为空（当前实况：字典 5 行全部 enabled=0）或全部为基线/待接入时，
        // 这句话是一个没有任何计算支撑的断言，属于把「没算」说成「部分算了」。
        var hasRealCalc = items.Exists(i => i.Source == "ORDER_FLOW_CALC");
        return new AdoS8ResultKpiSummaryDto
        {
            Items = items,
            Source = hasRealCalc ? "MIXED_BASELINE" : "DICTIONARY_MOCK",
        };
    }

    /// <summary>
    /// KPI 当前值演示基线。S8-CONFIG-GLOBAL-ROW-SEMANTICS-AND-KPI-TARGET-1 已把 TargetRatio 从本 map 解耦
    /// （目标值由 ado_s8_monitor_metric.default_target_ratio 承载），本 map 只保留 CurrentValue 与 Remark。
    /// S8-STEP4-KPI-CURRENT-VALUE-CLOSURE-1：ORDER_DELIVERY_RATE / PO_DELIVERY_RATE / WO_COMPLETION_RATE
    /// 三项已迁到订单链路真实聚合（见 ComputeResultKpiCurrentAsync），从本 map 移除。
    /// 仅 IQC_PASS_RATE 保留——S8 域内无任何权威 IQC 检验源表（IQC 明细归属 S6 qms_gcjydzb，未纳入 S8 订单链路），
    /// 因此它是**演示基线而非实算**，由 Source="DEMO_BASELINE" 如实对外标注，前端文案为「当前基线」。
    /// </summary>
    private static readonly Dictionary<string, (decimal CurrentValue, string Remark)> _demoBaselineMap = new()
    {
        ["IQC_PASS_RATE"] = (96.0m, "演示基线（非实算）：S8 域内无权威 IQC 检验源表，待接入后改为真实计算"),
    };

    /// <summary>
    /// S8-REAL-DATA-PRESENTATION-1：结果 KPI「当前值」的真实 Authority 分发点。
    /// 返回 null = 该指标当前没有真实计算，调用方回落 DEMO_BASELINE / PENDING_REAL。
    ///
    /// <para><b>这里为什么一个计算都没有了</b>：ORDER_DELIVERY_RATE / PO_DELIVERY_RATE /
    /// WO_COMPLETION_RATE / ORDER_FLOW_CYCLE_RATIO 此前分别读
    /// <c>ado_s8_order_flow_order</c> / <c>_procurement_pivot</c> / <c>_manufacturing_process</c> /
    /// <c>_stage</c>，并以 <c>Source="ORDER_FLOW_CALC"</c>（前端渲染「订单链路计算」）
    /// 宣称是对当前业务的实算。但这四张表**唯一的写入方是 SeedData**，实库全部行
    /// <c>data_source='SEED'</c>，四个查询也从不过滤 SEED —— 数字不是业务事实，标注是错的。</para>
    ///
    /// <para><b>为何不改成读中台而是直接不出值</b>（逐项核对，四项均无等价 Authority）：
    /// <list type="bullet">
    ///   <item>ORDER_DELIVERY_RATE：<c>dwd_t8_order_shipment_fulfillment</c> 是「行级发运及时率 / 按 biz_date」，
    ///         与「订单周期 actual &lt;= target」不同口径，换算须自行发明时间窗并改分母粒度；</item>
    ///   <item>PO_DELIVERY_RATE：<c>mdp_std_purchase_order_completion</c> **既无承诺到期日、也无实际到货日**
    ///         （<c>observed_at</c> / <c>source_update_time</c> 在表注释中被明确标注「禁止冒充业务完成时间」），
    ///         按期到货率在现有中台里根本不可算；</item>
    ///   <item>WO_COMPLETION_RATE：<c>dwd_t8_work_order_mfg_fulfillment</c> 粒度是
    ///         (biz_date, 工单, 物料) 的窗口完成率，与「工序 achievement_rate 算术平均」不同，
    ///         换算须自行选定 biz_date 与再聚合规则；</item>
    ///   <item>ORDER_FLOW_CYCLE_RATIO：中台没有任何对象承载 S8 五阶段的 planned/actual days。</item>
    /// </list>
    /// 按「不得为了保住卡片而发明公式」的口径，四项一律不出当前值，落 PENDING_REAL
    /// （前端「待真实接入」），与 IQC_PASS_RATE 的如实标注是同一范式。</para>
    ///
    /// <para>⚠️ 真实 Authority 就位后在此接回并改回具体 Source；
    /// <b>不要改回读 ado_s8_order_flow_*</b> —— 那是 seed，不是业务事实。</para>
    /// </summary>
    private static Task<(decimal? CurrentValue, string Source, string Remark)?> ComputeResultKpiCurrentAsync(
        string metricCode, long tenantId)
    {
        _ = metricCode;
        _ = tenantId;
        return Task.FromResult<(decimal? CurrentValue, string Source, string Remark)?>(null);
    }


    /// <summary>
    /// 生效目标值：rows 已按 (0,0) 平台默认 ‖ 本租户覆盖取回并按「租户行优先」去重，
    /// 因此 <paramref name="m"/> 本身即生效行，直接取其 default_target_ratio。
    /// 未配置返回 null —— 由 DB 作为唯一事实源，不回落任何 C# 常量。
    /// </summary>
    private static decimal? ResolveEffectiveTarget(AdoS8MonitorMetric m) => m.DefaultTargetRatio;

}