package jnpf.elnService.impl;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import jnpf.elnEntity.runtime.ElnRecordForms;
import jnpf.elnEntity.runtime.ElnRecordVos;
import jnpf.elnEntity.runtime.ElnSharedFillOperationEntity;
import jnpf.elnEntity.runtime.ElnSharedFillTargetOperationEntity;
import jnpf.elnMapper.ElnSharedFillOperationMapper;
import jnpf.elnMapper.ElnSharedFillTargetOperationMapper;
import jnpf.exception.DataException;
import jnpf.util.JsonUtil;
import org.junit.Before;
import org.junit.Test;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

public class ElnRecordSharedFillOperationServiceTest {

    private ElnSharedFillOperationMapper operationMapper;
    private ElnSharedFillTargetOperationMapper targetMapper;
    private ElnRecordSharedFillOperationService service;

    @Before
    public void setUp() {
        operationMapper = mock(ElnSharedFillOperationMapper.class);
        targetMapper = mock(ElnSharedFillTargetOperationMapper.class);
        service = new ElnRecordSharedFillOperationService(operationMapper, targetMapper);
    }

    @Test
    public void rejectsTheSameOperationCodeForADifferentRequest() {
        when(operationMapper.insertIgnore(any())).thenReturn(0);
        when(operationMapper.selectOne(any(Wrapper.class)))
                .thenReturn(operation("OPEN", "digest-a", "user-1", null));

        try {
            service.begin("tenant-a", "user-1", "shared-fill-1", "digest-b");
            fail("a reused operation code must keep the original request digest");
        } catch (DataException expected) {
            assertEquals("批量填写操作码已用于其他请求", expected.getMessage());
        }
    }

    @Test
    public void rejectsAnUnknownPersistentOperationStatus() {
        when(operationMapper.insertIgnore(any())).thenReturn(0);
        when(operationMapper.selectOne(any(Wrapper.class)))
                .thenReturn(operation("FAILED", "digest-a", "user-1", null));

        try {
            service.begin("tenant-a", "user-1", "shared-fill-1", "digest-a");
            fail("an unknown operation status must not be resumed");
        } catch (DataException expected) {
            assertEquals("批量填写操作状态无效", expected.getMessage());
        }
    }

    @Test
    public void revalidatesAnOpenOperationThatHasNoCompletedTarget() {
        when(operationMapper.insertIgnore(any())).thenReturn(0);
        when(operationMapper.selectOne(any(Wrapper.class)))
                .thenReturn(operation("OPEN", "digest-a", "user-1", null));
        when(targetMapper.selectCount(any(Wrapper.class))).thenReturn(0L);

        ElnRecordSharedFillServiceImpl.OperationStart start = service.begin(
                "tenant-a", "user-1", "shared-fill-1", "digest-a");

        assertEquals(false, start.isResuming());
    }

    @Test
    public void resumesAnOpenOperationAfterATargetCompleted() {
        when(operationMapper.insertIgnore(any())).thenReturn(0);
        when(operationMapper.selectOne(any(Wrapper.class)))
                .thenReturn(operation("OPEN", "digest-a", "user-1", null));
        when(targetMapper.selectCount(any(Wrapper.class))).thenReturn(1L);

        ElnRecordSharedFillServiceImpl.OperationStart start = service.begin(
                "tenant-a", "user-1", "shared-fill-1", "digest-a");

        assertEquals(true, start.isResuming());
    }

    @Test
    public void replaysACompletedTargetWithoutReservingItAgain() {
        ElnRecordVos.SharedFillTargetResult stored = targetResult("COMMITTED", 4);
        when(targetMapper.insertIgnore(any())).thenReturn(0);
        when(targetMapper.selectOne(any(Wrapper.class))).thenReturn(
                targetOperation("COMPLETED", "record-1",
                        JsonUtil.getObjectToString(stored)));

        ElnRecordVos.SharedFillTargetResult replayed = service.reserveTarget(
                "tenant-a", "user-1", "shared-fill-1", target());

        assertNotNull(replayed);
        assertEquals("COMMITTED", replayed.getStatus());
        assertEquals(Integer.valueOf(4), replayed.getRecordVersion());
    }

    @Test
    public void returnsNullAfterPersistingANewTargetReservation() {
        when(targetMapper.insertIgnore(any())).thenReturn(1);

        assertNull(service.reserveTarget(
                "tenant-a", "user-1", "shared-fill-1", target()));
    }

    @Test
    public void returnsTheStoredSummaryWhenCompletionCasAlreadyWon() {
        ElnRecordVos.SharedFilled stored = summary("shared-fill-1", "COMMITTED");
        when(operationMapper.complete(anyString(), anyString(), anyString(),
                anyString(), anyString())).thenReturn(0);
        when(operationMapper.selectOne(any(Wrapper.class))).thenReturn(
                operation("COMPLETED", "digest-a", "user-1",
                        JsonUtil.getObjectToString(stored)));

        ElnRecordVos.SharedFilled replayed = service.complete(
                "tenant-a", "user-1", "shared-fill-1", "digest-a",
                summary("shared-fill-1", "REJECTED"));

        assertEquals("COMMITTED", replayed.getTargets().get(0).getStatus());
        verify(operationMapper).complete(eq("tenant-a"), eq("shared-fill-1"),
                eq("digest-a"), anyString(), eq("user-1"));
    }

    private static ElnSharedFillOperationEntity operation(
            String status, String digest, String userId, String resultJson) {
        ElnSharedFillOperationEntity value = new ElnSharedFillOperationEntity();
        value.setOperationStatus(status);
        value.setRequestDigest(digest);
        value.setOperatorUserId(userId);
        value.setResultJson(resultJson);
        return value;
    }

    private static ElnSharedFillTargetOperationEntity targetOperation(
            String status, String recordId, String resultJson) {
        ElnSharedFillTargetOperationEntity value =
                new ElnSharedFillTargetOperationEntity();
        value.setOperationStatus(status);
        value.setDianziJiluId(recordId);
        value.setResultJson(resultJson);
        return value;
    }

    private static ElnRecordForms.SharedFillTarget target() {
        ElnRecordForms.SharedFillTarget value = new ElnRecordForms.SharedFillTarget();
        value.setTestWorkItemId("item-1");
        value.setRecordId("record-1");
        value.setExpectedRecordVersion(3);
        return value;
    }

    private static ElnRecordVos.SharedFillTargetResult targetResult(
            String status, int recordVersion) {
        ElnRecordVos.SharedFillTargetResult value =
                new ElnRecordVos.SharedFillTargetResult();
        value.setTestWorkItemId("item-1");
        value.setRecordId("record-1");
        value.setStatus(status);
        value.setRecordVersion(recordVersion);
        return value;
    }

    private static ElnRecordVos.SharedFilled summary(
            String operationCode, String targetStatus) {
        ElnRecordVos.SharedFilled value = new ElnRecordVos.SharedFilled();
        value.setOperationCode(operationCode);
        value.getTargets().add(targetResult(targetStatus, 4));
        return value;
    }
}