package jnpf.limsService.support;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import jnpf.limsMapper.LimsHaocaiRukuYanshouMapper;
import jnpf.limsMapper.LimsHaocaiRukuZixiangMapper;
import jnpf.limsMapper.LimsHaocaiXiaohuiShenqingMapper;
import jnpf.limsMapper.LimsHaocaiXiaohuiShenqingZixiangMapper;
import jnpf.limsMapper.LimsHuanjingJianceBaogaoMapper;
import jnpf.limsMapper.LimsHuanjingJianceJihuaMapper;
import jnpf.limsMapper.LimsHuanjingJianceJihuaZhongzhiMapper;
import jnpf.limsMapper.LimsLiuyangJihuaBiangengShenqingMapper;
import jnpf.limsMapper.LimsQingyandanYichangShenqingMapper;
import jnpf.limsMapper.LimsShebeiYiqiJiaozhunNeibuMapper;
import jnpf.limsMapper.LimsShebeiYiqiJiaozhunWaibuMapper;
import jnpf.limsMapper.LimsShebeiYiqiJiliangMapper;
import jnpf.limsMapper.LimsShebeiYiqiPeijianGenghuanZixiangMapper;
import jnpf.limsMapper.LimsShebeiYiqiQijuBaofeiMapper;
import jnpf.limsMapper.LimsShebeiYiqiYanzhengMapper;
import jnpf.limsMapper.LimsShebeiYiqiWeibaoZixiangMapper;
import jnpf.limsMapper.LimsWendingxingChurukuMapper;
import jnpf.limsMapper.LimsWendingxingChurukuZixiangMapper;
import jnpf.limsMapper.LimsWendingxingKaocaJihuaBiangengMapper;
import jnpf.limsMapper.LimsWendingxingKaocaJihuaBiangengZhouqiMapper;
import jnpf.limsMapper.LimsWendingxingXiaohuiShenqingMapper;
import jnpf.util.context.SpringContext;

import java.util.List;
import java.util.Map;

/** 为 @AuditLog 的 SpEL 在业务执行前解析关联表真实主键。 */
public final class LimsAuditTargetIds {

    private LimsAuditTargetIds() {
    }

    public static String liuyangJihuaByChangeFlow(String flowId, String taskId) {
        return lookup(LimsLiuyangJihuaBiangengShenqingMapper.class,
                "f_flow_id", flowId, "f_flow_task_id", taskId, "liuyang_jihua_id");
    }

    public static String huanjingJihuaByFlow(String flowId, String taskId) {
        return lookup(LimsHuanjingJianceJihuaMapper.class,
                "f_flow_id", flowId, "f_flow_task_id", taskId, "f_id");
    }

    public static String huanjingJihuaByTerminateFlow(String flowId, String taskId) {
        return lookup(LimsHuanjingJianceJihuaZhongzhiMapper.class,
                "f_flow_id", flowId, "f_flow_task_id", taskId, "jihua_id");
    }

    public static String huanjingBaogaoByFlow(String flowId, String taskId) {
        return lookup(LimsHuanjingJianceBaogaoMapper.class,
                "f_flow_id", flowId, "f_flow_task_id", taskId, "f_id");
    }

    public static String qingyandanByExceptionFlow(String flowId, String taskId) {
        return lookup(LimsQingyandanYichangShenqingMapper.class,
                "f_flow_id", flowId, "f_flow_task_id", taskId, "qingyandan_id");
    }

    public static String qijuByExternalCalibration(String calibrationId) {
        return lookupById(LimsShebeiYiqiJiaozhunWaibuMapper.class, calibrationId, "qiju_id");
    }

    public static String qijuByInternalCalibrationFlow(String flowId, String taskId) {
        return lookup(LimsShebeiYiqiJiaozhunNeibuMapper.class,
                "f_flow_id", flowId, "f_flow_task_id", taskId, "qiju_id");
    }

    public static String qijuByScrapFlow(String flowId, String taskId) {
        return lookup(LimsShebeiYiqiQijuBaofeiMapper.class,
                "f_flow_id", flowId, "f_flow_task_id", taskId, "qiju_id");
    }

    public static String yiqiByVerification(String verificationId) {
        return lookupById(LimsShebeiYiqiYanzhengMapper.class, verificationId, "yiqi_id");
    }

    public static String yiqiByMeasurement(String measurementId) {
        return lookupById(LimsShebeiYiqiJiliangMapper.class, measurementId, "yiqi_id");
    }

    public static String wendingxingDestroyByFlow(String flowId, String taskId) {
        return lookup(LimsWendingxingXiaohuiShenqingMapper.class,
                "f_flow_id", flowId, "f_flow_task_id", taskId, "f_id");
    }

    public static String haocaiAcceptanceByFlow(String flowId, String taskId) {
        return lookup(LimsHaocaiRukuYanshouMapper.class,
                "f_flow_id", flowId, "f_flow_task_id", taskId, "f_id");
    }

    public static String haocaiAcceptanceRequestByFlow(String flowId, String taskId) {
        return lookup(LimsHaocaiRukuYanshouMapper.class,
                "f_flow_id", flowId, "f_flow_task_id", taskId, "shenqing_id");
    }

    public static String firstPartReplacementItem(String replacementId) {
        return lookupFirst(LimsShebeiYiqiPeijianGenghuanZixiangMapper.class,
                "f_foreign_id", replacementId, "f_id");
    }

    public static String firstMaintenanceItem(String maintenanceId) {
        return lookupFirst(LimsShebeiYiqiWeibaoZixiangMapper.class,
                "f_foreign_id", maintenanceId, "f_id");
    }

    public static String firstHaocaiRukuItem(List<String> rukuIds) {
        return lookupFirstIn(LimsHaocaiRukuZixiangMapper.class,
                "f_foreign_id", rukuIds, "f_id");
    }

    public static String firstHaocaiDestroyItem(String destroyNumber) {
        String requestId = lookupFirst(LimsHaocaiXiaohuiShenqingMapper.class,
                "xiaohui_danhao", destroyNumber, "f_id");
        return firstHaocaiDestroyItemByRequest(requestId);
    }

    public static String firstHaocaiDestroyItemByFlow(String flowId, String taskId) {
        String requestId = lookup(LimsHaocaiXiaohuiShenqingMapper.class,
                "f_flow_id", flowId, "f_flow_task_id", taskId, "f_id");
        return firstHaocaiDestroyItemByRequest(requestId);
    }

    public static String firstWendingxingChurukuItemByFlow(String flowId, String taskId) {
        String churukuId = lookup(LimsWendingxingChurukuMapper.class,
                "f_flow_id", flowId, "f_flow_task_id", taskId, "f_id");
        return lookupFirst(LimsWendingxingChurukuZixiangMapper.class,
                "f_foreign_id", churukuId, "f_id");
    }

    public static String firstWendingxingChangedPeriod(String flowId, String taskId) {
        String changeId = lookup(LimsWendingxingKaocaJihuaBiangengMapper.class,
                "f_flow_id", flowId, "f_flow_task_id", taskId, "f_id");
        return lookupFirstNotBlank(LimsWendingxingKaocaJihuaBiangengZhouqiMapper.class,
                "biangeng_id", changeId, "yuanjihua_zhouqi_id");
    }

    private static String firstHaocaiDestroyItemByRequest(String requestId) {
        String barcode = lookupFirstNotBlank(LimsHaocaiXiaohuiShenqingZixiangMapper.class,
                "f_foreign_id", requestId, "tiaoma_bianma");
        return lookupFirst(LimsHaocaiRukuZixiangMapper.class,
                "tiaoma_bianma", barcode, "f_id");
    }

    private static String lookupById(Class<? extends BaseMapper<?>> mapperType,
                                     String id, String selectedColumn) {
        return lookup(mapperType, "f_id", id, null, null, selectedColumn);
    }

    private static String lookupFirst(Class<? extends BaseMapper<?>> mapperType,
                                      String conditionColumn, String conditionValue,
                                      String selectedColumn) {
        if (isBlank(conditionValue)) {
            return null;
        }
        return selectFirst(mapperType, new QueryWrapper<>().eq(conditionColumn, conditionValue),
                selectedColumn, false);
    }

    private static String lookupFirstNotBlank(Class<? extends BaseMapper<?>> mapperType,
                                              String conditionColumn, String conditionValue,
                                              String selectedColumn) {
        if (isBlank(conditionValue)) {
            return null;
        }
        QueryWrapper<Object> query = new QueryWrapper<>();
        query.eq(conditionColumn, conditionValue).isNotNull(selectedColumn).ne(selectedColumn, "");
        return selectFirst(mapperType, query, selectedColumn, false);
    }

    private static String lookupFirstIn(Class<? extends BaseMapper<?>> mapperType,
                                        String conditionColumn, List<String> conditionValues,
                                        String selectedColumn) {
        if (conditionValues == null || conditionValues.isEmpty()) {
            return null;
        }
        return selectFirst(mapperType, new QueryWrapper<>().in(conditionColumn, conditionValues),
                selectedColumn, false);
    }

    @SuppressWarnings({"rawtypes", "unchecked"})
    private static String selectFirst(Class<? extends BaseMapper<?>> mapperType,
                                      QueryWrapper<?> conditions, String selectedColumn,
                                      boolean requireUnique) {
        BaseMapper mapper = SpringContext.getBean(mapperType);
        QueryWrapper query = conditions.select(selectedColumn).orderByAsc("f_id");
        List<Map<String, Object>> rows = mapper.selectMaps(query);
        if (rows == null || rows.isEmpty() || (requireUnique && rows.size() != 1)) {
            return null;
        }
        return mapValue(rows.get(0), selectedColumn);
    }

    @SuppressWarnings({"rawtypes", "unchecked"})
    private static String lookup(Class<? extends BaseMapper<?>> mapperType,
                                 String firstColumn, String firstValue,
                                 String secondColumn, String secondValue,
                                 String selectedColumn) {
        if (isBlank(firstValue) || (secondColumn != null && isBlank(secondValue))) {
            return null;
        }
        BaseMapper mapper = SpringContext.getBean(mapperType);
        QueryWrapper<Object> query = new QueryWrapper<>();
        query.select(selectedColumn).eq(firstColumn, firstValue);
        if (secondColumn != null) {
            query.eq(secondColumn, secondValue);
        }
        List<Map<String, Object>> rows = mapper.selectMaps(query);
        if (rows == null || rows.size() != 1) {
            return null;
        }
        return mapValue(rows.get(0), selectedColumn);
    }

    private static String mapValue(Map<String, Object> row, String column) {
        Object value = row.get(column);
        if (value == null) {
            value = row.get(column.toUpperCase());
        }
        return value == null ? null : String.valueOf(value);
    }

    private static boolean isBlank(String value) {
        return value == null || value.trim().isEmpty();
    }
}