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

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.infra.api.config.ConfigApi;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdItemDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdProductBomDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.alert.MesProOverConsumeAlertDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.feedback.MesProFeedbackDO;
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.wm.itemconsume.MesWmItemConsumeLineDO;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.alert.MesProOverConsumeAlertMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.feedback.MesProFeedbackMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.workorder.MesProWorkOrderMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.wm.itemconsume.MesWmItemConsumeLineMapper;
import cn.iocoder.yudao.module.mes.enums.pro.MesProFeedbackStatusEnum;
import cn.iocoder.yudao.module.mes.service.md.item.MesMdItemService;
import cn.iocoder.yudao.module.mes.service.md.item.MesMdProductBomService;
import cn.iocoder.yudao.module.mes.service.pro.cost.dto.MesProMaterialPriceRespDTO;
import cn.iocoder.yudao.module.mes.service.pro.workorder.MesProWorkOrderBomService;
import cn.iocoder.yudao.module.system.api.notify.NotifyMessageSendApi;
import cn.iocoder.yudao.module.system.api.notify.dto.NotifySendSingleToUserReqDTO;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * MES 生产工单物料成本 Service 实现类
 *
 * @author 超级管理员
 */
@Service
@Validated
@Slf4j
public class MesProWorkOrderCostServiceImpl implements MesProWorkOrderCostService {

    /**
     * 全局默认超耗报警比例（%）
     */
    private static final String CONFIG_DEFAULT_RATIO = "mes.pro-over-consume.default-ratio";
    /**
     * 超耗报警站内信接收人用户编号（逗号分隔）
     */
    private static final String CONFIG_NOTIFY_USER_IDS = "mes.pro-over-consume.notify-user-ids";
    /**
     * 超耗报警站内信模板编号
     */
    private static final String TEMPLATE_CODE = "mes_pro_work_order_over_consume";
    private static final BigDecimal DEFAULT_THRESHOLD = new BigDecimal("5");
    private static final BigDecimal HUNDRED = new BigDecimal("100");
    private static final int SCALE = 6;

    @Resource
    private MesProWorkOrderMapper workOrderMapper;
    @Resource
    private MesProWorkOrderBomService workOrderBomService;
    @Resource
    private MesMdProductBomService productBomService;
    @Resource
    private MesMdItemService itemService;
    @Resource
    private MesProMaterialPriceService materialPriceService;
    @Resource
    private MesProFeedbackMapper feedbackMapper;
    @Resource
    private MesWmItemConsumeLineMapper consumeLineMapper;
    @Resource
    private MesProOverConsumeAlertMapper alertMapper;
    @Resource
    private ConfigApi configApi;
    @Resource
    private NotifyMessageSendApi notifyMessageSendApi;

    @Override
    public void recalculateWorkOrderCost(Long workOrderId) {
        if (workOrderId == null) {
            return;
        }
        MesProWorkOrderDO workOrder = workOrderMapper.selectById(workOrderId);
        if (workOrder == null) {
            return;
        }
        // 1. 标准 BOM 单位用量 + 实际消耗
        Map<Long, BigDecimal> perUnitBom = getPerUnitStandardBom(workOrder);
        Map<Long, BigDecimal> actualQuantities = getActualConsumption(workOrderId);
        Set<Long> itemIds = new HashSet<>(perUnitBom.keySet());
        itemIds.addAll(actualQuantities.keySet());
        Map<Long, MesProMaterialPriceRespDTO> priceMap = getPriceMap(itemIds);

        BigDecimal plannedQuantity = defaultZero(workOrder.getQuantity());
        BigDecimal reportedQuantity = getReportedQuantity(workOrder);
        BigDecimal standardCost = BigDecimal.ZERO;
        BigDecimal actualCost = BigDecimal.ZERO;
        BigDecimal overCost = BigDecimal.ZERO;
        for (Long itemId : itemIds) {
            BigDecimal unitPrice = getUnitPrice(priceMap, itemId);
            BigDecimal perUnit = perUnitBom.getOrDefault(itemId, BigDecimal.ZERO);
            BigDecimal actualQuantity = actualQuantities.getOrDefault(itemId, BigDecimal.ZERO);
            standardCost = standardCost.add(perUnit.multiply(plannedQuantity).multiply(unitPrice));
            actualCost = actualCost.add(actualQuantity.multiply(unitPrice));
            BigDecimal standardForReported = perUnit.multiply(reportedQuantity);
            if (standardForReported.compareTo(BigDecimal.ZERO) > 0) {
                BigDecimal overQuantity = actualQuantity.subtract(standardForReported);
                if (overQuantity.compareTo(BigDecimal.ZERO) > 0) {
                    overCost = overCost.add(overQuantity.multiply(unitPrice));
                }
            }
        }
        // 2. 回写工单
        BigDecimal materialUnitCost = reportedQuantity.compareTo(BigDecimal.ZERO) > 0
                ? actualCost.divide(reportedQuantity, SCALE, RoundingMode.HALF_UP) : null;
        workOrderMapper.updateById(new MesProWorkOrderDO().setId(workOrderId)
                .setStandardMaterialCost(scale(standardCost))
                .setActualMaterialCost(scale(actualCost))
                .setOverConsumeCost(scale(overCost))
                .setMaterialUnitCost(materialUnitCost)
                .setCostUpdateTime(LocalDateTime.now()));
    }

    @Override
    public void handleFeedbackApproved(MesProFeedbackDO feedback) {
        if (feedback == null || feedback.getWorkOrderId() == null) {
            return;
        }
        try {
            recalculateWorkOrderCost(feedback.getWorkOrderId());
        } catch (Exception ex) {
            log.error("[handleFeedbackApproved][工单({}) 重算物料成本失败]",
                    feedback.getWorkOrderId(), ex);
        }
        try {
            checkOverConsumeAlerts(feedback.getWorkOrderId());
        } catch (Exception ex) {
            log.error("[handleFeedbackApproved][工单({}) 超耗报警检查失败]",
                    feedback.getWorkOrderId(), ex);
        }
    }

    // ==================== 超耗报警 ====================

    private void checkOverConsumeAlerts(Long workOrderId) {
        MesProWorkOrderDO workOrder = workOrderMapper.selectById(workOrderId);
        if (workOrder == null) {
            return;
        }
        Map<Long, BigDecimal> perUnitBom = getPerUnitStandardBom(workOrder);
        if (perUnitBom.isEmpty()) {
            return;
        }
        Map<Long, BigDecimal> actualQuantities = getActualConsumption(workOrderId);
        if (actualQuantities.isEmpty()) {
            return;
        }
        BigDecimal reportedQuantity = getReportedQuantity(workOrder);
        BigDecimal threshold = resolveThreshold(workOrder);
        BigDecimal allowedFactor = BigDecimal.ONE.add(threshold.divide(HUNDRED, SCALE, RoundingMode.HALF_UP));

        // 1. 找出超耗物料
        Map<Long, BigDecimal> overQuantityMap = new LinkedHashMap<>();
        for (Map.Entry<Long, BigDecimal> entry : perUnitBom.entrySet()) {
            BigDecimal standardQuantity = entry.getValue().multiply(reportedQuantity);
            if (standardQuantity.compareTo(BigDecimal.ZERO) <= 0) {
                continue;
            }
            BigDecimal actualQuantity = actualQuantities.getOrDefault(entry.getKey(), BigDecimal.ZERO);
            if (actualQuantity.compareTo(standardQuantity.multiply(allowedFactor)) > 0) {
                overQuantityMap.put(entry.getKey(), actualQuantity.subtract(standardQuantity));
            }
        }
        if (overQuantityMap.isEmpty()) {
            return;
        }

        // 2. 逐个物料生成报警记录（同一工单+物料只报警一次）
        Set<Long> itemIds = new HashSet<>(overQuantityMap.keySet());
        itemIds.add(workOrder.getProductId());
        Map<Long, MesMdItemDO> itemMap = itemService.getItemMap(itemIds);
        Map<Long, MesProMaterialPriceRespDTO> priceMap = getPriceMap(overQuantityMap.keySet());
        MesMdItemDO product = itemMap.get(workOrder.getProductId());
        String notifyUserIds = getNotifyUserIds();
        for (Map.Entry<Long, BigDecimal> entry : overQuantityMap.entrySet()) {
            Long itemId = entry.getKey();
            if (alertMapper.selectByWorkOrderIdAndItemId(workOrderId, itemId) != null) {
                continue;
            }
            MesMdItemDO item = itemMap.get(itemId);
            BigDecimal perUnit = perUnitBom.getOrDefault(itemId, BigDecimal.ZERO);
            BigDecimal standardQuantity = perUnit.multiply(reportedQuantity);
            BigDecimal actualQuantity = actualQuantities.getOrDefault(itemId, BigDecimal.ZERO);
            BigDecimal overQuantity = entry.getValue();
            BigDecimal unitPrice = getUnitPrice(priceMap, itemId);

            MesProOverConsumeAlertDO alert = MesProOverConsumeAlertDO.builder()
                    .workOrderId(workOrderId).workOrderCode(workOrder.getCode())
                    .productId(workOrder.getProductId())
                    .productName(product != null ? product.getName() : null)
                    .itemId(itemId).itemCode(item != null ? item.getCode() : null)
                    .itemName(item != null ? item.getName() : null)
                    .standardQuantity(scale(standardQuantity))
                    .actualQuantity(scale(actualQuantity))
                    .overQuantity(scale(overQuantity))
                    .overRatio(overQuantity.multiply(HUNDRED).divide(standardQuantity, 4, RoundingMode.HALF_UP))
                    .thresholdRatio(threshold.setScale(4, RoundingMode.HALF_UP))
                    .unitPrice(scale(unitPrice))
                    .overAmount(scale(overQuantity.multiply(unitPrice)))
                    .notifyUserIds(notifyUserIds)
                    .status("FAILED")
                    .build();
            alertMapper.insert(alert);

            try {
                sendOverConsumeMessage(alert, notifyUserIds);
            } catch (Exception ex) {
                log.warn("[checkOverConsumeAlerts][工单({}) 物料({}) 超耗站内信发送失败]",
                        workOrder.getCode(), item != null ? item.getCode() : itemId, ex);
                alert.setStatus("FAILED");
                alert.setErrorMessage(StrUtil.maxLength(
                        "发送失败：" + StrUtil.blankToDefault(ex.getMessage(), ex.getClass().getSimpleName()), 500));
            }
            alertMapper.updateById(alert);
        }
    }

    private void sendOverConsumeMessage(MesProOverConsumeAlertDO alert, String notifyUserIds) {
        if (StrUtil.isBlank(notifyUserIds)) {
            throw new IllegalStateException(
                    "未配置超耗报警接收人，请在参数配置中设置 mes.pro-over-consume.notify-user-ids");
        }
        Map<String, Object> params = new HashMap<>();
        params.put("workOrderCode", StrUtil.blankToDefault(alert.getWorkOrderCode(), ""));
        params.put("productName", StrUtil.blankToDefault(alert.getProductName(), ""));
        params.put("itemName", StrUtil.blankToDefault(alert.getItemName(), ""));
        params.put("standardQuantity", alert.getStandardQuantity().toPlainString());
        params.put("actualQuantity", alert.getActualQuantity().toPlainString());
        params.put("overQuantity", alert.getOverQuantity().toPlainString());
        params.put("overRatio", alert.getOverRatio().toPlainString());
        params.put("threshold", alert.getThresholdRatio().stripTrailingZeros().toPlainString());
        params.put("overAmount", alert.getOverAmount().toPlainString());

        List<String> failures = new ArrayList<>();
        Long firstMessageId = null;
        int successCount = 0;
        for (String userIdText : notifyUserIds.split(",")) {
            String trimmed = userIdText.trim();
            if (trimmed.isEmpty()) {
                continue;
            }
            try {
                Long userId = Long.parseLong(trimmed);
                NotifySendSingleToUserReqDTO message = new NotifySendSingleToUserReqDTO();
                message.setUserId(userId);
                message.setTemplateCode(TEMPLATE_CODE);
                message.setTemplateParams(params);
                Long messageId = notifyMessageSendApi.sendSingleMessageToAdmin(message);
                if (messageId == null) {
                    throw new IllegalStateException("站内信模板已停用或不存在");
                }
                if (firstMessageId == null) {
                    firstMessageId = messageId;
                }
                successCount++;
            } catch (Exception ex) {
                failures.add("用户[" + trimmed + "]：" + StrUtil.blankToDefault(
                        ex.getMessage(), ex.getClass().getSimpleName()));
            }
        }
        alert.setMessageId(firstMessageId);
        if (failures.isEmpty()) {
            alert.setStatus("SENT");
            alert.setErrorMessage(null);
            return;
        }
        alert.setStatus(successCount > 0 ? "SENT" : "FAILED");
        alert.setErrorMessage(StrUtil.maxLength("部分接收人发送失败：" + String.join("；", failures), 500));
    }

    // ==================== 成本基础数据 ====================

    /**
     * 产品标准 BOM 单位用量；无产品 BOM 时回退工单 BOM
     */
    private Map<Long, BigDecimal> getPerUnitStandardBom(MesProWorkOrderDO workOrder) {
        Map<Long, BigDecimal> perUnitBom = new LinkedHashMap<>();
        List<MesMdProductBomDO> productBomList = productBomService
                .getProductBomListByItemId(workOrder.getProductId());
        if (CollUtil.isNotEmpty(productBomList)) {
            for (MesMdProductBomDO bom : productBomList) {
                if (bom.getBomItemId() != null && bom.getQuantity() != null) {
                    perUnitBom.merge(bom.getBomItemId(), bom.getQuantity(), BigDecimal::add);
                }
            }
            return perUnitBom;
        }
        List<MesProWorkOrderBomDO> workOrderBomList = workOrderBomService
                .getWorkOrderBomListByWorkOrderId(workOrder.getId());
        if (CollUtil.isEmpty(workOrderBomList)) {
            return perUnitBom;
        }
        BigDecimal workOrderQuantity = defaultZero(workOrder.getQuantity());
        BigDecimal divisor = workOrderQuantity.compareTo(BigDecimal.ZERO) > 0
                ? workOrderQuantity : BigDecimal.ONE;
        for (MesProWorkOrderBomDO bom : workOrderBomList) {
            if (bom.getItemId() == null || bom.getQuantity() == null) {
                continue;
            }
            // 无工序行在手工建单时已按工单数量放大，需折算回单位用量；有工序行为单位用量
            BigDecimal perUnit = bom.getProcessId() == null
                    ? bom.getQuantity().divide(divisor, SCALE, RoundingMode.HALF_UP)
                    : bom.getQuantity();
            perUnitBom.merge(bom.getItemId(), perUnit, BigDecimal::add);
        }
        return perUnitBom;
    }

    private Map<Long, BigDecimal> getActualConsumption(Long workOrderId) {
        Map<Long, BigDecimal> actualQuantities = new LinkedHashMap<>();
        for (MesWmItemConsumeLineDO line : consumeLineMapper.selectListByWorkOrderId(workOrderId)) {
            if (line.getItemId() != null && line.getQuantity() != null) {
                actualQuantities.merge(line.getItemId(), line.getQuantity(), BigDecimal::add);
            }
        }
        return actualQuantities;
    }

    /**
     * 已报工数量：工单已生产数量 与 各工序已审批报工累计数量 取大
     *
     * 工单 quantityProduced 只在末道工序报工后更新，取各工序最大值可保证中间工序报工后即可计算超耗
     */
    private BigDecimal getReportedQuantity(MesProWorkOrderDO workOrder) {
        BigDecimal reported = defaultZero(workOrder.getQuantityProduced());
        List<MesProFeedbackDO> feedbackList = feedbackMapper.selectList(
                new LambdaQueryWrapperX<MesProFeedbackDO>()
                        .eq(MesProFeedbackDO::getWorkOrderId, workOrder.getId())
                        .in(MesProFeedbackDO::getStatus,
                                MesProFeedbackStatusEnum.FINISHED.getStatus(),
                                MesProFeedbackStatusEnum.UNCHECK.getStatus()));
        if (CollUtil.isEmpty(feedbackList)) {
            return reported;
        }
        Map<Long, BigDecimal> quantityByProcess = new HashMap<>();
        for (MesProFeedbackDO feedback : feedbackList) {
            if (feedback.getFeedbackQuantity() == null) {
                continue;
            }
            Long key = feedback.getProcessId() != null ? feedback.getProcessId() : 0L;
            quantityByProcess.merge(key, feedback.getFeedbackQuantity(), BigDecimal::add);
        }
        BigDecimal maxProcessQuantity = quantityByProcess.values().stream()
                .max(BigDecimal::compareTo).orElse(BigDecimal.ZERO);
        return reported.max(maxProcessQuantity);
    }

    private BigDecimal resolveThreshold(MesProWorkOrderDO workOrder) {
        if (workOrder.getOverConsumeRatio() != null) {
            return workOrder.getOverConsumeRatio();
        }
        MesMdItemDO product = workOrder.getProductId() != null
                ? itemService.getItem(workOrder.getProductId()) : null;
        if (product != null && product.getOverConsumeRatio() != null) {
            return product.getOverConsumeRatio();
        }
        String configValue = null;
        try {
            configValue = configApi.getConfigValueByKey(CONFIG_DEFAULT_RATIO);
        } catch (Exception ex) {
            log.warn("[resolveThreshold][读取超耗报警默认比例失败，使用默认值 {}]", DEFAULT_THRESHOLD, ex);
        }
        if (StrUtil.isNotBlank(configValue)) {
            try {
                return new BigDecimal(configValue.trim());
            } catch (NumberFormatException ex) {
                log.warn("[resolveThreshold][超耗报警默认比例配置值非法：{}，使用默认值 {}]",
                        configValue, DEFAULT_THRESHOLD);
            }
        }
        return DEFAULT_THRESHOLD;
    }

    private String getNotifyUserIds() {
        try {
            return StrUtil.trimToEmpty(configApi.getConfigValueByKey(CONFIG_NOTIFY_USER_IDS));
        } catch (Exception ex) {
            log.warn("[getNotifyUserIds][读取超耗报警接收人失败]", ex);
            return "";
        }
    }

    private Map<Long, MesProMaterialPriceRespDTO> getPriceMap(Collection<Long> itemIds) {
        if (CollUtil.isEmpty(itemIds)) {
            return Collections.emptyMap();
        }
        try {
            return materialPriceService.getMaterialPriceMap(itemIds);
        } catch (Exception ex) {
            log.error("[getPriceMap][获取物料价格失败，按无价格处理] itemIds={}", itemIds, ex);
            return Collections.emptyMap();
        }
    }

    private static BigDecimal getUnitPrice(Map<Long, MesProMaterialPriceRespDTO> priceMap, Long itemId) {
        MesProMaterialPriceRespDTO price = priceMap.get(itemId);
        return price != null && price.getUnitPrice() != null ? price.getUnitPrice() : BigDecimal.ZERO;
    }

    private static BigDecimal defaultZero(BigDecimal value) {
        return value != null ? value : BigDecimal.ZERO;
    }

    private static BigDecimal scale(BigDecimal value) {
        return value.setScale(SCALE, RoundingMode.HALF_UP);
    }

}