using Admin.NET.Plugin.AiDOP.Dto.S0.Quality;

namespace Admin.NET.Plugin.AiDOP.Controllers.S0.Quality;

/// <summary>
/// 检验规范聚合（主单 + 检验明细）的必填契约守卫。
///
/// 契约来源：UAT-S0-10 拍板（2026-09-02）。此前四张检规表在前端表单、后端 DTO、DB 列三层
/// 都只约束「文件编号」，导致只填文件编号即可落库空壳检规。本守卫是该契约的唯一实现处，
/// Create / Import 两条写入入口共用，避免再次出现「导入宽于表单」。
///
/// 两条入口的规则不同，刻意分成两个方法：
/// · 新增（Create / Import）——必填字段必须全部有值，且至少 1 条有内容的检验明细；
/// · 编辑（Update）——「历史兼容、禁止劣化」：历史记录原本就缺的字段允许继续为空，
///   但原本有值的必填字段不允许被清空；原本 0 明细允许保持 0，原本有明细不允许删空。
///
/// 【为什么四张检规表的 DTO 上一个 [Required] 都不留】
/// Create 与 Update 共用同一个 UpsertDto。任何 [Required] 都会在 MVC 模型绑定阶段先于本守卫触发，
/// 把 Update 直接挡成 400，从而绕过并破坏 ValidateUpdate(existing, incoming) 的历史兼容语义
/// ——实测 qms_gcjygf 有 3 行 wjbh 为空，正是被遗留的 FileNumber[Required] 锁死不可编辑。
/// 因此「文件编号」的新增必填也统一迁到本守卫，特性层不再承担任何必填职责。
///
/// 【明细归一化】全空明细是 UI 占位行 / Excel 空行，不是业务明细，一律不落库。
/// Create / Update / Import 三条入口都必须先经 Meaningful(...) 过滤，再用过滤结果做数量校验与写入，
/// 保证「校验看到的」与「写进库的」是同一份数据。
/// </summary>
public static class AdoS0QmsSpecAggregateGuard
{
    /// <summary>新增校验。返回 null 表示通过，否则为面向用户的错误文案。</summary>
    public static string? ValidateCreate(IReadOnlyList<(string Label, string? Value)> requiredFields, int meaningfulItemCount)
    {
        foreach (var (label, value) in requiredFields)
        {
            if (string.IsNullOrWhiteSpace(value)) return $"{label}不能为空";
        }
        return meaningfulItemCount > 0 ? null : "检验明细至少需要 1 条";
    }

    /// <summary>编辑校验（历史兼容、禁止劣化）。返回 null 表示通过，否则为面向用户的错误文案。</summary>
    public static string? ValidateUpdate(
        IReadOnlyList<(string Label, string? Existing, string? Incoming)> requiredFields,
        int existingItemCount,
        int incomingMeaningfulItemCount)
    {
        foreach (var (label, existing, incoming) in requiredFields)
        {
            // 原本为空 → 放行（不强制本次补齐）；原本有值 → 不允许清空。
            if (!string.IsNullOrWhiteSpace(existing) && string.IsNullOrWhiteSpace(incoming))
                return $"{label}原本已有值，不允许清空";
        }
        if (existingItemCount > 0 && incomingMeaningfulItemCount == 0)
            return $"该检规原有 {existingItemCount} 条检验明细，不允许全部删除";
        return null;
    }

    // ==================== 明细归一化：过滤全空占位行 ====================
    // 唯一入口。控制器一律用 Meaningful(...) 的返回值同时做数量校验与写库，
    // 不得再各自 Where/Count 一遍，避免「校验一套、写入另一套」。

    public static List<AdoS0QmsRawInspectionSpecEntryDto> Meaningful(IEnumerable<AdoS0QmsRawInspectionSpecEntryDto> items)
        => items.Where(HasValue).ToList();

    public static List<AdoS0QmsProcessInspectionSpecEntryDto> Meaningful(IEnumerable<AdoS0QmsProcessInspectionSpecEntryDto> items)
        => items.Where(HasValue).ToList();

    public static List<AdoS0QmsFqcInspectionSpecEntryDto> Meaningful(IEnumerable<AdoS0QmsFqcInspectionSpecEntryDto> items)
        => items.Where(HasValue).ToList();

    public static List<AdoS0QmsOqcInspectionSpecEntryDto> Meaningful(IEnumerable<AdoS0QmsOqcInspectionSpecEntryDto> items)
        => items.Where(HasValue).ToList();

    // ==================== 明细「有内容」判据 ====================
    // 整行全空的明细不计数、不落库，否则前端 openCreate 自动补的那一行空明细
    // 会让「≥1 条」形同虚设，并持续制造新的空明细脏数据。
    //
    // 导入行（ImportRow）的重载与实体侧同语义，只是模板列少了图像分类/备注/附件等非模板列——
    // 判据仍集中在本类，导入侧不再自带一份定义。

    public static bool HasDetailValue(AdoS0QmsRawInspectionSpecImportRow r)
        => r.Seq.HasValue
           || AnyNotBlank(r.InspectionItem, r.InspectionStandard, r.InspectionMethod,
               r.SamplingScheme, r.UpperLimit, r.LowerLimit);

    public static bool HasDetailValue(AdoS0QmsProcessLikeInspectionSpecImportRow r)
        => AnyNotBlank(r.OperationCode, r.OperationName, r.InspectionItem, r.InspectionMethod,
            r.InspectionSpec, r.InspectionFrequency, r.UpperLimit, r.LowerLimit);

    public static bool HasValue(AdoS0QmsRawInspectionSpecEntryDto e)
        => e.Seq.HasValue
           || AnyNotBlank(e.InspectionItem, e.InspectionStandard, e.InspectionMethod, e.ImageCategory,
               e.SamplingScheme, e.Remark, e.Attachment, e.UpperLimit, e.LowerLimit);

    public static bool HasValue(AdoS0QmsProcessInspectionSpecEntryDto e)
        => e.PeelingForce.HasValue
           || AnyNotBlank(e.OperationCode, e.OperationName, e.InspectionItem, e.InspectionMethod, e.InspectionSpec,
               e.ImageCategory, e.InspectionFrequency, e.TechnicalStandard, e.UpperLimit, e.LowerLimit);

    public static bool HasValue(AdoS0QmsFqcInspectionSpecEntryDto e)
        => e.PeelingForce.HasValue
           || AnyNotBlank(e.OperationCode, e.OperationName, e.InspectionItem, e.InspectionMethod, e.InspectionSpec,
               e.ImageCategory, e.InspectionFrequency, e.TechnicalStandard, e.UpperLimit, e.LowerLimit);

    public static bool HasValue(AdoS0QmsOqcInspectionSpecEntryDto e)
        => e.PeelingForce.HasValue
           || AnyNotBlank(e.OperationCode, e.OperationName, e.InspectionItem, e.InspectionMethod, e.InspectionSpec,
               e.ImageCategory, e.InspectionFrequency, e.TechnicalStandard, e.UpperLimit, e.LowerLimit);

    private static bool AnyNotBlank(params string?[] values)
    {
        foreach (var v in values)
        {
            if (!string.IsNullOrWhiteSpace(v)) return true;
        }
        return false;
    }
}