package jnpf.elnMapper;

import jnpf.elnEntity.formula.ElnFormulaDefEntity;
import jnpf.elnEntity.formula.ElnFormulaParameterSlotEntity;
import jnpf.elnEntity.formula.ElnFormulaVersionEntity;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Update;
import org.junit.Test;

import java.lang.reflect.Method;

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

public class ElnFormulaMapperContractTest {

    @Test
    public void definitionUpdateUsesTenantIdAndOptimisticVersion() throws Exception {
        String sql = updateSql(ElnFormulaDefMapper.class,
                "updateMutableByTenantAndVersion", ElnFormulaDefEntity.class);

        assertTenantIdVersionGuard(sql);
        assertTrue(sql.contains("gongshi_mingcheng ="));
        assertTrue(sql.contains("f_version = f_version + 1"));
        assertFalse(sql.contains("gongshi_bianma ="));
        assertFalse(setClause(sql).contains("f_tenant_id ="));
    }

    @Test
    public void versionUpdateUsesTenantIdAndOptimisticVersion() throws Exception {
        String sql = updateSql(ElnFormulaVersionMapper.class,
                "updateMutableByTenantAndVersion", ElnFormulaVersionEntity.class);

        assertTenantIdVersionGuard(sql);
        assertTrue(sql.contains("biaodashi ="));
        assertTrue(sql.contains("biz_status ="));
        assertFalse(sql.contains("gongshi_dingyi_id ="));
        assertFalse(sql.contains("banben_hao ="));
    }

    @Test
    public void slotUpdateAndDeleteUseTenantIdAndOptimisticVersion() throws Exception {
        String updateSql = updateSql(ElnFormulaParameterSlotMapper.class,
                "updateMutableByTenantAndVersion", ElnFormulaParameterSlotEntity.class);
        assertTenantIdVersionGuard(updateSql);
        assertTrue(updateSql.contains("canshu_mingcheng ="));
        assertFalse(updateSql.contains("canshu_bianma ="));
        assertFalse(updateSql.contains("gongshi_banben_id ="));

        Method deleteMethod = ElnFormulaParameterSlotMapper.class.getDeclaredMethod(
                "deleteByTenantAndVersion", ElnFormulaParameterSlotEntity.class, Integer.class);
        String deleteSql = normalize(String.join(" ",
                deleteMethod.getAnnotation(Delete.class).value()));
        assertTenantIdVersionGuard(deleteSql);
    }

    @Test
    public void slotInsertIgnoresOnlyTenantVersionAndParameterCodeConflict() {
        Method insertMethod = null;
        for (Method method : ElnFormulaParameterSlotMapper.class.getDeclaredMethods()) {
            if (method.getAnnotation(Insert.class) != null) {
                insertMethod = method;
                break;
            }
        }
        assertTrue(insertMethod != null);

        String sql = normalize(String.join(" ", insertMethod.getAnnotation(Insert.class).value()));
        assertTrue(sql.contains("insert into eln_formula_parameter_slot (gongshi_banben_id, "
                + "canshu_bianma, canshu_mingcheng, shuju_leixing, danwei, shifou_bitian, "
                + "paixu, f_id, f_tenant_id, f_version, f_creator_user_id, f_creator_time, "
                + "f_last_modify_user_id, f_last_modify_time, f_delete_user_id, f_delete_time, "
                + "f_delete_mark) values ("));
        assertTrue(sql.contains("on conflict (f_tenant_id, gongshi_banben_id, canshu_bianma) "
                + "do nothing"));
    }

    private static String updateSql(Class<?> mapper, String name, Class<?> entity)
            throws Exception {
        Method method = mapper.getDeclaredMethod(name, entity, Integer.class);
        return normalize(String.join(" ", method.getAnnotation(Update.class).value()));
    }

    private static void assertTenantIdVersionGuard(String sql) {
        assertTrue(sql.contains("where f_tenant_id = #{entity.ftenantid}"));
        assertTrue(sql.contains("and f_id = #{entity.id}"));
        assertTrue(sql.contains("and f_version = #{expectedversion}"));
    }

    private static String normalize(String sql) {
        return sql.toLowerCase().replaceAll("\\s+", " ").trim();
    }

    private static String setClause(String sql) {
        return sql.substring(0, sql.indexOf(" where "));
    }
}