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

import cn.iocoder.yudao.module.qcreport.dal.dataobject.version.ReportTemplateSchema;
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.report.EvaluationOutcome;
import cn.iocoder.yudao.module.qcreport.engine.report.ReportEvaluator;
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.RuleEvaluator;
import cn.iocoder.yudao.module.qcreport.engine.rule.RuleRuntimeException;
import cn.iocoder.yudao.module.qcreport.engine.rule.RuleScope;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.util.List;
import java.util.Map;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * 判定语义测试。
 * <p>
 * {@link FrontendConformanceTest} 保证后端引擎与前端引擎算得一样，
 * 这里管的是「算得对不对」：判定优先级、为什么不给结论、规则写错时报什么。
 * 其中「待判定不给合格结论」是 Phase 2 修过的一个真实缺陷，下面有用例守着。
 */
class ReportEvaluatorTest {

    /* ------------------------------ 单项判定 ------------------------------ */

    @Test
    @DisplayName("实测值在规格上下限内判合格，超出判不合格")
    void judgesItemByLimits() {
        ReportContext context = ReportContext.empty().setInspectionItems(List.of(
                item("长度", "10.2", 10.5, 9.5),
                item("硬度", "62", 60.0, 50.0),
                item("宽度", "4.9", 5.0, 5.0)));

        List<InspectionItem> items = ReportEvaluator.evaluate(context, List.of()).context().getInspectionItems();

        assertEquals("PASS", items.get(0).getResult());
        assertEquals("合格", items.get(0).getResultText());
        assertEquals("FAIL", items.get(1).getResult());
        assertEquals("不合格", items.get(1).getResultText());
        assertEquals("FAIL", items.get(2).getResult(), "低于下限同样判不合格");
    }

    @Test
    @DisplayName("只有单侧规格时只按有的一侧判")
    void judgesItemWithOneSidedLimit() {
        ReportContext context = ReportContext.empty().setInspectionItems(List.of(
                item("厚度", "0.9", null, 1.0),
                item("重量", "3", 5.0, null)));

        List<InspectionItem> items = ReportEvaluator.evaluate(context, List.of()).context().getInspectionItems();

        assertEquals("FAIL", items.get(0).getResult(), "只给了下限，0.9 低于 1.0");
        assertEquals("PASS", items.get(1).getResult(), "只给了上限，3 没超 5.0");
    }

    @Test
    @DisplayName("逐项规则优先于规格上下限")
    void itemRuleWinsOverLimits() {
        // 实测值明明在上下限内，但规则要求实测值≥50，所以应判不合格
        ReportContext context = ReportContext.empty().setInspectionItems(List.of(item("硬度", "10.2", 10.5, 9.5)));
        List<QualityRuleDefinition> rules = List.of(itemRule("实测值达标", "item.actualValue >= 50"));

        List<InspectionItem> items = ReportEvaluator.evaluate(context, rules).context().getInspectionItems();

        assertEquals("FAIL", items.get(0).getResult(), "有规则时以规则为准，不再看上下限");
    }

    @Test
    @DisplayName("没有规则也没有上下限时取数据自带的结果")
    void fallsBackToDataSuppliedResult() {
        InspectionItem appearance = item("外观", "合格", null, null).setResult("FAIL");
        ReportContext context = ReportContext.empty().setInspectionItems(List.of(appearance));

        List<InspectionItem> items = ReportEvaluator.evaluate(context, List.of()).context().getInspectionItems();

        assertEquals("FAIL", items.get(0).getResult(), "数据里已经填了判定值就直接用");
        assertEquals("不合格", items.get(0).getResultText());
    }

    @Test
    @DisplayName("既无规则也无上下限、数据里也没结果时标为无判定规则并记进问题清单")
    void marksUndecidableItemWithoutVerdict() {
        ReportContext context = ReportContext.empty()
                .setInspectionItems(List.of(item("外观", "无划痕", null, null)));

        EvaluationOutcome outcome = ReportEvaluator.evaluate(context, List.of());
        InspectionItem item = outcome.context().getInspectionItems().get(0);

        assertEquals("", item.getResult());
        assertEquals(QualityResult.UNDECIDABLE_TEXT, item.getResultText());
        assertEquals(1, outcome.errors().size());
        assertEquals("第 1 项「外观」没有规格上下限也没有判定规则，无法判定", outcome.errors().get(0));
        assertEquals(1, outcome.context().getReport().getTotal(), "总数照实算，不因为判不了就不算");
        assertEquals("", outcome.context().getReport().getPassRate(), "一项都判不了时合格率留空而不是 0.00%");
    }

    @Test
    @DisplayName("无判定规则的项不计入合格率分母，也不压住合格结论")
    void undecidableItemIsExcludedFromPassRate() {
        // 「试样质量 m」这类过程参数只供公式取数，没有规格也就无从判定
        ReportContext context = ReportContext.empty().setInspectionItems(List.of(
                item("长度", "10.2", 10.5, 9.5),
                item("试样质量 m", "50.2", null, null)));

        EvaluationOutcome outcome = ReportEvaluator.evaluate(context, List.of());

        assertEquals("PASS", outcome.context().getReport().getResult(), "过程参数不该把全合格的报告压成待判定");
        assertEquals(2, outcome.context().getReport().getTotal(), "总数仍是真实的检验项数");
        assertEquals(1, outcome.context().getReport().getPassCount());
        assertEquals("100.00%", outcome.context().getReport().getPassRate(), "分母只算可判定项");
        assertEquals(QualityResult.UNDECIDABLE_TEXT,
                outcome.context().getInspectionItems().get(1).getResultText());
    }

    @Test
    @DisplayName("规则执行报错时该项不给结论，错误里带上项名与规则名")
    void reportsRuleFailureWithoutVerdict() {
        ReportContext context = ReportContext.empty().setInspectionItems(List.of(item("硬度", "62", 60.0, 50.0)));
        List<QualityRuleDefinition> rules = List.of(itemRule("除零规则", "item.actualValue / 0 > 0"));

        EvaluationOutcome outcome = ReportEvaluator.evaluate(context, rules);
        InspectionItem item = outcome.context().getInspectionItems().get(0);

        assertEquals("", item.getResult(), "规则跑不通就不能说合格也不能说不合格");
        assertEquals(QualityResult.PENDING_TEXT, item.getResultText());
        assertEquals(List.of("第 1 项「硬度」的规则「除零规则」无法执行：规则里出现了除以 0"), outcome.errors());
    }

    /* ------------------------------ 报告汇总 ------------------------------ */

    @Test
    @DisplayName("全部检验项合格才给合格结论，合格率 100%")
    void allPassGivesPassVerdict() {
        ReportContext context = ReportContext.empty().setInspectionItems(List.of(
                item("长度", "10.2", 10.5, 9.5),
                item("宽度", "4.9", 5.0, 4.0)));

        EvaluationOutcome outcome = ReportEvaluator.evaluate(context, List.of());

        assertEquals("PASS", outcome.context().getReport().getResult());
        assertEquals("合格", outcome.context().getReport().getConclusion());
        assertEquals(2, outcome.context().getReport().getTotal());
        assertEquals(2, outcome.context().getReport().getPassCount());
        assertEquals("100.00%", outcome.context().getReport().getPassRate());
    }

    @Test
    @DisplayName("有不合格项就给不合格结论，合格率按比例算")
    void anyFailGivesFailVerdict() {
        ReportContext context = ReportContext.empty().setInspectionItems(List.of(
                item("长度", "10.2", 10.5, 9.5),
                item("硬度", "62", 60.0, 50.0),
                item("宽度", "4.9", 5.0, 4.0)));

        EvaluationOutcome outcome = ReportEvaluator.evaluate(context, List.of());

        assertEquals("FAIL", outcome.context().getReport().getResult());
        assertEquals(2, outcome.context().getReport().getPassCount());
        assertEquals(1, outcome.context().getReport().getFailCount());
        assertEquals("66.67%", outcome.context().getReport().getPassRate());
    }

    /**
     * Phase 2 的真实缺陷：三项里两项合格、一项没验出结论，旧逻辑只数「有没有不合格」，
     * 于是给出「结论合格、合格率 66.67%」这种自相矛盾的报告。没验过的项不能让报告背合格。
     * <p>
     * 「无判定规则」拆分出去之后，「待判定」只剩一个来源：项规则跑挂了。
     * （没规则又没上下限的那种是「无判定规则」，已不计入分母。）所以这条用例改用
     * 一条在「外观」上算不出来的规则来复现。
     */
    @Test
    @DisplayName("存在待判定项时不给合格结论（回归：不得出现「合格 + 合格率不足 100%」）")
    void pendingItemBlocksPassVerdict() {
        ReportContext context = ReportContext.empty().setInspectionItems(List.of(
                item("长度", "10.2", 10.5, 9.5),
                item("宽度", "4.9", 5.0, 4.0),
                item("外观", "无划痕", null, null)));
        // 外观实测值是「无划痕」，数值函数在它身上算不出来 → 该项待判定
        List<QualityRuleDefinition> rules = List.of(itemRule("实测值可算", "ABS(item.actualValue) >= 0"));

        EvaluationOutcome outcome = ReportEvaluator.evaluate(context, rules);

        assertEquals("", outcome.context().getReport().getResult());
        assertEquals(QualityResult.PENDING_TEXT, outcome.context().getReport().getConclusion());
        assertEquals(2, outcome.context().getReport().getPassCount());
        assertEquals(0, outcome.context().getReport().getFailCount(), "待判定既不算合格也不算不合格");
        assertEquals(3, outcome.context().getReport().getTotal());
        assertEquals("66.67%", outcome.context().getReport().getPassRate(), "待判定项仍留在合格率分母里");
    }

    @Test
    @DisplayName("一项都没有时不给结论，合格率留空而不是 0.00%")
    void emptyReportHasNoVerdict() {
        EvaluationOutcome outcome = ReportEvaluator.evaluate(ReportContext.empty(), List.of());

        assertEquals("", outcome.context().getReport().getResult());
        assertEquals(0, outcome.context().getReport().getTotal());
        assertEquals("", outcome.context().getReport().getPassRate());
        assertTrue(outcome.errors().isEmpty());
    }

    @Test
    @DisplayName("有报告级规则时以规则为准，不再看逐项汇总")
    void reportRuleWinsOverAggregation() {
        // 逐项全合格，但报告级规则要求合格率≥150%，必然不成立
        ReportContext context = ReportContext.empty().setInspectionItems(List.of(item("长度", "10.2", 10.5, 9.5)));
        List<QualityRuleDefinition> rules = List.of(
                new QualityRuleDefinition("r", "整体合格", RuleScope.REPORT, "PASS_RATE(inspectionItems.result) >= 150", true));

        EvaluationOutcome outcome = ReportEvaluator.evaluate(context, rules);

        assertEquals("FAIL", outcome.context().getReport().getResult());
        assertEquals(1, outcome.context().getReport().getPassCount(), "汇总数据照常算出来，只是不拿来定结论");
    }

    @Test
    @DisplayName("停用的规则不参与判定")
    void disabledRuleIsIgnored() {
        ReportContext context = ReportContext.empty().setInspectionItems(List.of(item("长度", "10.2", 10.5, 9.5)));
        List<QualityRuleDefinition> rules = List.of(
                new QualityRuleDefinition("r", "实测值达标", RuleScope.ITEM, "item.actualValue >= 50", false));

        EvaluationOutcome outcome = ReportEvaluator.evaluate(context, rules);

        assertEquals("PASS", outcome.context().getInspectionItems().get(0).getResult(), "规则被停用，退回按上下限判");
        assertTrue(outcome.errors().isEmpty());
    }

    @Test
    @DisplayName("判定不修改传进来的上下文")
    void doesNotMutateInputContext() {
        ReportContext context = ReportContext.empty().setInspectionItems(List.of(item("硬度", "62", 60.0, 50.0)));

        ReportEvaluator.evaluate(context, List.of());

        assertEquals("", context.getInspectionItems().get(0).getResult(), "原上下文的检验项不该被写回判定值");
        assertEquals("", context.getReport().getResult());
        assertEquals(0, context.getReport().getTotal());
    }

    /* ------------------------------ 规则求值的健壮性 ------------------------------ */

    @Test
    @DisplayName("函数缺参报可读错误，而不是抛下标越界穿透到接口层")
    void missingArgumentGivesReadableError() {
        RuleRuntimeException error = assertThrows(RuleRuntimeException.class,
                () -> RuleEngine.evaluate("SUM()", ReportContext.empty().toScope()));

        assertEquals("函数 SUM 需要数值型参数，实际取到「」", error.getMessage());
    }

    @Test
    @DisplayName("未知函数报错里列出全部可用函数，顺序稳定")
    void unknownFunctionListsAvailableFunctions() {
        RuleRuntimeException error = assertThrows(RuleRuntimeException.class,
                () -> RuleEngine.evaluate("FOO(1)", ReportContext.empty().toScope()));

        assertEquals("不支持函数 FOO，可用函数：ABS、AVG、COUNT、CP、CPK、FAIL_RATE、MAX、MIN、PASS_RATE、ROUND、STDDEV、SUM",
                error.getMessage());
    }

    @Test
    @DisplayName("保存前校验：语法错误与未知函数都能被拦下")
    void validateCatchesSyntaxAndUnknownFunction() {
        assertEquals(List.of("规则「写得不对」语法错误：表达式不完整（第 20 个字符）"),
                RuleEngine.validate(itemRule("写得不对", "item.actualValue >= ")));
        assertTrue(RuleEngine.validate(itemRule("写得对", "item.actualValue >= item.lowerLimit")).isEmpty());
        assertEquals("FOO", RuleEngine.findUnknownFunction("FOO(item.actualValue)"));
        assertNull(RuleEngine.findUnknownFunction("ABS(item.actualValue)"));
    }

    @Test
    @DisplayName("空表达式单独给一条提示，不再当成语法错误")
    void validateReportsEmptyExpression() {
        assertEquals(List.of("规则「空规则」的表达式为空"), RuleEngine.validate(itemRule("空规则", "   ")));
    }

    /**
     * 保存前的整份模板校验。语法与白名单两块都要拦：只拦语法的话，
     * {@code FOO(1)} 这种调用会一路存进库里，之后每张报告都带一条「无法执行」。
     */
    @Test
    @DisplayName("模板级规则校验：语法错与白名单外的函数都要拦下，并指明是哪条规则")
    void validatesAllRulesBeforeSave() {
        ReportTemplateSchema schema = new ReportTemplateSchema();
        schema.setSchemaVersion(ReportTemplateSchema.SCHEMA_VERSION);
        schema.setRules(List.of(
                Map.of("id", "r1", "name", "语法写错", "scope", "item", "expression", "item.actualValue >= "),
                Map.of("id", "r2", "name", "函数不存在", "scope", "report", "expression", "FOO(inspectionItems)"),
                Map.of("id", "r3", "name", "正常规则", "scope", "item", "expression", "item.actualValue > 0")));

        assertEquals(List.of(
                        "规则「语法写错」语法错误：表达式不完整（第 20 个字符）",
                        "规则「函数不存在」调用了不支持的函数 FOO，可用函数：ABS、AVG、COUNT、CP、CPK、FAIL_RATE、MAX、MIN、PASS_RATE、ROUND、STDDEV、SUM"),
                QualityReportEngine.validateRules(schema));
    }

    @Test
    @DisplayName("规则都合规时校验返回空清单")
    void validatePassesWhenRulesAreFine() {
        ReportTemplateSchema schema = new ReportTemplateSchema();
        schema.setRules(List.of(
                Map.of("id", "r1", "name", "规格内", "scope", "item", "expression", "item.actualValue BETWEEN item.lowerLimit AND item.upperLimit"),
                Map.of("id", "r2", "name", "合格率", "scope", "report", "expression", "PASS_RATE(inspectionItems.result) >= 60")));

        assertTrue(QualityReportEngine.validateRules(schema).isEmpty());
    }

    /**
     * 历史脏数据里可能有缺 expression 的规则项。读的时候宽容地留着（执行期会报出来），
     * 但保存前校验要拦下来：规则编辑界面已经做出来了，用户在设计器里删掉这条就能继续保存。
     * 在此之前这条是放行的——当时没有规则界面，报错只会让人卡在保存不了，无处可改。
     */
    @Test
    @DisplayName("缺 expression 的规则会被读取到，但阻断保存（规则界面里删得掉，不再是死路）")
    void blankExpressionRuleBlocksSave() {
        ReportTemplateSchema schema = new ReportTemplateSchema();
        schema.setRules(List.of(
                Map.of("scope", "item"),
                Map.of("id", "r2", "name", "合格率", "scope", "report", "expression", "PASS_RATE(inspectionItems.result) >= 60")));

        assertEquals(2, QualityReportEngine.rulesOf(schema).size(), "宽松读取：两个都留着");
        assertEquals(List.of("规则「未命名规则」的表达式为空"), QualityReportEngine.validateRules(schema),
                "空表达式也要拦住，且不能因此把另一条正常规则也报成错的");
    }

    @Test
    @DisplayName("空表达式的规则在执行期会被报出来，不至于静默失效")
    void blankExpressionRuleSurfacesAtExecution() {
        ReportTemplateSchema schema = new ReportTemplateSchema();
        schema.setRules(List.of(Map.of("id", "r1", "name", "空规则", "scope", "item")));

        EvaluationOutcome outcome = ReportEvaluator.evaluate(
                ReportContext.empty().setInspectionItems(List.of(item("外观", "无划痕", null, null))),
                QualityReportEngine.rulesOf(schema));

        assertEquals(List.of("第 1 项「外观」的规则「空规则」无法执行：规则表达式为空"), outcome.errors());
        assertEquals(QualityResult.PENDING_TEXT, outcome.context().getInspectionItems().get(0).getResultText());
    }

    @Test
    @DisplayName("判定结果取值兼容中文、布尔与 1/0")
    void normalizesResultTokens() {
        assertEquals("PASS", RuleEvaluator.normalizeResultToken("合格"));
        assertEquals("PASS", RuleEvaluator.normalizeResultToken(true));
        assertEquals("PASS", RuleEvaluator.normalizeResultToken("1"));
        assertEquals("FAIL", RuleEvaluator.normalizeResultToken("NG"));
        assertEquals("FAIL", RuleEvaluator.normalizeResultToken(false));
        assertEquals("FAIL", RuleEvaluator.normalizeResultToken("否"));
        assertEquals("", RuleEvaluator.normalizeResultToken("也许"), "认不出来的取值不能瞎猜");
    }

    /**
     * 这里的真值口径是「引擎口径」不是「JS Boolean() 口径」：
     * 能当数字看的取值统一按 {@code !== 0} 判真，所以字符串 "0" 是假值，
     * 而原生 JS 的 {@code Boolean("0")} 是真值。前端引擎就是这么写的，后端照搬才有一致性，
     * 改动前必须先改前端，否则预览与出件会分叉。
     */
    @Test
    @DisplayName("真值判定与前端引擎同口径")
    void truthinessMatchesEngine() {
        assertFalse(RuleEvaluator.truthy(null));
        assertFalse(RuleEvaluator.truthy(""));
        assertFalse(RuleEvaluator.truthy(0));
        assertFalse(RuleEvaluator.truthy(false));
        assertFalse(RuleEvaluator.truthy("0"), "能当数字看，所以是假值——与原生 JS Boolean(\"0\") 不同");
        assertTrue(RuleEvaluator.truthy("abc"), "当不成数字的字符串是真值");
        assertTrue(RuleEvaluator.truthy(1));
        assertFalse(RuleEvaluator.truthy(List.of()), "空数组判假：没有检验项不能算「有数据」");
        assertTrue(RuleEvaluator.truthy(List.of("PASS")));
        assertTrue(RuleEvaluator.isBlank(null));
        assertTrue(RuleEvaluator.isBlank(""));
        // 空值与真值是两码事：空数组「不空」但「假」
        assertFalse(RuleEvaluator.isBlank(List.of()), "空数组不算空");
    }

    /* ------------------------------ 辅助 ------------------------------ */

    private static InspectionItem item(String name, String actual, Double upper, Double lower) {
        return new InspectionItem()
                .setItemName(name).setActualValue(actual)
                .setUpperLimit(upper).setLowerLimit(lower);
    }

    private static QualityRuleDefinition itemRule(String name, String expression) {
        return new QualityRuleDefinition("rule-" + name, name, RuleScope.ITEM, expression, true);
    }

}