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;
    // S9-RESULT-KPI-DEMO-BASELINE-AND-ORDER-FLOW-CALC-1：ORDER_FLOW_CYCLE_RATIO 半真实计算依赖订单链路阶段表
    private readonly SqlSugarRepository<AdoS8OrderFlowStage> _orderFlowStageRep;
    // S8-STEP4-KPI-CURRENT-VALUE-CLOSURE-1：ORDER_DELIVERY_RATE / PO_DELIVERY_RATE / WO_COMPLETION_RATE
    // 由 DEMO_BASELINE 常量改为订单链路真实聚合，各自依赖以下三张表。
    private readonly SqlSugarRepository<AdoS8OrderFlowOrder> _orderFlowOrderRep;
    private readonly SqlSugarRepository<AdoS8OrderFlowProcurementPivot> _procurementPivotRep;
    private readonly SqlSugarRepository<AdoS8OrderFlowManufacturingProcess> _manufacturingProcessRep;

    public S8MonitoringService(
        SqlSugarRepository<AdoS8Exception> rep,
        SqlSugarRepository<AdoS8ExceptionType> typeRep,
        SqlSugarRepository<AdoS0DepartmentMaster> deptRep,
        SqlSugarRepository<AdoS8MonitorMetric> metricRep,
        SqlSugarRepository<AdoS8OrderFlowStage> orderFlowStageRep,
        SqlSugarRepository<AdoS8OrderFlowOrder> orderFlowOrderRep,
        SqlSugarRepository<AdoS8OrderFlowProcurementPivot> procurementPivotRep,
        SqlSugarRepository<AdoS8OrderFlowManufacturingProcess> manufacturingProcessRep)
    {
        _rep = rep;
        _typeRep = typeRep;
        _deptRep = deptRep;
        _metricRep = metricRep;
        _orderFlowStageRep = orderFlowStageRep;
        _orderFlowOrderRep = orderFlowOrderRep;
        _procurementPivotRep = procurementPivotRep;
        _manufacturingProcessRep = manufacturingProcessRep;
    }

    /// <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,
                Frequency       = total,
                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)
    {
        DateTime from, toExclusive;
        int effectiveDays;
        var (periodFrom, periodTo) = S8PeriodHelper.Resolve(period);
        if (periodFrom.HasValue && periodTo.HasValue)
        {
            from = periodFrom.Value;
            toExclusive = periodTo.Value;
            effectiveDays = Math.Max(1, Math.Min(90, (int)(toExclusive - from).TotalDays));
        }
        else
        {
            effectiveDays = Math.Clamp(days, 1, 30);
            var today = DateTime.Today;
            from = today.AddDays(-(effectiveDays - 1));
            toExclusive = today.AddDays(1);
        }

        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);
        for (var i = 0; i < effectiveDays; i++)
        {
            var d = from.AddDays(i);
            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,
            });
        }

        var totalSum = dayList.Sum(d => d.Total);
        var peak = dayList.OrderByDescending(d => d.Total).FirstOrDefault();
        var todayDay = dayList.Last();
        var yesterday = dayList.Count >= 2 ? dayList[^2] : null;
        double? changeRate = (yesterday is null || yesterday.Total == 0)
            ? (double?)null
            : Math.Round((todayDay.Total - yesterday.Total) * 100.0 / yesterday.Total, 1);

        var summary = new AdoS8DeliveryTrendSummaryDto
        {
            PeakValue       = peak?.Total ?? 0,
            PeakDate        = (peak is null || peak.Total == 0) ? null : peak.RawDate,
            AvgValue        = Math.Round(totalSum / (double)effectiveDays, 2),
            TodayValue      = todayDay.Total,
            TodayChangeRate = changeRate,
        };

        return new AdoS8DeliveryTrendDto { Days = dayList, Summary = summary };
    }

    /// <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)
    {
        DateTime from, toExclusive;
        int effectiveDays;
        var (periodFrom, periodTo) = S8PeriodHelper.Resolve(period);
        if (periodFrom.HasValue && periodTo.HasValue)
        {
            from = periodFrom.Value;
            toExclusive = periodTo.Value;
            effectiveDays = Math.Max(1, Math.Min(90, (int)(toExclusive - from).TotalDays));
        }
        else
        {
            effectiveDays = Math.Clamp(days, 1, 30);
            var today = DateTime.Today;
            from = today.AddDays(-(effectiveDays - 1));
            toExclusive = today.AddDays(1);
        }

        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);
        for (var i = 0; i < effectiveDays; i++)
        {
            var d = from.AddDays(i);
            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,
            });
        }

        var totalSum = dayList.Sum(d => d.Total);
        var peak = dayList.OrderByDescending(d => d.Total).FirstOrDefault();
        var todayDay = dayList.Last();
        var yesterday = dayList.Count >= 2 ? dayList[^2] : null;
        double? changeRate = (yesterday is null || yesterday.Total == 0)
            ? (double?)null
            : Math.Round((todayDay.Total - yesterday.Total) * 100.0 / yesterday.Total, 1);

        var summary = new AdoS8DeliveryTrendSummaryDto
        {
            PeakValue       = peak?.Total ?? 0,
            PeakDate        = (peak is null || peak.Total == 0) ? null : peak.RawDate,
            AvgValue        = Math.Round(totalSum / (double)effectiveDays, 2),
            TodayValue      = todayDay.Total,
            TodayChangeRate = changeRate,
        };

        return new AdoS8ProductionTrendDto { Days = dayList, Summary = summary };
    }

    /// <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)
    {
        DateTime from, toExclusive;
        int effectiveDays;
        var (periodFrom, periodTo) = S8PeriodHelper.Resolve(period);
        if (periodFrom.HasValue && periodTo.HasValue)
        {
            from = periodFrom.Value;
            toExclusive = periodTo.Value;
            effectiveDays = Math.Max(1, Math.Min(90, (int)(toExclusive - from).TotalDays));
        }
        else
        {
            effectiveDays = Math.Clamp(days, 1, 30);
            var today = DateTime.Today;
            from = today.AddDays(-(effectiveDays - 1));
            toExclusive = today.AddDays(1);
        }

        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);
        for (var i = 0; i < effectiveDays; i++)
        {
            var d = from.AddDays(i);
            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,
            });
        }

        var totalSum = dayList.Sum(d => d.Total);
        var peak = dayList.OrderByDescending(d => d.Total).FirstOrDefault();
        var todayDay = dayList.Last();
        var yesterday = dayList.Count >= 2 ? dayList[^2] : null;
        double? changeRate = (yesterday is null || yesterday.Total == 0)
            ? (double?)null
            : Math.Round((todayDay.Total - yesterday.Total) * 100.0 / yesterday.Total, 1);

        var summary = new AdoS8DeliveryTrendSummaryDto
        {
            PeakValue       = peak?.Total ?? 0,
            PeakDate        = (peak is null || peak.Total == 0) ? null : peak.RawDate,
            AvgValue        = Math.Round(totalSum / (double)effectiveDays, 2),
            TodayValue      = todayDay.Total,
            TodayChangeRate = changeRate,
        };

        return new AdoS8SupplyTrendDto { Days = dayList, Summary = summary };
    }

    /// <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>
    /// S9-RESULT-KPI-DEMO-BASELINE-AND-ORDER-FLOW-CALC-1：A+B 混合方案。
    /// 4 个 KPI（ORDER_DELIVERY_RATE/PO_DELIVERY_RATE/IQC_PASS_RATE/WO_COMPLETION_RATE）→ DEMO_BASELINE 演示基线；
    /// 1 个 KPI（ORDER_FLOW_CYCLE_RATIO）→ ORDER_FLOW_CALC 基于 ado_s8_order_flow_stage 半真实计算；
    /// 不写 DB / 不接 period / 不启用 watch_rule。
    /// 来源：ado_s8_monitor_metric WHERE mechanism='RATIO' AND is_result_kpi=1（保留字典顺序与 metricName）。
    /// </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",
                });
            }
        }

        return new AdoS8ResultKpiSummaryDto
        {
            Items = items,
            Source = "MIXED_BASELINE",
        };
    }

    /// <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-STEP4-KPI-CURRENT-VALUE-CLOSURE-1：结果 KPI 当前值的真实聚合分发。
    /// 返回 null 表示该指标不由订单链路计算（调用方回落 DEMO_BASELINE / PENDING_REAL）。
    /// 统一口径：只统计 tenant/factory 内未删除、且 <c>order_code</c> 非空的**订单关联业务记录**；
    /// order_code 为空的 BASELINE_PPT / DEMO 演示装置行不是业务记录，一律排除。
    /// </summary>
    private async Task<(decimal? CurrentValue, string Source, string Remark)?> ComputeResultKpiCurrentAsync(
        string metricCode, long tenantId) => metricCode switch
    {
        "ORDER_DELIVERY_RATE"    => await ComputeOrderDeliveryRateAsync(tenantId),
        "PO_DELIVERY_RATE"       => await ComputePoDeliveryRateAsync(tenantId),
        "WO_COMPLETION_RATE"     => await ComputeWoCompletionRateAsync(tenantId),
        "ORDER_FLOW_CYCLE_RATIO" => await ComputeOrderFlowCycleRatioItemAsync(tenantId),
        _ => null,
    };

    /// <summary>
    /// 订单交付满足率 = 已完工订单中 actual_cycle_days &lt;= target_cycle_days 的占比。
    /// 分母只含 actual_cycle_days 已回填的订单（在制订单尚无实际周期，纳入会系统性低估）。
    /// </summary>
    private async Task<(decimal? CurrentValue, string Source, string Remark)> ComputeOrderDeliveryRateAsync(
        long tenantId)
    {
        var rows = await _orderFlowOrderRep.AsQueryable()
            .Where(x => !x.IsDeleted && x.TenantId == tenantId
                && x.ActualCycleDays != null)
            .Select(x => new { x.ActualCycleDays, x.TargetCycleDays })
            .ToListAsync();
        const string remark = "基于订单链路已完工订单 actual_cycle_days/target_cycle_days 计算，在制订单不纳入分母";
        if (rows.Count == 0) return (null, "ORDER_FLOW_CALC_EMPTY", remark);
        var numerator = rows.Count(x => x.ActualCycleDays!.Value <= x.TargetCycleDays);
        return (Math.Round(numerator * 100m / rows.Count, 1), "ORDER_FLOW_CALC", remark);
    }

    /// <summary>
    /// 到货达成率 = 采购透视中 status='green'（按期到货）的占比；yellow/red 均计入分母。
    /// </summary>
    private async Task<(decimal? CurrentValue, string Source, string Remark)> ComputePoDeliveryRateAsync(
        long tenantId)
    {
        var rows = await _procurementPivotRep.AsQueryable()
            .Where(x => !x.IsDeleted && x.TenantId == tenantId
                && x.OrderCode != null && x.OrderCode != "")
            .Select(x => x.Status)
            .ToListAsync();
        const string remark = "基于订单关联采购透视 status 计算：green 为按期到货，yellow/red 计入分母";
        if (rows.Count == 0) return (null, "ORDER_FLOW_CALC_EMPTY", remark);
        var numerator = rows.Count(s => s == "green");
        return (Math.Round(numerator * 100m / rows.Count, 1), "ORDER_FLOW_CALC", remark);
    }

    /// <summary>
    /// 工单完工率 = 订单关联制造工序 achievement_rate 的算术平均（存储为 0~1 比率，×100 转百分比）。
    /// </summary>
    private async Task<(decimal? CurrentValue, string Source, string Remark)> ComputeWoCompletionRateAsync(
        long tenantId)
    {
        var rows = await _manufacturingProcessRep.AsQueryable()
            .Where(x => !x.IsDeleted && x.TenantId == tenantId
                && x.OrderCode != null && x.OrderCode != "" && x.AchievementRate != null)
            .Select(x => x.AchievementRate)
            .ToListAsync();
        const string remark = "基于订单关联制造工序 achievement_rate 平均值计算（0~1 比率换算百分比）";
        if (rows.Count == 0) return (null, "ORDER_FLOW_CALC_EMPTY", remark);
        return (Math.Round(rows.Sum(x => x!.Value) * 100m / rows.Count, 1), "ORDER_FLOW_CALC", remark);
    }

    /// <summary>ORDER_FLOW_CYCLE_RATIO 适配到统一分发签名；计算逻辑保持不变。</summary>
    private async Task<(decimal? CurrentValue, string Source, string Remark)> ComputeOrderFlowCycleRatioItemAsync(
        long tenantId)
    {
        var (cv, source) = await ComputeOrderFlowCycleRatioAsync(tenantId);
        return (cv, source, "基于已完成订单链路阶段 actual_days/planned_days 计算，pending 阶段暂不纳入");
    }

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

    /// <summary>
    /// 候选 A：actual_days IS NOT NULL 的已完成阶段中 actual_days <= planned_days 的占比。
    /// pending 阶段不纳入 denominator；不依赖 status 字段；按 tenant 过滤（S8-TENANT-ONLY-BATCH6）。
    /// </summary>
    private async Task<(decimal? CurrentValue, string Source)> ComputeOrderFlowCycleRatioAsync(long tenantId)
    {
        try
        {
            var stages = await _orderFlowStageRep.AsQueryable()
                .Where(x => !x.IsDeleted && x.TenantId == tenantId
                    && x.ActualDays != null)
                .Select(x => new { x.ActualDays, x.PlannedDays })
                .ToListAsync();

            var denominator = stages.Count;
            if (denominator == 0) return (null, "ORDER_FLOW_CALC_EMPTY");

            var numerator = stages.Count(s => s.ActualDays!.Value <= s.PlannedDays);
            var value = Math.Round(numerator * 100m / denominator, 1);
            return (value, "ORDER_FLOW_CALC");
        }
        catch
        {
            return (null, "ORDER_FLOW_CALC_EMPTY");
        }
    }
}