package jnpf.elnService.template;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import jnpf.audit.model.AuditEventDTO;
import jnpf.elnEntity.template.ElnTemplateBindingEntity;
import jnpf.elnEntity.formula.ElnTemplateFormulaBindingEntity;
import jnpf.elnEntity.template.ElnTemplateVos;
import jnpf.elnMapper.ElnFieldVersionMapper;
import jnpf.elnMapper.ElnTemplateBindingMapper;
import jnpf.elnService.template.docx.DocxControlSnapshot;
import jnpf.util.JsonUtil;
import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

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

public class ElnPendingBindingCleanupServiceTest {

    private static final Date NOW = new Date(2_000_000L);

    @Test
    public void cancelsOnlyExpiredPendingWithoutAControlAndAuditsTheCasWinner() {
        Fixture fixture = new Fixture();
        fixture.add("b1", "tenant-a", "template-1", new Date(1_000_000L));

        List<ElnTemplateVos.Diagnostic> result = fixture.service.reconcileExpired(
                "tenant-a", "template-1", NOW, Collections.emptyList());

        assertEquals("CANCELLED", fixture.binding("b1").getBangdingZhuangtai());
        assertEquals("PENDING_TIMEOUT_NO_CONTROL", fixture.binding("b1").getZhuangtaiYuanyin());
        assertCode(result, "PENDING_TIMEOUT_NO_CONTROL");
        assertEquals(1, fixture.audits.size());
        assertEquals("ELN_TEMPLATE_BINDING_CANCEL", fixture.audits.get(0).getActionCode());
    }

    @Test
    public void keepsSingleMatchingControlPendingForPluginConfirmation() {
        Fixture fixture = new Fixture();
        fixture.add("b1", "tenant-a", "template-1", new Date(1_000_000L));

        List<ElnTemplateVos.Diagnostic> result = fixture.service.reconcileExpired(
                "tenant-a", "template-1", NOW,
                Collections.singletonList(control("eln.field.sample_code", "TEXT",
                        "PRIMARY", Collections.emptyMap())));

        assertEquals("PENDING", fixture.binding("b1").getBangdingZhuangtai());
        assertCode(result, "PENDING_CONFIRMATION_REQUIRED");
        assertTrue(fixture.audits.isEmpty());
    }

    @Test
    public void ignoresUnobservableTextBusinessConfig() {
        Fixture fixture = new Fixture();
        fixture.add("text", "tenant-a", "template-1", new Date(1_000_000L));
        Map<String, Object> fieldConfig = new LinkedHashMap<>();
        fieldConfig.put("placeholder", "请输入");
        fieldConfig.put("defaultValue", "默认文本");
        fixture.configs.put("text", fieldConfig);

        List<ElnTemplateVos.Diagnostic> result = fixture.service.reconcileExpired(
                "tenant-a", "template-1", NOW,
                Collections.singletonList(control("eln.field.sample_code", "TEXT",
                        "PRIMARY", Collections.emptyMap())));

        assertBindingCode(result, "text", "PENDING_CONFIRMATION_REQUIRED");
        assertNoBindingCode(result, "text", "CONFIG_MISMATCH");
    }

    @Test
    public void canonicalizesDropdownOptionsAndReportsRealDifference() {
        Fixture fixture = new Fixture();
        fixture.add("same", "tenant-a", "template-1", new Date(1_000_000L));
        fixture.binding("same").setKongjianBiaoqian("eln.field.same");
        fixture.binding("same").setKongjianLeixing("DROPDOWN");
        fixture.configs.put("same", dropdownConfig());
        fixture.add("different", "tenant-a", "template-1", new Date(1_000_000L));
        fixture.binding("different").setKongjianBiaoqian("eln.field.different");
        fixture.binding("different").setKongjianLeixing("DROPDOWN");
        fixture.configs.put("different", dropdownConfig());
        Map<String, Object> reordered = new LinkedHashMap<>();
        reordered.put("FAIL", "不合格");
        reordered.put("PASS", "合格");
        Map<String, Object> different = new LinkedHashMap<>();
        different.put("PASS", "合格");
        different.put("FAIL", "异常");

        List<ElnTemplateVos.Diagnostic> result = fixture.service.reconcileExpired(
                "tenant-a", "template-1", NOW, Arrays.asList(
                        control("eln.field.same", "DROPDOWN", "PRIMARY", reordered),
                        control("eln.field.different", "DROPDOWN", "PRIMARY", different)));

        assertBindingCode(result, "same", "PENDING_CONFIRMATION_REQUIRED");
        assertNoBindingCode(result, "same", "CONFIG_MISMATCH");
        assertBindingCode(result, "different", "CONFIG_MISMATCH");
    }

    @Test
    public void reportsDuplicateRoleTypeAndConfigurationMismatchWithoutCancelling() {
        Fixture fixture = new Fixture();
        fixture.add("duplicate", "tenant-a", "template-1", new Date(1_000_000L));
        fixture.add("role", "tenant-a", "template-1", new Date(1_000_000L));
        fixture.binding("role").setKongjianBiaoqian("eln.field.role");
        fixture.add("type", "tenant-a", "template-1", new Date(1_000_000L));
        fixture.binding("type").setKongjianBiaoqian("eln.field.type");
        fixture.add("config", "tenant-a", "template-1", new Date(1_000_000L));
        fixture.binding("config").setKongjianBiaoqian("eln.field.config");
        fixture.binding("config").setKongjianLeixing("DROPDOWN");
        fixture.configs.put("config", dropdownConfig());
        List<DocxControlSnapshot> controls = new ArrayList<>();
        controls.add(control("eln.field.sample_code", "TEXT", "PRIMARY", Collections.emptyMap()));
        controls.add(control("eln.field.sample_code", "TEXT", "PRIMARY", Collections.emptyMap()));
        controls.add(control("eln.field.role", "TEXT", "REFERENCE", Collections.emptyMap()));
        controls.add(control("eln.field.type", "DATE", "PRIMARY", Collections.emptyMap()));
        Map<String, Object> differentOptions = new LinkedHashMap<>();
        differentOptions.put("PASS", "合格");
        differentOptions.put("FAIL", "异常");
        controls.add(control("eln.field.config", "DROPDOWN", "PRIMARY", differentOptions));

        List<ElnTemplateVos.Diagnostic> result = fixture.service.reconcileExpired(
                "tenant-a", "template-1", NOW, controls);

        assertCode(result, "DUPLICATE_TAG");
        assertCode(result, "ROLE_MISMATCH");
        assertCode(result, "TYPE_MISMATCH");
        assertCode(result, "CONFIG_MISMATCH");
        assertTrue(fixture.audits.isEmpty());
        assertTrue(fixture.bindings.values().stream()
                .allMatch(item -> "PENDING".equals(item.getBangdingZhuangtai())));
    }

    @Test
    public void tenantCannotReconcileAnotherTenantAndCopiedPendingNeverExpires() {
        Fixture fixture = new Fixture();
        fixture.add("tenant-b", "tenant-b", "template-1", new Date(1_000_000L));
        fixture.add("copied", "tenant-a", "template-1", null);

        fixture.service.reconcileExpired("tenant-a", "template-1", NOW,
                Collections.emptyList());

        assertEquals("PENDING", fixture.binding("tenant-b").getBangdingZhuangtai());
        assertEquals("PENDING", fixture.binding("copied").getBangdingZhuangtai());
        assertTrue(fixture.audits.isEmpty());
    }

    @Test
    public void twoInstancesProduceOnlyOneCancellationAudit() {
        Fixture fixture = new Fixture();
        fixture.add("b1", "tenant-a", "template-1", new Date(1_000_000L));
        ElnPendingBindingCleanupService second =
                new ElnPendingBindingCleanupService(fixture.store, fixture.audits::add);

        fixture.service.reconcileExpired("tenant-a", "template-1", NOW,
                Collections.emptyList());
        second.reconcileExpired("tenant-a", "template-1", NOW, Collections.emptyList());

        assertEquals(1, fixture.audits.size());
    }

    @Test
    public void cancellationCasExcludesLogicallyDeletedBindings() throws Exception {
        TableInfoHelper.initTableInfo(new MapperBuilderAssistant(
                new MybatisConfiguration(), "eln-pending-cleanup-test"),
                ElnTemplateBindingEntity.class);
        final Wrapper<?>[] captured = new Wrapper<?>[1];
        ElnTemplateBindingMapper mapper = (ElnTemplateBindingMapper) Proxy.newProxyInstance(
                ElnTemplateBindingMapper.class.getClassLoader(),
                new Class<?>[]{ElnTemplateBindingMapper.class}, (proxy, method, args) -> {
                    if ("update".equals(method.getName())) {
                        captured[0] = (Wrapper<?>) args[1];
                        return 1;
                    }
                    return null;
                });
        Constructor<?> constructor = Class.forName(
                "jnpf.elnService.template.ElnPendingBindingCleanupService$MyBatisStore")
                .getDeclaredConstructor(ElnTemplateBindingMapper.class,
                        ElnFieldVersionMapper.class);
        constructor.setAccessible(true);
        ElnPendingBindingCleanupService.Store store =
                (ElnPendingBindingCleanupService.Store) constructor.newInstance(mapper, null);
        ElnTemplateBindingEntity binding = new ElnTemplateBindingEntity();
        binding.setId("b1");
        binding.setFTenantId("tenant-a");
        binding.setMubanId("template-1");

        assertTrue(store.cancelIfPending(binding, 1, NOW, "timeout"));
        String sql = captured[0].getSqlSegment().toLowerCase(Locale.ROOT);
        assertTrue(sql, sql.contains("f_delete_mark") && sql.contains("is null"));
    }

    @Test
    public void reconcilesExpiredFormulaPendingFromAuthoritativeLockSnapshot() {
        FormulaCleanupStore formulaStore = new FormulaCleanupStore();
        formulaStore.add("unlocked", "result-unlocked", new Date(1_000_000L));
        formulaStore.add("locked", "result-locked", new Date(1_000_000L));
        formulaStore.add("partial", "result-partial", new Date(1_000_000L));
        List<AuditEventDTO> audits = new ArrayList<>();
        ElnPendingBindingCleanupService service = new ElnPendingBindingCleanupService(
                new Fixture().store, formulaStore, audits::add);

        List<ElnTemplateVos.Diagnostic> result = service.reconcileExpired(
                "tenant-a", "template-1", NOW, Arrays.asList(
                        lockControl("eln.field.result-unlocked", null),
                        lockControl("eln.field.result-unlocked-ref", null),
                        lockControl("eln.field.result-locked", "sdtContentLocked"),
                        lockControl("eln.field.result-locked-ref", "sdtContentLocked"),
                        lockControl("eln.field.result-partial", "sdtContentLocked")));

        assertEquals("CANCELLED", formulaStore.bindings.get("unlocked").getBangdingZhuangtai());
        assertEquals("PENDING", formulaStore.bindings.get("locked").getBangdingZhuangtai());
        assertEquals("PENDING", formulaStore.bindings.get("partial").getBangdingZhuangtai());
        assertBindingCode(result, "unlocked", "PENDING_TIMEOUT_NO_LOCK");
        assertBindingCode(result, "locked", "PENDING_CONFIRMATION_REQUIRED");
        assertBindingCode(result, "partial", "FORMULA_RESULT_LOCK_MISMATCH");
        assertEquals(1, audits.stream().filter(item ->
                "ELN_TEMPLATE_FORMULA_CANCEL".equals(item.getActionCode())).count());
        AuditEventDTO cancellation = audits.stream().filter(item ->
                "ELN_TEMPLATE_FORMULA_CANCEL".equals(item.getActionCode())).findFirst().get();
        @SuppressWarnings("unchecked")
        Map<String, Object> snapshot = JsonUtil.getJsonToBean(
                cancellation.getDataSnapshot(), Map.class);
        assertTrue(snapshot.containsKey("before"));
        assertTrue(snapshot.containsKey("after"));
    }

    @Test
    public void keepsFormulaPendingWhenPrimaryIsUnlockedButReferenceIsLocked() {
        FormulaCleanupStore formulaStore = new FormulaCleanupStore();
        formulaStore.add("partial-unlocked", "result-partial-unlocked", new Date(1_000_000L));
        List<AuditEventDTO> audits = new ArrayList<>();
        ElnPendingBindingCleanupService service = new ElnPendingBindingCleanupService(
                new Fixture().store, formulaStore, audits::add);

        List<ElnTemplateVos.Diagnostic> result = service.reconcileExpired(
                "tenant-a", "template-1", NOW, Arrays.asList(
                        lockControl("eln.field.result-partial-unlocked", null),
                        lockControl("eln.field.result-partial-unlocked-ref", "sdtContentLocked")));

        assertEquals("PENDING",
                formulaStore.bindings.get("partial-unlocked").getBangdingZhuangtai());
        assertBindingCode(result, "partial-unlocked", "FORMULA_RESULT_LOCK_MISMATCH");
        assertTrue(audits.isEmpty());
    }

    private static DocxControlSnapshot lockControl(String tag, String lock) {
        return new DocxControlSnapshot(tag, null, lock, "TEXT", "PRIMARY",
                "word/document.xml", "OK", Collections.emptyMap());
    }

    private static DocxControlSnapshot control(String tag, String type, String role,
            Map<String, Object> config) {
        return new DocxControlSnapshot(tag, null, null, type, role,
                "word/document.xml", "OK", config);
    }

    private static void assertCode(List<ElnTemplateVos.Diagnostic> diagnostics, String code) {
        assertTrue("缺少诊断: " + code,
                diagnostics.stream().anyMatch(item -> code.equals(item.getCode())));
    }

    private static void assertBindingCode(List<ElnTemplateVos.Diagnostic> diagnostics,
            String bindingId, String code) {
        assertTrue("缺少诊断: " + bindingId + "/" + code,
                diagnostics.stream().anyMatch(item -> bindingId.equals(item.getBindingId())
                        && code.equals(item.getCode())));
    }

    private static void assertNoBindingCode(List<ElnTemplateVos.Diagnostic> diagnostics,
            String bindingId, String code) {
        assertTrue("不应存在诊断: " + bindingId + "/" + code,
                diagnostics.stream().noneMatch(item -> bindingId.equals(item.getBindingId())
                        && code.equals(item.getCode())));
    }

    private static Map<String, Object> dropdownConfig() {
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("controlType", "dropdown");
        result.put("placeholder", "请选择");
        result.put("defaultOptionValue", "PASS");
        Map<String, Object> pass = new LinkedHashMap<>();
        pass.put("display", "合格");
        pass.put("value", "PASS");
        Map<String, Object> fail = new LinkedHashMap<>();
        fail.put("display", "不合格");
        fail.put("value", "FAIL");
        result.put("options", Arrays.asList(pass, fail));
        return result;
    }

    private static final class Fixture {
        private final Map<String, ElnTemplateBindingEntity> bindings = new LinkedHashMap<>();
        private final Map<String, Map<String, Object>> configs = new LinkedHashMap<>();
        private final List<AuditEventDTO> audits = new ArrayList<>();
        private final MemoryStore store = new MemoryStore(bindings, configs);
        private final ElnPendingBindingCleanupService service =
                new ElnPendingBindingCleanupService(store, audits::add);

        private void add(String id, String tenant, String template, Date expiresAt) {
            ElnTemplateBindingEntity item = new ElnTemplateBindingEntity();
            item.setId(id);
            item.setFTenantId(tenant);
            item.setMubanId(template);
            item.setZiduanDingyiId("field-1");
            item.setZiduanBanbenId("version-1");
            item.setZiduanBianma("sample_code");
            item.setKongjianBiaoqian("eln.field.sample_code");
            item.setKongjianLeixing("TEXT");
            item.setKongjianJuese("PRIMARY");
            item.setBangdingZhuangtai("PENDING");
            item.setDaoqiShijian(expiresAt);
            item.setFVersion(1);
            bindings.put(id, item);
            configs.put(id, Collections.emptyMap());
        }

        private ElnTemplateBindingEntity binding(String id) {
            return bindings.get(id);
        }
    }

    private static final class MemoryStore implements ElnPendingBindingCleanupService.Store {
        private final Map<String, ElnTemplateBindingEntity> bindings;
        private final Map<String, Map<String, Object>> configs;

        private MemoryStore(Map<String, ElnTemplateBindingEntity> bindings,
                Map<String, Map<String, Object>> configs) {
            this.bindings = bindings;
            this.configs = configs;
        }

        @Override
        public List<ElnTemplateBindingEntity> listExpired(
                String tenantId, String templateId, Date now) {
            List<ElnTemplateBindingEntity> result = new ArrayList<>();
            for (ElnTemplateBindingEntity item : bindings.values()) {
                if (tenantId.equals(item.getFTenantId()) && templateId.equals(item.getMubanId())
                        && "PENDING".equals(item.getBangdingZhuangtai())
                        && item.getDaoqiShijian() != null && item.getDaoqiShijian().before(now)) {
                    result.add(item);
                }
            }
            return result;
        }

        @Override
        public Map<String, Object> expectedControlConfig(
                String tenantId, ElnTemplateBindingEntity binding) {
            return configs.get(binding.getId());
        }

        @Override
        public boolean cancelIfPending(ElnTemplateBindingEntity binding, int expectedVersion,
                Date now, String reason) {
            ElnTemplateBindingEntity current = bindings.get(binding.getId());
            if (current == null || !binding.getFTenantId().equals(current.getFTenantId())
                    || !"PENDING".equals(current.getBangdingZhuangtai())
                    || current.getFVersion() != expectedVersion
                    || current.getDaoqiShijian() == null
                    || !current.getDaoqiShijian().before(now)) {
                return false;
            }
            current.setBangdingZhuangtai("CANCELLED");
            current.setZhuangtaiYuanyin(reason);
            current.setFVersion(expectedVersion + 1);
            return true;
        }
    }

    private static final class FormulaCleanupStore
            implements ElnPendingBindingCleanupService.FormulaStore {
        private final Map<String, ElnTemplateFormulaBindingEntity> bindings = new LinkedHashMap<>();
        private final Map<String, List<ElnTemplateBindingEntity>> resultControls = new LinkedHashMap<>();

        private void add(String id, String resultId, Date expiresAt) {
            ElnTemplateFormulaBindingEntity item = new ElnTemplateFormulaBindingEntity();
            item.setId(id); item.setFTenantId("tenant-a"); item.setMubanId("template-1");
            item.setBangdingZhuangtai("PENDING"); item.setJieguoBangdingId(resultId);
            item.setDaoqiShijian(expiresAt); item.setFVersion(1); item.setCaozuoBianma("op-" + id);
            bindings.put(id, item);
            List<ElnTemplateBindingEntity> controls = new ArrayList<>();
            controls.add(fieldBinding(resultId, "eln.field." + resultId, "PRIMARY", null));
            controls.add(fieldBinding(resultId + "-ref", "eln.field." + resultId + "-ref",
                    "REFERENCE", resultId));
            resultControls.put(id, controls);
        }

        @Override public List<ElnTemplateFormulaBindingEntity> listExpired(
                String tenantId, String templateId, Date now) {
            List<ElnTemplateFormulaBindingEntity> result = new ArrayList<>();
            for (ElnTemplateFormulaBindingEntity item : bindings.values())
                if (item.getDaoqiShijian() != null && item.getDaoqiShijian().before(now)
                        && "PENDING".equals(item.getBangdingZhuangtai())) result.add(item);
            return result;
        }
        @Override public List<ElnTemplateBindingEntity> resultControls(
                String tenantId, String templateId, String formulaBindingId) {
            return resultControls.get(formulaBindingId);
        }
        @Override public boolean cancelIfPending(ElnTemplateFormulaBindingEntity item,
                int expectedVersion, Date now, String reason) {
            if (!"PENDING".equals(item.getBangdingZhuangtai())
                    || item.getFVersion() != expectedVersion) return false;
            item.setBangdingZhuangtai("CANCELLED"); item.setZhuangtaiYuanyin(reason);
            item.setFVersion(expectedVersion + 1); return true;
        }
        private static ElnTemplateBindingEntity fieldBinding(String id, String tag,
                String role, String primary) {
            ElnTemplateBindingEntity result = new ElnTemplateBindingEntity();
            result.setId(id); result.setKongjianBiaoqian(tag); result.setKongjianJuese(role);
            result.setYinyongShiliId(primary); result.setBangdingZhuangtai("ACTIVE");
            return result;
        }
    }
}