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.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.sinata.appointment.config.MiniStpUtil;
import com.sinata.appointment.constants.AppointmentBizConstants;
import com.sinata.appointment.constants.ApprovalInstanceStatus;
import com.sinata.appointment.constants.ApprovalNodeCode;
import com.sinata.appointment.constants.ApprovalTaskStatus;
import com.sinata.appointment.constants.BizErrorCode;
import com.sinata.appointment.dto.MiniApprovalTodoVo;
import com.sinata.appointment.dto.MiniApprovalActionRequest;
import com.sinata.appointment.dto.MiniHandlerApprovalActionRequest;
import com.sinata.appointment.dto.MiniHandlerApprovalTodoVo;
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.BizApprovalNodeConfig;
import com.sinata.appointment.entity.BizVisitReason;
import com.sinata.appointment.entity.MpPassAccessArea;
import com.sinata.appointment.entity.MpPassLocalUnit;
import com.sinata.appointment.entity.MpVisitor;
import com.sinata.appointment.exception.BizException;
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.BizApprovalNodeConfigMapper;
import com.sinata.appointment.mapper.BizVisitReasonMapper;
import com.sinata.appointment.mapper.MpVisitorMapper;
import com.sinata.appointment.mapper.MpPassAccessAreaMapper;
import com.sinata.appointment.mapper.MpPassLocalUnitMapper;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Stream;
import java.util.stream.Collectors;
import java.util.LinkedHashMap;
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 com.sinata.appointment.util.UuidAssert;

@Slf4j
@Service
@RequiredArgsConstructor
public class MiniHandlerApprovalApplicationService {

    private final ApprovalTaskMapper approvalTaskMapper;
    private final ApprovalInstanceMapper approvalInstanceMapper;
    private final AppointmentOrderMapper appointmentOrderMapper;
    private final AppointmentVisitorMapper appointmentVisitorMapper;
    private final AppointmentVehicleMapper appointmentVehicleMapper;
    private final MpVisitorMapper mpVisitorMapper;
    private final BizVisitReasonMapper bizVisitReasonMapper;
    private final ApprovalEngineService approvalEngineService;
    private final IntegrationWechatService integrationWechatService;
    private final PostApprovalOrchestrationService postApprovalOrchestrationService;
    private final BizApprovalNodeConfigMapper bizApprovalNodeConfigMapper;
    private final MpPassAccessAreaMapper mpPassAccessAreaMapper;
    private final MpPassLocalUnitMapper mpPassLocalUnitMapper;
    private final ObjectMapper objectMapper;

    public IPage<MiniApprovalTodoVo> pageMyTodoAll(long page, long size) {
        return pageMyTodoAll(page, size, null, null);
    }

    public IPage<MiniApprovalTodoVo> pageMyTodoAll(
            long page, long size, String visitedUserNameKeyword, LocalDate visitDate) {
        long uid = MiniStpUtil.getLoginIdAsLong();
        List<ApprovalTask> tasks =
                approvalTaskMapper.selectList(
                        new LambdaQueryWrapper<ApprovalTask>()
                                .eq(ApprovalTask::getAssigneeUserId, uid)
                                .eq(ApprovalTask::getTaskStatus, ApprovalTaskStatus.PENDING)
                                .orderByDesc(ApprovalTask::getCreateTime)
                                .orderByDesc(ApprovalTask::getId));
        if (tasks.isEmpty()) {
            return new Page<>(page, size);
        }
        List<Long> instanceIds =
                tasks.stream()
                        .map(ApprovalTask::getInstanceId)
                        .filter(Objects::nonNull)
                        .toList();
        Map<Long, ApprovalInstance> instanceMap = loadInstanceMap(instanceIds);
        List<Long> orderIds =
                instanceMap.values().stream()
                        .map(ApprovalInstance::getOrderId)
                        .filter(Objects::nonNull)
                        .toList();
        Map<Long, AppointmentOrder> orderMap = loadOrderMap(orderIds);
        Map<Long, String> visitorDisplayMap = loadVisitorDisplayMap(orderIds);
        Map<Long, String> plateTextMap = loadPlateTextMap(orderIds);
        Map<String, String> reasonNameMap = loadReasonNameMap(orderMap.values());
        Map<String, String> nodeNameMap = loadNodeNameMap();
        List<MiniApprovalTodoVo> rowsAll =
                tasks.stream()
                        .filter(t -> matchTodoFilters(t, instanceMap, orderMap, visitorDisplayMap, visitedUserNameKeyword, visitDate))
                        .map(t -> toMiniTodoVo(t, instanceMap, orderMap, nodeNameMap, visitorDisplayMap, plateTextMap, reasonNameMap))
                        .toList();
        return slicePage(page, size, rowsAll);
    }

    public IPage<MiniHandlerApprovalTodoVo> pageMyTodo(long page, long size) {
        return pageMyTodo(page, size, null, null);
    }

    public IPage<MiniHandlerApprovalTodoVo> pageMyTodo(
            long page, long size, String visitedUserNameKeyword, LocalDate visitDate) {
        long uid = MiniStpUtil.getLoginIdAsLong();
        List<ApprovalTask> tasks =
                approvalTaskMapper.selectList(
                        new LambdaQueryWrapper<ApprovalTask>()
                                .eq(ApprovalTask::getAssigneeUserId, uid)
                                .eq(ApprovalTask::getNodeCode, ApprovalNodeCode.LEVEL1_HANDLER)
                                .eq(ApprovalTask::getTaskStatus, ApprovalTaskStatus.PENDING)
                                .orderByDesc(ApprovalTask::getCreateTime)
                                .orderByDesc(ApprovalTask::getId));
        if (tasks.isEmpty()) {
            return new Page<>(page, size);
        }
        List<Long> instanceIds =
                tasks.stream()
                        .map(ApprovalTask::getInstanceId)
                        .filter(Objects::nonNull)
                        .toList();
        Map<Long, ApprovalInstance> instanceMap = loadInstanceMap(instanceIds);
        List<Long> orderIds =
                instanceMap.values().stream()
                        .map(ApprovalInstance::getOrderId)
                        .filter(Objects::nonNull)
                        .toList();
        Map<Long, AppointmentOrder> orderMap = loadOrderMap(orderIds);
        Map<Long, String> visitorDisplayMap = loadVisitorDisplayMap(orderIds);
        List<MiniHandlerApprovalTodoVo> rowsAll =
                tasks.stream()
                        .filter(t -> matchTodoFilters(t, instanceMap, orderMap, visitorDisplayMap, visitedUserNameKeyword, visitDate))
                        .map(t -> toTodoVo(t, instanceMap, orderMap))
                        .toList();
        return slicePage(page, size, rowsAll);
    }

    @Transactional(rollbackFor = Exception.class)
    public void handleAction(MiniHandlerApprovalActionRequest req) {
        long uid = MiniStpUtil.getLoginIdAsLong();
        ApprovalTask task = approvalTaskMapper.selectById(req.getTaskId());
        if (task == null || (task.getDelFlag() != null && task.getDelFlag() == 1)) {
            throw new BizException(BizErrorCode.APPROVAL_TASK_NOT_FOUND, "审批任务不存在");
        }
        UuidAssert.match(task, req.getTaskUuid());
        if (!ApprovalNodeCode.LEVEL1_HANDLER.equals(task.getNodeCode())) {
            throw new BizException(BizErrorCode.AUTH_FORBIDDEN, "仅支持经办人一级审批");
        }
        if (!ApprovalTaskStatus.PENDING.equals(task.getTaskStatus())) {
            throw new BizException(BizErrorCode.APPROVAL_CONFLICT, "任务已处理");
        }
        if (!Objects.equals(task.getAssigneeUserId(), uid)) {
            throw new BizException(BizErrorCode.AUTH_FORBIDDEN, "无权处理该任务");
        }
        String comment = req.getComment() == null ? null : req.getComment().trim();

        ApprovalInstance inst = approvalInstanceMapper.selectById(task.getInstanceId());
        if (inst == null || (inst.getDelFlag() != null && inst.getDelFlag() == 1)) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "审批实例不存在");
        }
        AppointmentOrder order = appointmentOrderMapper.selectById(inst.getOrderId());
        if (order == null || (order.getDelFlag() != null && order.getDelFlag() == 1)) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "预约单不存在");
        }

        if (Boolean.FALSE.equals(req.getApprove())) {
            if (!StringUtils.hasText(comment)) {
                throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "审批意见不能为空");
            }
            validateRejectCommentLength(comment);
            task.setTaskStatus(ApprovalTaskStatus.REJECTED);
            task.setComment(comment);
            approvalTaskMapper.updateById(task);
            approvalEngineService.rejectInstance(inst, comment);
            postApprovalOrchestrationService.onOrderRejected(order, comment);
            return;
        }

        fillOrderApprovalExtraFields(order, req);
        appointmentOrderMapper.updateById(order);

        task.setTaskStatus(ApprovalTaskStatus.APPROVED);
        task.setComment(comment);
        approvalTaskMapper.updateById(task);
        approvalEngineService.markGroupSkippedExcept(task);
        approvalEngineService.rebuildAfterHandlerApproved(task, inst, order);
        ApprovalInstance latest = approvalInstanceMapper.selectById(inst.getId());
        if (ApprovalInstanceStatus.APPROVED.equals(latest.getStatus())) {
            AppointmentOrder fresh = appointmentOrderMapper.selectById(order.getId());
            postApprovalOrchestrationService.onOrderFullyApproved(fresh);
            return;
        }
        if (ApprovalInstanceStatus.IN_PROGRESS.equals(latest.getStatus())) {
            try {
                integrationWechatService.notifyCurrentApprovers(order, latest.getId());
            } catch (Exception ex) {
                log.warn("notify current approvers failed, orderId={}", order.getId(), ex);
            }
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void handleOtherAction(MiniApprovalActionRequest req) {
        long uid = MiniStpUtil.getLoginIdAsLong();
        ApprovalTask task = approvalTaskMapper.selectById(req.getTaskId());
        if (task == null || (task.getDelFlag() != null && task.getDelFlag() == 1)) {
            throw new BizException(BizErrorCode.APPROVAL_TASK_NOT_FOUND, "审批任务不存在");
        }
        UuidAssert.match(task, req.getTaskUuid());
        if (ApprovalNodeCode.LEVEL1_HANDLER.equals(task.getNodeCode())) {
            throw new BizException(BizErrorCode.AUTH_FORBIDDEN, "经办人一级请走专用审批接口");
        }
        if (!ApprovalTaskStatus.PENDING.equals(task.getTaskStatus())) {
            throw new BizException(BizErrorCode.APPROVAL_CONFLICT, "任务已处理");
        }
        if (!Objects.equals(task.getAssigneeUserId(), uid)) {
            throw new BizException(BizErrorCode.AUTH_FORBIDDEN, "无权处理该任务");
        }

        ApprovalInstance inst = approvalInstanceMapper.selectById(task.getInstanceId());
        if (inst == null || (inst.getDelFlag() != null && inst.getDelFlag() == 1)) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "审批实例不存在");
        }
        AppointmentOrder order = appointmentOrderMapper.selectById(inst.getOrderId());
        if (order == null || (order.getDelFlag() != null && order.getDelFlag() == 1)) {
            throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "预约单不存在");
        }

        String comment = req.getComment() == null ? null : req.getComment().trim();
        appendNoticeIdsIfNeeded(task, req.getNoticeIds());
        if (Boolean.FALSE.equals(req.getApprove())) {
            if (StringUtils.hasText(comment)) {
                validateRejectCommentLength(comment);
            }
            String reason = StringUtils.hasText(comment) ? comment : "拒绝";
            task.setTaskStatus(ApprovalTaskStatus.REJECTED);
            task.setComment(reason);
            approvalTaskMapper.updateById(task);
            approvalEngineService.rejectInstance(inst, reason);
            postApprovalOrchestrationService.onOrderRejected(order, reason);
            return;
        }

        task.setTaskStatus(ApprovalTaskStatus.APPROVED);
        task.setComment(comment);
        approvalTaskMapper.updateById(task);
        approvalEngineService.markGroupSkippedExcept(task);
        if (approvalEngineService.isCurrentNodeComplete(inst)) {
            approvalEngineService.advanceOrComplete(inst, order);
            ApprovalInstance latest = approvalInstanceMapper.selectById(inst.getId());
            if (ApprovalInstanceStatus.APPROVED.equals(latest.getStatus())) {
                AppointmentOrder fresh = appointmentOrderMapper.selectById(order.getId());
                postApprovalOrchestrationService.onOrderFullyApproved(fresh);
                return;
            }
            if (ApprovalInstanceStatus.IN_PROGRESS.equals(latest.getStatus())) {
                try {
                    integrationWechatService.notifyCurrentApprovers(order, latest.getId());
                } catch (Exception ex) {
                    log.warn("notify current approvers failed, orderId={}", order.getId(), ex);
                }
            }
        }
    }

    private void appendNoticeIdsIfNeeded(ApprovalTask task, List<Long> noticeIds) {
        if (!ApprovalNodeCode.LEVEL3_LOCAL_DEPT_LEADER.equals(task.getNodeCode())) {
            return;
        }
        List<Long> normalized = normalizeIds(noticeIds);
        if (normalized.isEmpty()) {
            return;
        }
        LinkedHashSet<Long> merged = new LinkedHashSet<>(parseNoticeIds(task.getNoticeIds()));
        merged.addAll(normalized);
        task.setNoticeIds(merged.stream().map(String::valueOf).collect(Collectors.joining(",")));
    }

    private List<Long> parseNoticeIds(String raw) {
        if (!StringUtils.hasText(raw)) {
            return List.of();
        }
        return Stream.of(raw.split(","))
                .filter(StringUtils::hasText)
                .map(String::trim)
                .map(value -> {
                    try {
                        return Long.parseLong(value);
                    } catch (NumberFormatException ex) {
                        return null;
                    }
                })
                .filter(Objects::nonNull)
                .filter(id -> id > 0)
                .distinct()
                .toList();
    }

    private Map<Long, AppointmentOrder> loadOrderMap(List<Long> orderIds) {
        if (orderIds.isEmpty()) {
            return Map.of();
        }
        List<AppointmentOrder> rows =
                appointmentOrderMapper.selectList(
                        new LambdaQueryWrapper<AppointmentOrder>()
                                .eq(AppointmentOrder::getDelFlag, 0)
                                .in(AppointmentOrder::getId, orderIds));
        return rows.stream().collect(Collectors.toMap(AppointmentOrder::getId, x -> x, (a, b) -> a));
    }

    private Map<Long, ApprovalInstance> loadInstanceMap(List<Long> instanceIds) {
        if (instanceIds.isEmpty()) {
            return Map.of();
        }
        List<ApprovalInstance> rows =
                approvalInstanceMapper.selectList(
                        new LambdaQueryWrapper<ApprovalInstance>()
                                .eq(ApprovalInstance::getDelFlag, 0)
                                .in(ApprovalInstance::getId, instanceIds));
        return rows.stream().collect(Collectors.toMap(ApprovalInstance::getId, x -> x, (a, b) -> a));
    }

    private MiniHandlerApprovalTodoVo toTodoVo(
            ApprovalTask task,
            Map<Long, ApprovalInstance> instanceMap,
            Map<Long, AppointmentOrder> orderMap) {
        MiniHandlerApprovalTodoVo vo = new MiniHandlerApprovalTodoVo();
        vo.setTaskId(task.getId());
        vo.setTaskUuid(task.getUuid());
        vo.setCreateTime(task.getCreateTime());
        ApprovalInstance inst = instanceMap.get(task.getInstanceId());
        if (inst == null) {
            return vo;
        }
        AppointmentOrder order = orderMap.get(inst.getOrderId());
        if (order == null) {
            return vo;
        }
        vo.setOrderId(order.getId());
        vo.setOrderUuid(order.getUuid());
        vo.setOrderNo(order.getOrderNo());
        vo.setVisitedUserName(order.getVisitedUserName());
        vo.setVisitStartDate(order.getVisitStartDate());
        vo.setVisitEndDate(order.getVisitEndDate());
        vo.setVisitReasonCode(order.getVisitReasonCode());
        return vo;
    }

    private Map<String, String> loadNodeNameMap() {
        List<BizApprovalNodeConfig> rows =
                bizApprovalNodeConfigMapper.selectList(
                        new LambdaQueryWrapper<BizApprovalNodeConfig>()
                                .eq(BizApprovalNodeConfig::getDelFlag, 0)
                                .orderByAsc(BizApprovalNodeConfig::getSortOrder));
        Map<String, String> out = new java.util.LinkedHashMap<>();
        for (BizApprovalNodeConfig row : rows) {
            out.put(row.getNodeCode(), row.getNodeName());
        }
        return out;
    }

    private MiniApprovalTodoVo toMiniTodoVo(
            ApprovalTask task,
            Map<Long, ApprovalInstance> instanceMap,
            Map<Long, AppointmentOrder> orderMap,
            Map<String, String> nodeNameMap,
            Map<Long, String> visitorDisplayMap,
            Map<Long, String> plateTextMap,
            Map<String, String> reasonNameMap) {
        MiniApprovalTodoVo vo = new MiniApprovalTodoVo();
        vo.setTaskId(task.getId());
        vo.setTaskUuid(task.getUuid());
        vo.setCreateTime(task.getCreateTime());
        vo.setNodeCode(task.getNodeCode());
        vo.setNodeName(nodeNameMap.getOrDefault(task.getNodeCode(), task.getNodeCode()));
        ApprovalInstance inst = instanceMap.get(task.getInstanceId());
        if (inst == null) {
            return vo;
        }
        AppointmentOrder order = orderMap.get(inst.getOrderId());
        if (order == null) {
            return vo;
        }
        vo.setOrderId(order.getId());
        vo.setOrderUuid(order.getUuid());
        vo.setOrderNo(order.getOrderNo());
        vo.setVisitedUserName(order.getVisitedUserName());
        vo.setVisitorDisplayText(visitorDisplayMap.get(order.getId()));
        vo.setPlateNoText(plateTextMap.get(order.getId()));
        vo.setVisitStartDate(order.getVisitStartDate());
        vo.setVisitEndDate(order.getVisitEndDate());
        vo.setVisitReasonCode(order.getVisitReasonCode());
        vo.setVisitReasonText(buildVisitReasonText(order, reasonNameMap));
        vo.setVisitReasonOther(order.getVisitReasonOther());
        vo.setVisitTimeText(buildVisitTimeText(order));
        return vo;
    }

    private void fillOrderApprovalExtraFields(AppointmentOrder order, MiniHandlerApprovalActionRequest req) {
        List<Long> areaIds = normalizeIds(req.getPassAccessAreaIds());
        if (areaIds.isEmpty()) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "通行区域不能为空");
        }
        List<MpPassAccessArea> areas =
                mpPassAccessAreaMapper.selectList(
                        new LambdaQueryWrapper<MpPassAccessArea>()
                                .eq(MpPassAccessArea::getDelFlag, 0)
                                .in(MpPassAccessArea::getId, areaIds));
        Map<Long, String> areaNameMap =
                areas.stream()
                        .collect(Collectors.toMap(MpPassAccessArea::getId, MpPassAccessArea::getAreaName, (a, b) -> a));
        List<String> areaNames = new ArrayList<>();
        for (Long id : areaIds) {
            String name = areaNameMap.get(id);
            if (!StringUtils.hasText(name)) {
                throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "通行区域不存在: " + id);
            }
            areaNames.add(name);
        }

        boolean involve = Boolean.TRUE.equals(req.getInvolveOtherLocalUnit());
        List<Long> unitIds = normalizeIds(req.getPassLocalUnitIds());
        List<String> unitNames = List.of();
        if (involve) {
            if (unitIds.isEmpty()) {
                throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "涉及其他属地单位时，单位列表不能为空");
            }
            List<MpPassLocalUnit> units =
                    mpPassLocalUnitMapper.selectList(
                            new LambdaQueryWrapper<MpPassLocalUnit>()
                                    .eq(MpPassLocalUnit::getDelFlag, 0)
                                    .in(MpPassLocalUnit::getId, unitIds));
            Map<Long, String> unitNameMap =
                    units.stream()
                            .collect(Collectors.toMap(MpPassLocalUnit::getId, MpPassLocalUnit::getUnitName, (a, b) -> a));
            List<String> names = new ArrayList<>();
            for (Long id : unitIds) {
                String name = unitNameMap.get(id);
                if (!StringUtils.hasText(name)) {
                    throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "属地单位不存在: " + id);
                }
                names.add(name);
            }
            unitNames = names;
        } else {
            unitIds = List.of();
        }

        order.setPassAccessAreaIds(writeJson(areaIds));
        order.setPassAccessAreaNames(writeJson(areaNames));
        order.setInvolveOtherLocalUnit(involve);
        order.setPassLocalUnitIds(writeJson(unitIds));
        order.setPassLocalUnitNames(writeJson(unitNames));
    }

    private static List<Long> normalizeIds(List<Long> ids) {
        if (ids == null || ids.isEmpty()) {
            return List.of();
        }
        LinkedHashSet<Long> out = new LinkedHashSet<>();
        for (Long id : ids) {
            if (id != null && id > 0) {
                out.add(id);
            }
        }
        return out.stream().toList();
    }

    private void validateRejectCommentLength(String comment) {
        if (comment.length() > 30) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "驳回原因最多30个字");
        }
    }

    private String writeJson(Object value) {
        try {
            return objectMapper.writeValueAsString(value);
        } catch (JsonProcessingException ex) {
            throw new BizException(BizErrorCode.AUTH_FORBIDDEN, "数据序列化失败");
        }
    }

    private boolean matchTodoFilters(
            ApprovalTask task,
            Map<Long, ApprovalInstance> instanceMap,
            Map<Long, AppointmentOrder> orderMap,
            Map<Long, String> visitorDisplayMap,
            String visitedUserNameKeyword,
            LocalDate visitDate) {
        ApprovalInstance inst = instanceMap.get(task.getInstanceId());
        if (inst == null) {
            return false;
        }
        AppointmentOrder order = orderMap.get(inst.getOrderId());
        if (order == null) {
            return false;
        }
        if (StringUtils.hasText(visitedUserNameKeyword)) {
            String keyword = visitedUserNameKeyword.trim();
            String visitorDisplayText = visitorDisplayMap.get(order.getId());
            if (!StringUtils.hasText(visitorDisplayText) || !visitorDisplayText.contains(keyword)) {
                return false;
            }
        }
        if (visitDate != null) {
            if (order.getVisitStartDate() == null || order.getVisitEndDate() == null) {
                return false;
            }
            if (visitDate.isBefore(order.getVisitStartDate()) || visitDate.isAfter(order.getVisitEndDate())) {
                return false;
            }
        }
        return true;
    }

    private Map<Long, String> loadVisitorDisplayMap(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 = loadVisitorCompanyMap(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 joined = entry.getValue().stream().distinct().collect(Collectors.joining(","));
            if (StringUtils.hasText(joined)) {
                result.put(entry.getKey(), joined);
            }
        }
        return result;
    }

    private Map<Long, String> loadVisitorCompanyMap(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> loadPlateTextMap(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 joined = entry.getValue().stream().distinct().collect(Collectors.joining(","));
            if (StringUtils.hasText(joined)) {
                result.put(entry.getKey(), joined);
            }
        }
        return result;
    }

    private Map<String, String> loadReasonNameMap(java.util.Collection<AppointmentOrder> orders) {
        Set<String> codes =
                orders.stream()
                        .map(AppointmentOrder::getVisitReasonCode)
                        .filter(StringUtils::hasText)
                        .map(String::trim)
                        .filter(code -> !"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));
    }

    private String buildVisitReasonText(AppointmentOrder order, Map<String, String> reasonNameMap) {
        String reasonCode = trimToNull(order.getVisitReasonCode());
        if (AppointmentBizConstants.VISIT_REASON_OTHER.equalsIgnoreCase(reasonCode)) {
            return "其他";
        }
        String reasonName = reasonNameMap.get(reasonCode);
        return StringUtils.hasText(reasonName) ? reasonName : reasonCode;
    }

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

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

    private <T> IPage<T> slicePage(long page, long size, List<T> 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<T> records = from >= to ? List.of() : rowsAll.subList(from, to);
        Page<T> out = new Page<>(current, pageSize);
        out.setTotal(total);
        out.setRecords(records);
        return out;
    }
}