package jnpf.elnService.impl;

import jnpf.elnEntity.field.ElnFieldVersionEntity;
import jnpf.elnEntity.runtime.ElnRecordEntity;
import jnpf.elnEntity.runtime.ElnRecordFieldValueEntity;
import jnpf.elnEntity.runtime.ElnRecordForms;
import jnpf.elnEntity.runtime.ElnRecordRepeatRowEntity;
import jnpf.elnEntity.runtime.ElnRecordRepeatValueEntity;
import jnpf.elnEntity.runtime.ElnRecordRevisionEntity;
import jnpf.elnEntity.runtime.ElnRecordVos;
import jnpf.elnMapper.ElnFieldVersionMapper;
import jnpf.elnMapper.ElnRecordFieldValueMapper;
import jnpf.elnMapper.ElnRecordMapper;
import jnpf.elnMapper.ElnRecordRepeatRowMapper;
import jnpf.elnMapper.ElnRecordRepeatValueMapper;
import jnpf.elnMapper.ElnRecordRevisionMapper;
import jnpf.elnService.ElnTestWorkItemSnapshotProvider;
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 org.junit.Test;
import org.springframework.transaction.support.TransactionSynchronization;
import org.springframework.transaction.support.TransactionSynchronizationManager;

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

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

public class ElnRecordRevisionServiceImplTest {

    @Test
    public void auditRejectedCreatesExclusiveRevisionAndRefreshesAuthoritativeValues() {
        Fixture fixture = new Fixture("audit_rejected");

        ElnRecordVos.Created created = fixture.open("revision-operation-1");

        assertFalse(created.isExisting());
        assertEquals("record-1", created.getRecordId());
        assertNotEquals("revision-1", created.getRevisionId());
        assertEquals(created.getRevisionId() + ".docx", created.getDocument().getFileId());
        assertEquals("HISTORICAL", fixture.sourceRevision.getBizStatus());
        assertEquals(created.getRevisionId(), fixture.record.getDangqianXiudingId());
        assertEquals(5, fixture.record.getFVersion().intValue());
        assertEquals(1, fixture.markHistoricalCalls.get());
        assertEquals(1, fixture.switchCalls.get());
        assertEquals(1, fixture.copyCalls.get());
        assertTrue(fixture.copySource.startsWith("["));
        assertTrue(fixture.copySource.contains("revision-1.docx"));
        assertEquals(created.getRevisionId(), fixture.copyTarget);
        assertEquals(3, fixture.insertedValues.size());

        ElnRecordFieldValueEntity manual = fixture.insertedValues.get(0);
        assertEquals("manual value", manual.getZhiWenben());
        assertEquals("MANUAL", manual.getZhiLaiyuan());

        ElnRecordFieldValueEntity lims = fixture.insertedValues.get(1);
        assertEquals("new basis", lims.getZhiWenben());
        assertEquals("LIMS_TASK", lims.getZhiLaiyuan());
        assertEquals("test.basis", lims.getYuanShuxing());
        assertEquals("item-1", lims.getYuanYinyongId());

        ElnRecordFieldValueEntity system = fixture.insertedValues.get(2);
        assertEquals("新操作人", system.getZhiWenben());
        assertEquals("SYSTEM", system.getZhiLaiyuan());
        assertEquals("user-2", system.getYuanYinyongId());
        assertEquals(1, fixture.recalculateAllCalls.get());
        assertEquals(1, fixture.formulaUpdateCalls.get());
        assertEquals(1, fixture.fenceAcquireCalls.get());
        assertEquals(1, fixture.fenceCompleteCalls.get());
        assertEquals(0, fixture.fenceReleaseCalls.get());

        assertEquals(4, fixture.insertedRepeatRows.size());
        assertEquals(4, fixture.insertedRepeatValues.size());
        for (int index = 0; index < fixture.sourceRepeatRows.size(); index++) {
            ElnRecordRepeatRowEntity source = fixture.sourceRepeatRows.get(index);
            ElnRecordRepeatRowEntity copied = fixture.insertedRepeatRows.get(index);
            assertNotEquals(source.getId(), copied.getId());
            assertEquals(created.getRevisionId(), copied.getXiudingId());
            assertEquals(source.getRepeatGroupCode(), copied.getRepeatGroupCode());
            assertEquals(source.getRowId(), copied.getRowId());
            assertEquals(source.getRowOrder(), copied.getRowOrder());
            assertEquals(source.getOperationCode(), copied.getOperationCode());
            assertEquals(source.getOperationStatus(), copied.getOperationStatus());
            assertEquals(source.getDeleteReason(), copied.getDeleteReason());
            assertEquals(source.getFDeleteMark(), copied.getFDeleteMark());
            assertEquals(0, copied.getFVersion().intValue());
            assertEquals("user-2", copied.getFCreatorUserId());
            assertEquals("revision-1", source.getXiudingId());
            assertEquals(source.getRowOrder(), source.getFVersion());

            ElnRecordRepeatValueEntity sourceValue = fixture.sourceRepeatValues.get(index);
            ElnRecordRepeatValueEntity copiedValue = fixture.insertedRepeatValues.get(index);
            assertNotEquals(sourceValue.getId(), copiedValue.getId());
            assertEquals(created.getRevisionId(), copiedValue.getXiudingId());
            assertEquals(sourceValue.getRepeatRowId(), copiedValue.getRepeatRowId());
            assertEquals(sourceValue.getRepeatGroupCode(), copiedValue.getRepeatGroupCode());
            assertEquals(sourceValue.getMubanBangdingId(), copiedValue.getMubanBangdingId());
            assertEquals(sourceValue.getZhiWenben(), copiedValue.getZhiWenben());
            assertEquals(sourceValue.getFDeleteMark(), copiedValue.getFDeleteMark());
            assertEquals(0, copiedValue.getFVersion().intValue());
            assertEquals("user-2", copiedValue.getFCreatorUserId());
            assertEquals("revision-1", sourceValue.getXiudingId());
        }
    }

    @Test
    public void auditRejectedCopiesConfiguredSourceSnapshotWithoutRefreshingIt() {
        Fixture fixture = new Fixture("audit_rejected");
        ElnRecordFieldValueEntity source = fixture.sourceValues.get(1);
        Date acquiredAt = new Date(123456L);
        Date dateValue = new Date(654321L);
        source.setZhiWenben("configured snapshot");
        source.setZhiShuzhi(new BigDecimal("123.456789012345678901"));
        source.setZhiRiqi(dateValue);
        source.setYuanShuxing("verification.test_basis");
        source.setYuanShuxingBanben(1);
        source.setYuanYinyongLeixing("LIMS_TASK");
        source.setYuanYinyongId("item-1");
        source.setYuanHuoquShijian(acquiredAt);
        source.setYuanQuzhiZhuangtai("CLEARED");
        source.setYuanQuzhiYuanyin("按审核要求保留空值");
        source.setYuanXueyuan("verification.task_snapshot@1/test_basis");
        fixture.versionResults.remove(1);

        fixture.open("revision-configured-source-copy");

        ElnRecordFieldValueEntity copied = fixture.insertedValues.get(1);
        assertEquals("configured snapshot", copied.getZhiWenben());
        assertEquals(0, new BigDecimal("123.456789012345678901")
                .compareTo(copied.getZhiShuzhi()));
        assertEquals(dateValue, copied.getZhiRiqi());
        assertEquals("LIMS_TASK", copied.getZhiLaiyuan());
        assertEquals("verification.test_basis", copied.getYuanShuxing());
        assertEquals(Integer.valueOf(1), copied.getYuanShuxingBanben());
        assertEquals("LIMS_TASK", copied.getYuanYinyongLeixing());
        assertEquals("item-1", copied.getYuanYinyongId());
        assertEquals(acquiredAt, copied.getYuanHuoquShijian());
        assertEquals("CLEARED", copied.getYuanQuzhiZhuangtai());
        assertEquals("按审核要求保留空值", copied.getYuanQuzhiYuanyin());
        assertEquals("verification.task_snapshot@1/test_basis", copied.getYuanXueyuan());
    }

    @Test
    public void cancelledAlsoCreatesANewRevisionOnTheSameRecord() {
        Fixture fixture = new Fixture("cancelled");

        ElnRecordVos.Created created = fixture.open("revision-operation-cancelled");

        assertFalse(created.isExisting());
        assertEquals("record-1", created.getRecordId());
        assertEquals(2, fixture.currentRevision.getXiudingHao().intValue());
        assertEquals("revision-1", fixture.currentRevision.getLaiyuanXiudingId());
    }

    @Test
    public void pendingTestReusesCurrentDraftWithoutRefreshingSnapshots() {
        Fixture fixture = new Fixture("pending_test");

        ElnRecordVos.Created created = fixture.open("ordinary-open");

        assertTrue(created.isExisting());
        assertEquals("record-1", created.getRecordId());
        assertEquals("revision-1", created.getRevisionId());
        assertEquals(0, fixture.insertedValues.size());
        assertEquals(0, fixture.versionReads.get());
        assertEquals(0, fixture.copyCalls.get());
        assertEquals(0, fixture.markHistoricalCalls.get());
        assertEquals(0, fixture.switchCalls.get());
        assertEquals(0, fixture.recalculateAllCalls.get());
    }

    @Test
    public void copiesCrossTemplateLineageWithoutReadingTheSourceAgain() {
        Fixture fixture = new Fixture("audit_rejected");
        ElnRecordFieldValueEntity source = fixture.sourceValues.get(1);
        fixture.versionResults.remove(1);
        source.setZhiLaiyuan("CROSS_TEMPLATE");
        source.setZhiWenben("cross-template snapshot");
        source.setKuamoLaiyuanJiluId("source-record");
        source.setKuamoLaiyuanXiudingId("source-revision");
        source.setKuamoLaiyuanZhiId("source-value");
        source.setKuamoLaiyuanZiduanBanbenId("source-field-version");
        source.setKuamoHuoquShijian(new Date(123456L));

        fixture.open("revision-cross-copy");

        ElnRecordFieldValueEntity copied = fixture.insertedValues.get(1);
        assertEquals("CROSS_TEMPLATE", copied.getZhiLaiyuan());
        assertEquals("cross-template snapshot", copied.getZhiWenben());
        assertEquals("source-record", copied.getKuamoLaiyuanJiluId());
        assertEquals("source-revision", copied.getKuamoLaiyuanXiudingId());
        assertEquals("source-value", copied.getKuamoLaiyuanZhiId());
        assertEquals("source-field-version", copied.getKuamoLaiyuanZiduanBanbenId());
        assertEquals(new Date(123456L), copied.getKuamoHuoquShijian());
        assertEquals(2, fixture.versionReads.get());
    }

    @Test
    public void repeatedOpenInTheSameReturnCycleReusesTheNewDraft() {
        Fixture fixture = new Fixture("audit_rejected");
        ElnRecordVos.Created first = fixture.open("revision-operation-1");

        ElnRecordVos.Created second = fixture.open("revision-operation-2");

        assertTrue(second.isExisting());
        assertEquals(first.getRevisionId(), second.getRevisionId());
        assertEquals(1, fixture.copyCalls.get());
        assertEquals(1, fixture.markHistoricalCalls.get());
        assertEquals(1, fixture.switchCalls.get());
    }

    @Test
    public void repeatedOperationCodeIsIdempotent() {
        Fixture fixture = new Fixture("audit_rejected");
        ElnRecordVos.Created first = fixture.open("revision-operation-1");

        ElnRecordVos.Created second = fixture.open("revision-operation-1");

        assertTrue(second.isExisting());
        assertEquals(first.getRevisionId(), second.getRevisionId());
        assertEquals(1, fixture.copyCalls.get());
        assertEquals(1, fixture.switchCalls.get());
        assertEquals(4, fixture.insertedRepeatRows.size());
        assertEquals(4, fixture.insertedRepeatValues.size());
    }

    @Test
    public void repeatValueCopyFailureStopsBeforeCurrentSwitchAndFormulaCalculation() {
        Fixture fixture = new Fixture("audit_rejected");
        fixture.repeatValueInsertResult = 0;

        expectDataException(() -> fixture.open("revision-operation-1"), "重复字段值复制失败");

        assertEquals(4, fixture.insertedRepeatRows.size());
        assertEquals(0, fixture.insertedRepeatValues.size());
        assertEquals(0, fixture.switchCalls.get());
        assertEquals(0, fixture.recalculateAllCalls.get());
        assertEquals("revision-1", fixture.record.getDangqianXiudingId());
        assertEquals(1, fixture.fenceReleaseCalls.get());
    }

    @Test
    public void repeatRowCopyFailureStopsBeforeValuesAndCurrentSwitch() {
        Fixture fixture = new Fixture("audit_rejected");
        fixture.repeatRowInsertResult = 0;

        expectDataException(() -> fixture.open("revision-operation-1"), "重复行复制失败");

        assertEquals(0, fixture.insertedRepeatRows.size());
        assertEquals(0, fixture.insertedRepeatValues.size());
        assertEquals(0, fixture.switchCalls.get());
        assertEquals(0, fixture.recalculateAllCalls.get());
        assertEquals("revision-1", fixture.record.getDangqianXiudingId());
        assertEquals(1, fixture.fenceReleaseCalls.get());
    }

    @Test
    public void historicalTransitionConflictStopsBeforeCopyAndCurrentSwitch() {
        Fixture fixture = new Fixture("audit_rejected");
        fixture.markHistoricalResult = 0;

        expectDataException(() -> fixture.open("revision-operation-1"), "状态冲突");

        assertEquals(0, fixture.copyCalls.get());
        assertEquals(0, fixture.switchCalls.get());
        assertEquals("revision-1", fixture.record.getDangqianXiudingId());
        assertEquals(1, fixture.fenceReleaseCalls.get());
    }

    @Test
    public void currentRevisionCasConflictIsRejectedBeforeFormulaCalculation() {
        Fixture fixture = new Fixture("audit_rejected");
        fixture.switchResult = 0;

        expectDataException(() -> fixture.open("revision-operation-1"), "当前修订切换冲突");

        assertEquals(1, fixture.switchCalls.get());
        assertEquals(0, fixture.recalculateAllCalls.get());
        assertEquals(1, fixture.fenceReleaseCalls.get());
    }

    @Test
    public void activeOnlyOfficeSessionStopsRevisionBeforeHistoricalMutation() {
        Fixture fixture = new Fixture("audit_rejected");
        fixture.fenceBusy = true;

        expectDataException(() -> fixture.open("revision-operation-1"), "正在编辑");

        assertEquals(1, fixture.fenceAcquireCalls.get());
        assertEquals(0, fixture.markHistoricalCalls.get());
        assertEquals(0, fixture.copyCalls.get());
        assertEquals(0, fixture.switchCalls.get());
    }

    @Test
    public void transactionCommitCompletesFenceOnlyAfterCommit() {
        Fixture fixture = new Fixture("audit_rejected");
        TransactionSynchronizationManager.initSynchronization();
        try {
            fixture.open("revision-operation-1");
            assertEquals(0, fixture.fenceCompleteCalls.get());
            assertEquals(0, fixture.fenceReleaseCalls.get());

            for (TransactionSynchronization synchronization
                    : TransactionSynchronizationManager.getSynchronizations()) {
                synchronization.afterCompletion(TransactionSynchronization.STATUS_COMMITTED);
            }

            assertEquals(1, fixture.fenceCompleteCalls.get());
            assertEquals(0, fixture.fenceReleaseCalls.get());
        } finally {
            TransactionSynchronizationManager.clearSynchronization();
        }
    }

    @Test
    public void transactionRollbackReleasesFenceAfterFailure() {
        Fixture fixture = new Fixture("audit_rejected");
        fixture.markHistoricalResult = 0;
        TransactionSynchronizationManager.initSynchronization();
        try {
            expectDataException(() -> fixture.open("revision-operation-1"), "状态冲突");
            assertEquals(0, fixture.fenceCompleteCalls.get());
            assertEquals(0, fixture.fenceReleaseCalls.get());

            for (TransactionSynchronization synchronization
                    : TransactionSynchronizationManager.getSynchronizations()) {
                synchronization.afterCompletion(TransactionSynchronization.STATUS_ROLLED_BACK);
            }

            assertEquals(0, fixture.fenceCompleteCalls.get());
            assertEquals(1, fixture.fenceReleaseCalls.get());
        } finally {
            TransactionSynchronizationManager.clearSynchronization();
        }
    }

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

    private static final class Fixture {
        private final String taskStatus;
        private final ElnRecordEntity record = record();
        private final ElnRecordRevisionEntity sourceRevision = revision();
        private final List<ElnRecordFieldValueEntity> sourceValues = sourceValues();
        private final List<ElnRecordRepeatRowEntity> sourceRepeatRows = sourceRepeatRows();
        private final List<ElnRecordRepeatValueEntity> sourceRepeatValues =
                sourceRepeatValues(sourceRepeatRows);
        private final Map<String, ElnRecordRevisionEntity> revisionsByOperation = new LinkedHashMap<>();
        private final List<ElnRecordFieldValueEntity> insertedValues = new ArrayList<>();
        private final List<ElnRecordRepeatRowEntity> insertedRepeatRows = new ArrayList<>();
        private final List<ElnRecordRepeatValueEntity> insertedRepeatValues = new ArrayList<>();
        private final AtomicInteger markHistoricalCalls = new AtomicInteger();
        private final AtomicInteger switchCalls = new AtomicInteger();
        private final AtomicInteger copyCalls = new AtomicInteger();
        private final AtomicInteger recalculateAllCalls = new AtomicInteger();
        private final AtomicInteger formulaUpdateCalls = new AtomicInteger();
        private final AtomicInteger fenceAcquireCalls = new AtomicInteger();
        private final AtomicInteger fenceCompleteCalls = new AtomicInteger();
        private final AtomicInteger fenceReleaseCalls = new AtomicInteger();
        private final AtomicInteger revisionLookupCalls = new AtomicInteger();
        private final AtomicInteger versionReads = new AtomicInteger();
        private final List<ElnFieldVersionEntity> versionResults = new ArrayList<>();
        private final ElnRecordRevisionServiceImpl service;
        private ElnRecordRevisionEntity currentRevision = sourceRevision;
        private String lookupOperationCode;
        private String copySource;
        private String copyTarget;
        private int markHistoricalResult = 1;
        private int switchResult = 1;
        private int repeatRowInsertResult = 1;
        private int repeatValueInsertResult = 1;
        private boolean fenceBusy;

        private Fixture(String taskStatus) {
            this.taskStatus = taskStatus;
            ElnRecordMapper recordMapper = proxy(ElnRecordMapper.class, (method, args) -> {
                if ("selectLiveByTestWorkItem".equals(method)
                        || "selectLiveForUpdate".equals(method)) return record;
                if ("switchCurrentRevision".equals(method)) {
                    switchCalls.incrementAndGet();
                    return switchResult;
                }
                return null;
            });
            ElnRecordRevisionMapper revisionMapper = proxy(
                    ElnRecordRevisionMapper.class, (method, args) -> {
                        if ("selectOne".equals(method)) {
                            return revisionLookupCalls.getAndIncrement() % 2 == 0
                                    ? currentRevision : revisionsByOperation.get(lookupOperationCode);
                        }
                        if ("markHistorical".equals(method)) {
                            markHistoricalCalls.incrementAndGet();
                            if (markHistoricalResult == 1) {
                                sourceRevision.setBizStatus("HISTORICAL");
                                sourceRevision.setFVersion(sourceRevision.getFVersion() + 1);
                            }
                            return markHistoricalResult;
                        }
                        if ("insert".equals(method)) {
                            currentRevision = (ElnRecordRevisionEntity) args[0];
                            revisionsByOperation.put(
                                    currentRevision.getXiudingCaozuoBianma(), currentRevision);
                            return 1;
                        }
                        return null;
                    });
            ElnRecordFieldValueMapper valueMapper = proxy(
                    ElnRecordFieldValueMapper.class, (method, args) -> {
                        if ("selectList".equals(method)) return new ArrayList<>(sourceValues);
                        if ("insert".equals(method)) {
                            insertedValues.add((ElnRecordFieldValueEntity) args[0]);
                            return 1;
                        }
                        if ("updateById".equals(method)) {
                            formulaUpdateCalls.incrementAndGet();
                            return 1;
                        }
                        return null;
                    });
            ElnRecordRepeatRowMapper repeatRowMapper = proxy(
                    ElnRecordRepeatRowMapper.class, (method, args) -> {
                        if ("selectList".equals(method)) {
                            return new ArrayList<>(sourceRepeatRows);
                        }
                        if ("insert".equals(method)) {
                            if (repeatRowInsertResult == 1) {
                                insertedRepeatRows.add((ElnRecordRepeatRowEntity) args[0]);
                            }
                            return repeatRowInsertResult;
                        }
                        return null;
                    });
            ElnRecordRepeatValueMapper repeatValueMapper = proxy(
                    ElnRecordRepeatValueMapper.class, (method, args) -> {
                        if ("selectList".equals(method)) {
                            return new ArrayList<>(sourceRepeatValues);
                        }
                        if ("insert".equals(method)) {
                            if (repeatValueInsertResult == 1) {
                                insertedRepeatValues.add((ElnRecordRepeatValueEntity) args[0]);
                            }
                            return repeatValueInsertResult;
                        }
                        return null;
                    });
            versionResults.addAll(Arrays.asList(
                    version("version-manual", "definition-manual", null, null),
                    version("version-lims", "definition-lims", "LIMS_TASK", "test.basis"),
                    version("version-system", "definition-system", "SYSTEM", "current_user.real_name")));
            ElnFieldVersionMapper versionMapper = proxy(
                    ElnFieldVersionMapper.class, (method, args) ->
                            "selectOne".equals(method)
                                    ? versionResults.get(versionReads.getAndIncrement()) : null);
            ElnTemplateFileService fileService = new ElnTemplateFileService(null, null) {
                @Override
                public String copyDocx(String sourceAttachments, String targetTemplateId) {
                    copyCalls.incrementAndGet();
                    copySource = sourceAttachments;
                    copyTarget = targetTemplateId;
                    return "[{\"fileId\":\"" + targetTemplateId + ".docx\","
                            + "\"name\":\"" + targetTemplateId + ".docx\","
                            + "\"fileExtension\":\"docx\"}]";
                }
            };
            ElnRecordFormulaCalculationService calculation =
                    new ElnRecordFormulaCalculationService() {
                        @Override
                        public List<ElnRecordFieldValueEntity> recalculateAffected(
                                String tenantId, ElnRecordEntity record,
                                ElnRecordRevisionEntity revision,
                                List<ElnRecordFieldValueEntity> values,
                                Set<String> changedBindingIds,
                                String operationCode, String operatorUserId) {
                            return Collections.emptyList();
                        }

                        @Override
                        public List<ElnRecordFieldValueEntity> recalculateAll(
                                String tenantId, ElnRecordEntity actualRecord,
                                ElnRecordRevisionEntity actualRevision,
                                List<ElnRecordFieldValueEntity> values,
                                String operationCode, String operatorUserId) {
                            recalculateAllCalls.incrementAndGet();
                            assertEquals("tenant-1", tenantId);
                            assertEquals(currentRevision.getId(), actualRevision.getId());
                            assertEquals(3, values.size());
                            assertEquals("user-2", operatorUserId);
                            ElnRecordFieldValueEntity calculated = values.get(0);
                            calculated.setJisuanZhuangtai("SUCCESS");
                            return Collections.singletonList(calculated);
                        }
                    };
            ElnTestWorkItemSnapshotProvider taskProvider = new ElnTestWorkItemSnapshotProvider() {
                @Override
                public TestWorkItemSnapshotBatch resolve(
                        List<String> testWorkItemIds, List<String> properties) {
                    throw new AssertionError("必须使用显式负责人快照");
                }

                @Override
                public TestWorkItemSnapshotBatch resolveAsActor(
                        String tenantId, String userId,
                        List<String> testWorkItemIds, List<String> properties) {
                    assertEquals("tenant-1", tenantId);
                    assertEquals("user-2", userId);
                    assertEquals(Collections.singletonList("item-1"), testWorkItemIds);
                    assertEquals(Collections.singletonList("test.basis"), properties);
                    return snapshot(Fixture.this.taskStatus);
                }
            };
            ElnRecordRevisionServiceImpl.RecordRevisionFence fence =
                    new ElnRecordRevisionServiceImpl.RecordRevisionFence() {
                        @Override
                        public String acquire(String tenantId, String recordId,
                                              String fileId, String fileType) {
                            fenceAcquireCalls.incrementAndGet();
                            assertEquals("tenant-1", tenantId);
                            assertEquals("record-1", recordId);
                            assertEquals("revision-1.docx", fileId);
                            assertEquals("annex", fileType);
                            if (fenceBusy) {
                                throw new DataException("记录文档正在编辑");
                            }
                            return "fence-token";
                        }

                        @Override
                        public void complete(ElnRecordRevisionServiceImpl.FenceLease lease) {
                            fenceCompleteCalls.incrementAndGet();
                        }

                        @Override
                        public void release(ElnRecordRevisionServiceImpl.FenceLease lease) {
                            fenceReleaseCalls.incrementAndGet();
                        }
                    };
            service = new ElnRecordRevisionServiceImpl(
                    taskProvider, recordMapper, revisionMapper, valueMapper, versionMapper,
                    repeatRowMapper, repeatValueMapper, fileService, calculation, fence,
                    () -> new ElnRecordRevisionServiceImpl.UserContext(
                            "tenant-1", "user-2", "新操作人"));
        }

        private ElnRecordVos.Created open(String operationCode) {
            lookupOperationCode = operationCode;
            ElnRecordForms.Create command = new ElnRecordForms.Create();
            command.setTestWorkItemId("item-1");
            command.setOperationCode(operationCode);
            return service.open(command);
        }
    }

    private static ElnRecordEntity record() {
        ElnRecordEntity record = new ElnRecordEntity();
        record.setId("record-1");
        record.setJianyanXiangId("item-1");
        record.setMubanId("template-1");
        record.setDangqianXiudingId("revision-1");
        record.setFTenantId("tenant-1");
        record.setFVersion(4);
        record.setFDeleteMark(0);
        return record;
    }

    private static ElnRecordRevisionEntity revision() {
        ElnRecordRevisionEntity revision = new ElnRecordRevisionEntity();
        revision.setId("revision-1");
        revision.setDianziJiluId("record-1");
        revision.setXiudingHao(1);
        revision.setXiudingCaozuoBianma("create-operation");
        revision.setJiluWendang("revision-1.docx");
        revision.setBizStatus("DRAFT");
        revision.setFTenantId("tenant-1");
        revision.setFVersion(2);
        revision.setFDeleteMark(0);
        return revision;
    }

    private static List<ElnRecordFieldValueEntity> sourceValues() {
        return Arrays.asList(
                value("value-manual", "binding-manual", "definition-manual",
                        "version-manual", "manual_field", "MANUAL", "manual value"),
                value("value-lims", "binding-lims", "definition-lims",
                        "version-lims", "test_basis", "LIMS_TASK", "old basis"),
                value("value-system", "binding-system", "definition-system",
                        "version-system", "operator_name", "SYSTEM", "旧操作人"));
    }

    private static List<ElnRecordRepeatRowEntity> sourceRepeatRows() {
        ElnRecordRepeatRowEntity active = repeatRow(
                "repeat-physical-active", "group-a", "row-a1", 1, "ACTIVE", 0);
        ElnRecordRepeatRowEntity prepared = repeatRow(
                "repeat-physical-prepared", "group-a", "row-a2", 2, "PREPARED", 0);
        ElnRecordRepeatRowEntity deleting = repeatRow(
                "repeat-physical-deleting", "group-b", "row-b1", 1,
                "DELETE_PREPARED", 0);
        deleting.setDeleteOperationCode("delete-operation-b1");
        deleting.setDeleteReason("录入错误");
        deleting.setDeleteRequestedUserId("user-1");
        deleting.setDeleteRequestedTime(new Date(1000L));
        ElnRecordRepeatRowEntity deleted = repeatRow(
                "repeat-physical-deleted", "group-b", "row-b2", 2, "DELETED", 1);
        deleted.setDeleteOperationCode("delete-operation-b2");
        deleted.setDeleteReason("样品作废");
        deleted.setDeleteRequestedUserId("user-1");
        deleted.setDeleteRequestedTime(new Date(2000L));
        deleted.setFDeleteUserId("user-1");
        deleted.setFDeleteTime(new Date(3000L));
        return Arrays.asList(active, prepared, deleting, deleted);
    }

    private static ElnRecordRepeatRowEntity repeatRow(
            String id, String groupCode, String rowId, int rowOrder,
            String status, int deleteMark) {
        ElnRecordRepeatRowEntity row = new ElnRecordRepeatRowEntity();
        row.setId(id);
        row.setDianziJiluId("record-1");
        row.setXiudingId("revision-1");
        row.setMubanId("template-1");
        row.setRepeatGroupCode(groupCode);
        row.setRowId(rowId);
        row.setRowOrder(rowOrder);
        row.setOperationCode("append-" + rowId);
        row.setOperationStatus(status);
        row.setFTenantId("tenant-1");
        row.setFVersion(rowOrder);
        row.setFDeleteMark(deleteMark);
        return row;
    }

    private static List<ElnRecordRepeatValueEntity> sourceRepeatValues(
            List<ElnRecordRepeatRowEntity> rows) {
        List<ElnRecordRepeatValueEntity> values = new ArrayList<>();
        for (ElnRecordRepeatRowEntity row : rows) {
            ElnRecordRepeatValueEntity value = new ElnRecordRepeatValueEntity();
            value.setId("repeat-value-" + row.getRowId());
            value.setDianziJiluId("record-1");
            value.setXiudingId("revision-1");
            value.setMubanId("template-1");
            value.setRepeatRowId(row.getRowId());
            value.setRepeatGroupCode(row.getRepeatGroupCode());
            value.setMubanBangdingId("repeat-binding-" + row.getRepeatGroupCode());
            value.setZiduanDingyiId("repeat-definition-" + row.getRepeatGroupCode());
            value.setZiduanBianma("result");
            value.setZiduanBanbenId("repeat-version-" + row.getRepeatGroupCode());
            value.setBangdingJuese("REPEAT");
            value.setBangdingZhuangtai("ACTIVE");
            value.setZhiWenben("value-" + row.getRowId());
            value.setZhiLaiyuan("MANUAL");
            value.setFTenantId("tenant-1");
            value.setFVersion(row.getFVersion());
            value.setFDeleteMark(row.getFDeleteMark());
            value.setFDeleteUserId(row.getFDeleteUserId());
            value.setFDeleteTime(row.getFDeleteTime());
            values.add(value);
        }
        return values;
    }

    private static ElnRecordFieldValueEntity value(
            String id, String bindingId, String definitionId, String versionId,
            String code, String source, String text) {
        ElnRecordFieldValueEntity value = new ElnRecordFieldValueEntity();
        value.setId(id);
        value.setDianziJiluId("record-1");
        value.setXiudingId("revision-1");
        value.setMubanId("template-1");
        value.setMubanBangdingId(bindingId);
        value.setZiduanDingyiId(definitionId);
        value.setZiduanBanbenId(versionId);
        value.setZiduanBianma(code);
        value.setBangdingJuese("PRIMARY");
        value.setBangdingZhuangtai("ACTIVE");
        value.setZhiLaiyuan(source);
        value.setZhiWenben(text);
        value.setFTenantId("tenant-1");
        value.setFVersion(3);
        value.setFDeleteMark(0);
        return value;
    }

    private static ElnFieldVersionEntity version(
            String id, String definitionId, String source, String property) {
        ElnFieldVersionEntity version = new ElnFieldVersionEntity();
        version.setId(id);
        version.setZiduanDingyiId(definitionId);
        version.setShujuLeixing("TEXT");
        if (source != null) {
            version.setBangdingPeizhi("{\"read\":{\"source\":\"" + source
                    + "\",\"property\":\"" + property + "\"}}");
        }
        return version;
    }

    private static TestWorkItemSnapshotBatch snapshot(String status) {
        TestWorkItemSnapshotProperty property = new TestWorkItemSnapshotProperty();
        property.setProperty("test.basis");
        property.setDataType("TEXT");
        property.setValue("new basis");
        property.setSource("LIMS_TASK");
        property.setSourceRef("item-1");
        property.setOutcomeCode("SUCCESS");
        TestWorkItemSnapshot item = new TestWorkItemSnapshot();
        item.setTestWorkItemId("item-1");
        item.setTaskStatus(status);
        item.setOutcomeCode("SUCCESS");
        item.setProperties(Collections.singletonList(property));
        TestWorkItemSnapshotBatch batch = new TestWorkItemSnapshotBatch();
        batch.setItems(Collections.singletonList(item));
        return batch;
    }

    @SuppressWarnings("unchecked")
    private static <T> T proxy(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);
    }
}