package cn.iocoder.yudao.module.mes.service.pro.ai;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import cn.iocoder.yudao.module.ai.api.chat.AiChatApi;
import cn.iocoder.yudao.module.crm.api.customer.CrmCustomerApi;
import cn.iocoder.yudao.module.crm.api.customer.dto.CrmCustomerRespDTO;
import cn.iocoder.yudao.module.mdm.api.item.MdmItemApi;
import cn.iocoder.yudao.module.mdm.api.item.dto.MdmItemRespDTO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.ai.vo.*;
import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdProductBomDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.workstation.MesMdWorkstationMachineDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.feedback.MesProFeedbackDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.mps.MesProMpsDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.process.MesProProcessDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.task.MesProTaskDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.task.MesProTaskIssueDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.workorder.MesProWorkOrderBomDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.workorder.MesProWorkOrderDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.workorder.MesProWorkOrderProcessDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.ipqc.MesQcIpqcDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.wm.materialstock.MesWmMaterialStockDO;
import cn.iocoder.yudao.module.mes.dal.mysql.dv.machinery.MesDvMachineryMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.md.item.MesMdProductBomMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.md.workstation.MesMdWorkstationMachineMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.feedback.MesProFeedbackMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.mps.MesProMpsMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.task.MesProTaskIssueMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.task.MesProTaskMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.workorder.MesProWorkOrderBomMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.qc.ipqc.MesQcIpqcMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.wm.materialstock.MesWmMaterialStockMapper;
import cn.iocoder.yudao.module.mes.service.pro.mps.MesProMpsService;
import cn.iocoder.yudao.module.mes.service.pro.process.MesProProcessService;
import cn.iocoder.yudao.module.mes.service.pro.workorder.MesProWorkOrderProcessService;
import cn.iocoder.yudao.module.mes.service.pro.workorder.MesProWorkOrderService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.PRO_WORK_ORDER_NOT_EXISTS;

@Slf4j
@Service
public class MesProAiServiceImpl implements MesProAiService {

    // ==================== System Prompts ====================

    private static final String SYSTEM_PROMPT_MATERIAL = """
            你是一位资深的制造业物料管理专家，擅长分析生产工单的物料齐套性和短缺风险。
            你需要综合分析以下信息，给出专业的物料预测建议：

            ## 分析维度
            1. BOM 需求 vs 库存可用量：对比每个物料的预计使用量与当前库存可用量
            2. 库存可用量 = 在库数量 - 冻结数量 - 已占用数量
            3. 已投料情况：已经发放到工位的物料是否充足
            4. 风险评估：对有短缺风险的物料标注风险等级

            ## 风险等级定义
            - 充足：可用量 >= 需求量
            - 紧张：可用量 >= 需求量的50% 但 < 需求量
            - 短缺：可用量 < 需求量的50% 或可用量为0

            ## 输出格式
            请按以下JSON格式返回（不要包含其他内容）：
            {"riskLevel": 1, "reasoning": "综合分析...", "riskItems": [{"itemCode": "...", "itemName": "...", "requiredQuantity": 100.0, "availableQuantity": 50.0, "shortageQuantity": 50.0, "riskLevel": "紧张", "suggestion": "建议紧急采购或调拨"}]}

            riskLevel 取值：1=低风险 2=中风险 3=高风险
            """;

    private static final String SYSTEM_PROMPT_DURATION = """
            你是一位资深的生产计划专家，擅长预测生产工单的实际生产时长。
            你需要综合分析以下信息，给出专业的时长预测建议：

            ## 分析依据
            1. 标准工时：工艺路线设定的标准准备时间、等待时间、生产时间
            2. 设备效率：关联设备的每小时产量，传送履带倍率
            3. 生产数量：工单计划数量
            4. 实际历史数据：已完成工序的实际生产时长
            5. 计算公式：预测时长 = 准备时间 + 等待时间 + (计划数量 / (设备效率 * 传送履带系数))（效率单位为每小时产量）

            ## 输出格式
            请按以下JSON格式返回（不要包含其他内容）：
            {"predictedTotalHours": 48.5, "standardTotalHours": 40.0, "reasoning": "...", "keyPoints": ["关键工序A是瓶颈"], "processBreakdown": [{"processName": "...", "sort": 1, "standardPrepareTime": 30, "standardWaitTime": 15, "standardProductionTime": 8.0, "predictedProductionTime": 10.5}]}

            predictedTotalHours 和 standardTotalHours 为小数
            """;

    private static final String SYSTEM_PROMPT_RISK = """
            你是一位资深的制造风险管理专家，擅长识别生产过程中的各类风险。
            你需要综合分析以下信息，给出专业的风险评估：

            ## 分析维度
            1. 质量风险：过程检验(IPQC)的缺陷率数据（致命/严重/轻微缺陷率）
            2. 设备风险：设备状态、上次保养时间、上次点检时间、生产效率
            3. 物料风险：物料库存可用量与需求量的对比
            4. 工艺瓶颈：关键工序的设备产能、任务排队情况

            ## 风险等级定义
            - 高：存在致命缺陷率>5% 或 设备故障 或 关键物料短缺>50% 或 关键工序严重积压
            - 中：存在严重缺陷率>10% 或 设备长期未保养 或 物料紧张
            - 低：各项指标正常

            ## 输出格式
            请按以下JSON格式返回（不要包含其他内容）：
            {"overallRiskLevel": 2, "reasoning": "...", "keyPoints": ["关注点1"], "risks": [{"category": "设备", "description": "设备A上次保养距今已超30天", "severity": "中", "suggestion": "建议生产前保养"}]}

            overallRiskLevel 取值：1=低风险 2=中风险 3=高风险
            riskLevel 取值：充足/紧张/短缺
            severity 取值：高/中/低
            category 取值：质量/设备/物料/工艺瓶颈
            """;

    private static final String SYSTEM_PROMPT_DELIVERY = """
            你是一位资深的订单交付管理专家，擅长评估工单是否能按时交付。
            你需要综合分析以下信息，给出专业的交付评估：

            ## 分析依据
            1. 当前进度：已生产数量 / 计划数量的百分比
            2. 剩余时间：距离需求日期的天数（工作日按每天8小时计算）
            3. 预计剩余工时：根据工艺路线和设备效率预测的剩余生产时长
            4. 生产速度：根据已完成任务的实际生产速率
            5. 任务状态：各工序的完成情况

            ## 判定逻辑
            - 按时交付：剩余天数 * 8小时 >= 预计剩余工时，且进度正常
            - 有延期风险：剩余天数 * 8小时 >= 预计剩余工时的80%，但不足100%
            - 无法按时交付：剩余天数 * 8小时 < 预计剩余工时的80%，或关键工序卡阻

            ## 输出格式
            请按以下JSON格式返回（不要包含其他内容）：
            {"onTime": true, "confidence": 85.5, "reasoning": "...", "delayFactors": [], "progressPercent": 60.0, "remainingDays": 10}

            onTime: true=可按时交付 false=无法按时交付
            confidence: 0-100的数字，表示评估置信度
            """;

    // ==================== Dependencies ====================

    @Resource
    private MesProWorkOrderService workOrderService;
    @Resource
    private MesProWorkOrderBomMapper workOrderBomMapper;
    @Resource
    private MesMdProductBomMapper productBomMapper;
    @Resource
    private MesProWorkOrderProcessService workOrderProcessService;
    @Resource
    private MesProTaskMapper taskMapper;
    @Resource
    private MesProTaskIssueMapper taskIssueMapper;
    @Resource
    private MesProFeedbackMapper feedbackMapper;
    @Resource
    private MesQcIpqcMapper ipqcMapper;
    @Resource
    private MesWmMaterialStockMapper materialStockMapper;
    @Resource
    private MesMdWorkstationMachineMapper workstationMachineMapper;
    @Resource
    private MesDvMachineryMapper machineryMapper;
    @Resource
    private MesProMpsMapper mpsMapper;
    @Resource
    private MesProMpsService mpsService;
    @Resource
    private MesProProcessService processService;
    @Resource
    private MdmItemApi mdmItemApi;
    @Resource
    private CrmCustomerApi crmCustomerApi;
    @Autowired(required = false)
    private AiChatApi aiChatApi;

    // ==================== 1. 物料短缺预测 ====================

    @Override
    public MesProAiMaterialPredictRespVO predictMaterial(MesProAiMaterialPredictReqVO reqVO) {
        try {
            Map<String, Object> data;
            String logPrefix;
            if (reqVO.getMpsId() != null) {
                data = gatherMaterialDataFromMps(reqVO.getMpsId());
                logPrefix = "mpsId=" + reqVO.getMpsId();
            } else {
                data = gatherMaterialData(reqVO.getWorkOrderId());
                logPrefix = "workOrderId=" + reqVO.getWorkOrderId();
            }
            String aiResponse = aiChatApi.chat(SYSTEM_PROMPT_MATERIAL, JSONUtil.toJsonPrettyStr(data));
            log.info("AI 物料预测: {}, response={}", logPrefix, aiResponse);
            return parseMaterialResponse(aiResponse);
        } catch (Exception e) {
            log.warn("AI 物料预测失败，workOrderId={}, mpsId={}，切换本地规则核算",
                    reqVO.getWorkOrderId(), reqVO.getMpsId(), e);
            // AI 大模型未配置或调用失败时，退化为本地规则核算，保证功能可用
            return buildMaterialFallback(reqVO);
        }
    }

    /**
     * AI 不可用时的本地兜底：基于 BOM 需求量与实时库存可用量做确定性核算。
     *
     * 库存可用量 = 在库数量 - 冻结数量 - 已占用数量
     */
    private MesProAiMaterialPredictRespVO buildMaterialFallback(MesProAiMaterialPredictReqVO reqVO) {
        MesProAiMaterialPredictRespVO respVO = new MesProAiMaterialPredictRespVO();
        try {
            List<MaterialDemand> demands = reqVO.getMpsId() != null
                    ? buildMaterialDemandsFromMps(reqVO.getMpsId())
                    : buildMaterialDemandsFromWorkOrder(reqVO.getWorkOrderId());
            if (CollUtil.isEmpty(demands)) {
                respVO.setRiskLevel(1);
                respVO.setRiskItems(Collections.emptyList());
                respVO.setReasoning("AI 服务暂不可用，且未找到可核算的 BOM 物料，无法进行物料短缺预测。"
                        + "请先维护产品 BOM，或在「AI 大模型 - 模型管理」中配置可用的对话模型。");
                return respVO;
            }

            Map<Long, BigDecimal> stockMap = getAvailableStockMap(
                    demands.stream().map(MaterialDemand::itemId).collect(Collectors.toSet()));

            List<MesProAiMaterialPredictRespVO.RiskItem> riskItems = new ArrayList<>(demands.size());
            boolean hasShortage = false;
            boolean hasTight = false;
            int shortageCount = 0;
            for (MaterialDemand demand : demands) {
                BigDecimal required = demand.requiredQuantity();
                BigDecimal available = stockMap.getOrDefault(demand.itemId(), BigDecimal.ZERO);
                BigDecimal shortage = required.subtract(available).max(BigDecimal.ZERO);

                String level;
                String suggestion;
                if (shortage.compareTo(BigDecimal.ZERO) <= 0) {
                    level = "充足";
                    suggestion = "库存充足，无需补充";
                } else if (available.compareTo(required.multiply(BigDecimal.valueOf(0.5))) >= 0) {
                    level = "紧张";
                    suggestion = "库存偏紧，建议尽快采购或调拨，缺口 "
                            + shortage.stripTrailingZeros().toPlainString();
                    hasTight = true;
                } else {
                    level = "短缺";
                    suggestion = "库存不足，建议紧急采购或调拨，缺口 "
                            + shortage.stripTrailingZeros().toPlainString();
                    hasShortage = true;
                    shortageCount++;
                }

                MesProAiMaterialPredictRespVO.RiskItem item = new MesProAiMaterialPredictRespVO.RiskItem();
                MdmItemRespDTO itemInfo = getItemInfoQuietly(demand.itemId());
                item.setItemCode(itemInfo != null && StrUtil.isNotBlank(itemInfo.getCode())
                        ? itemInfo.getCode() : String.valueOf(demand.itemId()));
                item.setItemName(itemInfo != null && StrUtil.isNotBlank(itemInfo.getName())
                        ? itemInfo.getName() : "物料" + demand.itemId());
                item.setRequiredQuantity(required);
                item.setAvailableQuantity(available);
                item.setShortageQuantity(shortage);
                item.setRiskLevel(level);
                item.setSuggestion(suggestion);
                riskItems.add(item);
            }

            // 短缺项优先展示，缺口大的在前
            riskItems.sort(Comparator
                    .comparingInt((MesProAiMaterialPredictRespVO.RiskItem item) -> riskSeverity(item.getRiskLevel()))
                    .reversed()
                    .thenComparing(MesProAiMaterialPredictRespVO.RiskItem::getShortageQuantity,
                            Comparator.reverseOrder()));

            respVO.setRiskLevel(hasShortage ? 3 : (hasTight ? 2 : 1));
            respVO.setRiskItems(riskItems);
            String source = reqVO.getMpsId() != null ? "MPS 产品 BOM" : "工单 BOM";
            respVO.setReasoning(String.format(
                    "AI 大模型暂不可用，已自动切换本地规则引擎完成物料核算：基于%s与实时库存可用量"
                            + "（在库 - 冻结 - 已占用）逐项比对，共核算 %d 项物料，其中短缺 %d 项、紧张 %d 项。",
                    source, demands.size(), shortageCount, riskItems.size() - shortageCount - countSufficient(riskItems)));
        } catch (Exception e) {
            log.warn("本地物料核算失败，workOrderId={}, mpsId={}",
                    reqVO.getWorkOrderId(), reqVO.getMpsId(), e);
            respVO.setRiskLevel(1);
            respVO.setRiskItems(Collections.emptyList());
            respVO.setReasoning("AI 分析暂时不可用，且本地物料数据核算失败，请稍后重试或检查工单/MPS 数据。");
        }
        return respVO;
    }

    private List<MaterialDemand> buildMaterialDemandsFromWorkOrder(Long workOrderId) {
        if (workOrderId == null) {
            return Collections.emptyList();
        }
        List<MesProWorkOrderBomDO> bomList = workOrderBomMapper.selectListByWorkOrderId(workOrderId);
        if (CollUtil.isEmpty(bomList)) {
            return Collections.emptyList();
        }
        Map<Long, BigDecimal> demandByItem = new LinkedHashMap<>();
        for (MesProWorkOrderBomDO bom : bomList) {
            if (bom.getItemId() == null || bom.getQuantity() == null
                    || bom.getQuantity().compareTo(BigDecimal.ZERO) <= 0) {
                continue;
            }
            demandByItem.merge(bom.getItemId(), bom.getQuantity(), BigDecimal::add);
        }
        return toMaterialDemands(demandByItem);
    }

    private List<MaterialDemand> buildMaterialDemandsFromMps(Long mpsId) {
        if (mpsId == null) {
            return Collections.emptyList();
        }
        MesProMpsDO mps = mpsService.getMps(mpsId);
        if (mps == null) {
            return Collections.emptyList();
        }
        // 已下发工单时优先使用工单 BOM（更贴近实际生产需求）
        if (mps.getWorkOrderId() != null) {
            List<MaterialDemand> workOrderDemands = buildMaterialDemandsFromWorkOrder(mps.getWorkOrderId());
            if (CollUtil.isNotEmpty(workOrderDemands)) {
                return workOrderDemands;
            }
        }
        if (mps.getProductId() == null || mps.getQuantity() == null) {
            return Collections.emptyList();
        }
        BigDecimal produced = mps.getQuantityProduced() != null ? mps.getQuantityProduced() : BigDecimal.ZERO;
        BigDecimal remaining = mps.getQuantity().subtract(produced).max(BigDecimal.ZERO);
        if (remaining.compareTo(BigDecimal.ZERO) <= 0) {
            return Collections.emptyList();
        }
        List<MesMdProductBomDO> productBomList = productBomMapper.selectByItemId(mps.getProductId());
        if (CollUtil.isEmpty(productBomList)) {
            return Collections.emptyList();
        }
        Map<Long, BigDecimal> demandByItem = new LinkedHashMap<>();
        for (MesMdProductBomDO bom : productBomList) {
            if (bom.getBomItemId() == null || bom.getQuantity() == null
                    || bom.getQuantity().compareTo(BigDecimal.ZERO) <= 0) {
                continue;
            }
            demandByItem.merge(bom.getBomItemId(), remaining.multiply(bom.getQuantity()), BigDecimal::add);
        }
        return toMaterialDemands(demandByItem);
    }

    private List<MaterialDemand> toMaterialDemands(Map<Long, BigDecimal> demandByItem) {
        List<MaterialDemand> demands = new ArrayList<>(demandByItem.size());
        demandByItem.forEach((itemId, quantity) -> demands.add(new MaterialDemand(itemId, quantity)));
        return demands;
    }

    private Map<Long, BigDecimal> getAvailableStockMap(Collection<Long> itemIds) {
        if (CollUtil.isEmpty(itemIds)) {
            return Collections.emptyMap();
        }
        List<MesWmMaterialStockDO> stocks = materialStockMapper.selectList(
                new LambdaQueryWrapper<MesWmMaterialStockDO>()
                        .in(MesWmMaterialStockDO::getItemId, itemIds));
        Map<Long, BigDecimal> stockMap = new HashMap<>();
        for (MesWmMaterialStockDO stock : stocks) {
            if (stock.getItemId() == null || stock.getQuantity() == null) {
                continue;
            }
            BigDecimal frozen = stock.getFrozenQuantity() != null ? stock.getFrozenQuantity() : BigDecimal.ZERO;
            BigDecimal reserved = stock.getReservedQuantity() != null ? stock.getReservedQuantity() : BigDecimal.ZERO;
            BigDecimal available = stock.getQuantity().subtract(frozen).subtract(reserved);
            stockMap.merge(stock.getItemId(), available, BigDecimal::add);
        }
        stockMap.replaceAll((itemId, available) -> available.max(BigDecimal.ZERO));
        return stockMap;
    }

    private MdmItemRespDTO getItemInfoQuietly(Long itemId) {
        if (itemId == null) {
            return null;
        }
        try {
            return mdmItemApi.getItem(itemId).getCheckedData();
        } catch (Exception ignored) {
            return null;
        }
    }

    private int riskSeverity(String riskLevel) {
        return switch (riskLevel) {
            case "短缺" -> 3;
            case "紧张" -> 2;
            case "充足" -> 1;
            default -> 0;
        };
    }

    private long countSufficient(List<MesProAiMaterialPredictRespVO.RiskItem> riskItems) {
        return riskItems.stream().filter(item -> "充足".equals(item.getRiskLevel())).count();
    }

    private record MaterialDemand(Long itemId, BigDecimal requiredQuantity) {
    }

    private Map<String, Object> gatherMaterialData(Long workOrderId) {
        Map<String, Object> data = new LinkedHashMap<>();
        MesProWorkOrderDO workOrder = workOrderService.getWorkOrder(workOrderId);
        if (workOrder == null) throw exception(PRO_WORK_ORDER_NOT_EXISTS);

        data.put("工单编号", workOrder.getCode());
        data.put("工单名称", workOrder.getName());
        data.put("计划数量", workOrder.getQuantity());
        data.put("已生产数量", workOrder.getQuantityProduced());
        fillItemInfo(data, workOrder.getProductId());

        // BOM 物料需求
        List<MesProWorkOrderBomDO> bomList = workOrderBomMapper.selectListByWorkOrderId(workOrderId);
        if (CollUtil.isNotEmpty(bomList)) {
            List<Map<String, Object>> materials = new ArrayList<>();
            for (MesProWorkOrderBomDO bom : bomList) {
                Map<String, Object> item = new LinkedHashMap<>();
                item.put("物料ID", bom.getItemId());
                String itemName = resolveItemName(bom.getItemId());
                item.put("物料名称", itemName);
                item.put("需求量", bom.getQuantity());

                // 查询库存可用量
                List<MesWmMaterialStockDO> stocks = materialStockMapper.selectList(
                        new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<MesWmMaterialStockDO>()
                                .eq(MesWmMaterialStockDO::getItemId, bom.getItemId())
                                .ne(MesWmMaterialStockDO::getQuantity, BigDecimal.ZERO));
                BigDecimal available = BigDecimal.ZERO;
                if (CollUtil.isNotEmpty(stocks)) {
                    for (MesWmMaterialStockDO stock : stocks) {
                        BigDecimal frozen = stock.getFrozenQuantity() != null ? stock.getFrozenQuantity() : BigDecimal.ZERO;
                        BigDecimal reserved = stock.getReservedQuantity() != null ? stock.getReservedQuantity() : BigDecimal.ZERO;
                        available = available.add(stock.getQuantity().subtract(frozen).subtract(reserved));
                    }
                }
                item.put("库存可用量", available.compareTo(BigDecimal.ZERO) > 0 ? available : BigDecimal.ZERO);
                materials.add(item);
            }
            data.put("物料需求清单", materials);
        }

        // 已投料情况
        List<MesProTaskDO> tasks = taskMapper.selectListByWorkOrderId(workOrderId);
        if (CollUtil.isNotEmpty(tasks)) {
            List<Map<String, Object>> issuedMaterials = new ArrayList<>();
            for (MesProTaskDO task : tasks) {
                List<MesProTaskIssueDO> issues = taskIssueMapper.selectListByTaskId(task.getId());
                for (MesProTaskIssueDO issue : issues) {
                    Map<String, Object> issued = new LinkedHashMap<>();
                    issued.put("物料ID", issue.getItemId());
                    issued.put("已投料数量", issue.getIssuedQuantity());
                    issued.put("已使用数量", issue.getUsedQuantity());
                    issued.put("可用数量", issue.getAvailableQuantity());
                    issuedMaterials.add(issued);
                }
            }
            if (!issuedMaterials.isEmpty()) {
                data.put("已投料记录", issuedMaterials);
            }
        }

        return data;
    }

    private Map<String, Object> gatherMaterialDataFromMps(Long mpsId) {
        Map<String, Object> data = new LinkedHashMap<>();
        MesProMpsDO mps = mpsService.getMps(mpsId);
        if (mps == null) throw exception(PRO_WORK_ORDER_NOT_EXISTS);

        data.put("MPS 编号", mps.getCode());
        data.put("来源", "MPS 未下发，基于产品信息预测");
        data.put("计划数量", mps.getQuantity());
        data.put("已生产数量", mps.getQuantityProduced() != null ? mps.getQuantityProduced() : BigDecimal.ZERO);
        fillItemInfo(data, mps.getProductId());

        // 查询产品在库物料库存（通用，非工单特定 BOM）
        List<MesWmMaterialStockDO> stocks = materialStockMapper.selectList(
                new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<MesWmMaterialStockDO>()
                        .ne(MesWmMaterialStockDO::getQuantity, BigDecimal.ZERO));
        if (CollUtil.isNotEmpty(stocks)) {
            List<Map<String, Object>> materials = new ArrayList<>();
            for (MesWmMaterialStockDO stock : stocks) {
                Map<String, Object> item = new LinkedHashMap<>();
                item.put("物料ID", stock.getItemId());
                item.put("物料名称", resolveItemName(stock.getItemId()));
                item.put("库存可用量", stock.getQuantity());
                materials.add(item);
            }
            data.put("当前库存物料", materials);
        } else {
            data.put("提示", "暂无库存数据，请参考产品编码评估物料需求");
        }

        return data;
    }

    private MesProAiMaterialPredictRespVO parseMaterialResponse(String aiResponse) {
        MesProAiMaterialPredictRespVO respVO = new MesProAiMaterialPredictRespVO();
        try {
            String json = extractJson(aiResponse);
            Map<String, Object> parsed = JSONUtil.toBean(json, Map.class);
            Object riskLevel = parsed.get("riskLevel");
            if (riskLevel instanceof Number num) respVO.setRiskLevel(num.intValue());
            respVO.setReasoning((String) parsed.get("reasoning"));
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> items = (List<Map<String, Object>>) parsed.get("riskItems");
            if (CollUtil.isNotEmpty(items)) {
                respVO.setRiskItems(items.stream().map(m -> {
                    MesProAiMaterialPredictRespVO.RiskItem ri = new MesProAiMaterialPredictRespVO.RiskItem();
                    ri.setItemCode((String) m.get("itemCode"));
                    ri.setItemName((String) m.get("itemName"));
                    ri.setRequiredQuantity(toBigDecimal(m.get("requiredQuantity")));
                    ri.setAvailableQuantity(toBigDecimal(m.get("availableQuantity")));
                    ri.setShortageQuantity(toBigDecimal(m.get("shortageQuantity")));
                    ri.setRiskLevel((String) m.get("riskLevel"));
                    ri.setSuggestion((String) m.get("suggestion"));
                    return ri;
                }).collect(Collectors.toList()));
            }
        } catch (Exception e) {
            log.warn("解析 AI 物料预测响应失败: {}", aiResponse, e);
            respVO.setReasoning(aiResponse);
        }
        return respVO;
    }

    // ==================== 2. 生产时长预测 ====================

    @Override
    public MesProAiDurationPredictRespVO predictDuration(MesProAiDurationPredictReqVO reqVO) {
        Map<String, Object> data = null;
        String logPrefix;
        try {
            if (reqVO.getMpsId() != null) {
                data = gatherDurationDataFromMps(reqVO.getMpsId());
                logPrefix = "mpsId=" + reqVO.getMpsId();
            } else {
                data = gatherDurationData(reqVO.getWorkOrderId());
                logPrefix = "workOrderId=" + reqVO.getWorkOrderId();
            }
            String aiResponse = aiChatApi.chat(SYSTEM_PROMPT_DURATION, JSONUtil.toJsonPrettyStr(data));
            log.info("AI 时长预测: {}, response={}", logPrefix, aiResponse);
            return parseDurationResponse(aiResponse);
        } catch (Exception e) {
            log.warn("AI 时长预测失败，workOrderId={}, mpsId={}，切换本地规则估算",
                    reqVO.getWorkOrderId(), reqVO.getMpsId(), e);
            return buildDurationFallback(reqVO, data);
        }
    }

    /**
     * AI 不可用时的本地时长估算：标准准备/等待时间 + 计划数量 / 设备效率，生产时间预留 10% 缓冲。
     */
    private MesProAiDurationPredictRespVO buildDurationFallback(MesProAiDurationPredictReqVO reqVO,
                                                               Map<String, Object> gathered) {
        MesProAiDurationPredictRespVO respVO = new MesProAiDurationPredictRespVO();
        try {
            Map<String, Object> data = resolveWorkOrderId(reqVO.getWorkOrderId(), reqVO.getMpsId()) != null
                    ? gatherDurationData(resolveWorkOrderId(reqVO.getWorkOrderId(), reqVO.getMpsId()))
                    : gathered;
            DurationEstimate estimate = computeDurationEstimate(data);
            if (!estimate.hasProcessData()) {
                respVO.setPredictedTotalHours(BigDecimal.ZERO);
                respVO.setStandardTotalHours(BigDecimal.ZERO);
                respVO.setProcessBreakdown(Collections.emptyList());
                respVO.setKeyPoints(Collections.emptyList());
                respVO.setReasoning("AI 大模型暂不可用，且当前工单/MPS 没有可用的工序或设备数据，无法估算生产时长。"
                        + "请先维护工艺路线并完成排产，或在「AI 大模型 - 模型管理」中配置可用的对话模型。");
                return respVO;
            }
            respVO.setPredictedTotalHours(estimate.predictedHours());
            respVO.setStandardTotalHours(estimate.standardHours());
            respVO.setProcessBreakdown(estimate.breakdown());
            respVO.setKeyPoints(estimate.keyPoints());
            respVO.setReasoning("AI 大模型暂不可用，已自动切换本地规则引擎估算：按工艺路线标准准备/等待时间"
                    + "加上「剩余计划数量 ÷ 设备效率」计算生产时间，并对生产时间预留 10% 缓冲。");
        } catch (Exception e) {
            log.warn("本地时长估算失败，workOrderId={}, mpsId={}",
                    reqVO.getWorkOrderId(), reqVO.getMpsId(), e);
            respVO.setPredictedTotalHours(BigDecimal.ZERO);
            respVO.setStandardTotalHours(BigDecimal.ZERO);
            respVO.setProcessBreakdown(Collections.emptyList());
            respVO.setKeyPoints(Collections.emptyList());
            respVO.setReasoning("AI 分析暂时不可用，且本地工序数据核算失败，请稍后重试或检查工艺路线/排产数据。");
        }
        return respVO;
    }

    /** MPS 已下发时优先使用关联工单的数据 */
    private Long resolveWorkOrderId(Long workOrderId, Long mpsId) {
        if (workOrderId != null) {
            return workOrderId;
        }
        if (mpsId != null) {
            MesProMpsDO mps = mpsService.getMps(mpsId);
            if (mps != null) {
                return mps.getWorkOrderId();
            }
        }
        return null;
    }

    @SuppressWarnings("unchecked")
    private DurationEstimate computeDurationEstimate(Map<String, Object> data) {
        if (data == null) {
            return DurationEstimate.empty();
        }
        Object rawProcesses = data.get("工序明细");
        List<Map<String, Object>> processes = rawProcesses instanceof List<?>
                ? (List<Map<String, Object>>) rawProcesses : Collections.emptyList();
        if (CollUtil.isEmpty(processes)) {
            return DurationEstimate.empty();
        }
        BigDecimal prepareWaitHours = toBigDecimal(data.get("标准总准备+等待时间(小时)"));
        BigDecimal standardProduction = BigDecimal.ZERO;
        BigDecimal predictedProduction = BigDecimal.ZERO;
        List<MesProAiDurationPredictRespVO.ProcessTimeBreakdown> breakdown = new ArrayList<>(processes.size());
        List<String> keyPoints = new ArrayList<>();
        int missingEfficiency = 0;

        for (Map<String, Object> proc : processes) {
            MesProAiDurationPredictRespVO.ProcessTimeBreakdown item =
                    new MesProAiDurationPredictRespVO.ProcessTimeBreakdown();
            String processName = (String) proc.get("工序名称");
            item.setProcessName(processName);
            item.setSort(toInteger(proc.get("顺序")));
            item.setStandardPrepareTime(toInteger(proc.get("标准准备时间(分钟)")));
            item.setStandardWaitTime(toInteger(proc.get("标准等待时间(分钟)")));

            BigDecimal productionHours = proc.get("预计生产时间(小时)") != null
                    ? toBigDecimal(proc.get("预计生产时间(小时)")) : BigDecimal.ZERO;
            BigDecimal predictedHours = productionHours.multiply(BigDecimal.valueOf(1.1));
            standardProduction = standardProduction.add(productionHours);
            predictedProduction = predictedProduction.add(predictedHours);

            item.setStandardProductionTime(productionHours.setScale(2, RoundingMode.HALF_UP));
            item.setPredictedProductionTime(predictedHours.setScale(2, RoundingMode.HALF_UP));
            breakdown.add(item);

            if (productionHours.compareTo(BigDecimal.ZERO) <= 0) {
                missingEfficiency++;
            }
            if (Boolean.TRUE.equals(proc.get("是否关键工序"))) {
                keyPoints.add(String.format("关键工序「%s」预计 %.2f 小时（含 10%% 缓冲）",
                        processName, predictedHours.doubleValue()));
            }
        }
        if (missingEfficiency > 0) {
            keyPoints.add(String.format("有 %d 道工序缺少设备效率或排产数据，生产时间按 0 计，建议补齐设备产能后重新预测",
                    missingEfficiency));
        }
        BigDecimal standardHours = prepareWaitHours.add(standardProduction).setScale(2, RoundingMode.HALF_UP);
        BigDecimal predictedHours = prepareWaitHours.add(predictedProduction).setScale(2, RoundingMode.HALF_UP);
        return new DurationEstimate(standardHours, predictedHours, breakdown, keyPoints, true);
    }

    private record DurationEstimate(BigDecimal standardHours, BigDecimal predictedHours,
                                    List<MesProAiDurationPredictRespVO.ProcessTimeBreakdown> breakdown,
                                    List<String> keyPoints, boolean hasProcessData) {

        private static DurationEstimate empty() {
            return new DurationEstimate(BigDecimal.ZERO, BigDecimal.ZERO,
                    Collections.emptyList(), Collections.emptyList(), false);
        }
    }

    private Map<String, Object> gatherDurationData(Long workOrderId) {
        Map<String, Object> data = new LinkedHashMap<>();
        MesProWorkOrderDO workOrder = workOrderService.getWorkOrder(workOrderId);
        if (workOrder == null) throw exception(PRO_WORK_ORDER_NOT_EXISTS);

        data.put("工单编号", workOrder.getCode());
        data.put("计划数量", workOrder.getQuantity());
        data.put("已生产数量", workOrder.getQuantityProduced());
        fillItemInfo(data, workOrder.getProductId());

        // 工序信息
        List<MesProWorkOrderProcessDO> processes = workOrderProcessService.getWorkOrderProcessListByWorkOrderId(workOrderId);
        List<MesProTaskDO> tasks = taskMapper.selectListByWorkOrderId(workOrderId);
        Map<Long, MesProTaskDO> taskByProcessId = new HashMap<>();
        if (CollUtil.isNotEmpty(tasks)) {
            for (MesProTaskDO task : tasks) {
                if (task.getProcessId() != null) {
                    taskByProcessId.put(task.getProcessId(), task);
                }
            }
        }

        List<Map<String, Object>> processList = new ArrayList<>();
        BigDecimal standardTotalHours = BigDecimal.ZERO;
        for (MesProWorkOrderProcessDO proc : processes) {
            Map<String, Object> item = new LinkedHashMap<>();
            String processName = resolveProcessName(proc.getProcessId());
            item.put("工序名称", processName);
            item.put("顺序", proc.getSort());
            item.put("标准准备时间(分钟)", proc.getPrepareTime() != null ? proc.getPrepareTime() : 0);
            item.put("标准等待时间(分钟)", proc.getWaitTime() != null ? proc.getWaitTime() : 0);
            item.put("是否关键工序", proc.getKeyFlag() != null && proc.getKeyFlag());
            item.put("是否质检工序", proc.getCheckFlag() != null && proc.getCheckFlag());

            // 设备效率
            MesProTaskDO task = taskByProcessId.get(proc.getProcessId());
            if (task != null && task.getWorkstationId() != null) {
                BigDecimal totalEfficiency = getWorkstationEfficiency(task.getWorkstationId());
                item.put("设备总效率(件/小时)", totalEfficiency);
                if (totalEfficiency.compareTo(BigDecimal.ZERO) > 0) {
                    BigDecimal productionHours = workOrder.getQuantity()
                            .subtract(workOrder.getQuantityProduced() != null ? workOrder.getQuantityProduced() : BigDecimal.ZERO)
                            .divide(totalEfficiency, 4, RoundingMode.HALF_UP);
                    item.put("预计生产时间(小时)", productionHours);
                }
                item.put("任务状态", task.getStatus());
                if (task.getDuration() != null) item.put("已用时长(小时)", task.getDuration());
            } else {
                item.put("设备总效率(件/小时)", "未排产无设备数据");
            }

            // 标准时间
            int prepareMin = proc.getPrepareTime() != null ? proc.getPrepareTime() : 0;
            int waitMin = proc.getWaitTime() != null ? proc.getWaitTime() : 0;
            BigDecimal standardHours = BigDecimal.valueOf(prepareMin + waitMin).divide(BigDecimal.valueOf(60), 4, RoundingMode.HALF_UP);
            standardTotalHours = standardTotalHours.add(standardHours);
            item.put("标准准备+等待时间(小时)", standardHours);

            processList.add(item);
        }
        data.put("工序明细", processList);
        data.put("标准总准备+等待时间(小时)", standardTotalHours);

        return data;
    }

    private BigDecimal getWorkstationEfficiency(Long workstationId) {
        BigDecimal totalEfficiency = BigDecimal.ZERO;
        List<MesMdWorkstationMachineDO> machines = workstationMachineMapper.selectListByWorkstationId(workstationId);
        if (CollUtil.isNotEmpty(machines)) {
            for (MesMdWorkstationMachineDO wm : machines) {
                MesDvMachineryDO machinery = machineryMapper.selectById(wm.getMachineryId());
                if (machinery != null && machinery.getProductionEfficiency() != null) {
                    BigDecimal efficiency = machinery.getProductionEfficiency();
                    if (machinery.getConveyorBelt() != null && machinery.getConveyorBelt() > 0) {
                        efficiency = efficiency.multiply(BigDecimal.valueOf(machinery.getConveyorBelt()));
                    }
                    totalEfficiency = totalEfficiency.add(efficiency);
                }
            }
        }
        return totalEfficiency;
    }

    private Map<String, Object> gatherDurationDataFromMps(Long mpsId) {
        Map<String, Object> data = new LinkedHashMap<>();
        MesProMpsDO mps = mpsService.getMps(mpsId);
        if (mps == null) throw exception(PRO_WORK_ORDER_NOT_EXISTS);

        data.put("MPS 编号", mps.getCode());
        data.put("来源", "MPS 未下发，基于产品信息估算");
        data.put("计划数量", mps.getQuantity());
        data.put("已生产数量", mps.getQuantityProduced() != null ? mps.getQuantityProduced() : BigDecimal.ZERO);
        data.put("需求日期", mps.getRequestDate() != null ? mps.getRequestDate().toString() : "未设置");
        fillItemInfo(data, mps.getProductId());
        data.put("提示", "MPS 未关联工单工序，请基于产品编码和经验估算生产时长");

        return data;
    }

    private MesProAiDurationPredictRespVO parseDurationResponse(String aiResponse) {
        MesProAiDurationPredictRespVO respVO = new MesProAiDurationPredictRespVO();
        try {
            String json = extractJson(aiResponse);
            Map<String, Object> parsed = JSONUtil.toBean(json, Map.class);
            respVO.setPredictedTotalHours(toBigDecimal(parsed.get("predictedTotalHours")));
            respVO.setStandardTotalHours(toBigDecimal(parsed.get("standardTotalHours")));
            respVO.setReasoning((String) parsed.get("reasoning"));
            @SuppressWarnings("unchecked")
            List<String> keyPoints = (List<String>) parsed.get("keyPoints");
            respVO.setKeyPoints(keyPoints);
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> breakdown = (List<Map<String, Object>>) parsed.get("processBreakdown");
            if (CollUtil.isNotEmpty(breakdown)) {
                respVO.setProcessBreakdown(breakdown.stream().map(m -> {
                    MesProAiDurationPredictRespVO.ProcessTimeBreakdown pt = new MesProAiDurationPredictRespVO.ProcessTimeBreakdown();
                    pt.setProcessName((String) m.get("processName"));
                    pt.setSort(toInteger(m.get("sort")));
                    pt.setStandardPrepareTime(toInteger(m.get("standardPrepareTime")));
                    pt.setStandardWaitTime(toInteger(m.get("standardWaitTime")));
                    pt.setStandardProductionTime(toBigDecimal(m.get("standardProductionTime")));
                    pt.setPredictedProductionTime(toBigDecimal(m.get("predictedProductionTime")));
                    return pt;
                }).collect(Collectors.toList()));
            }
        } catch (Exception e) {
            log.warn("解析 AI 时长预测响应失败: {}", aiResponse, e);
            respVO.setReasoning(aiResponse);
        }
        return respVO;
    }

    // ==================== 3. 生产风险预测 ====================

    @Override
    public MesProAiRiskPredictRespVO predictRisk(MesProAiRiskPredictReqVO reqVO) {
        Map<String, Object> data = null;
        String logPrefix;
        try {
            if (reqVO.getMpsId() != null) {
                data = gatherRiskDataFromMps(reqVO.getMpsId());
                logPrefix = "mpsId=" + reqVO.getMpsId();
            } else {
                data = gatherRiskData(reqVO.getWorkOrderId());
                logPrefix = "workOrderId=" + reqVO.getWorkOrderId();
            }
            String aiResponse = aiChatApi.chat(SYSTEM_PROMPT_RISK, JSONUtil.toJsonPrettyStr(data));
            log.info("AI 风险预测: {}, response={}", logPrefix, aiResponse);
            return parseRiskResponse(aiResponse);
        } catch (Exception e) {
            log.warn("AI 风险预测失败，workOrderId={}, mpsId={}，切换本地规则评估",
                    reqVO.getWorkOrderId(), reqVO.getMpsId(), e);
            return buildRiskFallback(reqVO, data);
        }
    }

    /**
     * AI 不可用时的本地风险评估：IPQC 缺陷率 + 设备状态/保养点检 + 物料可用量 + 关键工序。
     */
    private MesProAiRiskPredictRespVO buildRiskFallback(MesProAiRiskPredictReqVO reqVO,
                                                       Map<String, Object> gathered) {
        MesProAiRiskPredictRespVO respVO = new MesProAiRiskPredictRespVO();
        try {
            Long effectiveWorkOrderId = resolveWorkOrderId(reqVO.getWorkOrderId(), reqVO.getMpsId());
            Map<String, Object> data = effectiveWorkOrderId != null
                    ? gatherRiskData(effectiveWorkOrderId) : gathered;
            List<MesProAiRiskPredictRespVO.RiskItem> risks = new ArrayList<>();
            List<String> keyPoints = new ArrayList<>();

            if (data == null) {
                respVO.setOverallRiskLevel(1);
                respVO.setRisks(Collections.emptyList());
                respVO.setKeyPoints(Collections.emptyList());
                respVO.setReasoning("AI 服务暂不可用，且未获取到工单/MPS 风险数据，无法评估。");
                return respVO;
            }

            // 1. 质量风险
            for (Map<String, Object> qc : asMapList(data.get("过程检验(IPQC)记录"))) {
                BigDecimal critical = parsePercent(qc.get("致命缺陷率"));
                BigDecimal major = parsePercent(qc.get("严重缺陷率"));
                BigDecimal minor = parsePercent(qc.get("轻微缺陷率"));
                String code = StrUtil.blankToDefault((String) qc.get("检验单编号"), "过程检验单");
                if (critical.compareTo(BigDecimal.valueOf(5)) > 0) {
                    risks.add(risk("质量", String.format("%s 致命缺陷率 %s%%，超过 5%% 阈值", code, critical.stripTrailingZeros().toPlainString()),
                            "高", "建议立即停线排查，对已生产批次进行隔离复检"));
                } else if (major.compareTo(BigDecimal.TEN) > 0) {
                    risks.add(risk("质量", String.format("%s 严重缺陷率 %s%%，超过 10%% 阈值", code, major.stripTrailingZeros().toPlainString()),
                            "中", "建议分析缺陷根因并加强过程管控"));
                } else if (critical.compareTo(BigDecimal.ZERO) > 0 || major.compareTo(BigDecimal.ZERO) > 0
                        || minor.compareTo(BigDecimal.ZERO) > 0) {
                    risks.add(risk("质量", String.format("%s 存在不良品（致命 %s%%、严重 %s%%、轻微 %s%%）",
                                    code, critical.stripTrailingZeros().toPlainString(),
                                    major.stripTrailingZeros().toPlainString(),
                                    minor.stripTrailingZeros().toPlainString()),
                            "低", "建议持续跟踪检验数据，关注缺陷率变化趋势"));
                }
            }

            // 2. 设备风险
            for (Map<String, Object> eq : asMapList(data.get("关联设备信息"))) {
                String name = StrUtil.blankToDefault((String) eq.get("设备名称"),
                        String.valueOf(eq.get("设备编号")));
                int status = toInteger(eq.get("设备状态"));
                if (status == 1) {
                    risks.add(risk("设备", name + " 当前处于停机状态", "高",
                            "建议生产前确认停机原因并完成恢复，避免影响开工"));
                } else if (status == 3) {
                    risks.add(risk("设备", name + " 当前处于维护中", "中",
                            "建议确认维护完成时间，必要时调整排产计划"));
                }
                Long maintenanceDays = daysSince(eq.get("上次保养时间"));
                if (maintenanceDays != null && maintenanceDays > 30) {
                    risks.add(risk("设备", String.format("%s 已 %d 天未保养", name, maintenanceDays), "中",
                            "建议在生产前安排保养，降低设备故障风险"));
                }
                Long checkDays = daysSince(eq.get("上次点检时间"));
                if (checkDays != null && checkDays > 14) {
                    risks.add(risk("设备", String.format("%s 已 %d 天未点检", name, checkDays), "低",
                            "建议开工前完成设备点检"));
                }
            }

            // 3. 物料风险
            for (Map<String, Object> material : asMapList(data.get("物料短缺风险"))) {
                BigDecimal required = toBigDecimal(material.get("需求量"));
                BigDecimal available = toBigDecimal(material.get("可用量"));
                BigDecimal shortage = required.subtract(available).max(BigDecimal.ZERO);
                if (shortage.compareTo(BigDecimal.ZERO) <= 0) {
                    continue;
                }
                boolean severe = available.compareTo(required.multiply(BigDecimal.valueOf(0.5))) < 0;
                risks.add(risk("物料", String.format("%s 需求 %s、可用 %s，缺口 %s",
                                material.get("物料名称"), required.stripTrailingZeros().toPlainString(),
                                available.stripTrailingZeros().toPlainString(),
                                shortage.stripTrailingZeros().toPlainString()),
                        severe ? "高" : "中",
                        severe ? "建议紧急采购或调拨，避免影响开工" : "建议尽快补充采购或内部调拨"));
            }

            // 3.1 MPS 未下发时，按产品 BOM 补充物料风险
            if (effectiveWorkOrderId == null && reqVO.getMpsId() != null) {
                List<MaterialDemand> demands = buildMaterialDemandsFromMps(reqVO.getMpsId());
                Map<Long, BigDecimal> stockMap = getAvailableStockMap(
                        demands.stream().map(MaterialDemand::itemId).collect(Collectors.toSet()));
                for (MaterialDemand demand : demands) {
                    BigDecimal available = stockMap.getOrDefault(demand.itemId(), BigDecimal.ZERO);
                    BigDecimal shortage = demand.requiredQuantity().subtract(available).max(BigDecimal.ZERO);
                    if (shortage.compareTo(BigDecimal.ZERO) <= 0) {
                        continue;
                    }
                    boolean severe = available.compareTo(
                            demand.requiredQuantity().multiply(BigDecimal.valueOf(0.5))) < 0;
                    risks.add(risk("物料", String.format("物料 %s 需求 %s、可用 %s，缺口 %s",
                                    resolveItemName(demand.itemId()),
                                    demand.requiredQuantity().stripTrailingZeros().toPlainString(),
                                    available.stripTrailingZeros().toPlainString(),
                                    shortage.stripTrailingZeros().toPlainString()),
                            severe ? "高" : "中",
                            severe ? "建议紧急采购或调拨" : "建议尽快补充采购或内部调拨"));
                }
            }

            // 4. 关键工序关注点
            for (Map<String, Object> proc : asMapList(data.get("关键工序"))) {
                keyPoints.add(String.format("关键工序「%s」（顺序 %s）需重点关注产能与排队情况",
                        proc.get("工序名称"), proc.get("顺序")));
            }
            keyPoints.removeIf(StrUtil::isBlank);

            int overallLevel = risks.stream()
                    .mapToInt(item -> severityRank(item.getSeverity()))
                    .max().orElse(1);
            respVO.setOverallRiskLevel(overallLevel);
            respVO.setRisks(risks);
            respVO.setKeyPoints(keyPoints);
            if (risks.isEmpty()) {
                respVO.setReasoning("AI 大模型暂不可用，已自动切换本地规则引擎：综合 IPQC 缺陷率、设备状态与保养点检、"
                        + "物料可用量及关键工序进行评估，未发现明显风险。");
            } else {
                respVO.setReasoning(String.format(
                        "AI 大模型暂不可用，已自动切换本地规则引擎：综合 IPQC 缺陷率、设备状态与保养点检、"
                                + "物料可用量及关键工序进行评估，共识别 %d 项风险，整体风险等级为%s。",
                        risks.size(), overallLevel == 3 ? "高风险" : (overallLevel == 2 ? "中风险" : "低风险")));
            }
        } catch (Exception e) {
            log.warn("本地风险评估失败，workOrderId={}, mpsId={}",
                    reqVO.getWorkOrderId(), reqVO.getMpsId(), e);
            respVO.setOverallRiskLevel(1);
            respVO.setRisks(Collections.emptyList());
            respVO.setKeyPoints(Collections.emptyList());
            respVO.setReasoning("AI 分析暂时不可用，且本地风险数据核算失败，请稍后重试或检查工单数据。");
        }
        return respVO;
    }

    private MesProAiRiskPredictRespVO.RiskItem risk(String category, String description,
                                                     String severity, String suggestion) {
        MesProAiRiskPredictRespVO.RiskItem item = new MesProAiRiskPredictRespVO.RiskItem();
        item.setCategory(category);
        item.setDescription(description);
        item.setSeverity(severity);
        item.setSuggestion(suggestion);
        return item;
    }

    private Map<String, Object> gatherRiskData(Long workOrderId) {
        Map<String, Object> data = new LinkedHashMap<>();
        MesProWorkOrderDO workOrder = workOrderService.getWorkOrder(workOrderId);
        if (workOrder == null) throw exception(PRO_WORK_ORDER_NOT_EXISTS);

        data.put("工单编号", workOrder.getCode());
        data.put("工单名称", workOrder.getName());
        data.put("计划数量", workOrder.getQuantity());
        data.put("已生产数量", workOrder.getQuantityProduced());
        fillItemInfo(data, workOrder.getProductId());

        // 质量风险 - IPQC
        List<MesQcIpqcDO> ipqcList = ipqcMapper.selectList(
                new LambdaQueryWrapper<MesQcIpqcDO>()
                        .eq(MesQcIpqcDO::getWorkOrderId, workOrderId));
        if (CollUtil.isNotEmpty(ipqcList)) {
            List<Map<String, Object>> qcData = ipqcList.stream().map(ipqc -> {
                Map<String, Object> item = new LinkedHashMap<>();
                item.put("检验单编号", ipqc.getCode());
                item.put("致命缺陷率", ipqc.getCriticalRate() != null ? ipqc.getCriticalRate() + "%" : "0%");
                item.put("严重缺陷率", ipqc.getMajorRate() != null ? ipqc.getMajorRate() + "%" : "0%");
                item.put("轻微缺陷率", ipqc.getMinorRate() != null ? ipqc.getMinorRate() + "%" : "0%");
                item.put("致命缺陷数", ipqc.getCriticalQuantity() != null ? ipqc.getCriticalQuantity() : 0);
                item.put("严重缺陷数", ipqc.getMajorQuantity() != null ? ipqc.getMajorQuantity() : 0);
                item.put("轻微缺陷数", ipqc.getMinorQuantity() != null ? ipqc.getMinorQuantity() : 0);
                item.put("检验结果", ipqc.getCheckResult());
                return item;
            }).collect(Collectors.toList());
            data.put("过程检验(IPQC)记录", qcData);
        }

        // 设备风险
        List<MesProTaskDO> tasks = taskMapper.selectListByWorkOrderId(workOrderId);
        if (CollUtil.isNotEmpty(tasks)) {
            Set<Long> machineryIds = new HashSet<>();
            for (MesProTaskDO task : tasks) {
                if (task.getWorkstationId() != null) {
                    List<MesMdWorkstationMachineDO> wms = workstationMachineMapper.selectListByWorkstationId(task.getWorkstationId());
                    for (MesMdWorkstationMachineDO wm : wms) {
                        machineryIds.add(wm.getMachineryId());
                    }
                }
            }
            if (!machineryIds.isEmpty()) {
                List<Map<String, Object>> equipmentData = new ArrayList<>();
                for (Long mid : machineryIds) {
                    MesDvMachineryDO machinery = machineryMapper.selectById(mid);
                    if (machinery != null) {
                        Map<String, Object> eq = new LinkedHashMap<>();
                        eq.put("设备编号", machinery.getCode());
                        eq.put("设备名称", machinery.getName());
                        eq.put("设备状态", machinery.getStatus());
                        eq.put("生产效率(件/小时)", machinery.getProductionEfficiency());
                        eq.put("传送履带倍数", machinery.getConveyorBelt());
                        eq.put("上次保养时间", machinery.getLastMaintenTime() != null
                                ? machinery.getLastMaintenTime().toString() : "无记录");
                        eq.put("上次点检时间", machinery.getLastCheckTime() != null
                                ? machinery.getLastCheckTime().toString() : "无记录");
                        equipmentData.add(eq);
                    }
                }
                data.put("关联设备信息", equipmentData);
            }
        }

        // 物料风险（轻量级：仅标记可用量 < 20%的物料）
        List<MesProWorkOrderBomDO> bomList = workOrderBomMapper.selectListByWorkOrderId(workOrderId);
        if (CollUtil.isNotEmpty(bomList)) {
            List<Map<String, Object>> materialRisks = new ArrayList<>();
            for (MesProWorkOrderBomDO bom : bomList) {
                List<MesWmMaterialStockDO> stocks = materialStockMapper.selectList(
                        new LambdaQueryWrapper<MesWmMaterialStockDO>()
                                .eq(MesWmMaterialStockDO::getItemId, bom.getItemId())
                                .ne(MesWmMaterialStockDO::getQuantity, BigDecimal.ZERO));
                BigDecimal available = BigDecimal.ZERO;
                if (CollUtil.isNotEmpty(stocks)) {
                    for (MesWmMaterialStockDO stock : stocks) {
                        BigDecimal frozen = stock.getFrozenQuantity() != null ? stock.getFrozenQuantity() : BigDecimal.ZERO;
                        BigDecimal reserved = stock.getReservedQuantity() != null ? stock.getReservedQuantity() : BigDecimal.ZERO;
                        available = available.add(stock.getQuantity().subtract(frozen).subtract(reserved));
                    }
                }
                if (bom.getQuantity() != null && bom.getQuantity().compareTo(BigDecimal.ZERO) > 0
                        && available.compareTo(bom.getQuantity().multiply(BigDecimal.valueOf(0.2))) < 0) {
                    Map<String, Object> risk = new LinkedHashMap<>();
                    risk.put("物料ID", bom.getItemId());
                    risk.put("物料名称", resolveItemName(bom.getItemId()));
                    risk.put("需求量", bom.getQuantity());
                    risk.put("可用量", available);
                    risk.put("缺口比例", available.compareTo(BigDecimal.ZERO) > 0
                            ? BigDecimal.ONE.subtract(available.divide(bom.getQuantity(), 2, RoundingMode.HALF_UP)).multiply(BigDecimal.valueOf(100)) + "%"
                            : "100%");
                    materialRisks.add(risk);
                }
            }
            if (!materialRisks.isEmpty()) {
                data.put("物料短缺风险", materialRisks);
            }
        }

        // 工艺瓶颈 - 关键工序信息
        List<MesProWorkOrderProcessDO> processes = workOrderProcessService.getWorkOrderProcessListByWorkOrderId(workOrderId);
        if (CollUtil.isNotEmpty(processes)) {
            List<Map<String, Object>> keyProcesses = new ArrayList<>();
            for (MesProWorkOrderProcessDO proc : processes) {
                if (proc.getKeyFlag() != null && proc.getKeyFlag()) {
                    Map<String, Object> kp = new LinkedHashMap<>();
                    kp.put("工序名称", resolveProcessName(proc.getProcessId()));
                    kp.put("顺序", proc.getSort());
                    kp.put("标准准备时间(分钟)", proc.getPrepareTime());
                    kp.put("标准等待时间(分钟)", proc.getWaitTime());
                    keyProcesses.add(kp);
                }
            }
            if (!keyProcesses.isEmpty()) {
                data.put("关键工序", keyProcesses);
            }
        }

        return data;
    }

    private Map<String, Object> gatherRiskDataFromMps(Long mpsId) {
        Map<String, Object> data = new LinkedHashMap<>();
        MesProMpsDO mps = mpsService.getMps(mpsId);
        if (mps == null) throw exception(PRO_WORK_ORDER_NOT_EXISTS);

        data.put("MPS 编号", mps.getCode());
        data.put("来源", "MPS 未下发，风险评估基于产品信息");
        data.put("计划数量", mps.getQuantity());
        data.put("已生产数量", mps.getQuantityProduced() != null ? mps.getQuantityProduced() : BigDecimal.ZERO);
        data.put("需求日期", mps.getRequestDate() != null ? mps.getRequestDate().toString() : "未设置");
        data.put("下发日期", mps.getIssueDate() != null ? mps.getIssueDate().toString() : "未下发");
        fillItemInfo(data, mps.getProductId());

        // 产品库存情况
        List<MesWmMaterialStockDO> stocks = materialStockMapper.selectList(
                new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<MesWmMaterialStockDO>()
                        .ne(MesWmMaterialStockDO::getQuantity, BigDecimal.ZERO));
        if (CollUtil.isNotEmpty(stocks)) {
            List<Map<String, Object>> stockList = new ArrayList<>();
            for (MesWmMaterialStockDO stock : stocks) {
                Map<String, Object> item = new LinkedHashMap<>();
                item.put("物料ID", stock.getItemId());
                item.put("物料名称", resolveItemName(stock.getItemId()));
                item.put("可用量", stock.getQuantity());
                stockList.add(item);
            }
            data.put("库存物料", stockList);
        }

        data.put("提示", "MPS 未下发无工单数据，请结合产品特性和库存自行判断风险");

        return data;
    }

    private MesProAiRiskPredictRespVO parseRiskResponse(String aiResponse) {
        MesProAiRiskPredictRespVO respVO = new MesProAiRiskPredictRespVO();
        try {
            String json = extractJson(aiResponse);
            Map<String, Object> parsed = JSONUtil.toBean(json, Map.class);
            Object riskLevel = parsed.get("overallRiskLevel");
            if (riskLevel instanceof Number num) respVO.setOverallRiskLevel(num.intValue());
            respVO.setReasoning((String) parsed.get("reasoning"));
            @SuppressWarnings("unchecked")
            List<String> keyPoints = (List<String>) parsed.get("keyPoints");
            respVO.setKeyPoints(keyPoints);
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> risks = (List<Map<String, Object>>) parsed.get("risks");
            if (CollUtil.isNotEmpty(risks)) {
                respVO.setRisks(risks.stream().map(m -> {
                    MesProAiRiskPredictRespVO.RiskItem ri = new MesProAiRiskPredictRespVO.RiskItem();
                    ri.setCategory((String) m.get("category"));
                    ri.setDescription((String) m.get("description"));
                    ri.setSeverity((String) m.get("severity"));
                    ri.setSuggestion((String) m.get("suggestion"));
                    return ri;
                }).collect(Collectors.toList()));
            }
        } catch (Exception e) {
            log.warn("解析 AI 风险预测响应失败: {}", aiResponse, e);
            respVO.setReasoning(aiResponse);
        }
        return respVO;
    }

    // ==================== 4. 是否能按时交付 ====================

    @Override
    public MesProAiDeliveryPredictRespVO predictDelivery(MesProAiDeliveryPredictReqVO reqVO) {
        Map<String, Object> data = null;
        String logPrefix;
        try {
            if (reqVO.getMpsId() != null) {
                data = gatherDeliveryDataFromMps(reqVO.getMpsId());
                logPrefix = "mpsId=" + reqVO.getMpsId();
            } else {
                data = gatherDeliveryData(reqVO.getWorkOrderId());
                logPrefix = "workOrderId=" + reqVO.getWorkOrderId();
            }
            String aiResponse = aiChatApi.chat(SYSTEM_PROMPT_DELIVERY, JSONUtil.toJsonPrettyStr(data));
            log.info("AI 交付预测: {}, response={}", logPrefix, aiResponse);
            return parseDeliveryResponse(aiResponse);
        } catch (Exception e) {
            log.warn("AI 交付预测失败，workOrderId={}, mpsId={}，切换本地规则评估",
                    reqVO.getWorkOrderId(), reqVO.getMpsId(), e);
            return buildDeliveryFallback(reqVO, data);
        }
    }

    /**
     * AI 不可用时的本地交付评估：生产进度 + 剩余交期（按 8 小时/天）+ 剩余预测工时 + 物料缺口。
     */
    private MesProAiDeliveryPredictRespVO buildDeliveryFallback(MesProAiDeliveryPredictReqVO reqVO,
                                                               Map<String, Object> gathered) {
        MesProAiDeliveryPredictRespVO respVO = new MesProAiDeliveryPredictRespVO();
        List<String> delayFactors = new ArrayList<>();
        try {
            Long effectiveWorkOrderId = resolveWorkOrderId(reqVO.getWorkOrderId(), reqVO.getMpsId());
            Map<String, Object> data = effectiveWorkOrderId != null
                    ? gatherDeliveryData(effectiveWorkOrderId) : gathered;
            if (data == null) {
                respVO.setOnTime(false);
                respVO.setConfidence(0D);
                respVO.setProgressPercent(BigDecimal.ZERO);
                respVO.setRemainingDays(0);
                respVO.setDelayFactors(Collections.emptyList());
                respVO.setReasoning("AI 服务暂不可用，且未获取到工单/MPS 进度数据，无法评估交付。");
                return respVO;
            }

            BigDecimal progressPercent = toBigDecimal(data.get("生产进度(%)"));
            int remainingDays = toInteger(data.get("距离需求日期剩余天数"));
            respVO.setProgressPercent(progressPercent);
            respVO.setRemainingDays(remainingDays);

            if (progressPercent.compareTo(BigDecimal.valueOf(100)) >= 0) {
                respVO.setOnTime(true);
                respVO.setConfidence(99D);
                respVO.setDelayFactors(Collections.emptyList());
                respVO.setReasoning("AI 大模型暂不可用，已自动切换本地规则引擎：工单已全部完成，可按时交付。");
                return respVO;
            }

            BigDecimal availableHours = BigDecimal.valueOf(Math.max(remainingDays, 0))
                    .multiply(BigDecimal.valueOf(8));
            BigDecimal remainingHours = null;
            if (effectiveWorkOrderId != null) {
                DurationEstimate estimate = computeDurationEstimate(gatherDurationData(effectiveWorkOrderId));
                if (estimate.hasProcessData()) {
                    remainingHours = estimate.predictedHours();
                }
            }

            boolean onTime;
            double confidence;
            if (remainingDays <= 0) {
                onTime = false;
                confidence = 15D;
                delayFactors.add("需求日期已到或已过期，但工单尚未完成");
            } else if (remainingHours == null) {
                // 缺少工序/设备数据时，退化为按进度与交期粗判
                onTime = progressPercent.compareTo(BigDecimal.valueOf(50)) >= 0 || remainingDays >= 7;
                confidence = 55D;
                delayFactors.add("缺少工序/设备效率数据，无法精确计算剩余工时，仅按进度与交期粗判");
            } else {
                BigDecimal requiredWithBuffer = remainingHours.multiply(BigDecimal.valueOf(0.8));
                onTime = availableHours.compareTo(requiredWithBuffer) >= 0;
                BigDecimal ratio = availableHours.compareTo(BigDecimal.ZERO) > 0
                        ? availableHours.divide(remainingHours, 4, RoundingMode.HALF_UP)
                        : BigDecimal.ZERO;
                confidence = ratio.compareTo(BigDecimal.valueOf(1.5)) >= 0 ? 92D
                        : ratio.compareTo(BigDecimal.valueOf(1.1)) >= 0 ? 82D
                        : ratio.compareTo(BigDecimal.ONE) >= 0 ? 70D
                        : ratio.compareTo(BigDecimal.valueOf(0.8)) >= 0 ? 45D : 20D;
                if (availableHours.compareTo(remainingHours) < 0) {
                    delayFactors.add(String.format(
                            "剩余交期 %d 天（按 8 小时/天共 %.1f 小时），预计仍需 %.1f 小时，工期不足",
                            remainingDays, availableHours.doubleValue(), remainingHours.doubleValue()));
                }
            }

            // 任务完成情况
            long finishedTasks = toInteger(data.get("已完成任务数"));
            long totalTasks = toInteger(data.get("总任务数"));
            if (totalTasks > 0 && finishedTasks < totalTasks) {
                delayFactors.add(String.format("仍有 %d 个任务未完成（共 %d 个）",
                        totalTasks - finishedTasks, totalTasks));
            }

            // 物料缺口
            List<MaterialDemand> materialDemands = effectiveWorkOrderId != null
                    ? buildMaterialDemandsFromWorkOrder(effectiveWorkOrderId)
                    : (reqVO.getMpsId() != null ? buildMaterialDemandsFromMps(reqVO.getMpsId())
                    : Collections.emptyList());
            Map<Long, BigDecimal> stockMap = getAvailableStockMap(
                    materialDemands.stream().map(MaterialDemand::itemId).collect(Collectors.toSet()));
            long shortageItems = materialDemands.stream()
                    .filter(demand -> stockMap.getOrDefault(demand.itemId(), BigDecimal.ZERO)
                            .compareTo(demand.requiredQuantity()) < 0)
                    .count();
            if (shortageItems > 0) {
                delayFactors.add(String.format("有 %d 项物料库存不足，可能影响开工", shortageItems));
                if (onTime) {
                    onTime = false;
                    confidence = Math.min(confidence, 45D);
                }
            }

            respVO.setOnTime(onTime);
            respVO.setConfidence(confidence);
            respVO.setDelayFactors(delayFactors);
            respVO.setReasoning(String.format(
                    "AI 大模型暂不可用，已自动切换本地规则引擎：当前生产进度 %s%%，剩余交期 %d 天"
                            + "（按每天 8 小时折算 %.1f 小时）%s。",
                    progressPercent.stripTrailingZeros().toPlainString(), remainingDays,
                    availableHours.doubleValue(),
                    remainingHours != null
                            ? String.format("，预计剩余工时 %.1f 小时", remainingHours.doubleValue())
                            : "，因缺少工序/设备数据未计算剩余工时"));
        } catch (Exception e) {
            log.warn("本地交付评估失败，workOrderId={}, mpsId={}",
                    reqVO.getWorkOrderId(), reqVO.getMpsId(), e);
            respVO.setOnTime(false);
            respVO.setConfidence(0D);
            respVO.setProgressPercent(BigDecimal.ZERO);
            respVO.setRemainingDays(0);
            respVO.setDelayFactors(Collections.emptyList());
            respVO.setReasoning("AI 分析暂时不可用，且本地交付数据核算失败，请稍后重试或检查工单数据。");
        }
        return respVO;
    }

    private Map<String, Object> gatherDeliveryData(Long workOrderId) {
        Map<String, Object> data = new LinkedHashMap<>();
        MesProWorkOrderDO workOrder = workOrderService.getWorkOrder(workOrderId);
        if (workOrder == null) throw exception(PRO_WORK_ORDER_NOT_EXISTS);

        data.put("工单编号", workOrder.getCode());
        data.put("工单名称", workOrder.getName());
        data.put("计划数量", workOrder.getQuantity());
        data.put("已生产数量", workOrder.getQuantityProduced());
        data.put("工单状态", workOrder.getStatus());
        data.put("需求日期", workOrder.getRequestDate() != null ? workOrder.getRequestDate().toString() : "未设置");
        data.put("完成日期", workOrder.getFinishDate() != null ? workOrder.getFinishDate().toString() : "未完成");
        fillItemInfo(data, workOrder.getProductId());

        // 进度计算
        BigDecimal progressPercent = BigDecimal.ZERO;
        if (workOrder.getQuantity() != null && workOrder.getQuantity().compareTo(BigDecimal.ZERO) > 0
                && workOrder.getQuantityProduced() != null) {
            progressPercent = workOrder.getQuantityProduced()
                    .divide(workOrder.getQuantity(), 4, RoundingMode.HALF_UP)
                    .multiply(BigDecimal.valueOf(100));
        }
        data.put("生产进度(%)", progressPercent.setScale(1, RoundingMode.HALF_UP));

        // 剩余天数
        int remainingDays = 0;
        if (workOrder.getRequestDate() != null) {
            remainingDays = (int) ChronoUnit.DAYS.between(LocalDate.now(), workOrder.getRequestDate().toLocalDate());
        }
        data.put("距离需求日期剩余天数", Math.max(0, remainingDays));

        // 任务完成情况
        List<MesProTaskDO> tasks = taskMapper.selectListByWorkOrderId(workOrderId);
        if (CollUtil.isNotEmpty(tasks)) {
            List<Map<String, Object>> taskData = new ArrayList<>();
            long finishedTasks = 0;
            long totalDuration = 0;
            for (MesProTaskDO task : tasks) {
                Map<String, Object> t = new LinkedHashMap<>();
                t.put("任务编号", task.getCode());
                t.put("任务名称", task.getName());
                t.put("任务状态", task.getStatus());
                t.put("计划数量", task.getQuantity());
                t.put("已生产数量", task.getProducedQuantity());
                t.put("实际时长(小时)", task.getDuration());
                if (task.getStartTime() != null) t.put("开始时间", task.getStartTime().toString());
                if (task.getEndTime() != null) t.put("结束时间", task.getEndTime().toString());
                if (task.getLastFeedbackTime() != null)
                    t.put("最后报工时间", task.getLastFeedbackTime().toString());
                taskData.add(t);
                if (task.getStatus() != null && task.getStatus() >= 3) finishedTasks++;
                if (task.getDuration() != null) totalDuration += task.getDuration();
            }
            data.put("任务列表", taskData);
            data.put("已完成任务数", finishedTasks);
            data.put("总任务数", tasks.size());
            data.put("已完成总时长(小时)", totalDuration);
        }

        // MPS 和客户信息
        MesProMpsDO mps = mpsMapper.selectOne(
                new LambdaQueryWrapper<MesProMpsDO>()
                        .eq(MesProMpsDO::getWorkOrderId, workOrderId));
        if (mps != null) {
            data.put("MPS 编号", mps.getCode());
            data.put("销售订单号", mps.getSaleOrderNo());
            data.put("MPS 需求日期", mps.getRequestDate() != null ? mps.getRequestDate().toString() : "");
            data.put("MPS 下发日期", mps.getIssueDate() != null ? mps.getIssueDate().toString() : "");
            fillClientInfo(data, mps.getClientId());
        }

        return data;
    }

    private Map<String, Object> gatherDeliveryDataFromMps(Long mpsId) {
        Map<String, Object> data = new LinkedHashMap<>();
        MesProMpsDO mps = mpsService.getMps(mpsId);
        if (mps == null) throw exception(PRO_WORK_ORDER_NOT_EXISTS);

        data.put("MPS 编号", mps.getCode());
        data.put("来源", "MPS 未下发，基于产品信息评估");
        data.put("计划数量", mps.getQuantity());
        data.put("已生产数量", mps.getQuantityProduced() != null ? mps.getQuantityProduced() : BigDecimal.ZERO);
        data.put("MPS 状态", mps.getStatus());
        data.put("销售订单号", mps.getSaleOrderNo());
        data.put("需求日期", mps.getRequestDate() != null ? mps.getRequestDate().toString() : "未设置");
        data.put("下发日期", mps.getIssueDate() != null ? mps.getIssueDate().toString() : "未下发");
        fillItemInfo(data, mps.getProductId());
        fillClientInfo(data, mps.getClientId());

        // 进度计算
        BigDecimal progressPercent = BigDecimal.ZERO;
        if (mps.getQuantity() != null && mps.getQuantity().compareTo(BigDecimal.ZERO) > 0
                && mps.getQuantityProduced() != null) {
            progressPercent = mps.getQuantityProduced()
                    .divide(mps.getQuantity(), 4, RoundingMode.HALF_UP)
                    .multiply(BigDecimal.valueOf(100));
        }
        data.put("生产进度(%)", progressPercent.setScale(1, RoundingMode.HALF_UP));

        // 剩余天数
        int remainingDays = 0;
        if (mps.getRequestDate() != null) {
            remainingDays = (int) ChronoUnit.DAYS.between(LocalDate.now(), mps.getRequestDate().toLocalDate());
        }
        data.put("距离需求日期剩余天数", Math.max(0, remainingDays));

        return data;
    }

    private MesProAiDeliveryPredictRespVO parseDeliveryResponse(String aiResponse) {
        MesProAiDeliveryPredictRespVO respVO = new MesProAiDeliveryPredictRespVO();
        try {
            String json = extractJson(aiResponse);
            Map<String, Object> parsed = JSONUtil.toBean(json, Map.class);
            Object onTime = parsed.get("onTime");
            if (onTime instanceof Boolean b) respVO.setOnTime(b);
            Object confidence = parsed.get("confidence");
            if (confidence instanceof Number num) respVO.setConfidence(num.doubleValue());
            respVO.setReasoning((String) parsed.get("reasoning"));
            @SuppressWarnings("unchecked")
            List<String> delayFactors = (List<String>) parsed.get("delayFactors");
            respVO.setDelayFactors(delayFactors);
            respVO.setProgressPercent(toBigDecimal(parsed.get("progressPercent")));
            respVO.setRemainingDays(toInteger(parsed.get("remainingDays")));
        } catch (Exception e) {
            log.warn("解析 AI 交付预测响应失败: {}", aiResponse, e);
            respVO.setReasoning(aiResponse);
        }
        return respVO;
    }

    // ==================== Shared Utilities ====================

    @SuppressWarnings("unchecked")
    private List<Map<String, Object>> asMapList(Object value) {
        if (value instanceof List<?> list) {
            return (List<Map<String, Object>>) list;
        }
        return Collections.emptyList();
    }

    private BigDecimal parsePercent(Object value) {
        if (value == null) {
            return BigDecimal.ZERO;
        }
        String text = value.toString().replace("%", "").trim();
        try {
            return new BigDecimal(text);
        } catch (Exception e) {
            return BigDecimal.ZERO;
        }
    }

    /** 计算距今天数；无法解析或“无记录”时返回 null */
    private Long daysSince(Object value) {
        if (value == null) {
            return null;
        }
        String text = value.toString().trim();
        if (StrUtil.isBlank(text) || "无记录".equals(text)) {
            return null;
        }
        try {
            String normalized = text.replace(' ', 'T');
            if (normalized.length() >= 19) {
                normalized = normalized.substring(0, 19);
            }
            LocalDateTime time = normalized.length() > 10
                    ? LocalDateTime.parse(normalized)
                    : LocalDate.parse(normalized).atStartOfDay();
            return ChronoUnit.DAYS.between(time.toLocalDate(), LocalDate.now());
        } catch (Exception e) {
            return null;
        }
    }

    private int severityRank(String severity) {
        if (severity == null) {
            return 1;
        }
        return switch (severity) {
            case "高" -> 3;
            case "中" -> 2;
            case "低" -> 1;
            default -> 1;
        };
    }

    private String extractJson(String aiResponse) {
        int start = aiResponse.indexOf("{");
        int end = aiResponse.lastIndexOf("}");
        if (start >= 0 && end > start) {
            return aiResponse.substring(start, end + 1);
        }
        return aiResponse;
    }

    private BigDecimal toBigDecimal(Object value) {
        if (value == null) return BigDecimal.ZERO;
        if (value instanceof BigDecimal v) return v;
        if (value instanceof Number n) return BigDecimal.valueOf(n.doubleValue());
        try {
            return new BigDecimal(value.toString());
        } catch (Exception e) {
            return BigDecimal.ZERO;
        }
    }

    private Integer toInteger(Object value) {
        if (value == null) return 0;
        if (value instanceof Integer v) return v;
        if (value instanceof Number n) return n.intValue();
        try {
            return Integer.valueOf(value.toString());
        } catch (Exception e) {
            return 0;
        }
    }

    private String resolveItemName(Long itemId) {
        if (itemId == null) return "";
        try {
            MdmItemRespDTO item = mdmItemApi.getItem(itemId).getCheckedData();
            if (item != null && StrUtil.isNotBlank(item.getName())) return item.getName();
        } catch (Exception ignored) {}
        return "物料" + itemId;
    }

    private String resolveProcessName(Long processId) {
        if (processId == null) return "";
        try {
            MesProProcessDO process = processService.getProcess(processId);
            if (process != null && StrUtil.isNotBlank(process.getName())) return process.getName();
        } catch (Exception ignored) {}
        return "工序" + processId;
    }

    private void fillItemInfo(Map<String, Object> data, Long itemId) {
        if (itemId == null) return;
        try {
            MdmItemRespDTO item = mdmItemApi.getItem(itemId).getCheckedData();
            if (item != null) {
                data.put("物料编码", item.getCode() != null ? item.getCode() : itemId);
                data.put("物料名称", item.getName() != null ? item.getName() : "");
            }
        } catch (Exception e) {
            data.put("物料ID", itemId);
        }
    }

    private void fillClientInfo(Map<String, Object> data, Long clientId) {
        if (clientId == null) return;
        try {
            CrmCustomerRespDTO customer = crmCustomerApi.getCustomer(clientId);
            if (customer != null) {
                data.put("客户名称", customer.getName() != null ? customer.getName() : "");
            }
        } catch (Exception e) {
            data.put("客户ID", clientId);
        }
    }

}