package jnpf.limsController;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategies;
import jnpf.base.ActionResult;
import jnpf.base.UserInfo;
import jnpf.lims.api.TestWorkItemSnapshotApi;
import jnpf.lims.api.model.TestWorkItemSnapshotActorRequest;
import jnpf.lims.api.model.TestWorkItemSnapshotBatch;
import jnpf.lims.api.model.TestWorkItemSnapshot;
import jnpf.lims.api.model.TestWorkItemSnapshotProperty;
import jnpf.lims.api.model.TestWorkItemSnapshotRequest;
import jnpf.lims.api.model.TestWorkItemRequestIdentityActorRequest;
import jnpf.lims.api.model.TestWorkItemRequestIdentityBatch;
import jnpf.limsService.LimsTestWorkItemSnapshotService;
import org.junit.Test;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;

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

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

public class LimsTestWorkItemSnapshotControllerTest {

    @Test
    public void passesAuthenticatedUserAndFallbackTenantToSnapshotService() {
        UserInfo user = new UserInfo();
        user.setUserId("user-a");
        user.setTenantId("");
        TestWorkItemSnapshotBatch expected = new TestWorkItemSnapshotBatch();
        AtomicReference<String> tenant = new AtomicReference<>();
        AtomicReference<String> userId = new AtomicReference<>();
        LimsTestWorkItemSnapshotService service = (request, currentTenant, currentUser) -> {
            tenant.set(currentTenant);
            userId.set(currentUser);
            return expected;
        };

        ActionResult<TestWorkItemSnapshotBatch> actual = new LimsTestWorkItemSnapshotController(
                () -> user, service, actor -> expected,
                actor -> new TestWorkItemRequestIdentityBatch())
                .snapshots(new TestWorkItemSnapshotRequest());

        assertSame(expected, actual.getData());
        assertEquals("0", tenant.get());
        assertEquals("user-a", userId.get());
    }

    @Test
    public void controllerAndFeignShareTheInternalSnapshotPath() throws Exception {
        FeignClient feign = TestWorkItemSnapshotApi.class.getAnnotation(FeignClient.class);
        assertEquals("jnpf-lims", feign.name());
        assertEquals("/Internal/lims/testWorkItems", feign.path());
        assertEquals("/snapshots", TestWorkItemSnapshotApi.class.getMethod(
                "snapshots", TestWorkItemSnapshotRequest.class).getAnnotation(PostMapping.class).value()[0]);
        assertEquals("/snapshots", LimsTestWorkItemSnapshotController.class.getMethod(
                "snapshots", TestWorkItemSnapshotRequest.class).getAnnotation(PostMapping.class).value()[0]);
        assertEquals("/snapshots/asActor", TestWorkItemSnapshotApi.class.getMethod(
                "snapshotsAsActor", TestWorkItemSnapshotActorRequest.class).getAnnotation(PostMapping.class).value()[0]);
        assertEquals("/requestIdentities/asActor", TestWorkItemSnapshotApi.class.getMethod(
                "requestIdentitiesAsActor", TestWorkItemRequestIdentityActorRequest.class)
                .getAnnotation(PostMapping.class).value()[0]);
        assertEquals("/requestIdentities/asActor",
                LimsTestWorkItemSnapshotController.class.getMethod(
                        "requestIdentitiesAsActor", TestWorkItemRequestIdentityActorRequest.class)
                        .getAnnotation(PostMapping.class).value()[0]);
    }

    @Test
    public void snapshotContractKeepsLowerCamelJsonAcrossLimsAndFeignMappers() throws Exception {
        TestWorkItemSnapshotRequest request = new TestWorkItemSnapshotRequest();
        request.setTestWorkItemIds(Arrays.asList("item-1"));
        request.setProperties(Arrays.asList("test.basis"));
        TestWorkItemSnapshotActorRequest actor = new TestWorkItemSnapshotActorRequest();
        actor.setTenantId("tenant-1");
        actor.setUserId("user-1");
        actor.setRequest(request);

        TestWorkItemSnapshotProperty property = new TestWorkItemSnapshotProperty();
        property.setDataType("TEXT");
        property.setSourceRef("item-1");
        property.setOutcomeCode("SUCCESS");
        TestWorkItemSnapshot item = new TestWorkItemSnapshot();
        item.setTestWorkItemId("item-1");
        item.setTestRequestId("request-1");
        item.setTestDefinitionId("project-1");
        item.setTestDefinitionCode("HD_jyxm_0008");
        item.setTestDefinitionName("pH值");
        item.setTaskStatus("pending_test");
        item.setOutcomeCode("SUCCESS");
        item.getProperties().add(property);
        TestWorkItemSnapshotBatch batch = new TestWorkItemSnapshotBatch();
        batch.getItems().add(item);

        ObjectMapper limsMapper = new ObjectMapper()
                .setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
        JsonNode actorJson = limsMapper.readTree(limsMapper.writeValueAsString(actor));
        JsonNode batchJson = limsMapper.readTree(limsMapper.writeValueAsString(batch));

        assertEquals("item-1", actorJson.at("/request/testWorkItemIds/0").asText());
        assertEquals("tenant-1", actorJson.path("tenantId").asText());
        assertEquals("item-1", batchJson.at("/items/0/testWorkItemId").asText());
        assertEquals("request-1", batchJson.at("/items/0/testRequestId").asText());
        assertEquals("project-1", batchJson.at("/items/0/testDefinitionId").asText());
        assertEquals("HD_jyxm_0008", batchJson.at("/items/0/testDefinitionCode").asText());
        assertEquals("pH值", batchJson.at("/items/0/testDefinitionName").asText());
        assertEquals("pending_test", batchJson.at("/items/0/taskStatus").asText());
        assertEquals("SUCCESS", batchJson.at("/items/0/outcomeCode").asText());
        assertEquals("TEXT", batchJson.at("/items/0/properties/0/dataType").asText());
        assertEquals("item-1", batchJson.at("/items/0/properties/0/sourceRef").asText());

        ObjectMapper feignMapper = new ObjectMapper();
        TestWorkItemSnapshotActorRequest decodedActor = feignMapper.readValue(
                limsMapper.writeValueAsString(actor), TestWorkItemSnapshotActorRequest.class);
        TestWorkItemSnapshotBatch decodedBatch = feignMapper.readValue(
                limsMapper.writeValueAsString(batch), TestWorkItemSnapshotBatch.class);
        assertEquals("item-1", decodedActor.getRequest().getTestWorkItemIds().get(0));
        assertEquals("item-1", decodedBatch.getItems().get(0).getTestWorkItemId());
        assertEquals("request-1", decodedBatch.getItems().get(0).getTestRequestId());
        assertEquals("HD_jyxm_0008", decodedBatch.getItems().get(0).getTestDefinitionCode());
        assertEquals("pH值", decodedBatch.getItems().get(0).getTestDefinitionName());
        assertEquals("SUCCESS", decodedBatch.getItems().get(0).getProperties().get(0).getOutcomeCode());
    }

}