package com.sinata.appointment.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.sinata.appointment.constants.AppointmentOrderStatus;
import com.sinata.appointment.constants.AppointmentBizConstants;
import com.sinata.appointment.constants.AppointmentFieldCodes;
import com.sinata.appointment.constants.ApprovalInstanceStatus;
import com.sinata.appointment.constants.ApprovalTaskStatus;
import com.sinata.appointment.constants.BizErrorCode;
import com.sinata.appointment.constants.QrcodeTicketStatus;
import com.sinata.appointment.constants.SystemSettingKeys;
import com.sinata.appointment.dto.MiniAppointmentCreateRequest;
import com.sinata.appointment.dto.MiniAppointmentCreateResultVo;
import com.sinata.appointment.dto.MiniAppointmentListVo;
import com.sinata.appointment.dto.MiniApprovalHistoryRow;
import com.sinata.appointment.dto.MiniAppointmentVehicleItemRequest;
import com.sinata.appointment.dto.MiniApprovalDetailVisitorVo;
import com.sinata.appointment.dto.MiniMyAppointmentDetailVo;
import com.sinata.appointment.dto.MiniMyVisitorCodeOrderVo;
import com.sinata.appointment.dto.MiniMyVisitorCodeTicketVo;
import com.sinata.appointment.dto.MiniSharedAppointmentDetailVo;
import com.sinata.appointment.dto.MiniVisitRecordListVo;
import com.sinata.appointment.dto.ApprovalFlowNodeVo;
import com.sinata.appointment.entity.AppointmentOrder;
import com.sinata.appointment.entity.ApprovalInstance;
import com.sinata.appointment.entity.ApprovalTask;
import com.sinata.appointment.entity.AppointmentVehicle;
import com.sinata.appointment.entity.AppointmentVisitor;
import com.sinata.appointment.entity.BizFieldConfig;
import com.sinata.appointment.entity.BizVisitReason;
import com.sinata.appointment.entity.MpUser;
import com.sinata.appointment.entity.MpVisitor;
import com.sinata.appointment.entity.QrcodeTicket;
import com.sinata.appointment.entity.SysDept;
import com.sinata.appointment.exception.BizException;
import com.sinata.appointment.mapper.AppointmentOrderMapper;
import com.sinata.appointment.mapper.ApprovalInstanceMapper;
import com.sinata.appointment.mapper.ApprovalTaskMapper;
import com.sinata.appointment.mapper.AppointmentVehicleMapper;
import com.sinata.appointment.mapper.AppointmentVisitorMapper;
import com.sinata.appointment.mapper.BizFieldConfigMapper;
import com.sinata.appointment.mapper.BizVisitReasonMapper;
import com.sinata.appointment.mapper.MpUserMapper;
import com.sinata.appointment.mapper.MpVisitorMapper;
import com.sinata.appointment.mapper.QrcodeTicketMapper;
import com.sinata.appointment.mapper.SysDeptMapper;
import com.sinata.appointment.util.OrderNoGenerator;
import com.sinata.appointment.util.MobileMaskUtil;
import com.sinata.appointment.util.SensitiveDataUtil;
import com.sinata.appointment.util.UuidAssert;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import org.springframework.context.ApplicationEventPublisher;
import com.sinata.appointment.service.event.AppointmentApprovedEvent;
import com.sinata.appointment.service.event.AppointmentApproversNotifyEvent;

@Slf4j
@Service
@RequiredArgsConstructor
public class MiniAppointmentApplicationService {

    private static final String CANCEL_REASON_BY_SUBMITTER = "预约人取消";
    private static final String DISPLAY_STATUS_PENDING_VISIT = "PENDING_VISIT";
    private static final String DISPLAY_STATUS_EFFECTIVE = "EFFECTIVE";
    private static final String DISPLAY_STATUS_INVALID = "INVALID";
    private static final TypeReference<List<String>> STRING_LIST_TYPE = new TypeReference<>() {};

    private final MiniAuthApplicationService miniAuthApplicationService;
    private final MpUserMapper mpUserMapper;
    private final MpVisitorMapper mpVisitorMapper;
    private final BizVisitReasonMapper bizVisitReasonMapper;
    private final AppointmentOrderMapper appointmentOrderMapper;
    private final ApprovalTaskMapper approvalTaskMapper;
    private final ApprovalInstanceMapper approvalInstanceMapper;
    private final AppointmentVisitorMapper appointmentVisitorMapper;
    private final AppointmentVehicleMapper appointmentVehicleMapper;
    private final QrcodeTicketMapper qrcodeTicketMapper;
    private final BizFieldConfigMapper bizFieldConfigMapper;
    private final SysDeptMapper sysDeptMapper;
    private final BizHolidayDateCacheService bizHolidayDateCacheService;
    private final SysBizSettingCacheService sysBizSettingCacheService;
    private final ApprovalEngineService approvalEngineService;
    private final PostApprovalOrchestrationService postApprovalOrchestrationService;
    private final ApprovalFlowViewApplicationService approvalFlowViewApplicationService;
    private final SensitiveWordFilterService sensitiveWordFilterService;
    private final IntegrationHikvisionService integrationHikvisionService;
    private final ObjectMapper objectMapper;
    private final ApplicationEventPublisher applicationEventPublisher;

    @Transactional(rollbackFor = Exception.class)
    public MiniAppointmentCreateResultVo create(MiniAppointmentCreateRequest req) {
        MpUser current = miniAuthApplicationService.currentMpUser();
        FieldRequiredContext required = loadFieldRequiredContext();
        MpUser visited = loadVisitedUser(req.getVisitedUserId());
        validateByFieldConfig(req, required);
        validateVisitReason(req.getVisitReasonCode(), req.getVisitReasonOther());

        String mode = normalizeMode(req.getVisitTimeMode());
        validateAgainstSystemRangeMode(mode);

        DateRange range = resolveDateRange(req, mode);
        boolean holidayFlag = calcHolidayFlag(range.start(), range.end());
        boolean personEntry = req.getPersonEntry() == null || Boolean.TRUE.equals(req.getPersonEntry());
        boolean vehicleEntry = Boolean.TRUE.equals(req.getVehicleEntry());

        Set<Long> personIds = new LinkedHashSet<>();
        if (personEntry && req.getVisitorIds() != null) {
            personIds.addAll(req.getVisitorIds().stream().filter(Objects::nonNull).toList());
        }

        List<MiniAppointmentVehicleItemRequest> vehicles = vehicleEntry ? normalizeVehicles(req.getVehicles()) : List.of();
        for (MiniAppointmentVehicleItemRequest v : vehicles) {
            personIds.add(v.getDriverVisitorId());
        }

        if (personIds.isEmpty()) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "至少选择一名进场人员");
        }

        Map<Long, MpVisitor> visitorMap = loadCurrentUserVisitors(current.getId(), personIds);
        validateVisitorDataByFieldConfig(visitorMap.values(), required);

        AppointmentOrder order = new AppointmentOrder();
        order.setOrderNo(OrderNoGenerator.next());
        order.setVisitType(
                vehicleEntry
                        ? AppointmentBizConstants.VISIT_TYPE_VEHICLE
                        : AppointmentBizConstants.VISIT_TYPE_VISITOR);
        order.setVisitedUserId(visited.getId());
        order.setVisitedUserName(StringUtils.hasText(visited.getNickName()) ? visited.getNickName() : "员工");
        order.setVisitedDeptId(visited.getDeptId());
        order.setVisitReasonCode(req.getVisitReasonCode().trim());
        order.setVisitReasonOther(sensitiveWordFilterService.filter(trimToNull(req.getVisitReasonOther())));
        order.setVisitorOrg(resolveVisitorOrg(visitorMap.values()));
        order.setVisitTimeMode(mode);
        order.setVisitTimeSlot(
                AppointmentBizConstants.TIME_MODE_SINGLE.equals(mode)
                        ? normalizeSlot(req.getVisitTimeSlot())
                        : null);
        order.setVisitStartDate(range.start());
        order.setVisitEndDate(range.end());
        order.setPersonEntryFlag(personEntry);
        order.setVehicleEntryFlag(vehicleEntry);
        order.setSubmitterId(current.getId());
        order.setSubmitterVisibleFlag(1);
        order.setHolidayFlag(holidayFlag);
        order.setStatus(AppointmentOrderStatus.PENDING_APPROVAL);
        appointmentOrderMapper.insert(order);

        for (Long visitorId : personIds) {
            MpVisitor v = visitorMap.get(visitorId);
            AppointmentVisitor av = new AppointmentVisitor();
            av.setOrderId(order.getId());
            av.setMpVisitorId(v.getId());
            av.setName(v.getVisitorName());
            av.setIdCardCipher(v.getIdCardCipher());
            av.setMobile(v.getVisitorMobile());
            appointmentVisitorMapper.insert(av);
        }

        for (MiniAppointmentVehicleItemRequest v : vehicles) {
            MpVisitor driver = visitorMap.get(v.getDriverVisitorId());
            AppointmentVehicle row = new AppointmentVehicle();
            row.setOrderId(order.getId());
            row.setPlateNo(v.getPlateNo().trim());
            row.setDriverVisitorId(driver.getId());
            row.setDriverName(driver.getVisitorName());
            appointmentVehicleMapper.insert(row);
        }

        List<String> chain = approvalEngineService.resolveEnabledNodeChain(order);
        if (chain.isEmpty()) {
            applicationEventPublisher.publishEvent(new AppointmentApprovedEvent(order.getId()));
        } else {
            ApprovalInstance inst = approvalEngineService.startFlow(order);
            if (inst == null) {
                applicationEventPublisher.publishEvent(new AppointmentApprovedEvent(order.getId()));
            } else {
                applicationEventPublisher.publishEvent(
                        new AppointmentApproversNotifyEvent(order.getId(), inst.getId()));
            }
        }
        MiniAppointmentCreateResultVo result = new MiniAppointmentCreateResultVo();
        result.setId(order.getId());
        result.setUuid(order.getUuid());
        return result;
    }

    @Transactional(rollbackFor = Exception.class)
    public void cancelBySubmitter(Long orderId, String uuid) {
        if (orderId == null || orderId <= 0) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "预约单不存在");
        }
        MpUser current = miniAuthApplicationService.currentMpUser();
        AppointmentOrder order = appointmentOrderMapper.selectById(orderId);
        if (order == null || (order.getDelFlag() != null && order.getDelFlag() == 1)) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "预约单不存在");
        }
        UuidAssert.match(order, uuid);
        if (!Objects.equals(order.getSubmitterId(), current.getId())) {
            throw new BizException(BizErrorCode.AUTH_FORBIDDEN, "仅预约发起人可取消");
        }
        if (!isCancelableStatus(order.getStatus())) {
            throw new BizException(BizErrorCode.ORDER_STATE_INVALID, "当前状态不可取消");
        }

        ApprovalInstance latestInst = loadLatestInstanceByOrderId(order.getId());
        if (latestInst != null
                && ApprovalInstanceStatus.IN_PROGRESS.equals(latestInst.getStatus())) {
            approvalEngineService.cancelInstance(latestInst, CANCEL_REASON_BY_SUBMITTER);
        }

        order.setStatus(AppointmentOrderStatus.CANCELLED);
        order.setRejectReason(CANCEL_REASON_BY_SUBMITTER);
        appointmentOrderMapper.updateById(order);
        expireUnusedTicketsByOrderId(order.getId());
    }

    @Transactional(rollbackFor = Exception.class)
    public void deleteMyOrderRecord(Long orderId, String uuid) {
        if (orderId == null || orderId <= 0) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "预约单不存在");
        }
        MpUser current = miniAuthApplicationService.currentMpUser();
        AppointmentOrder order = appointmentOrderMapper.selectById(orderId);
        if (order == null || (order.getDelFlag() != null && order.getDelFlag() == 1)) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "预约单不存在");
        }
        UuidAssert.match(order, uuid);
        if (!Objects.equals(order.getSubmitterId(), current.getId())) {
            throw new BizException(BizErrorCode.AUTH_FORBIDDEN, "仅预约发起人可删除");
        }
        if (!isDeletableStatus(order.getStatus(), resolveDisplayStatus(order))) {
            throw new BizException(BizErrorCode.ORDER_STATE_INVALID, "当前状态不可删除");
        }
        order.setSubmitterVisibleFlag(0);
        appointmentOrderMapper.updateById(order);
    }

    public IPage<MiniAppointmentListVo> pageMine(
            long page, long size, String status, String visitedUserNameKeyword, LocalDate visitDate) {
        MpUser current = miniAuthApplicationService.currentMpUser();
        Page<MiniApprovalHistoryRow> rowPage = new Page<>(Math.max(1L, page), Math.max(1L, size));
        IPage<MiniApprovalHistoryRow> pagedRows =
                approvalTaskMapper.pageMiniApprovalHistory(
                        rowPage,
                        current.getId(),
                        trimToNull(status),
                        trimToNull(visitedUserNameKeyword),
                        visitDate);
        Page<MiniAppointmentListVo> result =
                new Page<>(pagedRows.getCurrent(), pagedRows.getSize(), pagedRows.getTotal());
        List<MiniApprovalHistoryRow> rows = pagedRows.getRecords();
        if (rows == null || rows.isEmpty()) {
            result.setRecords(List.of());
            return result;
        }
        List<AppointmentOrder> orders = rows.stream().map(this::toOrderSnapshot).toList();
        Map<Long, String> deptNameMap = loadDeptNameMap(orders);
        Map<String, String> reasonNameMap = loadReasonNameMap(orders);
        List<Long> orderIds = orders.stream().map(AppointmentOrder::getId).filter(Objects::nonNull).toList();
        Map<Long, String> visitorDisplayMap = loadVisitorDisplayMapByOrderIds(orderIds);
        Map<Long, String> plateTextMap = loadPlateTextMapByOrderIds(orderIds);
        List<MiniAppointmentListVo> records = new ArrayList<>();
        for (MiniApprovalHistoryRow row : rows) {
            AppointmentOrder order = toOrderSnapshot(row);
            MiniAppointmentListVo vo = toListVo(order);
            vo.setStatus(row.getTaskStatus());
            vo.setVisitedDeptName(deptNameMap.get(order.getVisitedDeptId()));
            vo.setVisitedUserDisplay(buildVisitedUserDisplay(order.getVisitedUserName(), vo.getVisitedDeptName()));
            vo.setVisitTimeText(buildVisitTimeText(order));
            vo.setVisitReasonText(buildVisitReasonText(order, reasonNameMap));
            vo.setAccessAreaText(buildAccessAreaText(order.getPassAccessAreaNames()));
            vo.setVisitorDisplayText(visitorDisplayMap.get(order.getId()));
            vo.setPlateNoText(plateTextMap.get(order.getId()));
            records.add(vo);
        }
        result.setRecords(records);
        return result;
    }

    public IPage<MiniVisitRecordListVo> pageVisitRecords(
            long page, long size, boolean futureOnly, String visitorNameKeyword, LocalDate visitDate) {
        MpUser current = miniAuthApplicationService.currentMpUser();
        Page<AppointmentOrder> orderPage = new Page<>(Math.max(1L, page), Math.max(1L, size));
        IPage<AppointmentOrder> pagedOrders =
                appointmentOrderMapper.pageMiniVisitRecords(
                        orderPage, current.getId(), futureOnly, trimToNull(visitorNameKeyword), visitDate);
        Page<MiniVisitRecordListVo> result =
                new Page<>(pagedOrders.getCurrent(), pagedOrders.getSize(), pagedOrders.getTotal());
        List<AppointmentOrder> orders = pagedOrders.getRecords();
        if (orders == null || orders.isEmpty()) {
            result.setRecords(List.of());
            return result;
        }
        Map<String, String> reasonNameMap = loadReasonNameMap(orders);
        List<Long> orderIds = orders.stream().map(AppointmentOrder::getId).filter(Objects::nonNull).toList();
        Map<Long, List<String>> visitorNamesMap = loadVisitorNamesMap(orders.stream().map(AppointmentOrder::getId).toList());
        Map<Long, String> visitorDisplayMap = loadVisitorDisplayMapByOrderIds(orderIds);
        Map<Long, String> plateTextMap = loadPlateTextMapByOrderIds(orderIds);
        List<MiniVisitRecordListVo> records = new ArrayList<>();
        for (AppointmentOrder order : orders) {
            MiniVisitRecordListVo vo = new MiniVisitRecordListVo();
            vo.setOrderId(order.getId());
            vo.setOrderNo(order.getOrderNo());
            vo.setVisitorNames(visitorNamesMap.getOrDefault(order.getId(), List.of()));
            vo.setVisitorDisplayText(visitorDisplayMap.get(order.getId()));
            vo.setPlateNoText(plateTextMap.get(order.getId()));
            vo.setVisitReasonText(buildVisitReasonText(order, reasonNameMap));
            vo.setVisitStartDate(order.getVisitStartDate());
            vo.setVisitEndDate(order.getVisitEndDate());
            vo.setVisitTimeMode(order.getVisitTimeMode());
            vo.setVisitTimeSlot(order.getVisitTimeSlot());
            vo.setCreateTime(order.getCreateTime());
            records.add(vo);
        }
        result.setRecords(records);
        return result;
    }

    public IPage<MiniAppointmentListVo> pageMyOrders(
            long page, long size, String status, String keyword) {
        MpUser current = miniAuthApplicationService.currentMpUser();
        Page<AppointmentOrder> orderPage = new Page<>(Math.max(1L, page), Math.max(1L, size));
        IPage<AppointmentOrder> pagedOrders =
                appointmentOrderMapper.pageMiniMyOrders(
                        orderPage, current.getId(), trimToNull(status), trimToNull(keyword));
        Page<MiniAppointmentListVo> result =
                new Page<>(pagedOrders.getCurrent(), pagedOrders.getSize(), pagedOrders.getTotal());
        List<AppointmentOrder> orders = pagedOrders.getRecords();
        if (orders == null || orders.isEmpty()) {
            result.setRecords(List.of());
            return result;
        }
        Map<Long, String> deptNameMap = loadDeptNameMap(orders);
        Map<String, String> reasonNameMap = loadReasonNameMap(orders);
        List<MiniAppointmentListVo> records = new ArrayList<>();
        for (AppointmentOrder order : orders) {
            records.add(toMyOrderListVo(order, deptNameMap, reasonNameMap));
        }
        result.setRecords(records);
        return result;
    }

    public List<MiniMyVisitorCodeOrderVo> listMyVisitorCodes() {
        MpUser current = miniAuthApplicationService.currentMpUser();
        List<AppointmentOrder> orders =
                appointmentOrderMapper.selectList(
                        new LambdaQueryWrapper<AppointmentOrder>()
                                .eq(AppointmentOrder::getDelFlag, 0)
                                .eq(AppointmentOrder::getSubmitterId, current.getId())
                                .eq(AppointmentOrder::getStatus, AppointmentOrderStatus.APPROVED)
                                .orderByDesc(AppointmentOrder::getVisitStartDate)
                                .orderByDesc(AppointmentOrder::getId));
        return buildVisitorCodeOrders(orders, true);
    }

    public MiniSharedAppointmentDetailVo detailSharedOrder(String uuid) {
        AppointmentOrder order = loadApprovedOrderByUuid(uuid);
        String deptName = loadDeptName(order.getVisitedDeptId());
        MiniSharedAppointmentDetailVo vo = new MiniSharedAppointmentDetailVo();
        vo.setOrderId(order.getId());
        vo.setOrderUuid(order.getUuid());
        vo.setVisitedUserDisplay(buildVisitedUserDisplay(order.getVisitedUserName(), deptName));
        vo.setAccessAreaText(buildAccessAreaText(order.getPassAccessAreaNames()));
        vo.setVisitTimeText(buildVisitTimeText(order));
        return vo;
    }

    public MiniMyVisitorCodeOrderVo getSharedVisitorCodes(String uuid) {
        AppointmentOrder order = loadApprovedOrderByUuid(uuid);
        List<MiniMyVisitorCodeOrderVo> rows = buildVisitorCodeOrders(List.of(order), false);
        if (rows.isEmpty()) {
            MiniMyVisitorCodeOrderVo vo = new MiniMyVisitorCodeOrderVo();
            vo.setOrderId(order.getId());
            vo.setOrderUuid(order.getUuid());
            vo.setVisitedUserDisplay(buildVisitedUserDisplay(order.getVisitedUserName(), loadDeptName(order.getVisitedDeptId())));
            vo.setAccessAreaText(buildAccessAreaText(order.getPassAccessAreaNames()));
            vo.setVisitTimeText(buildVisitTimeText(order));
            vo.setQrCodes(List.of());
            return vo;
        }
        return rows.get(0);
    }

    public MiniMyVisitorCodeOrderVo getSharedVisitorCodeByTicketUuid(String ticketUuid) {
        QrcodeTicket ticket = loadTicketByUuid(ticketUuid);
        AppointmentOrder order = loadApprovedOrderById(ticket.getOrderId());
        String deptName = loadDeptName(order.getVisitedDeptId());

        MiniMyVisitorCodeOrderVo vo = new MiniMyVisitorCodeOrderVo();
        vo.setOrderId(order.getId());
        vo.setOrderUuid(order.getUuid());
        vo.setVisitedUserDisplay(buildVisitedUserDisplay(order.getVisitedUserName(), deptName));
        vo.setAccessAreaText(buildAccessAreaText(order.getPassAccessAreaNames()));
        vo.setVisitTimeText(buildVisitTimeText(order));
        vo.setValidStartTime(ticket.getGenerateTime());
        vo.setValidEndTime(ticket.getExpireTime());

        if (!QrcodeTicketStatus.UNUSED.equals(ticket.getTicketStatus())) {
            vo.setQrCodes(List.of());
            return vo;
        }

        Map<Long, MpVisitor> visitorMap =
                loadMpVisitorMap(
                        ticket.getMpVisitorId() == null
                                ? Set.of()
                                : Set.of(ticket.getMpVisitorId()));
        List<AppointmentVisitor> orderVisitors =
                loadOrderVisitorRows(List.of(order.getId())).getOrDefault(order.getId(), List.of());
        vo.setQrCodes(List.of(toMyVisitorCodeTicketVo(ticket, orderVisitors, visitorMap)));
        return vo;
    }

    private List<MiniMyVisitorCodeOrderVo> buildVisitorCodeOrders(
            List<AppointmentOrder> orders, boolean futureOnly) {
        if (orders.isEmpty()) {
            return List.of();
        }

        List<AppointmentOrder> eligibleOrders = orders;
        if (futureOnly) {
            LocalDateTime now = LocalDateTime.now();
            eligibleOrders =
                    orders.stream()
                            .filter(order -> resolveVisitStartAt(order).isAfter(now))
                            .toList();
        }
        if (eligibleOrders.isEmpty()) {
            return List.of();
        }

        List<Long> orderIds = eligibleOrders.stream().map(AppointmentOrder::getId).toList();
        List<QrcodeTicket> tickets =
                qrcodeTicketMapper.selectList(
                        new LambdaQueryWrapper<QrcodeTicket>()
                                .eq(QrcodeTicket::getDelFlag, 0)
                                .in(QrcodeTicket::getOrderId, orderIds)
                                .eq(QrcodeTicket::getTicketStatus, QrcodeTicketStatus.UNUSED)
                                .orderByAsc(QrcodeTicket::getOrderId)
                                .orderByAsc(QrcodeTicket::getId));
        if (tickets.isEmpty()) {
            return List.of();
        }

        Map<Long, List<QrcodeTicket>> ticketMap =
                tickets.stream().collect(Collectors.groupingBy(QrcodeTicket::getOrderId, LinkedHashMap::new, Collectors.toList()));
        Set<Long> visitorIds =
                tickets.stream()
                        .map(QrcodeTicket::getMpVisitorId)
                        .filter(Objects::nonNull)
                        .collect(Collectors.toCollection(LinkedHashSet::new));
        Map<Long, MpVisitor> visitorMap = loadMpVisitorMap(visitorIds);
        Map<Long, List<AppointmentVisitor>> orderVisitorRows = loadOrderVisitorRows(orderIds);
        Map<Long, String> deptNameMap = loadDeptNameMap(eligibleOrders);

        List<MiniMyVisitorCodeOrderVo> result = new ArrayList<>();
        for (AppointmentOrder order : eligibleOrders) {
            List<QrcodeTicket> orderTickets = ticketMap.get(order.getId());
            if (orderTickets == null || orderTickets.isEmpty()) {
                continue;
            }
            MiniMyVisitorCodeOrderVo vo = new MiniMyVisitorCodeOrderVo();
            vo.setOrderId(order.getId());
            vo.setOrderUuid(order.getUuid());
            String deptName = deptNameMap.get(order.getVisitedDeptId());
            vo.setVisitedUserDisplay(buildVisitedUserDisplay(order.getVisitedUserName(), deptName));
            vo.setAccessAreaText(buildAccessAreaText(order.getPassAccessAreaNames()));
            vo.setVisitTimeText(buildVisitTimeText(order));
            vo.setValidStartTime(orderTickets.get(0).getGenerateTime());
            vo.setValidEndTime(orderTickets.get(0).getExpireTime());
            vo.setQrCodes(
                    orderTickets.stream()
                            .map(ticket -> toMyVisitorCodeTicketVo(ticket, orderVisitorRows.get(order.getId()), visitorMap))
                            .toList());
            result.add(vo);
        }
        return result;
    }

    private AppointmentOrder loadApprovedOrderByUuid(String uuid) {
        String normalizedUuid = trimToNull(uuid);
        if (!StringUtils.hasText(normalizedUuid)) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "预约单不存在");
        }
        AppointmentOrder order =
                appointmentOrderMapper.selectOne(
                        new LambdaQueryWrapper<AppointmentOrder>()
                                .eq(AppointmentOrder::getDelFlag, 0)
                                .eq(AppointmentOrder::getUuid, normalizedUuid)
                                .eq(AppointmentOrder::getStatus, AppointmentOrderStatus.APPROVED)
                                .last("limit 1"));
        if (order == null) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "预约单不存在");
        }
        return order;
    }

    private AppointmentOrder loadApprovedOrderById(Long orderId) {
        if (orderId == null || orderId <= 0) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "预约单不存在");
        }
        AppointmentOrder order =
                appointmentOrderMapper.selectOne(
                        new LambdaQueryWrapper<AppointmentOrder>()
                                .eq(AppointmentOrder::getDelFlag, 0)
                                .eq(AppointmentOrder::getId, orderId)
                                .eq(AppointmentOrder::getStatus, AppointmentOrderStatus.APPROVED)
                                .last("limit 1"));
        if (order == null) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "预约单不存在");
        }
        return order;
    }

    private QrcodeTicket loadTicketByUuid(String ticketUuid) {
        String normalizedTicketUuid = trimToNull(ticketUuid);
        if (!StringUtils.hasText(normalizedTicketUuid)) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "访客码不存在");
        }
        QrcodeTicket ticket =
                qrcodeTicketMapper.selectOne(
                        new LambdaQueryWrapper<QrcodeTicket>()
                                .eq(QrcodeTicket::getDelFlag, 0)
                                .eq(QrcodeTicket::getUuid, normalizedTicketUuid)
                                .last("limit 1"));
        if (ticket == null) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "访客码不存在");
        }
        return ticket;
    }

    public MiniMyAppointmentDetailVo detailMyOrder(Long orderId, String uuid) {
        if (orderId == null || orderId <= 0) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "预约单不存在");
        }
        MpUser current = miniAuthApplicationService.currentMpUser();
        AppointmentOrder order = appointmentOrderMapper.selectMiniVisibleOrderById(orderId, current.getId());
        if (order == null) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "预约单不存在");
        }
        UuidAssert.match(order, uuid);

        String deptName = loadDeptName(order.getVisitedDeptId());
        String reasonName = loadReasonName(order.getVisitReasonCode());
        String displayStatus = resolveDisplayStatus(order);

        MiniMyAppointmentDetailVo vo = new MiniMyAppointmentDetailVo();
        vo.setOrderId(order.getId());
        vo.setOrderUuid(order.getUuid());
        vo.setOrderNo(order.getOrderNo());
        vo.setStatus(order.getStatus());
        vo.setDisplayStatus(displayStatus);
        vo.setStatusText(resolveOrderStatusText(order));
        vo.setCancelable(isCancelableStatus(order.getStatus()));
        vo.setDeletable(isDeletableStatus(order.getStatus(), displayStatus));
        vo.setVisitedUserId(order.getVisitedUserId());
        vo.setVisitedUserName(order.getVisitedUserName());
        vo.setVisitedDeptName(deptName);
        vo.setVisitedUserDisplay(buildVisitedUserDisplay(order.getVisitedUserName(), deptName));
        vo.setAccessAreaText(buildAccessAreaText(order.getPassAccessAreaNames()));
        vo.setVisitTypeText(buildVisitTypeText(order));
        vo.setVisitReasonText(buildVisitReasonText(order, reasonName == null ? Map.of() : Map.of(trimToNull(order.getVisitReasonCode()), reasonName)));
        vo.setVisitReasonCode(order.getVisitReasonCode());
        vo.setVisitReasonOther(order.getVisitReasonOther());
        vo.setVisitTimeText(buildVisitTimeText(order));
        vo.setVisitTimeMode(order.getVisitTimeMode());
        vo.setVisitTimeSlot(order.getVisitTimeSlot());
        vo.setVisitStartDate(order.getVisitStartDate());
        vo.setVisitEndDate(order.getVisitEndDate());
        vo.setPersonEntry(order.getPersonEntryFlag() == null || Boolean.TRUE.equals(order.getPersonEntryFlag()));
        vo.setVehicleEntry(Boolean.TRUE.equals(order.getVehicleEntryFlag()));
        vo.setCreateTime(order.getCreateTime());
        vo.setVisitors(loadOrderVisitors(order.getId()));
        vo.setRebookVisitors(loadRebookVisitors(order.getId()));
        vo.setRebookVehicles(loadRebookVehicles(order.getId()));
        List<ApprovalFlowNodeVo> flowTree = approvalFlowViewApplicationService.treeByOrderId(order.getId());
        vo.setFlowTree(flowTree == null ? List.of() : flowTree);
        return vo;
    }

    private MpUser loadVisitedUser(Long visitedUserId) {
        MpUser visited = mpUserMapper.selectById(visitedUserId);
        if (visited == null || (visited.getDelFlag() != null && visited.getDelFlag() == 1)) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "被访人不存在");
        }
        if (visited.getStatus() != null && visited.getStatus() == 0) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "被访人已禁用");
        }
        if (visited.getDeptId() == null || visited.getDeptId() <= 0) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "被访人未绑定部门");
        }
        return visited;
    }

    private void validateVisitReason(String code, String other) {
        String c = trimToNull(code);
        if (!StringUtils.hasText(c)) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "拜访事由不能为空");
        }
        String txt = trimToNull(other);
        if (!StringUtils.hasText(txt)) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "请输入事由说明");
        }
        if (txt.length() > 15) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "事由说明不能超过15个字");
        }
        if (AppointmentBizConstants.VISIT_REASON_OTHER.equalsIgnoreCase(c)) {
            return;
        }
        Long cnt =
                bizVisitReasonMapper.selectCount(
                        new LambdaQueryWrapper<BizVisitReason>()
                                .eq(BizVisitReason::getDelFlag, 0)
                                .eq(BizVisitReason::getEnabled, 1)
                                .eq(BizVisitReason::getReasonCode, c));
        if (cnt == null || cnt <= 0) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "拜访事由无效");
        }
    }

    private String normalizeMode(String mode) {
        String m = trimToNull(mode);
        if (!StringUtils.hasText(m)) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "拜访时间类型不能为空");
        }
        m = m.toUpperCase();
        if (!AppointmentBizConstants.TIME_MODE_SINGLE.equals(m)
                && !AppointmentBizConstants.TIME_MODE_MULTI.equals(m)) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "拜访时间类型仅支持 SINGLE/MULTI");
        }
        return m;
    }

    private void validateAgainstSystemRangeMode(String reqMode) {
        String cfg = trimToNull(sysBizSettingCacheService.getValue(SystemSettingKeys.BOOKING_RANGE_MODE));
        String mode =
                StringUtils.hasText(cfg)
                        ? cfg.toUpperCase()
                        : AppointmentBizConstants.TIME_MODE_SINGLE;
        if (!AppointmentBizConstants.TIME_MODE_SINGLE.equals(mode)
                && !AppointmentBizConstants.TIME_MODE_MULTI.equals(mode)) {
            mode = AppointmentBizConstants.TIME_MODE_SINGLE;
        }
        if (AppointmentBizConstants.TIME_MODE_SINGLE.equals(mode)
                && AppointmentBizConstants.TIME_MODE_MULTI.equals(reqMode)) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "当前预约配置不支持该拜访时间类型");
        }
    }

    private DateRange resolveDateRange(MiniAppointmentCreateRequest req, String mode) {
        if (AppointmentBizConstants.TIME_MODE_SINGLE.equals(mode)) {
            if (req.getVisitDate() == null) {
                throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "单日模式下拜访日期不能为空");
            }
            normalizeSlot(req.getVisitTimeSlot());
            return new DateRange(req.getVisitDate(), req.getVisitDate());
        }
        if (req.getVisitStartDate() == null || req.getVisitEndDate() == null) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "多日模式下须填写起止日期");
        }
        if (req.getVisitEndDate().isBefore(req.getVisitStartDate())) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "结束日期不能早于开始日期");
        }
        long days = ChronoUnit.DAYS.between(req.getVisitStartDate(), req.getVisitEndDate()) + 1;
        int maxDays = getMaxConsecutiveDays();
        if (days > maxDays) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "多日预约不能超过最大天数: " + maxDays);
        }
        return new DateRange(req.getVisitStartDate(), req.getVisitEndDate());
    }

    private int getMaxConsecutiveDays() {
        String raw = trimToNull(sysBizSettingCacheService.getValue(SystemSettingKeys.BOOKING_MAX_CONSECUTIVE_DAYS));
        if (!StringUtils.hasText(raw)) {
            return 7;
        }
        try {
            return Math.max(1, Integer.parseInt(raw));
        } catch (NumberFormatException ex) {
            return 7;
        }
    }

    private String normalizeSlot(String slot) {
        String s = trimToNull(slot);
        if (!StringUtils.hasText(s)) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "单日模式下须选择全天/上午/下午");
        }
        s = s.toUpperCase();
        if (!AppointmentBizConstants.TIME_SLOT_ALL_DAY.equals(s)
                && !AppointmentBizConstants.TIME_SLOT_AM.equals(s)
                && !AppointmentBizConstants.TIME_SLOT_PM.equals(s)) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "单日时段仅支持 ALL_DAY/AM/PM");
        }
        return s;
    }

    private List<MiniAppointmentVehicleItemRequest> normalizeVehicles(List<MiniAppointmentVehicleItemRequest> raw) {
        if (raw == null || raw.isEmpty()) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "勾选车辆进场后，进场车辆列表不能为空");
        }
        List<MiniAppointmentVehicleItemRequest> out = new ArrayList<>();
        for (MiniAppointmentVehicleItemRequest v : raw) {
            if (v == null || !StringUtils.hasText(v.getPlateNo()) || v.getDriverVisitorId() == null) {
                throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "车辆信息不完整");
            }
            if (v.getPlateNo().trim().length() > 32) {
                throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "车牌号长度不能超过32");
            }
            out.add(v);
        }
        return out;
    }

    private Map<Long, MpVisitor> loadCurrentUserVisitors(Long currentMpUserId, Set<Long> ids) {
        List<MpVisitor> rows =
                mpVisitorMapper.selectList(
                        new LambdaQueryWrapper<MpVisitor>()
                                .eq(MpVisitor::getMpUserId, currentMpUserId)
                                .eq(MpVisitor::getDelFlag, 0)
                                .in(MpVisitor::getId, ids));
        Map<Long, MpVisitor> map = rows.stream().collect(Collectors.toMap(MpVisitor::getId, Function.identity(), (a, b) -> a));
        for (Long id : ids) {
            if (!map.containsKey(id)) {
                throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "来访人员不存在或不属于当前账号: " + id);
            }
        }
        return map;
    }

    private void validateByFieldConfig(MiniAppointmentCreateRequest req, FieldRequiredContext required) {
        boolean personEntry = req.getPersonEntry() == null || Boolean.TRUE.equals(req.getPersonEntry());
        boolean vehicleEntry = Boolean.TRUE.equals(req.getVehicleEntry());
        if (required.isRequired(AppointmentFieldCodes.RESPONDENT) && req.getVisitedUserId() == null) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "被访人不能为空");
        }
        if (required.isRequired(AppointmentFieldCodes.VISIT_REASON)
                && !StringUtils.hasText(trimToNull(req.getVisitReasonCode()))) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "拜访事由不能为空");
        }
        if (required.isRequired(AppointmentFieldCodes.VISIT_START_TIME)) {
            if (AppointmentBizConstants.TIME_MODE_SINGLE.equalsIgnoreCase(trimToNull(req.getVisitTimeMode()))) {
                if (req.getVisitDate() == null) {
                    throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "拜访时间不能为空");
                }
            } else if (req.getVisitStartDate() == null) {
                throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "开始拜访时间不能为空");
            }
        }
        if (required.isRequired(AppointmentFieldCodes.VISIT_END_TIME)
                && AppointmentBizConstants.TIME_MODE_MULTI.equalsIgnoreCase(trimToNull(req.getVisitTimeMode()))
                && req.getVisitEndDate() == null) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "结束拜访时间不能为空");
        }
        if (required.isRequired(AppointmentFieldCodes.VISIT_TYPE)
                && !personEntry
                && !vehicleEntry) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "来访类型不能为空");
        }
        if (required.isRequired(AppointmentFieldCodes.LICENSE_PLATE, AppointmentFieldCodes.DRIVER)
                && vehicleEntry
                && (req.getVehicles() == null || req.getVehicles().isEmpty())) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "车辆信息不能为空");
        }
    }

    private void validateVisitorDataByFieldConfig(
            java.util.Collection<MpVisitor> visitors, FieldRequiredContext required) {
        for (MpVisitor v : visitors) {
            if (required.isRequired(AppointmentFieldCodes.VISITOR_NAME)
                    && !StringUtils.hasText(trimToNull(v.getVisitorName()))) {
                throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "访客姓名不能为空");
            }
            if (required.isRequired(AppointmentFieldCodes.ID_CARD)
                    && !StringUtils.hasText(trimToNull(v.getIdCardCipher()))) {
                throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "身份证号码不能为空");
            }
            if (required.isRequired(AppointmentFieldCodes.GENDER)
                    && !StringUtils.hasText(trimToNull(v.getGender()))) {
                throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "性别不能为空");
            }
            if (required.isRequired(AppointmentFieldCodes.COMPANY)
                    && !StringUtils.hasText(trimToNull(v.getVisitorCompany()))) {
                throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "来访单位不能为空");
            }
            if (required.isRequired(AppointmentFieldCodes.MOBILE)
                    && !StringUtils.hasText(trimToNull(v.getVisitorMobile()))) {
                throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "联系电话不能为空");
            }
        }
    }

    private FieldRequiredContext loadFieldRequiredContext() {
        List<BizFieldConfig> rows =
                bizFieldConfigMapper.selectList(
                        new LambdaQueryWrapper<BizFieldConfig>()
                                .eq(BizFieldConfig::getDelFlag, 0)
                                .eq(BizFieldConfig::getVisible, 1)
                                .eq(BizFieldConfig::getRequiredFlag, 1));
        Set<String> required =
                rows.stream()
                        .map(BizFieldConfig::getFieldCode)
                        .filter(StringUtils::hasText)
                        .map(String::trim)
                        .collect(Collectors.toCollection(java.util.LinkedHashSet::new));
        return new FieldRequiredContext(required);
    }

    private String resolveVisitorOrg(java.util.Collection<MpVisitor> visitors) {
        for (MpVisitor v : visitors) {
            String company = trimToNull(v.getVisitorCompany());
            if (StringUtils.hasText(company)) {
                return company;
            }
        }
        return null;
    }

    private boolean calcHolidayFlag(LocalDate start, LocalDate end) {
        Set<LocalDate> holidays = bizHolidayDateCacheService.getAllEnabledHolidayDates();
        if (holidays.isEmpty()) {
            return false;
        }
        LocalDate d = start;
        while (!d.isAfter(end)) {
            if (holidays.contains(d)) {
                return true;
            }
            d = d.plusDays(1);
        }
        return false;
    }

    private static String trimToNull(String s) {
        if (s == null) {
            return null;
        }
        String t = s.trim();
        return t.isEmpty() ? null : t;
    }

    private MiniAppointmentListVo toListVo(AppointmentOrder row) {
        MiniAppointmentListVo vo = new MiniAppointmentListVo();
        vo.setId(row.getId());
        vo.setUuid(row.getUuid());
        vo.setOrderNo(row.getOrderNo());
        vo.setStatus(row.getStatus());
        vo.setVisitedUserName(row.getVisitedUserName());
        vo.setVisitStartDate(row.getVisitStartDate());
        vo.setVisitEndDate(row.getVisitEndDate());
        vo.setVisitReasonCode(row.getVisitReasonCode());
        vo.setVisitReasonOther(row.getVisitReasonOther());
        vo.setCreateTime(row.getCreateTime());
        return vo;
    }

    private MiniAppointmentListVo toMyOrderListVo(
            AppointmentOrder row,
            Map<Long, String> deptNameMap,
            Map<String, String> reasonNameMap) {
        MiniAppointmentListVo vo = toListVo(row);
        String deptName = deptNameMap.get(row.getVisitedDeptId());
        vo.setVisitedDeptName(deptName);
        vo.setVisitedUserDisplay(buildVisitedUserDisplay(row.getVisitedUserName(), deptName));
        vo.setDisplayStatus(resolveDisplayStatus(row));
        vo.setVisitTimeText(buildVisitTimeText(row));
        vo.setVisitReasonText(buildVisitReasonText(row, reasonNameMap));
        vo.setAccessAreaText(buildAccessAreaText(row.getPassAccessAreaNames()));
        return vo;
    }

    private AppointmentOrder toOrderSnapshot(MiniApprovalHistoryRow row) {
        AppointmentOrder order = new AppointmentOrder();
        order.setId(row.getId());
        order.setUuid(row.getUuid());
        order.setOrderNo(row.getOrderNo());
        order.setVisitedUserName(row.getVisitedUserName());
        order.setVisitedDeptId(row.getVisitedDeptId());
        order.setVisitStartDate(row.getVisitStartDate());
        order.setVisitEndDate(row.getVisitEndDate());
        order.setVisitReasonCode(row.getVisitReasonCode());
        order.setVisitReasonOther(row.getVisitReasonOther());
        order.setVisitTimeMode(row.getVisitTimeMode());
        order.setVisitTimeSlot(row.getVisitTimeSlot());
        order.setPassAccessAreaNames(row.getPassAccessAreaNames());
        order.setStatus(row.getStatus());
        order.setCreateTime(row.getCreateTime());
        return order;
    }

    private Map<Long, String> loadDeptNameMap(List<AppointmentOrder> orders) {
        Set<Long> deptIds =
                orders.stream()
                        .map(AppointmentOrder::getVisitedDeptId)
                        .filter(Objects::nonNull)
                        .collect(Collectors.toCollection(LinkedHashSet::new));
        if (deptIds.isEmpty()) {
            return Map.of();
        }
        List<SysDept> rows =
                sysDeptMapper.selectList(
                        new LambdaQueryWrapper<SysDept>()
                                .eq(SysDept::getDelFlag, 0)
                                .in(SysDept::getId, deptIds));
        return rows.stream()
                .collect(Collectors.toMap(SysDept::getId, SysDept::getDeptName, (a, b) -> a, LinkedHashMap::new));
    }

    private Map<String, String> loadReasonNameMap(List<AppointmentOrder> orders) {
        Set<String> codes =
                orders.stream()
                        .map(AppointmentOrder::getVisitReasonCode)
                        .filter(StringUtils::hasText)
                        .map(String::trim)
                        .filter(code -> !AppointmentBizConstants.VISIT_REASON_OTHER.equalsIgnoreCase(code))
                        .collect(Collectors.toCollection(LinkedHashSet::new));
        if (codes.isEmpty()) {
            return Map.of();
        }
        List<BizVisitReason> rows =
                bizVisitReasonMapper.selectList(
                        new LambdaQueryWrapper<BizVisitReason>()
                                .eq(BizVisitReason::getDelFlag, 0)
                                .in(BizVisitReason::getReasonCode, codes));
        return rows.stream()
                .collect(
                        Collectors.toMap(
                                BizVisitReason::getReasonCode,
                                BizVisitReason::getReasonName,
                                (a, b) -> a,
                                LinkedHashMap::new));
    }

    private Map<Long, List<String>> loadVisitorNamesMap(List<Long> orderIds) {
        if (orderIds == null || orderIds.isEmpty()) {
            return Map.of();
        }
        List<AppointmentVisitor> visitors =
                appointmentVisitorMapper.selectList(
                        new LambdaQueryWrapper<AppointmentVisitor>()
                                .eq(AppointmentVisitor::getDelFlag, 0)
                                .in(AppointmentVisitor::getOrderId, orderIds)
                                .orderByAsc(AppointmentVisitor::getId));
        Map<Long, List<String>> result = new LinkedHashMap<>();
        for (AppointmentVisitor row : visitors) {
            result.computeIfAbsent(row.getOrderId(), k -> new ArrayList<>());
            if (StringUtils.hasText(row.getName())) {
                result.get(row.getOrderId()).add(row.getName().trim());
            }
        }
        return result;
    }

    private String buildVisitedUserDisplay(String userName, String deptName) {
        String name = trimToNull(userName);
        String dept = trimToNull(deptName);
        if (StringUtils.hasText(name) && StringUtils.hasText(dept)) {
            return name + " " + dept;
        }
        if (StringUtils.hasText(name)) {
            return name;
        }
        return StringUtils.hasText(dept) ? dept : "-";
    }

    private Map<Long, String> loadVisitorDisplayMapByOrderIds(List<Long> orderIds) {
        if (orderIds == null || orderIds.isEmpty()) {
            return Map.of();
        }
        List<AppointmentVisitor> rows =
                appointmentVisitorMapper.selectList(
                        new LambdaQueryWrapper<AppointmentVisitor>()
                                .eq(AppointmentVisitor::getDelFlag, 0)
                                .in(AppointmentVisitor::getOrderId, orderIds)
                                .orderByAsc(AppointmentVisitor::getId));
        Set<Long> visitorIds =
                rows.stream()
                        .map(AppointmentVisitor::getMpVisitorId)
                        .filter(Objects::nonNull)
                        .collect(Collectors.toCollection(LinkedHashSet::new));
        Map<Long, String> companyMap = loadMpVisitorCompanyMap(visitorIds);
        Map<Long, List<String>> grouped = new LinkedHashMap<>();
        for (AppointmentVisitor row : rows) {
            if (row.getOrderId() == null) {
                continue;
            }
            String name = trimToNull(row.getName());
            if (!StringUtils.hasText(name)) {
                continue;
            }
            String company = companyMap.get(row.getMpVisitorId());
            String display = StringUtils.hasText(company) ? name + "(" + company + ")" : name;
            grouped.computeIfAbsent(row.getOrderId(), key -> new ArrayList<>()).add(display);
        }
        Map<Long, String> result = new LinkedHashMap<>();
        for (Map.Entry<Long, List<String>> entry : grouped.entrySet()) {
            String text = entry.getValue().stream().distinct().collect(Collectors.joining("、"));
            if (StringUtils.hasText(text)) {
                result.put(entry.getKey(), text);
            }
        }
        return result;
    }

    private Map<Long, String> loadMpVisitorCompanyMap(Set<Long> visitorIds) {
        if (visitorIds == null || visitorIds.isEmpty()) {
            return Map.of();
        }
        List<MpVisitor> rows =
                mpVisitorMapper.selectList(
                        new LambdaQueryWrapper<MpVisitor>()
                                .eq(MpVisitor::getDelFlag, 0)
                                .in(MpVisitor::getId, visitorIds));
        Map<Long, String> result = new LinkedHashMap<>();
        for (MpVisitor row : rows) {
            result.put(row.getId(), trimToNull(row.getVisitorCompany()));
        }
        return result;
    }

    private Map<Long, String> loadPlateTextMapByOrderIds(List<Long> orderIds) {
        if (orderIds == null || orderIds.isEmpty()) {
            return Map.of();
        }
        List<AppointmentVehicle> rows =
                appointmentVehicleMapper.selectList(
                        new LambdaQueryWrapper<AppointmentVehicle>()
                                .eq(AppointmentVehicle::getDelFlag, 0)
                                .in(AppointmentVehicle::getOrderId, orderIds)
                                .orderByAsc(AppointmentVehicle::getId));
        Map<Long, List<String>> grouped = new LinkedHashMap<>();
        for (AppointmentVehicle row : rows) {
            if (row.getOrderId() == null) {
                continue;
            }
            String plateNo = trimToNull(row.getPlateNo());
            if (!StringUtils.hasText(plateNo)) {
                continue;
            }
            grouped.computeIfAbsent(row.getOrderId(), key -> new ArrayList<>()).add(plateNo);
        }
        Map<Long, String> result = new LinkedHashMap<>();
        for (Map.Entry<Long, List<String>> entry : grouped.entrySet()) {
            String text = entry.getValue().stream().distinct().collect(Collectors.joining("、"));
            if (StringUtils.hasText(text)) {
                result.put(entry.getKey(), text);
            }
        }
        return result;
    }

    private String resolveOrderStatusText(AppointmentOrder row) {
        return switch (trimToNull(row.getStatus())) {
            case AppointmentOrderStatus.PENDING_APPROVAL -> "审批中";
            case AppointmentOrderStatus.APPROVED,
                    AppointmentOrderStatus.VISITED,
                    AppointmentOrderStatus.EXPIRED -> "审批通过";
            case AppointmentOrderStatus.REJECTED -> "审批驳回";
            case AppointmentOrderStatus.CANCELLED -> "已取消";
            default -> "已失效";
        };
    }

    private String resolveDisplayStatus(AppointmentOrder row) {
        LocalDate today = LocalDate.now();
        if (AppointmentOrderStatus.PENDING_APPROVAL.equals(row.getStatus())) {
            return DISPLAY_STATUS_PENDING_VISIT;
        }
        if (AppointmentOrderStatus.APPROVED.equals(row.getStatus())) {
            if (row.getVisitStartDate() != null && today.isBefore(row.getVisitStartDate())) {
                return DISPLAY_STATUS_PENDING_VISIT;
            }
            if (row.getVisitStartDate() != null
                    && row.getVisitEndDate() != null
                    && (today.isEqual(row.getVisitStartDate()) || today.isAfter(row.getVisitStartDate()))
                    && (today.isEqual(row.getVisitEndDate()) || today.isBefore(row.getVisitEndDate()))) {
                return DISPLAY_STATUS_EFFECTIVE;
            }
        }
        return DISPLAY_STATUS_INVALID;
    }

    private boolean isDeletableStatus(String status, String displayStatus) {
        if (AppointmentOrderStatus.CANCELLED.equals(status)) {
            return true;
        }
        return DISPLAY_STATUS_INVALID.equals(displayStatus);
    }

    private String buildVisitTimeText(AppointmentOrder row) {
        if (AppointmentBizConstants.TIME_MODE_SINGLE.equals(row.getVisitTimeMode())) {
            String slotLabel = switch (trimToNull(row.getVisitTimeSlot())) {
                case AppointmentBizConstants.TIME_SLOT_ALL_DAY -> "00:00-23:59";
                case AppointmentBizConstants.TIME_SLOT_AM -> "00:00-11:59";
                case AppointmentBizConstants.TIME_SLOT_PM -> "12:00-23:59";
                default -> "";
            };
            if (row.getVisitStartDate() == null) {
                return slotLabel;
            }
            return StringUtils.hasText(slotLabel)
                    ? row.getVisitStartDate() + " " + slotLabel
                    : row.getVisitStartDate().toString();
        }
        if (row.getVisitStartDate() == null && row.getVisitEndDate() == null) {
            return "-";
        }
        if (Objects.equals(row.getVisitStartDate(), row.getVisitEndDate()) || row.getVisitEndDate() == null) {
            return String.valueOf(row.getVisitStartDate());
        }
        return row.getVisitStartDate() + " 至 " + row.getVisitEndDate();
    }

    private String buildVisitReasonText(AppointmentOrder row, Map<String, String> reasonNameMap) {
        String reasonName = reasonNameMap.get(trimToNull(row.getVisitReasonCode()));
        return StringUtils.hasText(reasonName) ? reasonName : trimToNull(row.getVisitReasonCode());
    }

    private String buildAccessAreaText(String rawJson) {
        String raw = trimToNull(rawJson);
        if (!StringUtils.hasText(raw)) {
            return null;
        }
        try {
            List<String> rows = objectMapper.readValue(raw, STRING_LIST_TYPE);
            String joined =
                    rows.stream()
                            .filter(StringUtils::hasText)
                            .map(String::trim)
                            .collect(Collectors.joining("、"));
            return StringUtils.hasText(joined) ? joined : null;
        } catch (Exception ignore) {
            return raw;
        }
    }

    private LocalDateTime resolveVisitStartAt(AppointmentOrder row) {
        LocalDate date = row.getVisitEndDate() != null ? row.getVisitEndDate() : row.getVisitStartDate();
        if (date == null) {
            return LocalDateTime.MIN;
        }
        if (!AppointmentBizConstants.TIME_MODE_SINGLE.equals(row.getVisitTimeMode())) {
            return LocalDateTime.of(date, LocalTime.MAX);
        }
        return switch (trimToNull(row.getVisitTimeSlot())) {
            case AppointmentBizConstants.TIME_SLOT_AM -> LocalDateTime.of(date, LocalTime.of(12, 0));
            default -> LocalDateTime.of(date, LocalTime.MAX);
        };
    }

    private Map<Long, MpVisitor> loadMpVisitorMap(Set<Long> visitorIds) {
        if (visitorIds == null || visitorIds.isEmpty()) {
            return Map.of();
        }
        List<MpVisitor> rows =
                mpVisitorMapper.selectList(
                        new LambdaQueryWrapper<MpVisitor>()
                                .eq(MpVisitor::getDelFlag, 0)
                                .in(MpVisitor::getId, visitorIds));
        return rows.stream().collect(Collectors.toMap(MpVisitor::getId, Function.identity(), (a, b) -> a, LinkedHashMap::new));
    }

    private Map<Long, List<AppointmentVisitor>> loadOrderVisitorRows(List<Long> orderIds) {
        if (orderIds == null || orderIds.isEmpty()) {
            return Map.of();
        }
        List<AppointmentVisitor> rows =
                appointmentVisitorMapper.selectList(
                        new LambdaQueryWrapper<AppointmentVisitor>()
                                .eq(AppointmentVisitor::getDelFlag, 0)
                                .in(AppointmentVisitor::getOrderId, orderIds)
                                .orderByAsc(AppointmentVisitor::getId));
        return rows.stream()
                .collect(Collectors.groupingBy(AppointmentVisitor::getOrderId, LinkedHashMap::new, Collectors.toList()));
    }

    private MiniMyVisitorCodeTicketVo toMyVisitorCodeTicketVo(
            QrcodeTicket ticket,
            List<AppointmentVisitor> orderVisitors,
            Map<Long, MpVisitor> visitorMap) {
        MiniMyVisitorCodeTicketVo vo = new MiniMyVisitorCodeTicketVo();
        vo.setTicketId(ticket.getId());
        vo.setTicketUuid(ticket.getUuid());
        vo.setMpVisitorId(ticket.getMpVisitorId());
        vo.setPayload(integrationHikvisionService.encryptQrcodePayload(ticket.getPayload()));
        vo.setGenerateTime(ticket.getGenerateTime());
        vo.setExpireTime(ticket.getExpireTime());
        vo.setVisitorName(resolveVisitorName(ticket.getMpVisitorId(), orderVisitors, visitorMap));
        return vo;
    }

    private String resolveVisitorName(
            Long mpVisitorId, List<AppointmentVisitor> orderVisitors, Map<Long, MpVisitor> visitorMap) {
        if (orderVisitors != null && !orderVisitors.isEmpty()) {
            for (AppointmentVisitor row : orderVisitors) {
                if (Objects.equals(mpVisitorId, row.getMpVisitorId()) && StringUtils.hasText(row.getName())) {
                    return row.getName().trim();
                }
            }
        }
        MpVisitor visitor = mpVisitorId == null ? null : visitorMap.get(mpVisitorId);
        if (visitor != null && StringUtils.hasText(visitor.getVisitorName())) {
            return visitor.getVisitorName().trim();
        }
        return "访客";
    }

    private String buildVisitTypeText(AppointmentOrder order) {
        boolean personEntry = order.getPersonEntryFlag() == null || Boolean.TRUE.equals(order.getPersonEntryFlag());
        boolean vehicleEntry = Boolean.TRUE.equals(order.getVehicleEntryFlag());
        if (personEntry && vehicleEntry) {
            return "访客+车辆预约";
        }
        if (vehicleEntry) {
            return "车辆预约";
        }
        return "访客预约";
    }

    private List<MiniApprovalDetailVisitorVo> loadOrderVisitors(Long orderId) {
        List<AppointmentVisitor> rows =
                appointmentVisitorMapper.selectList(
                        new LambdaQueryWrapper<AppointmentVisitor>()
                                .eq(AppointmentVisitor::getDelFlag, 0)
                                .eq(AppointmentVisitor::getOrderId, orderId)
                                .orderByAsc(AppointmentVisitor::getId));
        if (rows.isEmpty()) {
            return List.of();
        }
        List<Long> visitorIds =
                rows.stream()
                        .map(AppointmentVisitor::getMpVisitorId)
                        .filter(Objects::nonNull)
                        .toList();
        Map<Long, MpVisitor> visitorMap = loadVisitorMap(visitorIds);
        Map<Long, String> plateMap = loadVisitorPlateMap(orderId);
        List<MiniApprovalDetailVisitorVo> result = new ArrayList<>();
        for (AppointmentVisitor row : rows) {
            MpVisitor visitor = visitorMap.get(row.getMpVisitorId());
            MiniApprovalDetailVisitorVo vo = new MiniApprovalDetailVisitorVo();
            vo.setVisitorId(row.getMpVisitorId());
            vo.setName(firstNonBlank(row.getName(), visitor == null ? null : visitor.getVisitorName(), "-"));
            vo.setGender(visitor == null ? null : visitor.getGender());
            vo.setCompanyName(visitor == null ? null : visitor.getVisitorCompany());
            vo.setMobileMasked(
                    MobileMaskUtil.mask(
                            firstNonBlank(
                                    row.getMobile(),
                                    visitor == null ? null : visitor.getVisitorMobile(),
                                    null)));
            String idCardPlain =
                    StringUtils.hasText(row.getIdCardCipher())
                            ? SensitiveDataUtil.decryptIdCard(row.getIdCardCipher())
                            : (visitor != null && StringUtils.hasText(visitor.getIdCardCipher())
                                    ? SensitiveDataUtil.decryptIdCard(visitor.getIdCardCipher())
                                    : null);
            vo.setIdCardMasked(
                    StringUtils.hasText(idCardPlain)
                            ? SensitiveDataUtil.maskIdCard(idCardPlain)
                            : null);
            vo.setPlateNo(plateMap.get(row.getMpVisitorId()));
            result.add(vo);
        }
        return result;
    }

    private List<MiniMyAppointmentDetailVo.RebookVisitorItem> loadRebookVisitors(Long orderId) {
        List<AppointmentVisitor> rows =
                appointmentVisitorMapper.selectList(
                        new LambdaQueryWrapper<AppointmentVisitor>()
                                .eq(AppointmentVisitor::getDelFlag, 0)
                                .eq(AppointmentVisitor::getOrderId, orderId)
                                .orderByAsc(AppointmentVisitor::getId));
        if (rows.isEmpty()) {
            return List.of();
        }
        List<Long> visitorIds =
                rows.stream()
                        .map(AppointmentVisitor::getMpVisitorId)
                        .filter(Objects::nonNull)
                        .toList();
        Map<Long, MpVisitor> visitorMap = loadVisitorMap(visitorIds);
        List<MiniMyAppointmentDetailVo.RebookVisitorItem> result = new ArrayList<>();
        for (AppointmentVisitor row : rows) {
            MpVisitor visitor = visitorMap.get(row.getMpVisitorId());
            MiniMyAppointmentDetailVo.RebookVisitorItem item = new MiniMyAppointmentDetailVo.RebookVisitorItem();
            item.setVisitorId(row.getMpVisitorId());
            item.setVisitorUuid(visitor == null ? null : visitor.getUuid());
            item.setName(firstNonBlank(row.getName(), visitor == null ? null : visitor.getVisitorName(), "-"));
            item.setGender(visitor == null ? null : visitor.getGender());
            item.setCompanyName(visitor == null ? null : trimToNull(visitor.getVisitorCompany()));
            item.setMobileMasked(
                    MobileMaskUtil.mask(
                            firstNonBlank(
                                    row.getMobile(),
                                    visitor == null ? null : visitor.getVisitorMobile(),
                                    null)));
            String idCardPlain =
                    StringUtils.hasText(row.getIdCardCipher())
                            ? SensitiveDataUtil.decryptIdCard(row.getIdCardCipher())
                            : (visitor != null && StringUtils.hasText(visitor.getIdCardCipher())
                                    ? SensitiveDataUtil.decryptIdCard(visitor.getIdCardCipher())
                                    : null);
            item.setIdCardMasked(
                    StringUtils.hasText(idCardPlain)
                            ? SensitiveDataUtil.maskIdCard(idCardPlain)
                            : null);
            result.add(item);
        }
        return result;
    }

    private List<MiniMyAppointmentDetailVo.RebookVehicleItem> loadRebookVehicles(Long orderId) {
        List<AppointmentVehicle> rows =
                appointmentVehicleMapper.selectList(
                        new LambdaQueryWrapper<AppointmentVehicle>()
                                .eq(AppointmentVehicle::getDelFlag, 0)
                                .eq(AppointmentVehicle::getOrderId, orderId)
                                .orderByAsc(AppointmentVehicle::getId));
        if (rows.isEmpty()) {
            return List.of();
        }
        List<MiniMyAppointmentDetailVo.RebookVehicleItem> result = new ArrayList<>();
        for (AppointmentVehicle row : rows) {
            MiniMyAppointmentDetailVo.RebookVehicleItem item = new MiniMyAppointmentDetailVo.RebookVehicleItem();
            item.setPlateNo(trimToNull(row.getPlateNo()));
            item.setDriverVisitorId(row.getDriverVisitorId());
            item.setDriverName(trimToNull(row.getDriverName()));
            result.add(item);
        }
        return result;
    }

    private Map<Long, MpVisitor> loadVisitorMap(List<Long> visitorIds) {
        if (visitorIds.isEmpty()) {
            return Map.of();
        }
        List<MpVisitor> rows =
                mpVisitorMapper.selectList(
                        new LambdaQueryWrapper<MpVisitor>()
                                .eq(MpVisitor::getDelFlag, 0)
                                .in(MpVisitor::getId, visitorIds));
        return rows.stream().collect(Collectors.toMap(MpVisitor::getId, Function.identity(), (a, b) -> a));
    }

    private Map<Long, String> loadVisitorPlateMap(Long orderId) {
        List<AppointmentVehicle> rows =
                appointmentVehicleMapper.selectList(
                        new LambdaQueryWrapper<AppointmentVehicle>()
                                .eq(AppointmentVehicle::getDelFlag, 0)
                                .eq(AppointmentVehicle::getOrderId, orderId)
                                .orderByAsc(AppointmentVehicle::getId));
        if (rows.isEmpty()) {
            return Map.of();
        }
        Map<Long, List<String>> plateMap = new LinkedHashMap<>();
        for (AppointmentVehicle row : rows) {
            if (row.getDriverVisitorId() == null) {
                continue;
            }
            plateMap.computeIfAbsent(row.getDriverVisitorId(), key -> new ArrayList<>());
            if (StringUtils.hasText(row.getPlateNo())) {
                plateMap.get(row.getDriverVisitorId()).add(row.getPlateNo().trim());
            }
        }
        Map<Long, String> result = new LinkedHashMap<>();
        for (Map.Entry<Long, List<String>> entry : plateMap.entrySet()) {
            result.put(entry.getKey(), String.join("、", entry.getValue()));
        }
        return result;
    }

    private String loadDeptName(Long deptId) {
        if (deptId == null || deptId <= 0) {
            return null;
        }
        SysDept dept = sysDeptMapper.selectById(deptId);
        return dept == null ? null : dept.getDeptName();
    }

    private String loadReasonName(String reasonCode) {
        String code = trimToNull(reasonCode);
        if (!StringUtils.hasText(code)
                || AppointmentBizConstants.VISIT_REASON_OTHER.equalsIgnoreCase(code)) {
            return null;
        }
        List<BizVisitReason> rows =
                bizVisitReasonMapper.selectList(
                        new LambdaQueryWrapper<BizVisitReason>()
                                .eq(BizVisitReason::getDelFlag, 0)
                                .eq(BizVisitReason::getReasonCode, code)
                                .last("limit 1"));
        if (rows.isEmpty()) {
            return null;
        }
        return trimToNull(rows.get(0).getReasonName());
    }

    private String firstNonBlank(String... values) {
        if (values == null) {
            return null;
        }
        for (String value : values) {
            if (StringUtils.hasText(value)) {
                return value.trim();
            }
        }
        return null;
    }

    private boolean containsIgnoreCase(String src, String keyword) {
        if (!StringUtils.hasText(src) || !StringUtils.hasText(keyword)) {
            return false;
        }
        return src.toLowerCase().contains(keyword.toLowerCase());
    }

    private IPage<MiniAppointmentListVo> slicePage(long page, long size, List<MiniAppointmentListVo> rowsAll) {
        long total = rowsAll == null ? 0 : rowsAll.size();
        long current = Math.max(1L, page);
        long pageSize = Math.max(1L, size);
        int from = (int) Math.min(total, (current - 1) * pageSize);
        int to = (int) Math.min(total, from + pageSize);
        List<MiniAppointmentListVo> records = from >= to ? List.of() : rowsAll.subList(from, to);
        Page<MiniAppointmentListVo> out = new Page<>(current, pageSize);
        out.setTotal(total);
        out.setRecords(records);
        return out;
    }

    private IPage<MiniVisitRecordListVo> slicePageVisitRecord(
            long page, long size, List<MiniVisitRecordListVo> rowsAll) {
        long total = rowsAll == null ? 0 : rowsAll.size();
        long current = Math.max(1L, page);
        long pageSize = Math.max(1L, size);
        int from = (int) Math.min(total, (current - 1) * pageSize);
        int to = (int) Math.min(total, from + pageSize);
        List<MiniVisitRecordListVo> records = from >= to ? List.of() : rowsAll.subList(from, to);
        Page<MiniVisitRecordListVo> out = new Page<>(current, pageSize);
        out.setTotal(total);
        out.setRecords(records);
        return out;
    }

    private int slotSortWeight(String slot) {
        if (AppointmentBizConstants.TIME_SLOT_ALL_DAY.equals(slot)) {
            return 3;
        }
        if (AppointmentBizConstants.TIME_SLOT_PM.equals(slot)) {
            return 2;
        }
        if (AppointmentBizConstants.TIME_SLOT_AM.equals(slot)) {
            return 1;
        }
        return 0;
    }

    private boolean isCancelableStatus(String status) {
        if (!StringUtils.hasText(status)) {
            return false;
        }
        if (AppointmentOrderStatus.REJECTED.equals(status)
                || AppointmentOrderStatus.APPROVED.equals(status)
                || AppointmentOrderStatus.VISITED.equals(status)
                || AppointmentOrderStatus.EXPIRED.equals(status)
                || AppointmentOrderStatus.CANCELLED.equals(status)) {
            return false;
        }
        return true;
    }

    private ApprovalInstance loadLatestInstanceByOrderId(Long orderId) {
        List<ApprovalInstance> rows =
                approvalInstanceMapper.selectList(
                        new LambdaQueryWrapper<ApprovalInstance>()
                                .eq(ApprovalInstance::getDelFlag, 0)
                                .eq(ApprovalInstance::getOrderId, orderId)
                                .orderByDesc(ApprovalInstance::getId)
                                .last("limit 1"));
        return rows.isEmpty() ? null : rows.get(0);
    }

    private void expireUnusedTicketsByOrderId(Long orderId) {
        List<QrcodeTicket> tickets =
                qrcodeTicketMapper.selectList(
                        new LambdaQueryWrapper<QrcodeTicket>()
                                .eq(QrcodeTicket::getDelFlag, 0)
                                .eq(QrcodeTicket::getOrderId, orderId)
                                .eq(QrcodeTicket::getTicketStatus, QrcodeTicketStatus.UNUSED));
        for (QrcodeTicket ticket : tickets) {
            ticket.setTicketStatus(QrcodeTicketStatus.EXPIRED);
            qrcodeTicketMapper.updateById(ticket);
        }
    }

    private int singleDaySlotSortWeight(MiniVisitRecordListVo row) {
        if (!AppointmentBizConstants.TIME_MODE_SINGLE.equals(row.getVisitTimeMode())) {
            return 0;
        }
        return slotSortWeight(row.getVisitTimeSlot());
    }

    private record FieldRequiredContext(Set<String> requiredCodes) {
        private boolean isRequired(String... codes) {
            for (String c : codes) {
                if (requiredCodes.contains(c)) {
                    return true;
                }
            }
            return false;
        }
    }

    private record DateRange(LocalDate start, LocalDate end) {}
}