package jnpf.elnService.impl;

import jnpf.elnEntity.runtime.ElnRecordEntity;
import jnpf.elnService.ElnTestRequestIdentityLookup;
import jnpf.elnService.ElnRecordSourceCandidateStore;
import jnpf.elnService.ElnRecordSourceResolver;
import jnpf.exception.DataException;
import org.junit.Test;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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

public class ElnRecordSourceResolverImplTest {

    @Test
    public void resolvesTheOnlySourceRecordUnderTheSameTenantRequestAndTemplateCode() {
        ElnRecordEntity source = record("source-1", "tenant-a", "item-source", "SOURCE-TEMPLATE");
        ElnRecordSourceResolver resolver = resolver(
                (tenantId, templateCode) -> Collections.singletonList(source),
                (tenantId, testWorkItemIds) -> identities("item-source", "request-1"));

        ElnRecordEntity actual = resolver.resolve("tenant-a", "request-1", "SOURCE-TEMPLATE");

        assertEquals("source-1", actual.getId());
    }

    @Test
    public void rejectsWhenNoSourceRecordMatchesTheRequestIdentity() {
        ElnRecordEntity source = record("source-1", "tenant-a", "item-source", "SOURCE-TEMPLATE");
        ElnRecordSourceResolver resolver = resolver(
                (tenantId, templateCode) -> Collections.singletonList(source),
                (tenantId, testWorkItemIds) -> identities("item-source", "another-request"));

        assertFailure(resolver, "SOURCE_RECORD_NOT_FOUND");
    }

    @Test
    public void rejectsWhenMoreThanOneSourceRecordMatchesTheRequestIdentity() {
        ElnRecordEntity first = record("source-1", "tenant-a", "item-source-1", "SOURCE-TEMPLATE");
        ElnRecordEntity second = record("source-2", "tenant-a", "item-source-2", "SOURCE-TEMPLATE");
        ElnRecordSourceResolver resolver = resolver(
                (tenantId, templateCode) -> Arrays.asList(first, second),
                (tenantId, testWorkItemIds) -> identities(
                        "item-source-1", "request-1", "item-source-2", "request-1"));

        assertFailure(resolver, "SOURCE_RECORD_AMBIGUOUS");
    }

    @Test
    public void excludesCandidatesFromAnotherTenantEvenWhenTheStoreLeaksThem() {
        ElnRecordEntity local = record("source-local", "tenant-a", "item-local", "SOURCE-TEMPLATE");
        ElnRecordEntity foreign = record("source-foreign", "tenant-b", "item-foreign", "SOURCE-TEMPLATE");
        ElnRecordSourceResolver resolver = resolver(
                (tenantId, templateCode) -> Arrays.asList(local, foreign),
                (tenantId, testWorkItemIds) -> {
                    assertEquals("tenant-a", tenantId);
                    return identities("item-local", "request-1", "item-foreign", "request-1");
                });

        ElnRecordEntity actual = resolver.resolve("tenant-a", "request-1", "SOURCE-TEMPLATE");

        assertEquals("source-local", actual.getId());
    }

    @Test
    public void rejectsMatchingSourceRecordsThatHaveNotBeenSubmitted() {
        ElnRecordEntity source = record("source-1", "tenant-a", "item-source", "SOURCE-TEMPLATE");
        ElnRecordSourceResolver resolver = resolver(
                (tenantId, templateCode) -> Collections.singletonList(source),
                (tenantId, testWorkItemIds) -> identitiesWithStatus(
                        "item-source", "request-1", "pending_test"));

        assertFailure(resolver, "SOURCE_RECORD_STATE_NOT_ALLOWED");
    }

    @Test
    public void acceptsBothSubmittedStatusesWithoutChangingSourceIdentity() {
        ElnRecordEntity source = record("source-1", "tenant-a", "item-source", "SOURCE-TEMPLATE");
        for (String status : Arrays.asList("pending_audit", "audited")) {
            ElnRecordSourceResolver resolver = resolver(
                    (tenantId, templateCode) -> Collections.singletonList(source),
                    (tenantId, testWorkItemIds) -> identitiesWithStatus(
                            "item-source", "request-1", status));

            assertEquals("source-1",
                    resolver.resolve("tenant-a", "request-1", "SOURCE-TEMPLATE").getId());
        }
    }

    private static ElnRecordSourceResolver resolver(ElnRecordSourceCandidateStore candidates,
                                                    ElnTestRequestIdentityLookup identities) {
        return new ElnRecordSourceResolverImpl(candidates, identities);
    }

    private static ElnRecordEntity record(String id, String tenantId, String testWorkItemId,
                                          String templateCode) {
        ElnRecordEntity result = new ElnRecordEntity();
        result.setId(id);
        result.setFTenantId(tenantId);
        result.setJianyanXiangId(testWorkItemId);
        result.setMubanBianhao(templateCode);
        return result;
    }

    private static Map<String, ElnTestRequestIdentityLookup.Identity> identities(
            String... pairs) {
        Map<String, ElnTestRequestIdentityLookup.Identity> result = new HashMap<>();
        for (int index = 0; index < pairs.length; index += 2) {
            result.put(pairs[index], new ElnTestRequestIdentityLookup.Identity(
                    pairs[index + 1], "pending_audit"));
        }
        return result;
    }

    private static Map<String, ElnTestRequestIdentityLookup.Identity> identitiesWithStatus(
            String itemId, String requestId, String status) {
        Map<String, ElnTestRequestIdentityLookup.Identity> result = new HashMap<>();
        result.put(itemId, new ElnTestRequestIdentityLookup.Identity(requestId, status));
        return result;
    }

    private static void assertFailure(ElnRecordSourceResolver resolver, String expectedCode) {
        try {
            resolver.resolve("tenant-a", "request-1", "SOURCE-TEMPLATE");
            fail("expected DataException");
        } catch (DataException e) {
            assertTrue(e.getMessage().contains(expectedCode));
        }
    }
}