klp-oa/klp-wms/src/main/java/com/klp/service/impl/WmsAttendanceCheckServiceImpl.java

package com.klp.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.utils.StringUtils;
import com.klp.domain.AttendanceRecords;
import com.klp.domain.WmsAttendanceCheck;
import com.klp.domain.WmsAttendanceRule;
import com.klp.domain.bo.AttendanceCheckBo;
import com.klp.domain.bo.AttendanceRecordsBo;
import com.klp.domain.bo.WmsAttendanceCheckBo;
import com.klp.domain.bo.WmsAttendanceScheduleBo;
import com.klp.domain.vo.AttendanceRecordsVo;
import com.klp.domain.vo.WmsAttendanceCheckVo;
import com.klp.domain.vo.WmsAttendanceScheduleVo;
import com.klp.mapper.WmsAttendanceCheckMapper;
import com.klp.mapper.WmsAttendanceRuleMapper;
import com.klp.service.IAttendanceRecordsService;
import com.klp.service.IWmsAttendanceCheckService;
import com.klp.service.IWmsAttendanceScheduleService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;

@RequiredArgsConstructor
@Service
public class WmsAttendanceCheckServiceImpl implements IWmsAttendanceCheckService {

    private static final List<String> STATUS_SEVERITY = java.util.Arrays.asList("normal", "late_warn", "early_warn",
        "late_one", "early_one", "late_two", "early_two", "absent_half");

    private static final int BATCH_SIZE = 500;

    private final WmsAttendanceCheckMapper baseMapper;
    private final IWmsAttendanceScheduleService scheduleService;
    private final IAttendanceRecordsService attendanceRecordsService;
    private final WmsAttendanceRuleMapper ruleMapper;

    @Override
    public WmsAttendanceCheckVo queryById(Long checkId) {
        return baseMapper.selectVoById(checkId);
    }

    @Override
    public TableDataInfo<WmsAttendanceCheckVo> queryPageList(WmsAttendanceCheckBo bo, PageQuery pageQuery) {
        LambdaQueryWrapper<WmsAttendanceCheck> lqw = buildQueryWrapper(bo);
        Page<WmsAttendanceCheckVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
        return TableDataInfo.build(result);
    }

    @Override
    public List<WmsAttendanceCheckVo> queryList(WmsAttendanceCheckBo bo) {
        LambdaQueryWrapper<WmsAttendanceCheck> lqw = buildQueryWrapper(bo);
        return baseMapper.selectVoList(lqw);
    }

    @Override
    public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
        return baseMapper.deleteBatchIds(ids) > 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateByBo(WmsAttendanceCheckBo bo) {
        WmsAttendanceCheck update = BeanUtil.toBean(bo, WmsAttendanceCheck.class);
        return baseMapper.updateById(update) > 0;
    }

    private LambdaQueryWrapper<WmsAttendanceCheck> buildQueryWrapper(WmsAttendanceCheckBo bo) {
        LambdaQueryWrapper<WmsAttendanceCheck> lqw = Wrappers.lambdaQuery();
        lqw.eq(bo.getUserId() != null, WmsAttendanceCheck::getUserId, bo.getUserId());
        lqw.like(StringUtils.isNotBlank(bo.getEmployeeName()), WmsAttendanceCheck::getEmployeeName, bo.getEmployeeName());
        lqw.eq(bo.getShiftId() != null, WmsAttendanceCheck::getShiftId, bo.getShiftId());
        lqw.ge(bo.getStartDate() != null, WmsAttendanceCheck::getWorkDate, bo.getStartDate());
        lqw.le(bo.getEndDate() != null, WmsAttendanceCheck::getWorkDate, bo.getEndDate());
        lqw.in(bo.getUserIds() != null, WmsAttendanceCheck::getUserId, bo.getUserIds());
        lqw.orderByDesc(WmsAttendanceCheck::getWorkDate);
        return lqw;
    }

    /**
     * 检查员工考勤情况
     *
     * @param bo 考勤检查业务对象，包含开始日期、结束日期和用户ID等信息
     */
    @Override
    @Transactional(rollbackFor = Exception.class) // 使用事务注解，确保方法内所有操作要么全部成功，要么全部回滚
    public void checkAttendance(AttendanceCheckBo bo) {
        // 创建考勤计划业务对象，并设置查询参数
        WmsAttendanceScheduleBo scheduleBo = new WmsAttendanceScheduleBo();
        scheduleBo.setStartDate(bo.getStartDate()); // 设置开始日期
        scheduleBo.setEndDate(bo.getEndDate()); // 设置结束日期
        scheduleBo.setUserIds(bo.getUserIds()); // 设置用户ID列表
        // 根据查询条件获取考勤计划列表
        List<WmsAttendanceScheduleVo> schedules = scheduleService.queryList(scheduleBo);

        // 如果没有考勤计划，直接返回
        if (schedules.isEmpty()) {
            return;
        }

        // 获取当前有效的考勤规则
        WmsAttendanceRule rule = getActiveRule();

//        // 将日期转换为LocalDate类型
//        LocalDate startLocal = toLocalDate(bo.getStartDate());
//        LocalDate endLocal = toLocalDate(bo.getEndDate());

        // 创建待处理的考勤计划列表
        List<WmsAttendanceScheduleVo> toProcess = new ArrayList<>();
        // 遍历考勤计划，过滤掉无效数据
        for (WmsAttendanceScheduleVo schedule : schedules) {
            if (schedule.getEmployeeName() == null) { // 跳过员工名为空的记录
                continue;
            }
            if (schedule.getShiftStartTime() == null && schedule.getShiftEndTime() == null) { // 跳过上下班时间为空的记录
                continue;
            }
            toProcess.add(schedule); // 添加到待处理列表
        }

        // 如果过滤后没有有效的考勤计划，直接返回
        if (toProcess.isEmpty()) {
            return;
        }

        // 倒班日重叠检测：若某天有正向跨天夜班(19:00→07:00)，且次日存在同员工、同上班时间的反向跨天班(夜转白 19:00→13:00)，
        // 则正向跨天班的下班时间校验跳过（实际下班按反向跨天班 13:00 算），但上班打卡仍然校验
        // 创建映射表，记录被反向跨天班覆盖的记录
        Map<String, LocalTime> backwardCoveredByEmployee = new HashMap<>();
        for (WmsAttendanceScheduleVo s : toProcess) {
            // 如果是跨天班且是反向跨天班，记录该员工在特定日期的上班时间
            if (isCrossDayShift(s) && isBackwardCrossDay(s) && s.getEmployeeName() != null) {
                LocalDate workLd = toLocalDate(s.getWorkDate());
                String key = s.getEmployeeName() + "_" + workLd.minusDays(1);
                backwardCoveredByEmployee.put(key, toLocalTime(s.getShiftStartTime()));
            }
        }
        // 记录需要覆盖下班检查的考勤计划ID
        Set<Long> endCheckOverridden = new HashSet<>();
        for (WmsAttendanceScheduleVo s : toProcess) {
            // 如果是正向跨天班，检查是否有对应的反向跨天班覆盖
            if (isCrossDayShift(s) && !isBackwardCrossDay(s) && s.getEmployeeName() != null && s.getShiftStartTime() != null) {
                LocalDate workLd = toLocalDate(s.getWorkDate());
                String key = s.getEmployeeName() + "_" + workLd;
                LocalTime backwardStart = backwardCoveredByEmployee.get(key);
                if (backwardStart != null && backwardStart.equals(toLocalTime(s.getShiftStartTime()))) {
                    endCheckOverridden.add(s.getScheduleId());
                }
            }
        }

        // 获取受影响的用户ID集合
        Set<Long> affectedUserIds = toProcess.stream()
            .map(WmsAttendanceScheduleVo::getUserId)
            .filter(Objects::nonNull)
            .collect(Collectors.toSet());

        // 按员工预取考勤记录
        Map<String, List<AttendanceRecords>> recordsByEmployee = prefetchAttendanceRecords(toProcess);

        // 获取所有待处理考勤计划的ID列表
        List<Long> scheduleIds = toProcess.stream()
            .map(WmsAttendanceScheduleVo::getScheduleId)
            .collect(Collectors.toList());
        // 批量删除这些考勤计划对应的考勤检查记录
        batchDeleteByScheduleIds(scheduleIds);

        // 创建要插入的考勤检查记录列表
        List<WmsAttendanceCheck> checksToInsert = new ArrayList<>(toProcess.size());
        // 遍历待处理的考勤计划，构建考勤检查记录
        for (WmsAttendanceScheduleVo schedule : toProcess) {
            boolean crossDay = isCrossDayShift(schedule);
            boolean backward = isBackwardCrossDay(schedule);
            // 根据考勤计划和考勤记录，按天切片考勤记录
            List<AttendanceRecords> records = sliceRecordsForDay(
                recordsByEmployee.get(schedule.getEmployeeName()),
                schedule.getWorkDate(),
                crossDay, backward);
            // 构建考勤检查记录并添加到插入列表
            checksToInsert.add(buildCheck(schedule, rule, records, crossDay, endCheckOverridden));
        }

        // 批量插入考勤检查记录
        baseMapper.insertBatch(checksToInsert, BATCH_SIZE);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void recalcContinuousAbsent(AttendanceCheckBo bo) {
        LocalDate startLocal = toLocalDate(bo.getStartDate());
        LocalDate endLocal = toLocalDate(bo.getEndDate());
        Set<Long> affectedUserIds;
        if (bo.getUserIds() != null && !bo.getUserIds().isEmpty()) {
            affectedUserIds = new HashSet<>(bo.getUserIds());
        } else {
            List<WmsAttendanceCheck> checks = baseMapper.selectList(Wrappers.<WmsAttendanceCheck>lambdaQuery()
                .select(WmsAttendanceCheck::getUserId)
                .ge(WmsAttendanceCheck::getWorkDate, toDate(startLocal.atStartOfDay()))
                .le(WmsAttendanceCheck::getWorkDate, toDate(endLocal.atTime(LocalTime.of(23, 59, 59))))
                .eq(WmsAttendanceCheck::getDelFlag, 0));
            affectedUserIds = checks.stream()
                .map(WmsAttendanceCheck::getUserId)
                .collect(Collectors.toSet());
        }
        updateContinuousAbsent(startLocal, endLocal, affectedUserIds);
    }

    private boolean isCrossDayShift(WmsAttendanceScheduleVo schedule) {
        return schedule.getShiftIsCrossDay() != null && schedule.getShiftIsCrossDay() == 1;
    }

    private boolean isBackwardCrossDay(WmsAttendanceScheduleVo schedule) {
        if (!isCrossDayShift(schedule)) return false;
        if (schedule.getShiftEndTime() == null) return false;
        return toLocalTime(schedule.getShiftEndTime()).getHour() >= 12;
    }

    private WmsAttendanceRule getActiveRule() {
        LambdaQueryWrapper<WmsAttendanceRule> wrapper = Wrappers.lambdaQuery();
        wrapper.eq(WmsAttendanceRule::getDelFlag, 0);
        wrapper.last("LIMIT 1");
        WmsAttendanceRule rule = ruleMapper.selectOne(wrapper);
        if (rule == null) {
            rule = new WmsAttendanceRule();
            rule.setLateWarn(3L);
            rule.setLateOne(5L);
            rule.setLateTwo(15L);
            rule.setDeductOne(new BigDecimal("10"));
            rule.setDeductTwo(new BigDecimal("30"));
            rule.setAbsentHalfDay(15L);
            rule.setContinuousAbsentDays(3L);
        }
        return rule;
    }

    /**
     * 一次 SQL 批量查询所有员工在日期范围内的打卡记录（用 IN/eq 精确匹配，走索引）。
     */
    private Map<String, List<AttendanceRecords>> prefetchAttendanceRecords(List<WmsAttendanceScheduleVo> toProcess) {
        Map<String, LocalDate> minByName = new HashMap<>();
        Map<String, LocalDate> maxByName = new HashMap<>();
        for (WmsAttendanceScheduleVo s : toProcess) {
            String name = s.getEmployeeName();
            LocalDate ld = toLocalDate(s.getWorkDate());
            minByName.merge(name, ld, (a, b) -> a.isBefore(b) ? a : b);
            maxByName.merge(name, ld, (a, b) -> a.isAfter(b) ? a : b);
        }
        if (minByName.isEmpty()) {
            return new HashMap<>();
        }
        LocalDate globalMin = minByName.values().stream().min(LocalDate::compareTo).get();
        LocalDate globalMax = maxByName.values().stream().max(LocalDate::compareTo).get();
        Date rangeStart = toDate(globalMin.atStartOfDay());
        Date rangeEnd = toDate(globalMax.plusDays(1).atTime(LocalTime.of(23, 59, 59)));

        List<String> allNames = new ArrayList<>(minByName.keySet());
        List<AttendanceRecords> allRecords = attendanceRecordsService.queryListByEnamesAndDateRange(
            allNames, rangeStart, rangeEnd);

        Map<String, List<AttendanceRecords>> out = new HashMap<>();
        for (AttendanceRecords r : allRecords) {
            out.computeIfAbsent(r.getEname(), k -> new ArrayList<>()).add(r);
        }
        for (String name : allNames) {
            out.computeIfAbsent(name, k -> new ArrayList<>());
        }
        return out;
    }

    private List<AttendanceRecords> sliceRecordsForDay(List<AttendanceRecords> prefetched, Date workDate, boolean crossDay, boolean backward) {
        if (prefetched == null || prefetched.isEmpty()) {
            return new ArrayList<>();
        }
        LocalDate ld = toLocalDate(workDate);
        LocalDateTime rangeStart = backward
            ? ld.minusDays(1).atStartOfDay()
            : ld.atStartOfDay();
        LocalDateTime rangeEnd = crossDay && !backward
            ? ld.plusDays(1).atTime(LocalTime.of(23, 59, 59))
            : ld.atTime(LocalTime.of(23, 59, 59));
        return prefetched.stream()
            .filter(r -> {
                LocalDateTime ct = toLocalDateTime(r.getChecktime());
                return ct != null && !ct.isBefore(rangeStart) && !ct.isAfter(rangeEnd);
            })
            .sorted(Comparator.comparing(AttendanceRecords::getChecktime))
            .collect(Collectors.toList());
    }

    private void batchDeleteByScheduleIds(List<Long> scheduleIds) {
        if (scheduleIds.isEmpty()) {
            return;
        }
        for (int i = 0; i < scheduleIds.size(); i += BATCH_SIZE) {
            int to = Math.min(i + BATCH_SIZE, scheduleIds.size());
            List<Long> chunk = scheduleIds.subList(i, to);
            baseMapper.delete(Wrappers.<WmsAttendanceCheck>lambdaQuery()
                .in(WmsAttendanceCheck::getScheduleId, chunk));
        }
    }

    /**
     * 构建考勤检查对象，根据排班信息和考勤记录生成考勤结果
     *
     * @param schedule           排班信息对象
     * @param rule               考勤规则对象
     * @param records            考勤记录列表
     * @param crossDay           是否跨天
     * @param endCheckOverridden 已覆盖的结束检查集合
     * @return 构建好的考勤检查对象
     */
    private WmsAttendanceCheck buildCheck(WmsAttendanceScheduleVo schedule, WmsAttendanceRule rule,
                                          List<AttendanceRecords> records, boolean crossDay,
                                          Set<Long> endCheckOverridden) {
        // 创建考勤检查对象
        WmsAttendanceCheck check = new WmsAttendanceCheck();
        // 设置排班基本信息
        check.setScheduleId(schedule.getScheduleId());
        check.setUserId(schedule.getUserId());
        check.setEmployeeName(schedule.getEmployeeName());
        check.setWorkDate(schedule.getWorkDate());
        check.setShiftId(schedule.getShiftId());
        check.setShiftName(schedule.getShiftName());
        check.setShiftType(schedule.getShiftType());

        // 判断是否有第二时段
        boolean hasPeriod2 = schedule.getShiftStartTime2() != null && schedule.getShiftEndTime2() != null;

        // 判断是否为向后跨天
        boolean backward = isBackwardCrossDay(schedule);

        // 处理时段设置
        if (hasPeriod2) {
            // 设置第一时段开始时间，考虑跨天情况
            check.setP1StartTime(crossDay && backward
                ? combinePrevDay(schedule.getWorkDate(), schedule.getShiftStartTime())
                : combineTime(schedule.getWorkDate(), schedule.getShiftStartTime()));
            // 设置第一时段结束时间，考虑跨天情况
            check.setP1EndTime(crossDay && !backward
                ? combineNextDay(schedule.getWorkDate(), schedule.getShiftEndTime())
                : combineTime(schedule.getWorkDate(), schedule.getShiftEndTime()));
            check.setP2StartTime(combineTime(schedule.getWorkDate(), schedule.getShiftStartTime2()));
            check.setP2EndTime(combineTime(schedule.getWorkDate(), schedule.getShiftEndTime2()));
        } else {
            check.setP1StartTime(crossDay && backward
                ? combinePrevDay(schedule.getWorkDate(), schedule.getShiftStartTime())
                : combineTime(schedule.getWorkDate(), schedule.getShiftStartTime()));
            check.setP1EndTime(crossDay && !backward
                ? combineNextDay(schedule.getWorkDate(), schedule.getShiftEndTime())
                : combineTime(schedule.getWorkDate(), schedule.getShiftEndTime()));
        }

        if (records.isEmpty()) {
            check.setP1Status("missed");
            if (hasPeriod2) {
                check.setP2Status("missed");
            }
            check.setOverallStatus("absent_full");
            check.setAbsentType("full_day");
            return check;
        }

        if (hasPeriod2) {
            LocalTime p1End = toLocalTime(schedule.getShiftEndTime());
            LocalTime p2Start = toLocalTime(schedule.getShiftStartTime2());
            LocalTime split = LocalTime.of(
                (p1End.getHour() + p2Start.getHour()) / 2,
                (p1End.getMinute() + p2Start.getMinute()) / 2);

            List<AttendanceRecords> p1Records = new ArrayList<>();
            List<AttendanceRecords> p2Records = new ArrayList<>();
            for (AttendanceRecords r : records) {
                LocalTime t = toLocalDateTime(r.getChecktime()).toLocalTime();
                if (t.isBefore(split)) {
                    p1Records.add(r);
                } else {
                    p2Records.add(r);
                }
            }

            checkPeriod(check, rule, 1, p1Records, check.getP1StartTime(), check.getP1EndTime());
            checkPeriod(check, rule, 2, p2Records, check.getP2StartTime(), check.getP2EndTime());
        } else {
            List<AttendanceRecords> filtered = filterWindow(records, schedule.getWorkDate(),
                schedule.getShiftStartTime(), schedule.getShiftEndTime(), crossDay);
            Date actualEnd = endCheckOverridden.contains(schedule.getScheduleId())
                ? null : check.getP1EndTime();
            checkPeriod(check, rule, 1, filtered, check.getP1StartTime(), actualEnd);
        }

        calculateOverall(check, rule);
        return check;
    }

    private List<AttendanceRecords> filterWindow(List<AttendanceRecords> records, Date workDate,
                                                 Date expectedStart, Date expectedEnd, boolean crossDay) {
        LocalDate ld = toLocalDate(workDate);
        LocalTime st = toLocalTime(expectedStart);
        LocalTime et = toLocalTime(expectedEnd);

        LocalDateTime windowStart;
        LocalDateTime windowEnd;

        boolean backward = crossDay && et != null && et.getHour() >= 12;

        if (crossDay && backward) {
            windowStart = st != null
                ? LocalDateTime.of(ld.minusDays(1), st).minusHours(2)
                : LocalDateTime.of(ld, et).minusHours(2);
            windowEnd = LocalDateTime.of(ld, et).plusHours(2);
        } else if (crossDay) {
            windowStart = LocalDateTime.of(ld, st).minusHours(2);
            windowEnd = LocalDateTime.of(ld.plusDays(1), et).plusHours(2);
        } else if (st != null && et != null) {
            windowStart = LocalDateTime.of(ld, st).minusHours(2);
            windowEnd = LocalDateTime.of(ld, et).plusHours(2);
        } else if (st != null) {
            windowStart = LocalDateTime.of(ld, st).minusHours(2);
            windowEnd = LocalDateTime.of(ld, st).plusHours(2);
        } else {
            windowStart = LocalDateTime.of(ld, et).minusHours(2);
            windowEnd = LocalDateTime.of(ld, et).plusHours(2);
        }

        LocalDateTime finalStart = windowStart;
        LocalDateTime finalEnd = windowEnd;
        return records.stream()
            .filter(r -> {
                LocalDateTime ct = toLocalDateTime(r.getChecktime());
                return !ct.isBefore(finalStart) && !ct.isAfter(finalEnd);
            })
            .collect(Collectors.toList());
    }

    private void checkPeriod(WmsAttendanceCheck check, WmsAttendanceRule rule, int period,
                             List<AttendanceRecords> periodRecords, Date expectedStart, Date expectedEnd) {
        if (periodRecords.isEmpty()) {
            if (period == 1) {
                check.setP1Status("missed");
            } else {
                check.setP2Status("missed");
            }
            return;
        }

        LocalDateTime expStart = toLocalDateTime(expectedStart);
        LocalDateTime expEnd = toLocalDateTime(expectedEnd);
        AttendanceRecords firstRec = periodRecords.get(0);
        AttendanceRecords lastRec = periodRecords.get(periodRecords.size() - 1);
        LocalDateTime firstCheck = toLocalDateTime(firstRec.getChecktime());
        LocalDateTime lastCheck = toLocalDateTime(lastRec.getChecktime());

        int lateMinutes = 0;
        int earlyMinutes = 0;
        BigDecimal deduct = BigDecimal.ZERO;
        String status = "normal";

        if (expStart != null && firstCheck.isAfter(expStart)) {
            lateMinutes = (int) Duration.between(expStart, firstCheck).toMinutes();
            if (lateMinutes > rule.getAbsentHalfDay()) {
                status = "absent_half";
            } else if (lateMinutes > rule.getLateOne()) {
                status = "late_two";
                deduct = deduct.add(rule.getDeductTwo());
            } else if (lateMinutes > rule.getLateWarn()) {
                status = "late_one";
                deduct = deduct.add(rule.getDeductOne());
            } else {
                status = "late_warn";
            }
        }

        if (expEnd != null && lastCheck.isBefore(expEnd)) {
            int min = (int) Duration.between(lastCheck, expEnd).toMinutes();
            if (min > rule.getAbsentHalfDay()) {
                status = maxSeverity(status, "absent_half");
                earlyMinutes = min;
            } else if (min > rule.getLateOne()) {
                status = maxSeverity(status, "early_two");
                deduct = deduct.add(rule.getDeductTwo());
                earlyMinutes = min;
            } else if (min > rule.getLateWarn()) {
                status = maxSeverity(status, "early_one");
                deduct = deduct.add(rule.getDeductOne());
                earlyMinutes = min;
            } else {
                if ("normal".equals(status)) {
                    status = "early_warn";
                }
                earlyMinutes = min;
            }
        }

        if (period == 1) {
            check.setP1FirstCheck(firstRec.getChecktime());
            check.setP1LastCheck(lastRec.getChecktime());
            check.setP1LateMinutes(lateMinutes);
            check.setP1EarlyMinutes(earlyMinutes);
            check.setP1Status(status);
            check.setP1Deduct(deduct);
        } else {
            check.setP2FirstCheck(firstRec.getChecktime());
            check.setP2LastCheck(lastRec.getChecktime());
            check.setP2LateMinutes(lateMinutes);
            check.setP2EarlyMinutes(earlyMinutes);
            check.setP2Status(status);
            check.setP2Deduct(deduct);
        }
    }

    private String maxSeverity(String a, String b) {
        int ai = STATUS_SEVERITY.indexOf(a);
        int bi = STATUS_SEVERITY.indexOf(b);
        return STATUS_SEVERITY.get(Math.max(ai, bi));
    }

    private void calculateOverall(WmsAttendanceCheck check, WmsAttendanceRule rule) {
        BigDecimal total = BigDecimal.ZERO;
        boolean hasAbsentHalf = false;

        if (check.getP1Deduct() != null) total = total.add(check.getP1Deduct());
        if (check.getP2Deduct() != null) total = total.add(check.getP2Deduct());

        check.setTotalDeduct(total);

        if ("absent_half".equals(check.getP1Status()) || "absent_half".equals(check.getP2Status())) {
            hasAbsentHalf = true;
        }
        if ("missed".equals(check.getP1Status())) {
            if (check.getP2StartTime() != null) {
                if ("missed".equals(check.getP2Status())) {
                    check.setAbsentType("full_day");
                    check.setOverallStatus("absent_full");
                    return;
                }
            } else {
                check.setAbsentType("full_day");
                check.setOverallStatus("absent_full");
                return;
            }
        }
        if (check.getP1StartTime() == null && check.getP2StartTime() == null) {
            check.setAbsentType("full_day");
            check.setOverallStatus("absent_full");
            return;
        }
        if (hasAbsentHalf) {
            check.setAbsentType("half_day");
            check.setOverallStatus("absent_half");
            return;
        }

        boolean abnormal = !"normal".equals(check.getP1Status()) || (check.getP2Status() != null && !"normal".equals(check.getP2Status()));
        check.setOverallStatus(abnormal ? "abnormal" : "normal");
    }

    private void updateContinuousAbsent(LocalDate startDate, LocalDate endDate, Set<Long> affectedUserIds) {
        if (affectedUserIds.isEmpty()) {
            return;
        }
        List<WmsAttendanceCheck> checks = baseMapper.selectList(Wrappers.<WmsAttendanceCheck>lambdaQuery()
            .in(WmsAttendanceCheck::getUserId, affectedUserIds)
            .ge(WmsAttendanceCheck::getWorkDate, toDate(startDate.atStartOfDay()))
            .le(WmsAttendanceCheck::getWorkDate, toDate(endDate.atTime(LocalTime.of(23, 59, 59))))
            .eq(WmsAttendanceCheck::getDelFlag, 0));

        if (checks.isEmpty()) {
            return;
        }

        List<Long> userIds = checks.stream()
            .map(WmsAttendanceCheck::getUserId)
            .distinct()
            .collect(Collectors.toList());

        Map<Long, Map<LocalDate, WmsAttendanceCheck>> historyByUserDate = loadAbsentHistoryByUser(userIds, endDate);

        List<WmsAttendanceCheck> toUpdate = new ArrayList<>();
        for (WmsAttendanceCheck check : checks) {
            if (check.getAbsentType() != null) {
                int continuous = countContinuousAbsentCached(
                    check.getUserId(), toLocalDate(check.getWorkDate()), historyByUserDate);
                check.setContinuousAbsentDays(continuous);
                toUpdate.add(check);
            }
        }
        if (!toUpdate.isEmpty()) {
            baseMapper.updateBatchById(toUpdate, BATCH_SIZE);
        }
    }

    /**
     * 加载各员工在 endDate 及之前的考勤结果，用于内存计算连续旷工（与按天 selectOne 结果一致）。
     */
    private Map<Long, Map<LocalDate, WmsAttendanceCheck>> loadAbsentHistoryByUser(List<Long> userIds, LocalDate endDate) {
        Map<Long, Map<LocalDate, WmsAttendanceCheck>> out = new HashMap<>();
        LocalDate startDate = endDate.minusDays(100);
        Date start = toDate(startDate.atStartOfDay());
        Date end = toDate(endDate.atTime(LocalTime.of(23, 59, 59)));
        for (int i = 0; i < userIds.size(); i += BATCH_SIZE) {
            int to = Math.min(i + BATCH_SIZE, userIds.size());
            List<Long> chunk = userIds.subList(i, to);
            List<WmsAttendanceCheck> rows = baseMapper.selectList(Wrappers.<WmsAttendanceCheck>lambdaQuery()
                .select(WmsAttendanceCheck::getUserId, WmsAttendanceCheck::getWorkDate, WmsAttendanceCheck::getAbsentType,
                    WmsAttendanceCheck::getCheckId, WmsAttendanceCheck::getDelFlag)
                .in(WmsAttendanceCheck::getUserId, chunk)
                .ge(WmsAttendanceCheck::getWorkDate, start)
                .le(WmsAttendanceCheck::getWorkDate, end)
                .eq(WmsAttendanceCheck::getDelFlag, 0));
            for (WmsAttendanceCheck row : rows) {
                LocalDate wd = toLocalDate(row.getWorkDate());
                out.computeIfAbsent(row.getUserId(), k -> new HashMap<>()).put(wd, row);
            }
        }
        return out;
    }

    private int countContinuousAbsentCached(Long userId, LocalDate workDate,
                                            Map<Long, Map<LocalDate, WmsAttendanceCheck>> historyByUserDate) {
        Map<LocalDate, WmsAttendanceCheck> userMap = historyByUserDate.get(userId);
        if (userMap == null) {
            return 0;
        }
        int count = 0;
        LocalDate date = workDate.minusDays(1);
        while (true) {
            WmsAttendanceCheck prev = userMap.get(date);
            if (prev != null && prev.getAbsentType() != null) {
                count++;
                date = date.minusDays(1);
            } else {
                break;
            }
        }
        return count;
    }

    private static LocalDate toLocalDate(Date date) {
        return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
    }

    private static LocalTime toLocalTime(Date date) {
        if (date == null) return null;
        return date.toInstant().atZone(ZoneId.systemDefault()).toLocalTime();
    }

    private static LocalDateTime toLocalDateTime(Date date) {
        if (date == null) return null;
        return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
    }

    private static Date toDate(LocalDateTime ldt) {
        return Date.from(ldt.atZone(ZoneId.systemDefault()).toInstant());
    }

    private static Date combineTime(Date workDate, Date shiftTime) {
        if (workDate == null || shiftTime == null) return null;
        LocalDate ld = toLocalDate(workDate);
        LocalTime lt = toLocalTime(shiftTime);
        return toDate(LocalDateTime.of(ld, lt));
    }

    private static Date combineNextDay(Date workDate, Date shiftTime) {
        if (workDate == null || shiftTime == null) return null;
        LocalDate ld = toLocalDate(workDate).plusDays(1);
        LocalTime lt = toLocalTime(shiftTime);
        return toDate(LocalDateTime.of(ld, lt));
    }

    private static Date combinePrevDay(Date workDate, Date shiftTime) {
        if (workDate == null || shiftTime == null) return null;
        LocalDate ld = toLocalDate(workDate).minusDays(1);
        LocalTime lt = toLocalTime(shiftTime);
        return toDate(LocalDateTime.of(ld, lt));
    }
}