package jnpf.elnService.cross;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import jnpf.elnEntity.field.ElnFieldDefEntity;
import jnpf.elnEntity.field.ElnFieldVersionEntity;
import jnpf.elnEntity.template.ElnTemplateBindingEntity;
import jnpf.elnEntity.template.ElnTemplateCrossReferenceEntity;
import jnpf.elnEntity.template.ElnTemplateForms;
import jnpf.elnEntity.template.ElnTemplateVersionEntity;
import jnpf.elnEntity.template.ElnTemplateVos;
import jnpf.elnMapper.ElnFieldDefMapper;
import jnpf.elnMapper.ElnFieldVersionMapper;
import jnpf.elnMapper.ElnTemplateBindingMapper;
import jnpf.elnMapper.ElnTemplateCrossReferenceMapper;
import jnpf.elnMapper.ElnTemplateMapper;
import jnpf.elnService.cross.impl.ElnCrossTemplateScalarReferenceServiceImpl;
import jnpf.elnService.template.ElnTemplateBindingService;
import jnpf.elnService.template.TemplateAnnotationAuthorization;
import jnpf.exception.DataException;
import org.junit.Test;
import org.mockito.ArgumentCaptor;

import java.lang.reflect.Constructor;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

public class ElnCrossTemplateScalarReferenceServiceImplTest {

    @Test
    public void exposesEnabledPublishedSourceTemplatesExceptCurrentTemplate() {
        Fixture fixture = new Fixture();

        List<ElnTemplateVos.CrossTemplateSourceTemplate> templates =
                fixture.service.sourceTemplates(authorization());

        assertEquals(1, templates.size());
        assertEquals("source-template", templates.get(0).getSourceTemplateId());
        assertEquals("SOURCE-TEMPLATE", templates.get(0).getSourceTemplateCode());
    }

    @Test
    public void excludesEveryVersionWithTheCurrentTemplateCode() {
        Fixture fixture = new Fixture();

        assertTrue(fixture.service.sourceTemplates(authorization()).stream()
                .noneMatch(item -> "TARGET-TEMPLATE".equals(item.getSourceTemplateCode())));

        when(fixture.templateMapper.selectOne(any(Wrapper.class)))
                .thenReturn(fixture.sameCodeTemplate);
        assertTrue(fixture.service.candidates(
                authorization(), fixture.sameCodeTemplate.getId()).isEmpty());
    }

    @Test
    public void exposesOnlyEligibleCandidatesFromSelectedSourceTemplate() {
        Fixture fixture = new Fixture();

        List<ElnTemplateVos.CrossTemplateScalarCandidate> candidates =
                fixture.service.candidates(authorization(), "source-template");

        assertEquals(1, candidates.size());
        assertEquals("source-template", candidates.get(0).getSourceTemplateId());
        assertEquals("SOURCE-TEMPLATE", candidates.get(0).getSourceTemplateCode());
        assertEquals("source-field", candidates.get(0).getSourceFieldId());
        assertEquals("source-version", candidates.get(0).getSourceFieldVersionId());

        fixture.field.setBizEnabled("disabled");
        assertTrue(fixture.service.candidates(authorization(), "source-template").isEmpty());
        assertTrue(fixture.service.candidates(authorization(), "other-template").isEmpty());
    }

    @Test
    public void reservePinsSourceIdentityAndReturnsStableReadOnlyMarker() {
        Fixture fixture = new Fixture();
        ElnTemplateForms.ReserveCrossTemplateScalarBinding form = fixture.form();

        ElnTemplateVos.Binding result = fixture.service.reserve(authorization(), form);

        assertEquals("CROSS_TEMPLATE", result.getValueSource());
        assertEquals(Boolean.TRUE, result.getReadOnly());
        ArgumentCaptor<ElnTemplateCrossReferenceEntity> captor =
                ArgumentCaptor.forClass(ElnTemplateCrossReferenceEntity.class);
        verify(fixture.referenceMapper).insert(captor.capture());
        ElnTemplateCrossReferenceEntity rule = captor.getValue();
        assertEquals("target-binding", rule.getMubanBangdingId());
        assertEquals("source-template", rule.getLaiyuanMubanId());
        assertEquals("SOURCE-TEMPLATE", rule.getLaiyuanMubanBianhao());
        assertEquals("source-field", rule.getLaiyuanZiduanDingyiId());
        assertEquals("source-version", rule.getLaiyuanZiduanBanbenId());
        assertEquals("tenant-1", rule.getFTenantId());
    }

    @Test
    public void rejectsReusingOperationBindingForAnotherSource() {
        Fixture fixture = new Fixture();
        ElnTemplateCrossReferenceEntity existing = new ElnTemplateCrossReferenceEntity();
        existing.setLaiyuanMubanBianhao("OTHER-TEMPLATE");
        existing.setLaiyuanZiduanBanbenId("source-version");
        when(fixture.referenceMapper.selectOne(any(Wrapper.class))).thenReturn(existing);

        expectDataException(() -> fixture.service.reserve(authorization(), fixture.form()), "已用于其他跨模板来源");

        verify(fixture.referenceMapper, never()).insert(any(ElnTemplateCrossReferenceEntity.class));
    }

    @Test
    public void rejectsCheckboxGroupBeforeReservingCrossTemplateBinding() {
        Fixture fixture = new Fixture();
        ElnTemplateForms.ReserveCrossTemplateScalarBinding form = fixture.form();
        form.setCheckboxGroupCode("result_choice");

        expectDataException(() -> fixture.service.reserve(authorization(), form),
                "跨模板只读字段不能加入选择组");

        verify(fixture.bindingService, never()).reservePrimary(any(), any());
        verify(fixture.referenceMapper, never()).insert(any(ElnTemplateCrossReferenceEntity.class));
    }

    @Test
    public void contextDecorationRestoresReadOnlyCrossTemplateIdentity() {
        Fixture fixture = new Fixture();
        ElnTemplateVos.Binding binding = new ElnTemplateVos.Binding();
        binding.setId("target-binding");
        binding.setStatus("PENDING");
        ElnTemplateVos.AnnotationContext context = new ElnTemplateVos.AnnotationContext();
        context.setBindings(Collections.singletonList(binding));
        ElnTemplateCrossReferenceEntity rule = new ElnTemplateCrossReferenceEntity();
        rule.setMubanBangdingId("target-binding");
        when(fixture.referenceMapper.selectList(any(Wrapper.class)))
                .thenReturn(Collections.singletonList(rule));

        fixture.service.decorate(authorization(), context);

        assertEquals("CROSS_TEMPLATE", binding.getValueSource());
        assertEquals(Boolean.TRUE, binding.getReadOnly());
    }

    private static void expectDataException(Action action, String fragment) {
        try {
            action.run();
            fail("expected DataException containing " + fragment);
        } catch (DataException expected) {
            assertTrue(expected.getMessage().contains(fragment));
        }
    }

    private static TemplateAnnotationAuthorization authorization() {
        try {
            Constructor<TemplateAnnotationAuthorization> constructor =
                    TemplateAnnotationAuthorization.class.getDeclaredConstructor(
                            String.class, String.class, String.class, String.class);
            constructor.setAccessible(true);
            return constructor.newInstance("tenant-1", "user-1", "target-template", "file-1");
        } catch (ReflectiveOperationException e) {
            throw new AssertionError(e);
        }
    }

    private interface Action {
        void run();
    }

    private static final class Fixture {
        private final ElnTemplateMapper templateMapper = mock(ElnTemplateMapper.class);
        private final ElnTemplateBindingMapper bindingMapper = mock(ElnTemplateBindingMapper.class);
        private final ElnFieldDefMapper fieldMapper = mock(ElnFieldDefMapper.class);
        private final ElnFieldVersionMapper versionMapper = mock(ElnFieldVersionMapper.class);
        private final ElnTemplateCrossReferenceMapper referenceMapper =
                mock(ElnTemplateCrossReferenceMapper.class);
        private final ElnTemplateBindingService bindingService = mock(ElnTemplateBindingService.class);
        private final ElnFieldDefEntity field = new ElnFieldDefEntity();
        private final ElnTemplateVersionEntity sameCodeTemplate = new ElnTemplateVersionEntity();
        private final ElnCrossTemplateScalarReferenceServiceImpl service;

        private Fixture() {
            ElnTemplateVersionEntity template = new ElnTemplateVersionEntity();
            template.setId("source-template");
            template.setFTenantId("tenant-1");
            template.setMubanBianhao("SOURCE-TEMPLATE");
            template.setBizStatus("PUBLISHED");
            template.setBizEnabled("enabled");
            template.setFDeleteMark(0);
            ElnTemplateVersionEntity targetTemplate = new ElnTemplateVersionEntity();
            targetTemplate.setId("target-template");
            targetTemplate.setFTenantId("tenant-1");
            targetTemplate.setMubanBianhao("TARGET-TEMPLATE");
            targetTemplate.setBizStatus("PUBLISHED");
            targetTemplate.setBizEnabled("enabled");
            targetTemplate.setFDeleteMark(0);
            sameCodeTemplate.setId("same-code-template");
            sameCodeTemplate.setFTenantId("tenant-1");
            sameCodeTemplate.setMubanBianhao("TARGET-TEMPLATE");
            sameCodeTemplate.setBizStatus("PUBLISHED");
            sameCodeTemplate.setBizEnabled("enabled");
            sameCodeTemplate.setFDeleteMark(0);
            when(templateMapper.selectList(any(Wrapper.class)))
                    .thenReturn(Arrays.asList(template, targetTemplate, sameCodeTemplate));
            when(templateMapper.selectOne(any(Wrapper.class))).thenReturn(template);
            when(templateMapper.selectById("target-template")).thenReturn(targetTemplate);

            ElnTemplateBindingEntity sourceBinding = new ElnTemplateBindingEntity();
            sourceBinding.setId("source-binding");
            sourceBinding.setMubanId("source-template");
            sourceBinding.setZiduanDingyiId("source-field");
            sourceBinding.setZiduanBanbenId("source-version");
            sourceBinding.setBangdingZhuangtai("ACTIVE");
            sourceBinding.setKongjianJuese("PRIMARY");
            sourceBinding.setFTenantId("tenant-1");
            sourceBinding.setFDeleteMark(0);
            when(bindingMapper.selectList(any(Wrapper.class)))
                    .thenReturn(Collections.singletonList(sourceBinding));

            field.setId("source-field");
            field.setFTenantId("tenant-1");
            field.setZiduanBianma("source_text");
            field.setZuoyongFanwei("GLOBAL");
            field.setBizEnabled("enabled");
            field.setFDeleteMark(0);
            when(fieldMapper.selectById("source-field")).thenReturn(field);

            ElnFieldVersionEntity version = new ElnFieldVersionEntity();
            version.setId("source-version");
            version.setFTenantId("tenant-1");
            version.setZiduanDingyiId("source-field");
            version.setZiduanMingcheng("来源文本");
            version.setShujuLeixing("TEXT");
            version.setBizStatus("PUBLISHED");
            version.setFDeleteMark(0);
            when(versionMapper.selectById("source-version")).thenReturn(version);

            ElnTemplateVos.Binding target = new ElnTemplateVos.Binding();
            target.setId("target-binding");
            target.setStatus("PENDING");
            when(bindingService.reservePrimary(any(), any())).thenReturn(target);
            when(referenceMapper.insert(any(ElnTemplateCrossReferenceEntity.class))).thenReturn(1);
            service = new ElnCrossTemplateScalarReferenceServiceImpl(
                    templateMapper, bindingMapper, fieldMapper, versionMapper,
                    referenceMapper, bindingService);
        }

        private ElnTemplateForms.ReserveCrossTemplateScalarBinding form() {
            ElnTemplateForms.ReserveCrossTemplateScalarBinding form =
                    new ElnTemplateForms.ReserveCrossTemplateScalarBinding();
            form.setOperationCode("reserve-op");
            form.setSourceTemplateId("source-template");
            form.setSourceTemplateCode("SOURCE-TEMPLATE");
            form.setSourceFieldId("source-field");
            form.setSourceFieldVersionId("source-version");
            return form;
        }
    }
}