package cn.iocoder.yudao.module.qcreport.engine.report;

import cn.iocoder.yudao.module.qcreport.engine.Paths;
import cn.iocoder.yudao.module.qcreport.engine.QualityResult;
import cn.iocoder.yudao.module.qcreport.engine.context.InspectionItem;
import cn.iocoder.yudao.module.qcreport.engine.context.ReportContext;
import cn.iocoder.yudao.module.qcreport.engine.context.ReportFields;
import cn.iocoder.yudao.module.qcreport.engine.rule.QualityRuleDefinition;
import cn.iocoder.yudao.module.qcreport.engine.rule.RuleEngine;
import cn.iocoder.yudao.module.qcreport.engine.rule.RuleScope;

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Map;

/**
 * 报告判定。
 * <p>
 * 在渲染前把检验项算成 PASS/FAIL，并汇总出报告结论与合格率。
 * 判定只发生在这里，组件与模板都不做计算，保证同一份数据在任何模板下判定一致。
 * <p>
 * 与前端 {@code engine/report-evaluator.ts} 一一对应，两边必须算出同一结果。
 */
public final class ReportEvaluator {

    private ReportEvaluator() {
    }

    /**
     * 计算检验项判定与报告汇总。
     * <p>
     * 单个检验项的判定优先级：item 作用域规则 → 规格上下限 → 数据自带结果。
     * 报告级判定默认取「全部检验项合格」，有 report 作用域规则时以规则为准。
     * <p>
     * 不修改传入的上下文，判定后的结果放在返回值里。
     */
    public static EvaluationOutcome evaluate(ReportContext context, List<QualityRuleDefinition> rules) {
        List<String> errors = new ArrayList<>();
        List<QualityRuleDefinition> itemRules = new ArrayList<>();
        List<QualityRuleDefinition> reportRules = new ArrayList<>();
        for (QualityRuleDefinition rule : rules == null ? List.<QualityRuleDefinition>of() : rules) {
            if (rule == null || !rule.active()) {
                continue;
            }
            if (rule.scope() == RuleScope.REPORT) {
                reportRules.add(rule);
            } else {
                itemRules.add(rule);
            }
        }

        List<InspectionItem> source = context.getInspectionItems() == null ? List.of() : context.getInspectionItems();
        List<InspectionItem> items = new ArrayList<>(source.size());
        for (InspectionItem item : source) {
            items.add(item.copy());
        }

        // 无判定依据的项数，只用来把这类项从合格率分母与报告结论里摘出去
        int undecidableCount = 0;

        for (int index = 0; index < items.size(); index++) {
            InspectionItem item = items.get(index);
            if (!itemRules.isEmpty()) {
                // 逐项规则在「单项上下文」里求值：item 指向当前行，index 从 1 开始与报告序号一致
                Map<String, Object> scoped = context.toScope();
                scoped.put("item", ReportContext.itemMap(item));
                scoped.put("index", index + 1);
                boolean passed = true;
                boolean failed = false;
                for (QualityRuleDefinition rule : itemRules) {
                    try {
                        if (!RuleEngine.test(rule.expression(), scoped)) {
                            passed = false;
                        }
                    } catch (RuntimeException error) {
                        failed = true;
                        errors.add("第 " + (index + 1) + " 项「" + orEmpty(item.getItemName()) + "」的规则「"
                                + rule.rawLabel() + "」无法执行：" + error.getMessage());
                    }
                }
                item.applyResult(failed ? null : (passed ? QualityResult.PASS : QualityResult.FAIL));
                continue;
            }

            QualityResult byLimit = evaluateByLimit(item);
            if (byLimit != null) {
                item.applyResult(byLimit);
                continue;
            }

            QualityResult existing = QualityResult.of(item.getResult());
            if (existing == null) {
                // 既没有规则、也没有判定依据：如实标出来，不要默认合格
                item.applyUndecidable();
                undecidableCount++;
                errors.add("第 " + (index + 1) + " 项「"
                        + (isBlank(item.getItemName()) ? "未命名" : item.getItemName())
                        + "」没有规格上下限也没有判定规则，无法判定");
                continue;
            }
            item.applyResult(existing);
        }

        int passCount = 0;
        int failCount = 0;
        for (InspectionItem item : items) {
            if (QualityResult.PASS.name().equals(item.getResult())) {
                passCount++;
            } else if (QualityResult.FAIL.name().equals(item.getResult())) {
                failCount++;
            }
        }
        int total = items.size();
        // 合格率的分母只算「能判定」的项，无判定规则的项既不加分也不减分
        int decidableCount = total - undecidableCount;

        QualityResult verdict = null;
        if (!reportRules.isEmpty()) {
            Map<String, Object> scoped = context.scope(items);
            scoped.put("index", 0);
            boolean passed = true;
            boolean failed = false;
            for (QualityRuleDefinition rule : reportRules) {
                try {
                    if (!RuleEngine.test(rule.expression(), scoped)) {
                        passed = false;
                    }
                } catch (RuntimeException error) {
                    failed = true;
                    errors.add("报告级规则「" + rule.rawLabel() + "」无法执行：" + error.getMessage());
                }
            }
            verdict = failed ? null : (passed ? QualityResult.PASS : QualityResult.FAIL);
        } else if (decidableCount > 0) {
            // 只有「全部可判定项都合格」才给合格结论。无判定规则的项不参与，它们没有对错可言。
            // 存在待判定项（规则跑挂）时不给结论：没验过不能说合格，没证据也不能说不合格，
            // 否则会出现「结论合格、合格率 0%」这种自相矛盾的报告。
            if (failCount > 0) {
                verdict = QualityResult.FAIL;
            } else if (passCount == decidableCount) {
                verdict = QualityResult.PASS;
            }
        }

        ReportFields report = context.getReport().copy()
                .setTotal(total)
                .setPassCount(passCount)
                .setFailCount(failCount)
                .setPassRate(formatPassRate(passCount, decidableCount))
                .applyResult(verdict);
        return new EvaluationOutcome(new ReportContext().setReport(report).setInspectionItems(items), errors);
    }

    /** 用规格上下限判定单项：实测值不在区间内即不合格 */
    private static QualityResult evaluateByLimit(InspectionItem item) {
        double actual = Paths.toNumber(item.getActualValue());
        if (!Double.isFinite(actual)) {
            return null;
        }
        boolean hasUpper = item.getUpperLimit() != null && Double.isFinite(item.getUpperLimit());
        boolean hasLower = item.getLowerLimit() != null && Double.isFinite(item.getLowerLimit());
        if (!hasUpper && !hasLower) {
            return null;
        }
        if (hasUpper && actual > item.getUpperLimit()) {
            return QualityResult.FAIL;
        }
        if (hasLower && actual < item.getLowerLimit()) {
            return QualityResult.FAIL;
        }
        return QualityResult.PASS;
    }

    private static String formatPassRate(int passCount, int total) {
        if (total == 0) {
            return "";
        }
        return String.format(Locale.ROOT, "%.2f%%", (double) passCount / total * 100);
    }

    private static String orEmpty(String value) {
        return value == null ? "" : value;
    }

    private static boolean isBlank(String value) {
        return value == null || value.isEmpty();
    }

}