package jnpf.elnController;

import jnpf.elnService.ElnRecordFillTicketService;
import jnpf.elnService.ElnRecordRepeatService;
import jnpf.elnService.ElnRecordSourceSyncService;
import jnpf.elnEntity.runtime.ElnRecordForms;
import jnpf.elnEntity.runtime.ElnRecordVos;
import jnpf.util.JsonUtil;
import jnpf.util.NoDataSourceBind;
import org.junit.Test;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.lang.reflect.Method;
import java.lang.reflect.Constructor;
import java.util.concurrent.atomic.AtomicReference;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertArrayEquals;

public class ElnRecordFillControllerTest {

    @Test
    public void recordFillIsCanonicalAndTemplateFillRemainsACompatibilityRoute() {
        RequestMapping mapping = ElnRecordFillController.class.getAnnotation(RequestMapping.class);

        assertNotNull(mapping);
        assertArrayEquals(new String[]{"/onlyoffice/recordFill", "/onlyoffice/templateFill"},
                mapping.value());
    }

    @Test
    public void synchronizesRecordSourceWithTheValidatedFillTicket() {
        ElnRecordFillTicketService tickets = new ElnRecordFillTicketService(
                ticket -> JsonUtil.getObjectToString(recordPayload()));
        AtomicReference<ElnRecordFillTicketService.FillTicketContext> observedTicket =
                new AtomicReference<>();
        AtomicReference<ElnRecordForms.SourceSync> observedCommand = new AtomicReference<>();
        ElnRecordVos.SourceSynchronized expected = new ElnRecordVos.SourceSynchronized();
        expected.setRecordId("record-1");
        ElnRecordSourceSyncService sourceSync = new ElnRecordSourceSyncService() {
            @Override
            public ElnRecordVos.SourceSyncPreview preview(String recordId) { return null; }

            @Override
            public ElnRecordVos.SourceSyncPreview preview(
                    ElnRecordFillTicketService.FillTicketContext ticket) { return null; }

            @Override
            public ElnRecordVos.SourceSynchronized synchronize(
                    String recordId, ElnRecordForms.SourceSync command) { return null; }

            @Override
            public ElnRecordVos.SourceSynchronized synchronize(
                    ElnRecordFillTicketService.FillTicketContext ticket,
                    ElnRecordForms.SourceSync command) {
                observedTicket.set(ticket);
                observedCommand.set(command);
                return expected;
            }
        };
        ElnRecordFillController controller = new ElnRecordFillController(
                tickets, ticket -> Collections.emptyMap(), null, sourceSync);
        ElnRecordForms.SourceSync command = new ElnRecordForms.SourceSync();
        command.setOperationCode("sync-1");

        ResponseEntity<ElnRecordVos.SourceSynchronized> response =
                controller.synchronizeSource("Ticket ticket-1", command);

        assertEquals(200, response.getStatusCodeValue());
        assertEquals(expected, response.getBody());
        assertEquals("record-1", observedTicket.get().getBizDataId());
        assertEquals(command, observedCommand.get());
    }

    @Test
    public void previewsRecordSourceSyncWithTheValidatedFillTicket() {
        ElnRecordFillTicketService tickets = new ElnRecordFillTicketService(
                ticket -> JsonUtil.getObjectToString(recordPayload()));
        AtomicReference<ElnRecordFillTicketService.FillTicketContext> observed =
                new AtomicReference<>();
        ElnRecordVos.SourceSyncPreview expected = new ElnRecordVos.SourceSyncPreview();
        expected.setRecordId("record-1");
        ElnRecordSourceSyncService sourceSync = new ElnRecordSourceSyncService() {
            @Override
            public ElnRecordVos.SourceSyncPreview preview(String recordId) {
                return null;
            }

            @Override
            public ElnRecordVos.SourceSyncPreview preview(
                    ElnRecordFillTicketService.FillTicketContext ticket) {
                observed.set(ticket);
                return expected;
            }

            @Override
            public ElnRecordVos.SourceSynchronized synchronize(
                    String recordId, ElnRecordForms.SourceSync command) {
                return null;
            }

            @Override
            public ElnRecordVos.SourceSynchronized synchronize(
                    ElnRecordFillTicketService.FillTicketContext ticket,
                    ElnRecordForms.SourceSync command) {
                return null;
            }
        };
        ElnRecordFillController controller = new ElnRecordFillController(
                tickets, ticket -> Collections.emptyMap(), null, sourceSync);

        ResponseEntity<ElnRecordVos.SourceSyncPreview> response =
                controller.previewSourceSync("Ticket ticket-1");

        assertEquals(200, response.getStatusCodeValue());
        assertEquals(expected, response.getBody());
        assertEquals("record-1", observed.get().getBizDataId());
        assertEquals("file-1", observed.get().getFileId());
    }

    @Test
    public void loadsPendingSourceSyncBeforeAuthoritativeDataWithTheValidatedTicket() {
        ElnRecordFillTicketService tickets = new ElnRecordFillTicketService(
                ticket -> JsonUtil.getObjectToString(recordPayload()));
        AtomicReference<ElnRecordFillTicketService.FillTicketContext> observedTicket =
                new AtomicReference<>();
        List<String> dataLoadOrder = new ArrayList<>();
        ElnRecordVos.SourceSynchronized expected = new ElnRecordVos.SourceSynchronized();
        expected.setRecordId("record-1");
        expected.setOperationCode("sync-1");
        ElnRecordSourceSyncService sourceSync = new ElnRecordSourceSyncService() {
            @Override public ElnRecordVos.SourceSyncPreview preview(String recordId) { return null; }
            @Override public ElnRecordVos.SourceSyncPreview preview(
                    ElnRecordFillTicketService.FillTicketContext ticket) { return null; }
            @Override public ElnRecordVos.SourceSynchronized synchronize(
                    String recordId, ElnRecordForms.SourceSync command) { return null; }
            @Override public ElnRecordVos.SourceSynchronized synchronize(
                    ElnRecordFillTicketService.FillTicketContext ticket,
                    ElnRecordForms.SourceSync command) { return null; }
            @Override public ElnRecordVos.SourceSynchronized pending(
                    ElnRecordFillTicketService.FillTicketContext ticket) {
                dataLoadOrder.add("pending");
                observedTicket.set(ticket);
                return expected;
            }
        };
        ElnRecordFillController controller = new ElnRecordFillController(
                tickets, ticket -> {
                    dataLoadOrder.add("data");
                    return Collections.emptyMap();
                }, null, sourceSync);
        assertEquals(expected, controller.data(
                "Ticket ticket-1").getBody().get("pendingSourceSync"));
        assertEquals("pending", dataLoadOrder.get(0));
        assertEquals("data", dataLoadOrder.get(1));
        assertEquals("record-1", observedTicket.get().getBizDataId());
    }

    @Test
    public void deleteAndRestoreRepeatRowUseTheValidatedFillTicket() {
        ElnRecordFillTicketService tickets = new ElnRecordFillTicketService(
                ticket -> JsonUtil.getObjectToString(recordPayload()));
        AtomicReference<ElnRecordFillTicketService.FillTicketContext> observed =
                new AtomicReference<>();
        ElnRecordVos.RepeatRow expected = new ElnRecordVos.RepeatRow();
        expected.setRowId("row-1");
        ElnRecordRepeatService repeats = new ElnRecordRepeatService() {
            @Override
            public ElnRecordVos.RepeatRow append(ElnRecordFillTicketService.FillTicketContext ticket,
                    ElnRecordForms.RepeatAppend form) {
                return null;
            }

            @Override
            public ElnRecordVos.RepeatRow requestDelete(
                    ElnRecordFillTicketService.FillTicketContext ticket,
                    ElnRecordForms.RepeatDelete form) {
                observed.set(ticket);
                return expected;
            }

            @Override
            public ElnRecordVos.RepeatRow restoreDelete(
                    ElnRecordFillTicketService.FillTicketContext ticket,
                    ElnRecordForms.RepeatRestore form) {
                observed.set(ticket);
                return expected;
            }
        };
        ElnRecordFillController controller = new ElnRecordFillController(
                tickets, ticket -> Collections.emptyMap(), repeats);

        assertEquals(expected, controller.deleteRepeatRow(
                "Ticket ticket-1", new ElnRecordForms.RepeatDelete()).getBody());
        assertEquals("record-1", observed.get().getBizDataId());
        assertEquals(expected, controller.restoreRepeatRow(
                "Ticket ticket-1", new ElnRecordForms.RepeatRestore()).getBody());
        assertEquals("record-1", observed.get().getBizDataId());
    }

    @Test
    public void validTicketReturnsEmptyFields() {
        ElnRecordFillTicketService tickets = new ElnRecordFillTicketService(ticket -> JsonUtil.getObjectToString(validPayload()));
        ResponseEntity<Map<String, Object>> response = new ElnRecordFillController(tickets).data("Ticket ticket-1");

        assertEquals(200, response.getStatusCodeValue());
        assertEquals(Collections.emptyMap(), response.getBody().get("fields"));
    }

    @Test
    public void missingOrInvalidTicketReturns401() {
        ElnRecordFillTicketService tickets = new ElnRecordFillTicketService(ticket -> null);
        ElnRecordFillController controller = new ElnRecordFillController(tickets);

        assertEquals(401, controller.data(null).getStatusCodeValue());
        assertEquals(401, controller.data("Bearer login-token").getStatusCodeValue());
        assertEquals(401, controller.data("Ticket expired").getStatusCodeValue());
        assertEquals(401, controller.previewSourceSync("Ticket expired").getStatusCodeValue());
        assertEquals(401, controller.synchronizeSource(
                "Ticket expired", new ElnRecordForms.SourceSync()).getStatusCodeValue());
    }

    @Test
    public void dataEndpointDoesNotBindTheAnonymousTicketRequestToAResidualTenant() throws Exception {
        Method data = ElnRecordFillController.class.getMethod("data", String.class);
        assertNotNull(data.getAnnotation(NoDataSourceBind.class));
    }

    @Test
    public void springUsesTheFullDependencyConstructor() throws Exception {
        Constructor<ElnRecordFillController> constructor = ElnRecordFillController.class.getConstructor(
                ElnRecordFillTicketService.class,
                jnpf.elnService.ElnRecordFillDataService.class,
                jnpf.elnService.ElnRecordRepeatService.class,
                jnpf.elnService.ElnRecordSourceSyncService.class);
        assertNotNull(constructor.getAnnotation(org.springframework.beans.factory.annotation.Autowired.class));
    }

    private Map<String, String> validPayload() {
        return new java.util.LinkedHashMap<String, String>() {{
            put("scope", ElnRecordFillTicketService.SCOPE); put("tenantId", "tenant-1");
            put("userId", "user-1"); put("fileId", "file-1"); put("bizDataId", "record-1");
            put("bizModule", ElnRecordFillTicketService.BIZ_MODULE);
            put("bizScene", ElnRecordFillTicketService.BIZ_SCENE);
            put("pluginGuid", "asc.{7F4E8F35-5D66-47F8-A5B4-6AB3FAACF565}");
        }};
    }

    private Map<String, String> recordPayload() {
        return validPayload();
    }
}