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

import cn.iocoder.yudao.module.qcreport.dal.dataobject.version.ReportTemplateSchema;
import cn.iocoder.yudao.module.qcreport.engine.QualityReportEngine;
import cn.iocoder.yudao.module.qcreport.engine.render.RenderOutcome;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

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

/**
 * 数据快照的编解码。
 * <p>
 * 这里是「历史报告可复现」的唯一实现路径，所以第一条用例不是比对快照本身，
 * 而是<b>走完整链路</b>：出件 → 冻结快照 → 从快照读回 → 重渲，产物必须与首次逐字相同。
 * 只要这条断了，报告实例就会出现「生成时一个样、重新生成后另一个样」，
 * 而库里的数据看不出任何异常——这种问题事后极难追。
 * <p>
 * 用的是与对拍同一份 fixture（{@code schema.json} / {@code context.json} /
 * {@code expected-html.html}），所以「重渲一致」与「前后端一致」在这里是一次性验证的。
 */
class ReportContextCodecTest {

    private static final ObjectMapper MAPPER = new ObjectMapper();

    private static final String FIXTURE = "qcreport/";

    @Test
    @DisplayName("冻结快照读回后重渲，产物与首次出件逐字相同")
    void roundTripReproducesHtml() throws IOException {
        ReportTemplateSchema schema = readSchema();

        // 1. 首次出件：判定 + 渲染
        RenderOutcome first = QualityReportEngine.render(schema, readContext());
        assertEquals(readFixture("expected-html.html"), first.html(), "首次出件就与前端引擎不一致");

        // 2. 冻结快照（存的就是判定后的上下文）
        Map<String, Object> snapshot = ReportContextCodec.toMap(first.context());

        // 3. 从快照读回，重渲
        RenderOutcome second = QualityReportEngine.render(schema, ReportContextCodec.fromMap(snapshot));

        assertEquals(first.html(), second.html(),
                "从数据快照重渲的 HTML 与首次出件不一致，历史报告不再可复现");
        assertEquals(first.errors(), second.errors(), "重渲的数据缺口清单与首次出件不一致");
    }

    @Test
    @DisplayName("快照里带着算好的判定结果与合格率")
    void snapshotCarriesEvaluation() throws IOException {
        RenderOutcome outcome = QualityReportEngine.render(readSchema(), readContext());

        Map<String, Object> snapshot = ReportContextCodec.toMap(outcome.context());

        @SuppressWarnings("unchecked")
        Map<String, Object> report = (Map<String, Object>) snapshot.get("report");
        assertEquals("FAIL", report.get("result"));
        assertEquals(3, report.get("total"));
        assertEquals("33.33%", report.get("passRate"));

        @SuppressWarnings("unchecked")
        List<Object> items = (List<Object>) snapshot.get("inspectionItems");
        assertEquals(3, items.size());
        assertEquals("FAIL", ((Map<?, ?>) items.get(0)).get("result"));
        assertEquals("PASS", ((Map<?, ?>) items.get(1)).get("result"));
    }

    @Test
    @DisplayName("编解码往返不丢字段：文本、整数、上下限、空值都原样回来")
    void roundTripIsLossless() {
        InspectionItem item = new InspectionItem()
                .setIndex(7)
                .setItemCode("LEN")
                .setItemName("长度")
                .setStandardValue("10±0.5")
                .setActualValue("10.2")
                .setUnit("mm")
                // 检测要求与检测方法各占一处：模板里常各写一列，往返时必须都不丢
                .setRequirement("10±0.5")
                .setCheckMethod("GB/T 1804-2000")
                .setUpperLimit(10.5D)
                .setLowerLimit(9.5D)
                .setResult("PASS")
                .setResultText("合格")
                .setRemark("抽检");
        ReportContext original = new ReportContext()
                .setReport(new ReportFields()
                        .setReportNo("QR20260918-0001")
                        .setReportName("出货检验报告")
                        .setProductName("法兰")
                        .setInspector("张三")
                        .setResult("PASS")
                        .setResultText("合格")
                        .setConclusion("准予出货")
                        .setPassRate("100.00%")
                        .setTotal(1)
                        .setPassCount(1)
                        .setFailCount(0))
                .setInspectionItems(new ArrayList<>(List.of(item)));

        ReportContext restored = ReportContextCodec.fromMap(ReportContextCodec.toMap(original));

        assertEquals(original, restored, "往返后有字段变了");
    }

    @Test
    @DisplayName("没有规格区间的项，上下限保持为 null，不会被填成 0")
    void absentLimitsStayNull() {
        String itemName = "外观";
        InspectionItem original = new InspectionItem().setIndex(1).setItemName(itemName);

        ReportContext restored = ReportContextCodec.fromMap(
                ReportContextCodec.toMap(new ReportContext().setInspectionItems(new ArrayList<>(List.of(original)))));

        InspectionItem item = restored.getInspectionItems().get(0);
        assertEquals(itemName, item.getItemName());
        assertNull(item.getUpperLimit(), "没写上限的项被判成「上限 0」，规格判定会全错");
        assertNull(item.getLowerLimit());
    }

    @Test
    @DisplayName("字段不全的快照照常读回：缺的字段是「没值」（空串），不是报错")
    void partialSnapshotReadsAsEmpty() {
        Map<String, Object> snapshot = new LinkedHashMap<>();
        Map<String, Object> report = new LinkedHashMap<>();
        report.put("reportNo", "QR20260918-0001");
        report.put("reportName", "来料检验报告");
        snapshot.put("report", report);
        snapshot.put("inspectionItems", List.of(Map.of("index", 1, "itemName", "外观")));

        ReportContext context = ReportContextCodec.fromMap(snapshot);

        assertEquals("QR20260918-0001", context.getReport().getReportNo());
        assertEquals("来料检验报告", context.getReport().getReportName());
        assertEquals("", context.getReport().getProductName(), "缺的字段应当是空串");
        assertEquals(0, context.getReport().getTotal());
        assertEquals(1, context.getInspectionItems().size());
        assertEquals("", context.getInspectionItems().get(0).getActualValue());
    }

    @Test
    @DisplayName("空快照读回空白上下文，不抛异常")
    void nullAndEmptySnapshotYieldEmptyContext() {
        assertNotNull(ReportContextCodec.fromMap(null).getReport());
        assertTrue(ReportContextCodec.fromMap(null).getInspectionItems().isEmpty());
        assertTrue(ReportContextCodec.fromMap(new LinkedHashMap<>()).getInspectionItems().isEmpty());
        assertNotNull(ReportContextCodec.toMap(null).get("report"));
    }

    @Test
    @DisplayName("检验项数组里混进非对象元素时跳过该元素，不让整份报告打不开")
    void malformedItemIsSkipped() {
        Map<String, Object> snapshot = new LinkedHashMap<>();
        snapshot.put("inspectionItems", List.of(
                Map.of("index", 1, "itemName", "外观"),
                "不是对象",
                Map.of("index", 3, "itemName", "硬度")));

        ReportContext context = ReportContextCodec.fromMap(snapshot);

        assertEquals(2, context.getInspectionItems().size());
        assertEquals("外观", context.getInspectionItems().get(0).getItemName());
        assertEquals("硬度", context.getInspectionItems().get(1).getItemName());
    }

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

    private static ReportTemplateSchema readSchema() throws IOException {
        return MAPPER.readValue(readFixture("schema.json"), ReportTemplateSchema.class);
    }

    private static ReportContext readContext() throws IOException {
        return MAPPER.readValue(readFixture("context.json"), ReportContext.class);
    }

    private static String readFixture(String name) throws IOException {
        try (InputStream in = ReportContextCodecTest.class.getClassLoader()
                .getResourceAsStream(FIXTURE + name)) {
            if (in == null) {
                throw new IOException("测试 fixture 缺失：" + FIXTURE + name);
            }
            return new String(in.readAllBytes(), StandardCharsets.UTF_8);
        }
    }

}