package jnpf.elnService.impl;

import jnpf.elnEntity.runtime.ElnRecordEntity;
import jnpf.elnEntity.runtime.ElnRecordFieldValueEntity;
import jnpf.elnEntity.runtime.ElnRecordForms;
import jnpf.elnEntity.runtime.ElnRecordRevisionEntity;
import jnpf.elnEntity.runtime.ElnRecordVos;
import jnpf.elnEntity.ElnDocumentFileVo;
import jnpf.elnEntity.field.ElnFieldVersionEntity;
import jnpf.elnEntity.template.ElnTemplateBindingEntity;
import jnpf.elnEntity.template.ElnTemplateVersionEntity;
import jnpf.elnMapper.ElnTemplateMapper;
import jnpf.elnMapper.ElnFieldVersionMapper;
import jnpf.elnMapper.ElnRecordFieldValueMapper;
import jnpf.elnMapper.ElnRecordMapper;
import jnpf.elnMapper.ElnRecordRevisionMapper;
import jnpf.elnMapper.ElnTemplateBindingMapper;
import jnpf.elnService.ElnTestWorkItemSnapshotProvider;
import jnpf.elnService.ElnCrossTemplateSnapshotResolver;
import jnpf.elnService.ElnRecordFormulaCalculationService;
import jnpf.elnService.template.ElnTemplateFileService;
import jnpf.exception.DataException;
import jnpf.lims.api.model.TestWorkItemSnapshotBatch;
import jnpf.lims.api.model.TestWorkItemSnapshot;
import jnpf.lims.api.model.TestWorkItemSnapshotProperty;
import jnpf.lims.api.model.ElnSourceSnapshot;
import jnpf.lims.api.model.ElnSourcePropertyRef;
import org.junit.Test;

import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

public class ElnRecordCreationServiceImplTest {

    @Test
    public void createsSnapshotFromPinnedSourceRevisionDespiteANewerPublishedRevision() {
        Fixture fixture = new Fixture();
        fixture.versions.get(0).setBangdingPeizhi(
                "{\"read\":{\"source\":\"LIMS_TASK\",\"property\":\"test.basis\",\"propertyRevision\":1}}");
        fixture.versions.get(0).setShujuLeixing("TEXT");
        fixture.configuredValues.put("test.basis@1", "CONFIGURED-V1");
        fixture.configuredValues.put("test.basis@2", "CONFIGURED-V2");

        fixture.service.create(command());

        ElnRecordFieldValueEntity value = fixture.fieldValues.get(0);
        assertEquals("CONFIGURED-V1", value.getZhiWenben());
        assertEquals(Integer.valueOf(1), value.getYuanShuxingBanben());
        assertEquals("SUCCESS", value.getYuanQuzhiZhuangtai());
        assertEquals("task.details@1/basis", value.getYuanXueyuan());
        assertEquals(java.util.Date.from(java.time.Instant.parse("2026-09-06T02:00:00Z")),
                value.getYuanHuoquShijian());
    }

    @Test
    public void createsExclusiveDocumentAndInitialFieldSnapshots() {
        Fixture fixture = new Fixture();

        ElnRecordVos.Created created = fixture.service.create(command());

        assertFalse(created.isExisting());
        assertNotNull(created.getRecordId());
        assertNotNull(created.getRevisionId());
        assertEquals(created.getRevisionId() + ".docx", created.getDocument().getFileId());
        assertEquals(1, fixture.copyCalls.get());
        assertEquals(created.getRevisionId(), fixture.copyTarget.get());
        assertEquals(1, fixture.recordInsertCalls.get());
        assertEquals(1, fixture.revisionInsertCalls.get());
        assertEquals(1, fixture.calculationCalls.get());
        assertEquals("tenant-1", fixture.snapshotTenant.get());
        assertEquals("user-1", fixture.snapshotUser.get());
        assertEquals("HD_jyxm_0008", fixture.templateLookupProjectCode.get());
        assertEquals(created.getDocument().getFileId(), fixture.revision.get().getJiluWendang());
        assertFalse(fixture.revision.get().getJiluWendang().startsWith("["));
        assertEquals(created.getRevisionId(), fixture.record.get().getDangqianXiudingId());
        assertEquals(2, fixture.fieldValues.size());

        ElnRecordFieldValueEntity lims = fixture.fieldValues.get(0);
        assertEquals("LIMS_TASK", lims.getZhiLaiyuan());
        assertEquals("GB/T 123", lims.getZhiWenben());
        assertEquals("basis-1", lims.getYuanYinyongId());

        ElnRecordFieldValueEntity system = fixture.fieldValues.get(1);
        assertEquals("SYSTEM", system.getZhiLaiyuan());
        assertEquals("测试员", system.getZhiWenben());
        assertEquals("user-1", system.getYuanYinyongId());
    }

    @Test
    public void preservesConfiguredDecimalPrecisionInTheTypedSnapshot() {
        Fixture fixture = new Fixture();
        fixture.versions.get(0).setBangdingPeizhi(
                "{\"read\":{\"source\":\"LIMS_TASK\",\"property\":\"result.amount\",\"propertyRevision\":1}}");
        fixture.versions.get(0).setShujuLeixing("DECIMAL");
        fixture.configuredValues.put("result.amount@1", "123456789012345.123456789012345");
        fixture.configuredResponse = value -> value.setDataType("DECIMAL");

        fixture.service.create(command());

        assertEquals(new java.math.BigDecimal("123456789012345.123456789012345"),
                fixture.fieldValues.get(0).getZhiShuzhi());
    }

    @Test
    public void rejectsNumbersThatWouldBeRoundedOrOverflowTheSnapshotColumn() {
        for (String input : Arrays.asList("0.1234567890123456789", "100000000000000000000", "1e100000")) {
            Fixture fixture = configuredFixture();
            fixture.versions.get(0).setShujuLeixing("DECIMAL");
            fixture.configuredValues.put("test.basis@1", input);
            fixture.configuredResponse = value -> value.setDataType("DECIMAL");
            try { fixture.service.create(command()); fail("Unrepresentable numeric snapshot must be rejected"); }
            catch (DataException expected) { fixture.assertNoWrites(); }
        }
    }

    @Test
    public void textSourcesCanFillCompatibleTextControls() {
        for (String type : Arrays.asList("TEXTAREA", "SELECT")) {
            Fixture fixture = configuredFixture();
            fixture.versions.get(0).setShujuLeixing(type);
            fixture.service.create(command());
            assertEquals("CONFIGURED-V1", fixture.fieldValues.get(0).getZhiWenben());
        }
    }

    @Test
    public void recordsOptionalMissingAndNotApplicableWithoutInventingAValue() {
        for (String outcome : Arrays.asList("MISSING", "NOT_APPLICABLE")) {
            Fixture fixture = configuredFixture();
            fixture.configuredResponse = value -> {
                value.setValue(null);
                value.setOutcomeCode(outcome);
                value.setReasonCode("MISSING".equals(outcome) ? "NAME_MISSING" : null);
            };

            fixture.service.create(command());

            ElnRecordFieldValueEntity value = fixture.fieldValues.get(0);
            assertEquals(null, value.getZhiWenben());
            assertEquals(outcome, value.getYuanQuzhiZhuangtai());
            assertEquals(Integer.valueOf(1), value.getYuanShuxingBanben());
        }
    }

    private static Fixture configuredFixture() {
        Fixture fixture = new Fixture();
        fixture.versions.get(0).setBangdingPeizhi(
                "{\"read\":{\"source\":\"LIMS_TASK\",\"property\":\"test.basis\",\"propertyRevision\":1}}");
        fixture.versions.get(0).setShujuLeixing("TEXT");
        fixture.configuredValues.put("test.basis@1", "CONFIGURED-V1");
        return fixture;
    }

    @Test
    public void rejectsRequiredMissingAndSourceFaultsBeforeCreatingAnything() {
        for (String outcome : Arrays.asList("MISSING", "NOT_APPLICABLE", "SOURCE_INVALID", "SOURCE_FORBIDDEN", "SOURCE_AMBIGUOUS")) {
            Fixture fixture = configuredFixture();
            if ("MISSING".equals(outcome) || "NOT_APPLICABLE".equals(outcome)) fixture.versions.get(0).setShifouBitian(1);
            fixture.configuredResponse = value -> value.setOutcomeCode(outcome);
            try {
                fixture.service.create(command());
                fail("Source failure must prevent creation: " + outcome);
            } catch (DataException expected) { fixture.assertNoWrites(); }
        }
    }

    @Test
    public void rejectsWrongTaskVersionAndTypeInsteadOfUsingLegacyValues() {
        List<java.util.function.Consumer<ElnSourceSnapshot>> invalid = Arrays.asList(
                value -> value.setSourceRef("another-task"),
                value -> value.setPropertyRevision(2),
                value -> value.setDataType("DECIMAL"),
                value -> value.setAcquiredAt("invalid"));
        for (java.util.function.Consumer<ElnSourceSnapshot> response : invalid) {
            Fixture fixture = configuredFixture();
            fixture.configuredResponse = response;
            try { fixture.service.create(command()); fail("Invalid source response must be rejected"); }
            catch (DataException expected) { fixture.assertNoWrites(); }
        }
    }

    @Test
    public void storesConfiguredDateInTheDateSlot() {
        Fixture fixture = configuredFixture();
        fixture.versions.get(0).setShujuLeixing("DATE");
        fixture.configuredValues.put("test.basis@1", "2026-09-06");
        fixture.configuredResponse = value -> value.setDataType("DATE");

        fixture.service.create(command());

        assertEquals(java.sql.Date.valueOf("2026-09-06"), fixture.fieldValues.get(0).getZhiRiqi());
    }

    @Test
    public void storesConfiguredDateTimeAndBooleanUsingDeclaredTypes() {
        Fixture time = configuredFixture();
        time.versions.get(0).setShujuLeixing("DATETIME");
        time.configuredValues.put("test.basis@1", "2026-09-06T10:30:00+08:00");
        time.configuredResponse = value -> value.setDataType("DATETIME");
        time.service.create(command());
        assertEquals(java.util.Date.from(java.time.Instant.parse("2026-09-06T02:30:00Z")),
                time.fieldValues.get(0).getZhiRiqi());

        Fixture checkbox = configuredFixture();
        checkbox.versions.get(0).setShujuLeixing("CHECKBOX");
        checkbox.configuredValues.put("test.basis@1", "false");
        checkbox.configuredResponse = value -> value.setDataType("BOOLEAN");
        checkbox.service.create(command());
        assertEquals("false", checkbox.fieldValues.get(0).getZhiWenben());
    }

    @Test
    public void acceptsPostgresLocalTimestampWithoutInventingAnOffset() {
        Fixture fixture = configuredFixture();
        fixture.versions.get(0).setShujuLeixing("DATETIME");
        fixture.configuredValues.put("test.basis@1", "2026-09-06T10:30:00");
        fixture.configuredResponse = value -> value.setDataType("DATETIME");
        fixture.service.create(command());
        assertEquals(java.sql.Timestamp.valueOf("2026-09-06 10:30:00"), fixture.fieldValues.get(0).getZhiRiqi());
    }

    @Test
    public void rejectsSubsecondSourceTimesInsteadOfRoundingTheSnapshot() {
        for (String input : Arrays.asList("2026-09-06T10:30:00.123456", "2026-09-06T10:30:00.123456+08:00")) {
            Fixture fixture = configuredFixture();
            fixture.versions.get(0).setShujuLeixing("DATETIME");
            fixture.configuredValues.put("test.basis@1", input);
            fixture.configuredResponse = value -> value.setDataType("DATETIME");
            try { fixture.service.create(command()); fail("Subsecond snapshot must not be silently rounded"); }
            catch (DataException expected) { fixture.assertNoWrites(); }
        }
    }

    @Test
    public void requestsEveryLimsPropertyUsedByActiveTemplateBindings() {
        Fixture fixture = new Fixture();
        fixture.bindings.add(binding("binding-3", "field-3", "sample_name", "version-3"));
        fixture.versions.add(version("version-3", "field-3",
                "{\"read\":{\"source\":\"LIMS_TASK\",\"property\":\"sample.name\"}}"));

        fixture.service.create(command());

        assertEquals(Arrays.asList(
                Collections.emptyList(),
                Arrays.asList("test.basis", "sample.name")), fixture.snapshotPropertyRequests);
        assertEquals(3, fixture.fieldValues.size());
        assertEquals("sample.name", fixture.fieldValues.get(2).getYuanShuxing());
        assertEquals("阿司匹林片", fixture.fieldValues.get(2).getZhiWenben());
    }

    @Test
    public void createsEmptyValueWhenOptionalLimsPropertyIsMissing() {
        Fixture fixture = new Fixture();
        fixture.missingProperty = "test.basis";

        fixture.service.create(command());

        assertEquals(2, fixture.fieldValues.size());
        ElnRecordFieldValueEntity optional = fixture.fieldValues.get(0);
        assertEquals("LIMS_TASK", optional.getZhiLaiyuan());
        assertEquals("test.basis", optional.getYuanShuxing());
        assertEquals(null, optional.getZhiWenben());
    }

    @Test
    public void rejectsMissingRequiredLimsPropertyBeforePersistingOrCopying() {
        Fixture fixture = new Fixture();
        fixture.versions.get(0).setShifouBitian(1);
        fixture.missingProperty = "test.basis";

        expectDataException(() -> fixture.service.create(command()), "检验任务快照中缺少检验依据");

        fixture.assertNoWrites();
    }

    @Test
    public void returnsExistingDraftWithoutCopyingOrInsertingAgain() {
        Fixture fixture = new Fixture();
        ElnRecordVos.Created first = fixture.service.create(command());

        ElnRecordVos.Created second = fixture.service.create(command());

        assertTrue(second.isExisting());
        assertEquals(first.getRecordId(), second.getRecordId());
        assertEquals(first.getRevisionId(), second.getRevisionId());
        assertEquals(first.getDocument().getFileId(), second.getDocument().getFileId());
        assertEquals(1, fixture.copyCalls.get());
        assertEquals(1, fixture.recordInsertCalls.get());
        assertEquals(1, fixture.revisionInsertCalls.get());
        assertEquals(2, fixture.fieldValues.size());
    }

    @Test
    public void rejectsMissingTemplateBeforePersistingOrCopying() {
        Fixture fixture = new Fixture();
        fixture.templates.clear();

        expectDataException(() -> fixture.service.create(command()), "未配置");

        fixture.assertNoWrites();
    }

    @Test
    public void rejectsAmbiguousTemplatesBeforePersistingOrCopying() {
        Fixture fixture = new Fixture();
        fixture.templates.add(template("template-2"));

        expectDataException(() -> fixture.service.create(command()), "多个");

        fixture.assertNoWrites();
    }

    @Test
    public void rejectsSnapshotWithoutTestDefinitionCode() {
        Fixture fixture = new Fixture();
        fixture.testDefinitionCode = " ";

        expectDataException(() -> fixture.service.create(command()), "检验项目编码");

        fixture.assertNoWrites();
    }

    @Test
    public void rejectsTemplateWithMismatchedTestDefinitionCode() {
        Fixture fixture = new Fixture();
        fixture.templates.get(0).setJianyanXiangmuBianma("HD_jyxm_9999");

        expectDataException(() -> fixture.service.create(command()), "编码与任务快照不一致");

        fixture.assertNoWrites();
    }

    @Test
    public void createsCrossTemplateScalarSnapshotWithCompleteLineageBeforePersistence() {
        ElnRecordFieldValueEntity source = new ElnRecordFieldValueEntity();
        source.setId("source-value-1");
        source.setDianziJiluId("source-record-1");
        source.setXiudingId("source-revision-1");
        source.setZiduanBanbenId("source-version-1");
        source.setZhiWenben("cross template result");
        Fixture fixture = new Fixture((tenantId, testWorkItemId, bindings) -> {
            assertEquals("tenant-1", tenantId);
            assertEquals("test-work-item-1", testWorkItemId);
            Map<String, ElnRecordFieldValueEntity> result = new LinkedHashMap<>();
            result.put("binding-1", source);
            return result;
        });

        fixture.service.create(command());

        ElnRecordFieldValueEntity target = fixture.fieldValues.get(0);
        assertEquals("cross template result", target.getZhiWenben());
        assertEquals("CROSS_TEMPLATE", target.getZhiLaiyuan());
        assertEquals("source-record-1", target.getKuamoLaiyuanJiluId());
        assertEquals("source-revision-1", target.getKuamoLaiyuanXiudingId());
        assertEquals("source-value-1", target.getKuamoLaiyuanZhiId());
        assertEquals("source-version-1", target.getKuamoLaiyuanZiduanBanbenId());
        assertNotNull(target.getKuamoHuoquShijian());
    }

    @Test
    public void rejectsCrossTemplateResolutionBeforeAnyDatabaseOrDocumentWrite() {
        Fixture fixture = new Fixture((tenantId, testWorkItemId, bindings) -> {
            throw new DataException("SOURCE_FIELD_VALUE_INVALID: source empty");
        });

        expectDataException(() -> fixture.service.create(command()), "SOURCE_FIELD_VALUE_INVALID");

        fixture.assertNoWrites();
    }

    private static ElnRecordForms.Create command() {
        ElnRecordForms.Create command = new ElnRecordForms.Create();
        command.setTestWorkItemId("test-work-item-1");
        command.setOperationCode("eln-single-test-work-item-1-1");
        return command;
    }

    private static void expectDataException(Runnable action, String messagePart) {
        try {
            action.run();
            fail("预期抛出 DataException");
        } catch (DataException expected) {
            assertTrue(expected.getMessage().contains(messagePart));
        }
    }

    private static ElnTemplateVersionEntity template(String id) {
        ElnTemplateVersionEntity template = new ElnTemplateVersionEntity();
        template.setId(id);
        template.setFTenantId("tenant-1");
        template.setMubanBianhao("TPL-001");
        template.setMubanBanben("V1");
        template.setJianyanXiangmuBianma("HD_jyxm_0008");
        template.setMubanFile("[{\"fileId\":\"source.docx\",\"name\":\"source.docx\","
                + "\"fileExtension\":\"docx\"}]");
        return template;
    }

    private static ElnTemplateBindingEntity binding(String id, String fieldId,
                                                     String fieldCode, String versionId) {
        ElnTemplateBindingEntity binding = new ElnTemplateBindingEntity();
        binding.setId(id);
        binding.setMubanId("template-1");
        binding.setZiduanDingyiId(fieldId);
        binding.setZiduanBianma(fieldCode);
        binding.setZiduanBanbenId(versionId);
        binding.setKongjianJuese("PRIMARY");
        binding.setBangdingZhuangtai("ACTIVE");
        binding.setFTenantId("tenant-1");
        return binding;
    }

    private static ElnFieldVersionEntity version(String id, String fieldId, String bindingConfig) {
        ElnFieldVersionEntity version = new ElnFieldVersionEntity();
        version.setId(id);
        version.setZiduanDingyiId(fieldId);
        version.setShifouBitian(0);
        version.setBangdingPeizhi(bindingConfig);
        version.setFTenantId("tenant-1");
        return version;
    }

    @SuppressWarnings("unchecked")
    private static <T> T mapper(Class<T> type, MapperInvocation invocation) {
        return (T) Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type},
                (proxy, method, args) -> {
                    if (method.getDeclaringClass() == Object.class) {
                        if ("toString".equals(method.getName())) {
                            return type.getSimpleName() + "Fake";
                        }
                        if ("hashCode".equals(method.getName())) {
                            return System.identityHashCode(proxy);
                        }
                        if ("equals".equals(method.getName())) {
                            return proxy == args[0];
                        }
                    }
                    Object result = invocation.invoke(method.getName(), args);
                    if (result != null || !method.getReturnType().isPrimitive()) {
                        return result;
                    }
                    if (method.getReturnType() == boolean.class) {
                        return false;
                    }
                    return 0;
                });
    }

    @FunctionalInterface
    private interface MapperInvocation {
        Object invoke(String method, Object[] args);
    }

    private static final class Fixture {
        private final List<ElnTemplateVersionEntity> templates = new ArrayList<>();
        private final List<ElnTemplateBindingEntity> bindings = new ArrayList<>();
        private final List<ElnFieldVersionEntity> versions = new ArrayList<>();
        private final List<ElnRecordFieldValueEntity> fieldValues = new ArrayList<>();
        private final AtomicReference<ElnRecordEntity> record = new AtomicReference<>();
        private final AtomicReference<ElnRecordRevisionEntity> revision = new AtomicReference<>();
        private final AtomicReference<String> copyTarget = new AtomicReference<>();
        private final AtomicReference<String> snapshotTenant = new AtomicReference<>();
        private final AtomicReference<String> snapshotUser = new AtomicReference<>();
        private final AtomicReference<String> templateLookupProjectCode = new AtomicReference<>();
        private final List<List<String>> snapshotPropertyRequests = new ArrayList<>();
        private final AtomicInteger versionReads = new AtomicInteger();
        private final AtomicInteger copyCalls = new AtomicInteger();
        private final AtomicInteger recordInsertCalls = new AtomicInteger();
        private final AtomicInteger revisionInsertCalls = new AtomicInteger();
        private final AtomicInteger calculationCalls = new AtomicInteger();
        private String testDefinitionCode = "HD_jyxm_0008";
        private String missingProperty;
        private final Map<String, String> configuredValues = new LinkedHashMap<>();
        private java.util.function.Consumer<ElnSourceSnapshot> configuredResponse = value -> { };
        private final ElnRecordCreationServiceImpl service;

        private Fixture() {
            this(ElnCrossTemplateSnapshotResolver.none());
        }

        private Fixture(ElnCrossTemplateSnapshotResolver crossTemplateSnapshotResolver) {
            templates.add(template("template-1"));
            bindings.add(binding("binding-1", "field-1", "test_basis", "version-1"));
            bindings.add(binding("binding-2", "field-2", "operator_name", "version-2"));
            versions.add(version("version-1", "field-1",
                    "{\"read\":{\"source\":\"LIMS_TASK\",\"property\":\"test.basis\"}}"));
            versions.add(version("version-2", "field-2",
                    "{\"read\":{\"source\":\"SYSTEM\",\"property\":\"current_user.real_name\"}}"));

            ElnTemplateMapper templateMapper = mapper(ElnTemplateMapper.class,
                    (method, args) -> {
                        if ("selectCurrentPublishedByTestDefinition".equals(method)) {
                            templateLookupProjectCode.set((String) args[1]);
                            return new ArrayList<>(templates);
                        }
                        return null;
                    });
            ElnTemplateBindingMapper bindingMapper = mapper(ElnTemplateBindingMapper.class,
                    (method, args) -> "selectList".equals(method)
                            ? new ArrayList<>(bindings) : null);
            ElnFieldVersionMapper fieldVersionMapper = mapper(ElnFieldVersionMapper.class,
                    (method, args) -> "selectOne".equals(method)
                            ? versions.get(versionReads.getAndIncrement()) : null);
            ElnRecordMapper recordMapper = mapper(ElnRecordMapper.class, (method, args) -> {
                if ("selectLiveByTestWorkItem".equals(method)) {
                    return record.get();
                }
                if ("insertIfAbsent".equals(method)) {
                    recordInsertCalls.incrementAndGet();
                    record.set((ElnRecordEntity) args[0]);
                    return 1;
                }
                if ("updateById".equals(method)) {
                    record.set((ElnRecordEntity) args[0]);
                    return 1;
                }
                return null;
            });
            ElnRecordRevisionMapper revisionMapper = mapper(ElnRecordRevisionMapper.class,
                    (method, args) -> {
                        if ("selectOne".equals(method)) {
                            return revision.get();
                        }
                        if ("insert".equals(method)) {
                            revisionInsertCalls.incrementAndGet();
                            revision.set((ElnRecordRevisionEntity) args[0]);
                            return 1;
                        }
                        return null;
                    });
            ElnRecordFieldValueMapper fieldValueMapper = mapper(ElnRecordFieldValueMapper.class,
                    (method, args) -> {
                        if ("insert".equals(method)) {
                            fieldValues.add((ElnRecordFieldValueEntity) args[0]);
                            return 1;
                        }
                        return null;
                    });
            ElnTemplateFileService fileService = new ElnTemplateFileService(null, null) {
                @Override
                public String copyDocx(String sourceAttachments, String targetTemplateId) {
                    copyCalls.incrementAndGet();
                    copyTarget.set(targetTemplateId);
                    return "[{\"fileId\":\"" + targetTemplateId + ".docx\","
                            + "\"name\":\"" + targetTemplateId + ".docx\","
                            + "\"fileExtension\":\"docx\",\"fileSize\":128}]";
                }
            };
            ElnRecordFormulaCalculationService formulaCalculation =
                    new ElnRecordFormulaCalculationService() {
                        @Override
                        public List<ElnRecordFieldValueEntity> recalculateAffected(
                                String tenantId, ElnRecordEntity record,
                                ElnRecordRevisionEntity revision,
                                List<ElnRecordFieldValueEntity> values,
                                Set<String> changedBindingIds,
                                String operationCode, String operatorUserId) {
                            calculationCalls.incrementAndGet();
                            return Collections.emptyList();
                        }

                        @Override
                        public List<ElnRecordFieldValueEntity> recalculateAll(
                                String tenantId, ElnRecordEntity record,
                                ElnRecordRevisionEntity revision,
                                List<ElnRecordFieldValueEntity> values,
                                String operationCode, String operatorUserId) {
                            return Collections.emptyList();
                        }
                    };

            ElnTestWorkItemSnapshotProvider taskProvider = new ElnTestWorkItemSnapshotProvider() {
                @Override
                public List<ElnSourceSnapshot> resolveConfiguredAsActor(String tenantId, String userId,
                        List<String> testWorkItemIds, List<ElnSourcePropertyRef> references) {
                    List<ElnSourceSnapshot> result = new ArrayList<>();
                    for (ElnSourcePropertyRef reference : references) {
                        ElnSourceSnapshot item = new ElnSourceSnapshot();
                        item.setSourceRef(testWorkItemIds.get(0));
                        item.setPropertyCode(reference.getPropertyCode());
                        item.setPropertyRevision(reference.getRevision());
                        item.setDataType("TEXT");
                        item.setValue(configuredValues.get(reference.getPropertyCode() + "@" + reference.getRevision()));
                        item.setOutcomeCode("SUCCESS");
                        item.setAcquiredAt("2026-09-06T02:00:00Z");
                        item.setLineage("task.details@1/basis");
                        configuredResponse.accept(item);
                        result.add(item);
                    }
                    return result;
                }

                @Override
                public TestWorkItemSnapshotBatch resolve(
                        List<String> testWorkItemIds, List<String> properties) {
                    fail("记录创建必须通过显式 actor 快照接口读取 LIMS 任务");
                    return null;
                }

                @Override
                public TestWorkItemSnapshotBatch resolveAsActor(
                        String tenantId, String userId,
                        List<String> testWorkItemIds, List<String> properties) {
                    snapshotTenant.set(tenantId);
                    snapshotUser.set(userId);
                    snapshotPropertyRequests.add(new ArrayList<>(properties));
                    return snapshot(properties);
                }
            };
            service = new ElnRecordCreationServiceImpl(taskProvider,
                    templateMapper, bindingMapper, fieldVersionMapper, recordMapper,
                    revisionMapper, fieldValueMapper, fileService, formulaCalculation,
                    command -> {
                        ElnRecordVos.Created existing = new ElnRecordVos.Created();
                        existing.setRecordId(record.get().getId());
                        existing.setRevisionId(revision.get().getId());
                        ElnDocumentFileVo document = new ElnDocumentFileVo();
                        document.setFileId(revision.get().getJiluWendang());
                        document.setName(revision.get().getJiluWendang());
                        document.setFileExtension("docx");
                        existing.setDocument(document);
                        existing.setExisting(true);
                        return existing;
                    },
                    () -> ElnRecordCreationServiceImpl.userContext(
                            "tenant-1", "user-1", "测试员"),
                    crossTemplateSnapshotResolver);
        }

        private void assertNoWrites() {
            assertEquals(0, copyCalls.get());
            assertEquals(0, recordInsertCalls.get());
            assertEquals(0, revisionInsertCalls.get());
            assertTrue(fieldValues.isEmpty());
        }

        private TestWorkItemSnapshotBatch snapshot(List<String> requestedProperties) {
            List<TestWorkItemSnapshotProperty> properties = new ArrayList<>();
            for (String requested : requestedProperties) {
                TestWorkItemSnapshotProperty property = new TestWorkItemSnapshotProperty();
                property.setProperty(requested);
                property.setSource("LIMS_TASK");
                property.setSourceRef("sample.name".equals(requested) ? "sample-1" : "basis-1");
                if (requested.equals(missingProperty)) {
                    property.setOutcomeCode("MISSING");
                    property.setReason("检验任务快照中缺少检验依据");
                } else {
                    property.setValue("sample.name".equals(requested) ? "阿司匹林片" : "GB/T 123");
                    property.setOutcomeCode("SUCCESS");
                }
                properties.add(property);
            }

            TestWorkItemSnapshot item = new TestWorkItemSnapshot();
            item.setTestWorkItemId("test-work-item-1");
            item.setTestDefinitionId("test-definition-1");
            item.setTestDefinitionCode(testDefinitionCode);
            item.setTestDefinitionName("pH值");
            item.setOutcomeCode("SUCCESS");
            item.setProperties(properties);

            TestWorkItemSnapshotBatch batch = new TestWorkItemSnapshotBatch();
            batch.setItems(Arrays.asList(item));
            return batch;
        }
    }
}