package com.sinata.appointment.service;

import com.alibaba.excel.EasyExcel;
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.ApprovalNodeCode;
import com.sinata.appointment.constants.ApprovalTaskStatus;
import com.sinata.appointment.dto.AppointmentAdminDetailVisitorVo;
import com.sinata.appointment.dto.AppointmentAdminDetailVo;
import com.sinata.appointment.dto.AppointmentAdminExportRow;
import com.sinata.appointment.dto.AppointmentAdminListVo;
import com.sinata.appointment.entity.AppointmentOrder;
import com.sinata.appointment.entity.AppointmentVehicle;
import com.sinata.appointment.entity.AppointmentVisitor;
import com.sinata.appointment.entity.ApprovalInstance;
import com.sinata.appointment.entity.ApprovalTask;
import com.sinata.appointment.entity.BizVisitReason;
import com.sinata.appointment.entity.MpUser;
import com.sinata.appointment.entity.MpVisitor;
import com.sinata.appointment.entity.SysDept;
import com.sinata.appointment.exception.BizException;
import com.sinata.appointment.constants.BizErrorCode;
import com.sinata.appointment.mapper.AppointmentOrderMapper;
import com.sinata.appointment.mapper.AppointmentVehicleMapper;
import com.sinata.appointment.mapper.AppointmentVisitorMapper;
import com.sinata.appointment.mapper.ApprovalInstanceMapper;
import com.sinata.appointment.mapper.ApprovalTaskMapper;
import com.sinata.appointment.mapper.BizVisitReasonMapper;
import com.sinata.appointment.mapper.MpUserMapper;
import com.sinata.appointment.mapper.MpVisitorMapper;
import com.sinata.appointment.mapper.SysDeptMapper;
import com.sinata.appointment.util.MobileMaskUtil;
import com.sinata.appointment.util.SensitiveDataUtil;
import com.sinata.appointment.util.UuidAssert;
import java.io.ByteArrayOutputStream;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Collection;
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.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

@Service
@RequiredArgsConstructor
public class AppointmentApplicationService {

    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 static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    private final AppointmentOrderMapper appointmentOrderMapper;
    private final AppointmentVehicleMapper appointmentVehicleMapper;
    private final AppointmentVisitorMapper appointmentVisitorMapper;
    private final ApprovalInstanceMapper approvalInstanceMapper;
    private final ApprovalTaskMapper approvalTaskMapper;
    private final BizVisitReasonMapper bizVisitReasonMapper;
    private final MpUserMapper mpUserMapper;
    private final MpVisitorMapper mpVisitorMapper;
    private final SysDeptMapper sysDeptMapper;
    private final ObjectMapper objectMapper;

    public IPage<AppointmentAdminListVo> pageOrders(
            long page,
            long size,
            String visitedUserName,
            Long visitedDeptId,
            String accessArea,
            String localUnit,
            LocalDate visitDateStart,
            LocalDate visitDateEnd,
            String displayStatus,
            String approvalStatus,
            String visitorKeyword,
            String visitReasonCode) {
        List<AppointmentAdminListVo> all =
                listAdminOrders(
                        visitedUserName,
                        visitedDeptId,
                        accessArea,
                        localUnit,
                        visitDateStart,
                        visitDateEnd,
                        displayStatus,
                        approvalStatus,
                        visitorKeyword,
                        visitReasonCode);
        return slicePage(page, size, all);
    }

    public byte[] exportExcel(
            String visitedUserName,
            Long visitedDeptId,
            String accessArea,
            String localUnit,
            LocalDate visitDateStart,
            LocalDate visitDateEnd,
            String displayStatus,
            String approvalStatus,
            String visitorKeyword,
            String visitReasonCode) {
        Set<Long> visitorOrderIds = findOrderIdsByVisitorKeyword(visitorKeyword);
        if (visitorOrderIds != null && visitorOrderIds.isEmpty()) {
            return writeExportRows(List.of());
        }

        List<AppointmentOrder> orders =
                appointmentOrderMapper.selectList(
                        buildOrderQuery(
                                visitedUserName,
                                visitedDeptId,
                                accessArea,
                                localUnit,
                                visitDateStart,
                                visitDateEnd,
                                visitReasonCode,
                                visitorOrderIds));
        if (orders.isEmpty()) {
            return writeExportRows(List.of());
        }

        List<Long> orderIds = orders.stream().map(AppointmentOrder::getId).filter(Objects::nonNull).toList();
        Map<Long, List<AppointmentVisitor>> visitorRowsMap = loadVisitorRows(orderIds);
        Map<Long, ApprovalInstance> approvalInstanceMap = loadApprovalInstanceMap(orderIds);
        Map<Long, String> deptNameMap = loadDeptNameMap(orders);
        Map<String, String> reasonNameMap = loadReasonNameMap(orders);

        List<AppointmentOrder> filteredOrders = new ArrayList<>();
        for (AppointmentOrder order : orders) {
            AppointmentAdminListVo vo =
                    toAdminListVo(
                            order,
                            deptNameMap.get(order.getVisitedDeptId()),
                            reasonNameMap,
                            visitorRowsMap.get(order.getId()),
                            approvalInstanceMap.get(order.getId()));
            if (matchesDisplayStatus(vo, displayStatus) && matchesApprovalStatus(vo, approvalStatus)) {
                filteredOrders.add(order);
            }
        }

        List<AppointmentAdminExportRow> rows = buildExportRows(filteredOrders, visitorRowsMap, approvalInstanceMap, reasonNameMap);
        return writeExportRows(rows);
    }

    private byte[] writeExportRows(List<AppointmentAdminExportRow> rows) {
        try (ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
            EasyExcel.write(bos, AppointmentAdminExportRow.class).sheet("预约记录").doWrite(rows);
            return bos.toByteArray();
        } catch (Exception e) {
            return new byte[0];
        }
    }

    public AppointmentOrder getById(Long id, String uuid) {
        AppointmentOrder o = appointmentOrderMapper.selectById(id);
        if (o == null || o.getDelFlag() != null && o.getDelFlag() == 1) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "预约单不存在");
        }
        UuidAssert.match(o, uuid);
        return o;
    }

    public AppointmentAdminDetailVo detail(Long id, String uuid) {
        AppointmentOrder order = getById(id, uuid);
        String deptName = loadDeptNameMap(List.of(order)).get(order.getVisitedDeptId());
        Map<String, String> reasonNameMap = loadReasonNameMap(List.of(order));
        List<AppointmentVisitor> visitorRows = listVisitors(id);
        Map<Long, MpVisitor> visitorMap = loadVisitorMap(visitorRows);
        Map<Long, String> plateMap = loadVisitorPlateMap(id);
        ApprovalInstance approvalInstance = loadLatestInstance(id);

        AppointmentAdminDetailVo vo = new AppointmentAdminDetailVo();
        vo.setId(order.getId());
        vo.setUuid(order.getUuid());
        vo.setOrderNo(order.getOrderNo());
        vo.setVisitTypeText(buildVisitTypeText(order));
        vo.setVisitedUserName(defaultText(trimToNull(order.getVisitedUserName())));
        vo.setVisitedDeptName(defaultText(trimToNull(deptName)));
        vo.setAccessAreaText(defaultText(buildJsonNameText(order.getPassAccessAreaNames())));
        vo.setLocalUnitText(defaultText(buildJsonNameText(order.getPassLocalUnitNames())));
        vo.setPlateNoText(defaultText(joinUniqueTexts(visitorRows, AppointmentVisitor::getPlateNo)));
        vo.setVisitReasonText(defaultText(buildVisitReasonText(order, reasonNameMap)));
        vo.setVisitStartText(defaultText(resolveVisitStartText(order)));
        vo.setVisitEndText(defaultText(resolveVisitEndText(order)));
        String displayStatusCode = resolveDisplayStatus(order);
        vo.setDisplayStatusCode(displayStatusCode);
        vo.setDisplayStatusText(resolveDisplayStatusText(displayStatusCode));
        String approvalStatusCode = resolveApprovalStatusCode(order, approvalInstance);
        vo.setApprovalStatusCode(approvalStatusCode);
        vo.setApprovalStatusText(resolveApprovalStatusText(approvalStatusCode));
        vo.setVisitors(buildDetailVisitors(visitorRows, visitorMap, plateMap));
        return vo;
    }

    public List<AppointmentVisitor> listVisitors(Long orderId) {
        return appointmentVisitorMapper.selectList(
                new LambdaQueryWrapper<AppointmentVisitor>()
                        .eq(AppointmentVisitor::getOrderId, orderId)
                        .eq(AppointmentVisitor::getDelFlag, 0)
                        .orderByAsc(AppointmentVisitor::getId));
    }

    private List<AppointmentAdminListVo> listAdminOrders(
            String visitedUserName,
            Long visitedDeptId,
            String accessArea,
            String localUnit,
            LocalDate visitDateStart,
            LocalDate visitDateEnd,
            String displayStatus,
            String approvalStatus,
            String visitorKeyword,
            String visitReasonCode) {
        Set<Long> visitorOrderIds = findOrderIdsByVisitorKeyword(visitorKeyword);
        if (visitorOrderIds != null && visitorOrderIds.isEmpty()) {
            return List.of();
        }

        List<AppointmentOrder> orders =
                appointmentOrderMapper.selectList(
                        buildOrderQuery(
                                visitedUserName,
                                visitedDeptId,
                                accessArea,
                                localUnit,
                                visitDateStart,
                                visitDateEnd,
                                visitReasonCode,
                                visitorOrderIds));
        if (orders.isEmpty()) {
            return List.of();
        }

        List<Long> orderIds = orders.stream().map(AppointmentOrder::getId).filter(Objects::nonNull).toList();
        Map<Long, List<AppointmentVisitor>> visitorRowsMap = loadVisitorRows(orderIds);
        Map<Long, ApprovalInstance> approvalInstanceMap = loadApprovalInstanceMap(orderIds);
        Map<Long, String> deptNameMap = loadDeptNameMap(orders);
        Map<String, String> reasonNameMap = loadReasonNameMap(orders);

        List<AppointmentAdminListVo> result = new ArrayList<>();
        for (AppointmentOrder order : orders) {
            AppointmentAdminListVo vo =
                    toAdminListVo(
                            order,
                            deptNameMap.get(order.getVisitedDeptId()),
                            reasonNameMap,
                            visitorRowsMap.get(order.getId()),
                            approvalInstanceMap.get(order.getId()));
            if (matchesDisplayStatus(vo, displayStatus) && matchesApprovalStatus(vo, approvalStatus)) {
                result.add(vo);
            }
        }
        return result;
    }

    private LambdaQueryWrapper<AppointmentOrder> buildOrderQuery(
            String visitedUserName,
            Long visitedDeptId,
            String accessArea,
            String localUnit,
            LocalDate visitDateStart,
            LocalDate visitDateEnd,
            String visitReasonCode,
            Set<Long> visitorOrderIds) {
        LambdaQueryWrapper<AppointmentOrder> q = new LambdaQueryWrapper<>();
        q.eq(AppointmentOrder::getDelFlag, 0);
        q.like(StringUtils.hasText(visitedUserName), AppointmentOrder::getVisitedUserName, trim(visitedUserName));
        q.eq(visitedDeptId != null, AppointmentOrder::getVisitedDeptId, visitedDeptId);
        q.like(StringUtils.hasText(accessArea), AppointmentOrder::getPassAccessAreaNames, trim(accessArea));
        q.like(StringUtils.hasText(localUnit), AppointmentOrder::getPassLocalUnitNames, trim(localUnit));
        q.eq(StringUtils.hasText(visitReasonCode), AppointmentOrder::getVisitReasonCode, trim(visitReasonCode));
        q.le(visitDateEnd != null, AppointmentOrder::getVisitStartDate, visitDateEnd);
        q.ge(visitDateStart != null, AppointmentOrder::getVisitEndDate, visitDateStart);
        if (visitorOrderIds != null) {
            q.in(AppointmentOrder::getId, visitorOrderIds);
        }
        q.orderByDesc(AppointmentOrder::getCreateTime).orderByDesc(AppointmentOrder::getId);
        return q;
    }

    private Set<Long> findOrderIdsByVisitorKeyword(String visitorKeyword) {
        String keyword = trimToNull(visitorKeyword);
        if (!StringUtils.hasText(keyword)) {
            return null;
        }
        List<AppointmentVisitor> rows =
                appointmentVisitorMapper.selectList(
                        new LambdaQueryWrapper<AppointmentVisitor>()
                                .eq(AppointmentVisitor::getDelFlag, 0)
                                .like(AppointmentVisitor::getName, keyword)
                                .select(AppointmentVisitor::getOrderId));
        return rows.stream()
                .map(AppointmentVisitor::getOrderId)
                .filter(Objects::nonNull)
                .collect(Collectors.toCollection(LinkedHashSet::new));
    }

    private Map<Long, MpVisitor> loadVisitorMap(List<AppointmentVisitor> rows) {
        if (rows == null || rows.isEmpty()) {
            return Map.of();
        }
        Set<Long> visitorIds =
                rows.stream()
                        .map(AppointmentVisitor::getMpVisitorId)
                        .filter(Objects::nonNull)
                        .collect(Collectors.toCollection(LinkedHashSet::new));
        if (visitorIds.isEmpty()) {
            return Map.of();
        }
        List<MpVisitor> visitors =
                mpVisitorMapper.selectList(
                        new LambdaQueryWrapper<MpVisitor>()
                                .eq(MpVisitor::getDelFlag, 0)
                                .in(MpVisitor::getId, visitorIds));
        return visitors.stream().collect(Collectors.toMap(MpVisitor::getId, v -> v, (a, b) -> a, LinkedHashMap::new));
    }

    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>> plates = new LinkedHashMap<>();
        for (AppointmentVehicle row : rows) {
            if (row.getDriverVisitorId() == null || !StringUtils.hasText(row.getPlateNo())) {
                continue;
            }
            plates.computeIfAbsent(row.getDriverVisitorId(), key -> new ArrayList<>());
            plates.get(row.getDriverVisitorId()).add(row.getPlateNo().trim());
        }
        Map<Long, String> result = new LinkedHashMap<>();
        for (Map.Entry<Long, List<String>> entry : plates.entrySet()) {
            String joined =
                    entry.getValue().stream()
                            .filter(StringUtils::hasText)
                            .map(String::trim)
                            .distinct()
                            .collect(Collectors.joining("、"));
            result.put(entry.getKey(), joined);
        }
        return result;
    }

    private Map<Long, List<AppointmentVisitor>> loadVisitorRows(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 Map<Long, ApprovalInstance> loadApprovalInstanceMap(List<Long> orderIds) {
        if (orderIds == null || orderIds.isEmpty()) {
            return Map.of();
        }
        List<ApprovalInstance> rows =
                approvalInstanceMapper.selectList(
                        new LambdaQueryWrapper<ApprovalInstance>()
                                .eq(ApprovalInstance::getDelFlag, 0)
                                .in(ApprovalInstance::getOrderId, orderIds)
                                .orderByDesc(ApprovalInstance::getId));
        Map<Long, ApprovalInstance> result = new LinkedHashMap<>();
        for (ApprovalInstance row : rows) {
            result.putIfAbsent(row.getOrderId(), row);
        }
        return result;
    }

    private ApprovalInstance loadLatestInstance(Long orderId) {
        List<ApprovalInstance> list =
                approvalInstanceMapper.selectList(
                        new LambdaQueryWrapper<ApprovalInstance>()
                                .eq(ApprovalInstance::getDelFlag, 0)
                                .eq(ApprovalInstance::getOrderId, orderId)
                                .orderByDesc(ApprovalInstance::getId));
        return list.isEmpty() ? null : list.get(0);
    }

    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)
                        .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 AppointmentAdminListVo toAdminListVo(
            AppointmentOrder order,
            String deptName,
            Map<String, String> reasonNameMap,
            List<AppointmentVisitor> visitorRows,
            ApprovalInstance approvalInstance) {
        AppointmentAdminListVo vo = new AppointmentAdminListVo();
        vo.setId(order.getId());
        vo.setUuid(order.getUuid());
        vo.setOrderNo(order.getOrderNo());
        vo.setVisitTypeText(buildVisitTypeText(order));
        vo.setVisitedUserName(defaultText(trimToNull(order.getVisitedUserName())));
        vo.setVisitedDeptName(defaultText(trimToNull(deptName)));
        vo.setAccessAreaText(defaultText(buildJsonNameText(order.getPassAccessAreaNames())));
        vo.setLocalUnitText(defaultText(buildJsonNameText(order.getPassLocalUnitNames())));
        vo.setPlateNoText(defaultText(joinUniqueTexts(visitorRows, AppointmentVisitor::getPlateNo)));
        vo.setVisitReasonText(defaultText(buildVisitReasonText(order, reasonNameMap)));
        vo.setVisitTimeText(defaultText(buildVisitTimeText(order)));
        vo.setVisitorNamesText(defaultText(joinUniqueTexts(visitorRows, AppointmentVisitor::getName)));
        vo.setStatus(order.getStatus());
        vo.setCreateTime(order.getCreateTime());

        String displayStatusCode = resolveDisplayStatus(order);
        vo.setDisplayStatusCode(displayStatusCode);
        vo.setDisplayStatusText(resolveDisplayStatusText(displayStatusCode));

        String approvalStatusCode = resolveApprovalStatusCode(order, approvalInstance);
        vo.setApprovalStatusCode(approvalStatusCode);
        vo.setApprovalStatusText(resolveApprovalStatusText(approvalStatusCode));
        return vo;
    }

    private List<AppointmentAdminExportRow> buildExportRows(
            List<AppointmentOrder> orders,
            Map<Long, List<AppointmentVisitor>> visitorRowsMap,
            Map<Long, ApprovalInstance> approvalInstanceMap,
            Map<String, String> reasonNameMap) {
        if (orders == null || orders.isEmpty()) {
            return List.of();
        }
        List<Long> orderIds = orders.stream().map(AppointmentOrder::getId).filter(Objects::nonNull).toList();
        List<AppointmentVisitor> allVisitorRows =
                orderIds.isEmpty()
                        ? List.of()
                        : visitorRowsMap.values().stream().flatMap(Collection::stream).toList();
        Map<Long, MpVisitor> visitorMap = loadVisitorMap(allVisitorRows);
        Map<Long, Map<Long, String>> visitorPlateMap = loadVisitorPlateMap(orderIds);
        Map<Long, Map<String, String>> approvalNameMap = loadApprovalNodeApproverTextMap(approvalInstanceMap.values());
        Map<Long, MpUser> submitterMap = loadSubmitterMap(orders);

        List<AppointmentAdminExportRow> result = new ArrayList<>();
        for (AppointmentOrder order : orders) {
            AppointmentAdminListVo summary =
                    toAdminListVo(
                            order,
                            null,
                            reasonNameMap,
                            visitorRowsMap.get(order.getId()),
                            approvalInstanceMap.get(order.getId()));
            Map<String, String> nodeApproverNames =
                    approvalNameMap.getOrDefault(order.getId(), Map.of());
            MpUser submitter = submitterMap.get(order.getSubmitterId());
            List<AppointmentVisitor> visitors = visitorRowsMap.get(order.getId());
            if (visitors == null || visitors.isEmpty()) {
                result.add(buildExportRow(summary, order, null, null, Map.of(), nodeApproverNames, submitter));
                continue;
            }
            Map<Long, String> orderPlateMap = visitorPlateMap.getOrDefault(order.getId(), Map.of());
            for (AppointmentVisitor visitorRow : visitors) {
                MpVisitor visitor = visitorMap.get(visitorRow.getMpVisitorId());
                result.add(buildExportRow(summary, order, visitorRow, visitor, orderPlateMap, nodeApproverNames, submitter));
            }
        }
        return result;
    }

    private AppointmentAdminExportRow buildExportRow(
            AppointmentAdminListVo summary,
            AppointmentOrder order,
            AppointmentVisitor visitorRow,
            MpVisitor visitor,
            Map<Long, String> orderPlateMap,
            Map<String, String> nodeApproverNames,
            MpUser submitter) {
        AppointmentAdminExportRow row = new AppointmentAdminExportRow();
        row.setVisitTypeText(summary.getVisitTypeText());
        row.setVisitedUserName(summary.getVisitedUserName());
        row.setAccessAreaText(summary.getAccessAreaText());
        row.setLocalUnitText(summary.getLocalUnitText());
        row.setPlateNoText(
                defaultText(
                        firstNonBlank(
                                visitorRow == null ? null : visitorRow.getPlateNo(),
                                visitorRow == null ? null : orderPlateMap.get(visitorRow.getMpVisitorId()),
                                summary.getPlateNoText())));
        row.setVisitReasonText(summary.getVisitReasonText());
        row.setVisitTimeText(summary.getVisitTimeText());
        row.setDisplayStatusText(summary.getDisplayStatusText());
        row.setVisitorLabel(defaultText(visitorRow == null ? null : trimToNull(visitorRow.getName())));
        row.setVisitorName(
                defaultText(
                        firstNonBlank(
                                visitorRow == null ? null : visitorRow.getName(),
                                visitor == null ? null : visitor.getVisitorName(),
                                null)));
        row.setIdCardText(defaultText(resolveIdCardMasked(visitorRow, visitor)));
        row.setMobileText(
                defaultText(
                        MobileMaskUtil.mask(
                                firstNonBlank(
                                        visitorRow == null ? null : visitorRow.getMobile(),
                                        visitor == null ? null : visitor.getVisitorMobile(),
                                        null))));
        row.setCompanyName(defaultText(visitor == null ? null : trimToNull(visitor.getVisitorCompany())));
        row.setHandlerApproverNames(defaultText(nodeApproverNames.get(ApprovalNodeCode.LEVEL1_HANDLER)));
        row.setDeptLeaderApproverNames(defaultText(nodeApproverNames.get(ApprovalNodeCode.LEVEL2_DEPT_LEADER)));
        row.setVisitDeptApproverNames(defaultText(nodeApproverNames.get(ApprovalNodeCode.LEVEL4_VISIT_DEPT)));
        row.setVisitDeptLeaderApproverNames(defaultText(nodeApproverNames.get(ApprovalNodeCode.LEVEL5_VISIT_DEPT_LEADER)));
        row.setLocalDeptLeaderApproverNames(defaultText(nodeApproverNames.get(ApprovalNodeCode.LEVEL3_LOCAL_DEPT_LEADER)));
        row.setSubmitterMobile(defaultText(MobileMaskUtil.mask(submitter == null ? null : trimToNull(submitter.getMobile()))));
        row.setSubmitTimeText(defaultText(formatDateTime(order.getCreateTime())));
        return row;
    }

    private Map<Long, MpUser> loadSubmitterMap(List<AppointmentOrder> orders) {
        Set<Long> submitterIds =
                orders.stream()
                        .map(AppointmentOrder::getSubmitterId)
                        .filter(Objects::nonNull)
                        .collect(Collectors.toCollection(LinkedHashSet::new));
        if (submitterIds.isEmpty()) {
            return Map.of();
        }
        List<MpUser> rows =
                mpUserMapper.selectList(
                        new LambdaQueryWrapper<MpUser>()
                                .eq(MpUser::getDelFlag, 0)
                                .in(MpUser::getId, submitterIds));
        return rows.stream().collect(Collectors.toMap(MpUser::getId, u -> u, (a, b) -> a, LinkedHashMap::new));
    }

    private Map<Long, Map<String, String>> loadApprovalNodeApproverTextMap(Collection<ApprovalInstance> instances) {
        List<ApprovalInstance> instanceList =
                instances == null ? List.of() : instances.stream().filter(Objects::nonNull).toList();
        if (instanceList.isEmpty()) {
            return Map.of();
        }
        List<Long> instanceIds = instanceList.stream().map(ApprovalInstance::getId).filter(Objects::nonNull).toList();
        if (instanceIds.isEmpty()) {
            return Map.of();
        }
        List<ApprovalTask> tasks =
                approvalTaskMapper.selectList(
                        new LambdaQueryWrapper<ApprovalTask>()
                                .eq(ApprovalTask::getDelFlag, 0)
                                .in(ApprovalTask::getInstanceId, instanceIds)
                                .ne(ApprovalTask::getTaskStatus, ApprovalTaskStatus.SKIPPED)
                                .orderByAsc(ApprovalTask::getId));
        if (tasks.isEmpty()) {
            return Map.of();
        }
        Set<Long> userIds =
                tasks.stream()
                        .map(ApprovalTask::getAssigneeUserId)
                        .filter(Objects::nonNull)
                        .collect(Collectors.toCollection(LinkedHashSet::new));
        Map<Long, String> userNameMap = loadMpUserNameMap(userIds);
        Map<Long, Long> orderIdByInstanceId =
                instanceList.stream()
                        .collect(Collectors.toMap(ApprovalInstance::getId, ApprovalInstance::getOrderId, (a, b) -> a, LinkedHashMap::new));
        Map<Long, Map<String, LinkedHashSet<String>>> grouped = new LinkedHashMap<>();
        for (ApprovalTask task : tasks) {
            Long orderId = orderIdByInstanceId.get(task.getInstanceId());
            if (orderId == null || !StringUtils.hasText(task.getNodeCode())) {
                continue;
            }
            String userName = trimToNull(userNameMap.get(task.getAssigneeUserId()));
            if (!StringUtils.hasText(userName)) {
                continue;
            }
            grouped.computeIfAbsent(orderId, key -> new LinkedHashMap<>());
            grouped.get(orderId).computeIfAbsent(task.getNodeCode(), key -> new LinkedHashSet<>());
            grouped.get(orderId).get(task.getNodeCode()).add(userName);
        }
        Map<Long, Map<String, String>> result = new LinkedHashMap<>();
        for (Map.Entry<Long, Map<String, LinkedHashSet<String>>> orderEntry : grouped.entrySet()) {
            Map<String, String> nodeTextMap = new LinkedHashMap<>();
            for (Map.Entry<String, LinkedHashSet<String>> nodeEntry : orderEntry.getValue().entrySet()) {
                nodeTextMap.put(nodeEntry.getKey(), String.join("、", nodeEntry.getValue()));
            }
            result.put(orderEntry.getKey(), nodeTextMap);
        }
        return result;
    }

    private Map<Long, String> loadMpUserNameMap(Set<Long> userIds) {
        if (userIds == null || userIds.isEmpty()) {
            return Map.of();
        }
        List<MpUser> rows =
                mpUserMapper.selectList(
                        new LambdaQueryWrapper<MpUser>()
                                .eq(MpUser::getDelFlag, 0)
                                .in(MpUser::getId, userIds));
        return rows.stream()
                .collect(
                        Collectors.toMap(
                                MpUser::getId,
                                user -> firstNonBlank(user.getNickName(), user.getMobile(), String.valueOf(user.getId())),
                                (a, b) -> a,
                                LinkedHashMap::new));
    }

    private Map<Long, Map<Long, String>> loadVisitorPlateMap(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));
        if (rows.isEmpty()) {
            return Map.of();
        }
        Map<Long, Map<Long, List<String>>> temp = new LinkedHashMap<>();
        for (AppointmentVehicle row : rows) {
            if (row.getOrderId() == null || row.getDriverVisitorId() == null || !StringUtils.hasText(row.getPlateNo())) {
                continue;
            }
            temp.computeIfAbsent(row.getOrderId(), key -> new LinkedHashMap<>());
            temp.get(row.getOrderId()).computeIfAbsent(row.getDriverVisitorId(), key -> new ArrayList<>());
            temp.get(row.getOrderId()).get(row.getDriverVisitorId()).add(row.getPlateNo().trim());
        }
        Map<Long, Map<Long, String>> result = new LinkedHashMap<>();
        for (Map.Entry<Long, Map<Long, List<String>>> orderEntry : temp.entrySet()) {
            Map<Long, String> visitorPlateTextMap = new LinkedHashMap<>();
            for (Map.Entry<Long, List<String>> visitorEntry : orderEntry.getValue().entrySet()) {
                String joined =
                        visitorEntry.getValue().stream()
                                .filter(StringUtils::hasText)
                                .map(String::trim)
                                .distinct()
                                .collect(Collectors.joining("、"));
                visitorPlateTextMap.put(visitorEntry.getKey(), joined);
            }
            result.put(orderEntry.getKey(), visitorPlateTextMap);
        }
        return result;
    }

    private String resolveIdCardMasked(AppointmentVisitor row, MpVisitor visitor) {
        String idCardPlain =
                row != null && StringUtils.hasText(row.getIdCardCipher())
                        ? SensitiveDataUtil.decryptIdCard(row.getIdCardCipher())
                        : (visitor != null && StringUtils.hasText(visitor.getIdCardCipher())
                                ? SensitiveDataUtil.decryptIdCard(visitor.getIdCardCipher())
                                : null);
        return StringUtils.hasText(idCardPlain) ? SensitiveDataUtil.maskIdCard(idCardPlain) : null;
    }

    private String formatDateTime(LocalDateTime value) {
        return value == null ? null : value.format(DATE_TIME_FORMATTER);
    }

    private List<AppointmentAdminDetailVisitorVo> buildDetailVisitors(
            List<AppointmentVisitor> rows, Map<Long, MpVisitor> visitorMap, Map<Long, String> plateMap) {
        if (rows == null || rows.isEmpty()) {
            return List.of();
        }
        List<AppointmentAdminDetailVisitorVo> result = new ArrayList<>();
        for (AppointmentVisitor row : rows) {
            MpVisitor visitor = visitorMap.get(row.getMpVisitorId());
            AppointmentAdminDetailVisitorVo vo = new AppointmentAdminDetailVisitorVo();
            vo.setVisitorId(row.getMpVisitorId());
            vo.setName(firstNonBlank(row.getName(), visitor == null ? null : visitor.getVisitorName(), "-"));
            vo.setGender(defaultText(visitor == null ? null : trimToNull(visitor.getGender())));
            vo.setCompanyName(defaultText(visitor == null ? null : trimToNull(visitor.getVisitorCompany())));
            vo.setMobileMasked(
                    defaultText(
                            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(
                    defaultText(
                            StringUtils.hasText(idCardPlain)
                                    ? SensitiveDataUtil.maskIdCard(idCardPlain)
                                    : null));
            vo.setPlateNo(defaultText(firstNonBlank(row.getPlateNo(), plateMap.get(row.getMpVisitorId()), null)));
            vo.setDriverName(defaultText(trimToNull(row.getDriverName())));
            result.add(vo);
        }
        return result;
    }

    private boolean matchesDisplayStatus(AppointmentAdminListVo row, String filter) {
        String value = trimToNull(filter);
        return !StringUtils.hasText(value) || Objects.equals(value, row.getDisplayStatusCode());
    }

    private boolean matchesApprovalStatus(AppointmentAdminListVo row, String filter) {
        String value = trimToNull(filter);
        return !StringUtils.hasText(value) || Objects.equals(value, row.getApprovalStatusCode());
    }

    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 String buildVisitReasonText(AppointmentOrder row, Map<String, String> reasonNameMap) {
        String code = trimToNull(row.getVisitReasonCode());
        if (!StringUtils.hasText(code)) {
            return null;
        }
        if ("OTHER".equalsIgnoreCase(code)) {
            String other = trimToNull(row.getVisitReasonOther());
            return StringUtils.hasText(other) ? "其他-" + other : "其他";
        }
        String reasonName = reasonNameMap.get(code);
        return StringUtils.hasText(reasonName) ? reasonName : code;
    }

    private String buildVisitTimeText(AppointmentOrder row) {
        if (row.getVisitStartDate() == null && row.getVisitEndDate() == null) {
            return null;
        }
        if (Objects.equals(row.getVisitStartDate(), row.getVisitEndDate()) || row.getVisitEndDate() == null) {
            return String.valueOf(row.getVisitStartDate());
        }
        return row.getVisitStartDate() + " 至 " + row.getVisitEndDate();
    }

    private String resolveVisitStartText(AppointmentOrder row) {
        return row.getVisitStartDate() == null ? null : row.getVisitStartDate().toString();
    }

    private String resolveVisitEndText(AppointmentOrder row) {
        LocalDate end = row.getVisitEndDate() != null ? row.getVisitEndDate() : row.getVisitStartDate();
        return end == null ? null : end.toString();
    }

    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 String resolveDisplayStatusText(String code) {
        return switch (trimToNull(code)) {
            case DISPLAY_STATUS_PENDING_VISIT -> "待拜访";
            case DISPLAY_STATUS_EFFECTIVE -> "生效中";
            default -> "已失效";
        };
    }

    private String resolveApprovalStatusCode(AppointmentOrder order, ApprovalInstance approvalInstance) {
        String status = trimToNull(order.getStatus());
        if (AppointmentOrderStatus.PENDING_APPROVAL.equals(status)) {
            String nodeCode = approvalInstance == null ? null : trimToNull(approvalInstance.getCurrentNodeCode());
            return StringUtils.hasText(nodeCode) ? nodeCode : AppointmentOrderStatus.PENDING_APPROVAL;
        }
        if (AppointmentOrderStatus.APPROVED.equals(status)
                || AppointmentOrderStatus.VISITED.equals(status)
                || AppointmentOrderStatus.EXPIRED.equals(status)) {
            return AppointmentOrderStatus.APPROVED;
        }
        if (AppointmentOrderStatus.REJECTED.equals(status)) {
            return AppointmentOrderStatus.REJECTED;
        }
        if (AppointmentOrderStatus.CANCELLED.equals(status)) {
            return AppointmentOrderStatus.CANCELLED;
        }
        return status;
    }

    private String resolveApprovalStatusText(String code) {
        return switch (trimToNull(code)) {
            case ApprovalNodeCode.LEVEL1_HANDLER -> "经办人";
            case ApprovalNodeCode.LEVEL2_DEPT_LEADER -> "部门";
            case ApprovalNodeCode.LEVEL3_LOCAL_DEPT_LEADER -> "属地部门";
            case ApprovalNodeCode.LEVEL4_VISIT_DEPT -> "主管部门";
            case ApprovalNodeCode.LEVEL5_VISIT_DEPT_LEADER -> "主管部门领导";
            case AppointmentOrderStatus.APPROVED -> "已通过";
            case AppointmentOrderStatus.REJECTED -> "已拒绝";
            case AppointmentOrderStatus.CANCELLED -> "已取消";
            case AppointmentOrderStatus.PENDING_APPROVAL -> "审批中";
            default -> "-";
        };
    }

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

    private String joinUniqueTexts(List<AppointmentVisitor> rows, java.util.function.Function<AppointmentVisitor, String> getter) {
        if (rows == null || rows.isEmpty()) {
            return null;
        }
        return rows.stream()
                .map(getter)
                .filter(StringUtils::hasText)
                .map(String::trim)
                .distinct()
                .collect(Collectors.joining("、"));
    }

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

    private static String trim(String value) {
        return value == null ? null : value.trim();
    }

    private static String trimToNull(String value) {
        String trimmed = trim(value);
        return StringUtils.hasText(trimmed) ? trimmed : null;
    }

    private static String defaultText(String value) {
        return StringUtils.hasText(value) ? value : "-";
    }

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