package jnpf.elnMapper;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.Version;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import jnpf.elnEntity.template.ElnTemplateBindingEntity;
import jnpf.elnEntity.template.ElnTemplateCurrentVersionEntity;
import jnpf.elnEntity.template.ElnTemplateCheckboxGroupEntity;
import jnpf.elnEntity.template.ElnTemplateEnums;
import jnpf.elnEntity.template.ElnTemplateRepeatGroupEntity;
import jnpf.elnEntity.template.ElnTemplateStageEntity;
import jnpf.elnEntity.template.ElnTemplateStepEntity;
import jnpf.elnEntity.template.ElnTemplateVersionEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.junit.Test;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

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

public class ElnTemplateMapperContractTest {

    @Test
    public void mapsTemplateVersionColumnsAndMapper() throws Exception {
        assertEquals("eln_template", tableName(ElnTemplateVersionEntity.class));
        assertEntityContract(ElnTemplateVersionEntity.class, templateVersionColumns());
        assertMapper(ElnTemplateMapper.class, ElnTemplateVersionEntity.class);
    }

    @Test
    public void mapsCurrentVersionColumnsAndMapper() throws Exception {
        assertEquals("eln_template_current_version", tableName(ElnTemplateCurrentVersionEntity.class));
        assertEntityContract(ElnTemplateCurrentVersionEntity.class, currentVersionColumns());
        assertMapper(ElnTemplateCurrentVersionMapper.class, ElnTemplateCurrentVersionEntity.class);
    }

    @Test
    public void mapsBindingColumnsAndMapper() throws Exception {
        assertEquals("eln_template_binding", tableName(ElnTemplateBindingEntity.class));
        assertEntityContract(ElnTemplateBindingEntity.class, bindingColumns());
        assertMapper(ElnTemplateBindingMapper.class, ElnTemplateBindingEntity.class);
    }

    @Test
    public void mapsRepeatGroupColumnsAndMapper() throws Exception {
        assertEquals("eln_template_repeat_group", tableName(ElnTemplateRepeatGroupEntity.class));
        assertEntityContract(ElnTemplateRepeatGroupEntity.class, repeatGroupColumns());
        assertMapper(ElnTemplateRepeatGroupMapper.class, ElnTemplateRepeatGroupEntity.class);
    }

    @Test
    public void mapsCheckboxGroupRuleColumnsAndMapper() throws Exception {
        assertEquals("eln_template_checkbox_group", tableName(ElnTemplateCheckboxGroupEntity.class));
        assertEntityContract(ElnTemplateCheckboxGroupEntity.class, checkboxGroupColumns());
        assertMapper(ElnTemplateCheckboxGroupMapper.class, ElnTemplateCheckboxGroupEntity.class);
    }

    @Test
    public void mapsStageAndStepColumnsAndMappers() throws Exception {
        assertEquals("eln_template_stage", tableName(ElnTemplateStageEntity.class));
        assertEntityContract(ElnTemplateStageEntity.class, stageColumns());
        assertMapper(ElnTemplateStageMapper.class, ElnTemplateStageEntity.class);

        assertEquals("eln_template_step", tableName(ElnTemplateStepEntity.class));
        assertEntityContract(ElnTemplateStepEntity.class, stepColumns());
        assertMapper(ElnTemplateStepMapper.class, ElnTemplateStepEntity.class);
    }

    @Test
    public void exposesTemplateLifecycleEnums() {
        assertArrayEquals(new String[]{"DRAFT", "PUBLISHED"},
                enumNames(ElnTemplateEnums.TemplateStatus.class));
        assertArrayEquals(new String[]{"PENDING", "ACTIVE", "CANCELLED", "REMOVED"},
                enumNames(ElnTemplateEnums.BindingStatus.class));
        assertArrayEquals(new String[]{"PRIMARY", "REFERENCE", "REPEAT"},
                enumNames(ElnTemplateEnums.ControlRole.class));
        assertArrayEquals(new String[]{"TEXT", "MULTILINE", "DROPDOWN", "CHECKBOX", "DATE"},
                enumNames(ElnTemplateEnums.ControlType.class));
    }

    @Test
    public void templateMapperDoesNotQueryLimsTestDefinitionTable() {
        for (java.lang.reflect.Method method : ElnTemplateMapper.class.getDeclaredMethods()) {
            Select select = method.getAnnotation(Select.class);
            if (select != null) {
                String sql = String.join(" ", select.value()).toLowerCase(java.util.Locale.ROOT);
                assertTrue("ELN Mapper 不得直接查询 LIMS 检验项目表: " + method.getName(),
                        !sql.contains("jianyan_xiangmu_guanli"));
            }
        }
    }

    @Test
    public void templateDirectoryOrdersOnlyByTemplateCreationTimeDescending() throws Exception {
        Select select = ElnTemplateMapper.class.getDeclaredMethod(
                "selectTemplateDirectory", com.baomidou.mybatisplus.core.metadata.IPage.class,
                String.class, String.class, String.class, String.class, String.class,
                String.class).getAnnotation(Select.class);
        String sql = String.join(" ", select.value())
                .toLowerCase(java.util.Locale.ROOT).replaceAll("\\s+", " ");
        String orderBy = sql.substring(sql.indexOf("order by"));

        assertTrue(orderBy.startsWith(
                "order by min(coalesce(m.chuangjian_shijian, m.f_creator_time)) desc"));
        assertTrue(!orderBy.contains("f_last_modify_time"));
    }

    private static String tableName(Class<?> entityType) {
        return entityType.getAnnotation(TableName.class).value();
    }

    private static void assertEntityContract(Class<?> entityType,
                                             Map<String, FieldSpec> expected) throws Exception {
        Set<String> actual = new HashSet<>();
        for (Field field : entityType.getDeclaredFields()) {
            if (!Modifier.isStatic(field.getModifiers())) {
                actual.add(field.getName());
            }
        }
        assertEquals("实体字段集合不一致: " + entityType.getSimpleName(),
                expected.keySet(), actual);

        for (Map.Entry<String, FieldSpec> entry : expected.entrySet()) {
            Field field = entityType.getDeclaredField(entry.getKey());
            FieldSpec spec = entry.getValue();
            assertEquals(spec.javaType, field.getType());
            if (spec.id) {
                TableId tableId = field.getAnnotation(TableId.class);
                assertTrue("主键缺少 @TableId: " + entry.getKey(), tableId != null);
                assertEquals(spec.column, tableId.value());
                assertEquals(IdType.INPUT, tableId.type());
                assertNull("主键不得同时标注 @TableField: " + entry.getKey(),
                        field.getAnnotation(TableField.class));
            } else {
                assertNull("非主键字段不得标注 @TableId: " + entry.getKey(),
                        field.getAnnotation(TableId.class));
                TableField tableField = field.getAnnotation(TableField.class);
                assertTrue("普通字段缺少 @TableField: " + entry.getKey(), tableField != null);
                assertEquals(spec.column, tableField.value());
                assertEquals(spec.fill, tableField.fill());
            }
        }

        assertPlatformAnnotations(entityType);
    }

    private static void assertPlatformAnnotations(Class<?> entityType) throws Exception {
        TableId tableId = entityType.getDeclaredField("id").getAnnotation(TableId.class);
        assertEquals("f_id", tableId.value());
        assertEquals(IdType.INPUT, tableId.type());

        Field version = entityType.getDeclaredField("fVersion");
        assertTrue(version.isAnnotationPresent(Version.class));
        assertEquals("f_version", version.getAnnotation(TableField.class).value());
        for (Field field : entityType.getDeclaredFields()) {
            if (!Modifier.isStatic(field.getModifiers()) && !"fVersion".equals(field.getName())) {
                assertTrue("非 fVersion 字段不得标注 @Version: " + field.getName(),
                        !field.isAnnotationPresent(Version.class));
            }
        }

        assertFill(entityType, "fCreatorUserId", "f_creator_user_id", FieldFill.INSERT);
        assertFill(entityType, "fCreatorTime", "f_creator_time", FieldFill.INSERT);
        assertFill(entityType, "fLastModifyUserId", "f_last_modify_user_id",
                FieldFill.INSERT_UPDATE);
        assertFill(entityType, "fLastModifyTime", "f_last_modify_time",
                FieldFill.INSERT_UPDATE);
    }

    private static void assertFill(Class<?> entityType, String fieldName, String column,
                                   FieldFill expectedFill) throws Exception {
        TableField tableField = entityType.getDeclaredField(fieldName)
                .getAnnotation(TableField.class);
        assertEquals(column, tableField.value());
        assertEquals(expectedFill, tableField.fill());
    }

    private static void assertMapper(Class<?> mapperType, Class<?> entityType) {
        assertTrue(BaseMapper.class.isAssignableFrom(mapperType));
        assertTrue(mapperType.isAnnotationPresent(Mapper.class));
        Type mapperInterface = Arrays.stream(mapperType.getGenericInterfaces())
                .filter(type -> type instanceof ParameterizedType)
                .findFirst()
                .orElseThrow(() -> new AssertionError("Mapper 必须声明 BaseMapper 泛型"));
        ParameterizedType parameterized = (ParameterizedType) mapperInterface;
        assertEquals(BaseMapper.class, parameterized.getRawType());
        assertEquals(entityType, parameterized.getActualTypeArguments()[0]);
    }

    private static String[] enumNames(Class<? extends Enum<?>> enumType) {
        return Arrays.stream(enumType.getEnumConstants()).map(Enum::name).toArray(String[]::new);
    }

    private static Map<String, FieldSpec> templateVersionColumns() {
        Map<String, FieldSpec> columns = platformColumns();
        columns.put("mubanBianhao", field("muban_bianhao", String.class));
        columns.put("mubanBanben", field("muban_banben", String.class));
        columns.put("mubanMingcheng", field("muban_mincheng", String.class));
        columns.put("shiyanBuzhou", field("shiyan_buzhou", String.class));
        columns.put("jianyanXiangmu", field("jianyan_xiangmu", String.class));
        columns.put("jianyanXiangmuBianma",
                field("jianyan_xiangmu_bianma", String.class));
        columns.put("jianyanXiangmuMingcheng",
                field("jianyan_xiangmu_mingcheng", String.class));
        columns.put("mubanFenlei", field("muban_fenlei", String.class));
        columns.put("mubanFenleiMingcheng", field("muban_fenlei_mingcheng", String.class));
        columns.put("chuangjianRenyuan", field("chuangjian_renyuan", String.class));
        columns.put("chuangjianShijian", field("chuangjian_shijian", Date.class));
        columns.put("mubanFile", field("muban_file", String.class));
        columns.put("shengxiaoRiqi", field("shengxiao_riqi", Date.class));
        columns.put("bizStatus", field("biz_status", String.class));
        columns.put("bizEnabled", field("biz_enabled", String.class));
        columns.put("laiyuanMubanId", field("laiyuan_muban_id", String.class));
        columns.put("shengbanCaozuoBianma", field("shengban_caozuo_bianma", String.class));
        return columns;
    }

    private static Map<String, FieldSpec> currentVersionColumns() {
        Map<String, FieldSpec> columns = platformColumns();
        columns.put("mubanBianhao", field("muban_bianhao", String.class));
        columns.put("dangqianMubanId", field("dangqian_muban_id", String.class));
        columns.put("jianyanXiangmuBianma",
                field("jianyan_xiangmu_bianma", String.class));
        return columns;
    }

    private static Map<String, FieldSpec> bindingColumns() {
        Map<String, FieldSpec> columns = platformColumns();
        columns.put("mubanId", field("muban_id", String.class));
        columns.put("mubanBianhao", field("muban_bianhao", String.class));
        columns.put("ziduanDingyiId", field("ziduan_dingyi_id", String.class));
        columns.put("ziduanBianma", field("ziduan_bianma", String.class));
        columns.put("ziduanBanbenId", field("ziduan_banben_id", String.class));
        columns.put("kongjianBiaoqian", field("kongjian_biaoqian", String.class));
        columns.put("kongjianBieming", field("kongjian_bieming", String.class));
        columns.put("kongjianLeixing", field("kongjian_leixing", String.class));
        columns.put("kongjianJuese", field("kongjian_juese", String.class));
        columns.put("yinyongShiliId", field("yinyong_shili_id", String.class));
        columns.put("repeatGroupCode", field("repeat_group_code", String.class));
        columns.put("repeatPrototypeRowId", field("repeat_prototype_row_id", String.class));
        columns.put("checkboxGroupCode", field("checkbox_group_code", String.class));
        columns.put("stepId", field("step_id", String.class));
        columns.put("bangdingZhuangtai", field("bangding_zhuangtai", String.class));
        columns.put("caozuoBianma", field("caozuo_bianma", String.class));
        columns.put("laiyuanBangdingId", field("laiyuan_bangding_id", String.class));
        columns.put("daoqiShijian", field("daoqi_shijian", Date.class));
        columns.put("zhuangtaiYuanyin", field("zhuangtai_yuanyin", String.class));
        return columns;
    }

    private static Map<String, FieldSpec> repeatGroupColumns() {
        Map<String, FieldSpec> columns = platformColumns();
        columns.put("mubanId", field("muban_id", String.class));
        columns.put("repeatGroupCode", field("repeat_group_code", String.class));
        columns.put("minRows", field("min_rows", Integer.class));
        columns.put("maxRows", field("max_rows", Integer.class));
        columns.put("stepId", field("step_id", String.class));
        return columns;
    }

    private static Map<String, FieldSpec> checkboxGroupColumns() {
        Map<String, FieldSpec> columns = platformColumns();
        columns.put("mubanId", field("muban_id", String.class));
        columns.put("groupCode", field("group_code", String.class));
        columns.put("minSelected", field("min_selected", Integer.class));
        columns.put("maxSelected", field("max_selected", Integer.class));
        return columns;
    }

    private static Map<String, FieldSpec> stageColumns() {
        Map<String, FieldSpec> columns = platformColumns();
        columns.put("mubanId", field("muban_id", String.class));
        columns.put("jieduanMingcheng", field("jieduan_mingcheng", String.class));
        columns.put("paixu", field("paixu", Integer.class));
        columns.put("laiyuanJieduanId", field("laiyuan_jieduan_id", String.class));
        return columns;
    }

    private static Map<String, FieldSpec> stepColumns() {
        Map<String, FieldSpec> columns = platformColumns();
        columns.put("mubanId", field("muban_id", String.class));
        columns.put("jieduanId", field("jieduan_id", String.class));
        columns.put("buzhouMingcheng", field("buzhou_mingcheng", String.class));
        columns.put("paixu", field("paixu", Integer.class));
        columns.put("laiyuanBuzhouId", field("laiyuan_buzhou_id", String.class));
        return columns;
    }

    private static Map<String, FieldSpec> platformColumns() {
        Map<String, FieldSpec> columns = new LinkedHashMap<>();
        columns.put("id", id("f_id", String.class));
        columns.put("fTenantId", field("f_tenant_id", String.class));
        columns.put("fVersion", field("f_version", Integer.class));
        columns.put("fCreatorUserId", field("f_creator_user_id", String.class, FieldFill.INSERT));
        columns.put("fCreatorTime", field("f_creator_time", Date.class, FieldFill.INSERT));
        columns.put("fLastModifyUserId", field("f_last_modify_user_id", String.class,
                FieldFill.INSERT_UPDATE));
        columns.put("fLastModifyTime", field("f_last_modify_time", Date.class,
                FieldFill.INSERT_UPDATE));
        columns.put("fDeleteUserId", field("f_delete_user_id", String.class));
        columns.put("fDeleteTime", field("f_delete_time", Date.class));
        columns.put("fDeleteMark", field("f_delete_mark", Integer.class));
        return columns;
    }

    private static FieldSpec id(String column, Class<?> javaType) {
        return new FieldSpec(column, javaType, true, FieldFill.DEFAULT);
    }

    private static FieldSpec field(String column, Class<?> javaType) {
        return field(column, javaType, FieldFill.DEFAULT);
    }

    private static FieldSpec field(String column, Class<?> javaType, FieldFill fill) {
        return new FieldSpec(column, javaType, false, fill);
    }

    private static final class FieldSpec {
        private final String column;
        private final Class<?> javaType;
        private final boolean id;
        private final FieldFill fill;

        private FieldSpec(String column, Class<?> javaType, boolean id, FieldFill fill) {
            this.column = column;
            this.javaType = javaType;
            this.id = id;
            this.fill = fill;
        }
    }
}