package jnpf.elnService.impl;

import jnpf.base.ActionResult;
import jnpf.exception.DataException;
import jnpf.lims.api.TestWorkItemSnapshotApi;
import jnpf.lims.api.ElnSourceApi;
import jnpf.lims.api.model.ElnSourceActorRequest;
import jnpf.lims.api.model.ElnSourcePropertyRef;
import jnpf.lims.api.model.ElnSourceSnapshot;
import jnpf.lims.api.model.TestWorkItemSnapshotActorRequest;
import jnpf.lims.api.model.TestWorkItemSnapshotBatch;
import jnpf.lims.api.model.TestWorkItemSnapshotRequest;
import jnpf.lims.api.model.TestWorkItemRequestIdentityActorRequest;
import jnpf.lims.api.model.TestWorkItemRequestIdentityBatch;
import org.junit.Test;

import java.util.Arrays;
import java.util.concurrent.atomic.AtomicReference;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;

public class LimsTestWorkItemSnapshotProviderAdapterTest {

    @Test
    public void sendsPinnedRevisionsAndOwnerIdentityToTheIndependentSourceInterface() {
        ElnSourceApi sourceApi = org.mockito.Mockito.mock(ElnSourceApi.class);
        ElnSourceSnapshot value = new ElnSourceSnapshot();
        value.setPropertyCode("sample.amount");
        value.setPropertyRevision(1);
        value.setDataType("DECIMAL");
        value.setValue("123456789012345.123456789012345");
        org.mockito.Mockito.when(sourceApi.resolveAsActor(org.mockito.ArgumentMatchers.any()))
                .thenReturn(ActionResult.success("OK", Arrays.asList(value)));
        LimsTestWorkItemSnapshotProviderAdapter provider = new LimsTestWorkItemSnapshotProviderAdapter(
                api(request -> { throw new AssertionError("Configured values must not use the legacy resolver"); }), sourceApi);

        java.util.List<ElnSourceSnapshot> result = provider.resolveConfiguredAsActor("0", "analyst",
                Arrays.asList("task-a"), Arrays.asList(new ElnSourcePropertyRef("sample.amount", 1)));

        assertEquals("123456789012345.123456789012345", result.get(0).getValue());
        org.mockito.ArgumentCaptor<ElnSourceActorRequest> request = org.mockito.ArgumentCaptor.forClass(ElnSourceActorRequest.class);
        org.mockito.Mockito.verify(sourceApi).resolveAsActor(request.capture());
        assertEquals("analyst", request.getValue().getUserId());
        assertEquals("0", request.getValue().getTenantId());
        assertEquals(Integer.valueOf(1), request.getValue().getProperties().get(0).getRevision());
    }

    @Test
    public void delegatesTheBatchContractToLimsWithoutReadingLimsEntities() {
        AtomicReference<TestWorkItemSnapshotRequest> captured = new AtomicReference<>();
        TestWorkItemSnapshotBatch expected = new TestWorkItemSnapshotBatch();
        TestWorkItemSnapshotApi api = api(request -> {
            captured.set(request);
            return ActionResult.success("读取成功", expected);
        });

        TestWorkItemSnapshotBatch actual = new LimsTestWorkItemSnapshotProviderAdapter(api).resolve(
                Arrays.asList("task-a", "task-b"), Arrays.asList("test.basis", "unknown.property"));

        assertSame(expected, actual);
        assertEquals(Arrays.asList("task-a", "task-b"), captured.get().getTestWorkItemIds());
        assertEquals(Arrays.asList("test.basis", "unknown.property"), captured.get().getProperties());
    }

    @Test(expected = DataException.class)
    public void rejectsRemoteBusinessFailureInsteadOfReturningAnEmptySnapshot() {
        TestWorkItemSnapshotApi api = api(request -> ActionResult.fail("LIMS 快照服务拒绝请求"));

        new LimsTestWorkItemSnapshotProviderAdapter(api).resolve(
                Arrays.asList("task-a"), Arrays.asList("test.basis"));
    }

    private static TestWorkItemSnapshotApi api(final SnapshotResponder responder) {
        return new TestWorkItemSnapshotApi() {
            @Override
            public ActionResult<TestWorkItemSnapshotBatch> snapshots(TestWorkItemSnapshotRequest request) {
                return responder.respond(request);
            }

            @Override
            public ActionResult<TestWorkItemSnapshotBatch> snapshotsAsActor(
                    TestWorkItemSnapshotActorRequest request) {
                return responder.respond(request.getRequest());
            }

            @Override
            public ActionResult<TestWorkItemRequestIdentityBatch> requestIdentitiesAsActor(
                    TestWorkItemRequestIdentityActorRequest request) {
                return ActionResult.fail("unused");
            }
        };
    }

    @FunctionalInterface
    private interface SnapshotResponder {
        ActionResult<TestWorkItemSnapshotBatch> respond(TestWorkItemSnapshotRequest request);
    }
}