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

import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.mes.controller.admin.pro.feedback.vo.MesProTaskExecutionRespVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.collect.MesCollectAlarmDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.collect.MesCollectRealtimeHistoryDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdItemDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.unitmeasure.MesMdUnitMeasureDO;
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.mysql.collect.MesCollectAlarmMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.collect.MesCollectRealtimeHistoryMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.md.item.MesMdItemMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.md.unitmeasure.MesMdUnitMeasureMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.task.MesProTaskIssueMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.task.MesProTaskMapper;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.invalidParamException;

/**
 * 生产任务执行反馈分析。
 *
 * <p>把计划、报工、设备采集、物料消耗、交期偏差汇总，用于定位延期原因。
 * 口径说明：
 * <ul>
 *   <li>实际耗时 = 首次报工到末次报工（无报工则为空，不用计划值代替）；</li>
 *   <li>延期判定 = 末次报工时间(或当前时间) 晚于计划完成时间；</li>
 *   <li>延期原因只列可观测信号（缺料、告警、设备离线、报工滞后），不推断管理原因。</li>
 * </ul>
 */
@Slf4j
@Service
public class MesProTaskExecutionService {

    @Resource private MesProTaskMapper taskMapper;
    @Resource private MesProTaskIssueMapper taskIssueMapper;
    @Resource private MesCollectRealtimeHistoryMapper historyMapper;
    @Resource private MesCollectAlarmMapper alarmMapper;
    @Resource private MesMdItemMapper itemMapper;
    @Resource private MesMdUnitMeasureMapper unitMeasureMapper;

    public MesProTaskExecutionRespVO getExecution(Long taskId) {
        MesProTaskDO task = taskId == null ? null : taskMapper.selectById(taskId);
        if (task == null) throw invalidParamException("生产任务不存在");

        var resp = new MesProTaskExecutionRespVO();
        resp.setTaskId(task.getId());
        resp.setTaskCode(task.getCode());
        resp.setTaskName(task.getName());
        resp.setWorkOrderId(task.getWorkOrderId());
        resp.setStatus(task.getStatus());
        resp.setPlannedQuantity(task.getQuantity());
        resp.setProducedQuantity(task.getProducedQuantity());
        resp.setQualifyQuantity(task.getQualifyQuantity());
        resp.setUnqualifyQuantity(task.getUnqualifyQuantity());
        resp.setStartTime(task.getStartTime());
        resp.setFirstFeedbackTime(task.getFirstFeedbackTime());
        resp.setLastFeedbackTime(task.getLastFeedbackTime());
        resp.setFinishDate(task.getFinishDate());
        resp.setPlannedDuration(task.getDuration());

        // 完成率
        if (task.getQuantity() != null && task.getQuantity().signum() > 0 && task.getProducedQuantity() != null) {
            resp.setCompletionRate(task.getProducedQuantity()
                    .multiply(BigDecimal.valueOf(100))
                    .divide(task.getQuantity(), 2, RoundingMode.HALF_UP));
        }

        // 实际耗时
        if (task.getFirstFeedbackTime() != null && task.getLastFeedbackTime() != null) {
            resp.setActualDuration(Duration.between(task.getFirstFeedbackTime(), task.getLastFeedbackTime()).toMinutes());
        }

        // 设备运行数据
        List<MesCollectRealtimeHistoryDO> history = historyMapper.selectList(
                new LambdaQueryWrapperX<MesCollectRealtimeHistoryDO>()
                        .eq(MesCollectRealtimeHistoryDO::getTaskId, taskId));
        List<MesProTaskExecutionRespVO.DeviceRun> deviceRuns = new ArrayList<>();
        Map<Long, List<MesCollectRealtimeHistoryDO>> byMachinery = history.stream()
                .filter(h -> h.getMachineryId() != null)
                .collect(Collectors.groupingBy(MesCollectRealtimeHistoryDO::getMachineryId));
        for (var e : byMachinery.entrySet()) {
            List<MesCollectRealtimeHistoryDO> list = e.getValue();
            var run = new MesProTaskExecutionRespVO.DeviceRun();
            run.setMachineryId(e.getKey());
            run.setDeviceCode(list.get(0).getDeviceCode());
            run.setSampleCount((long) list.size());
            run.setTotalRunTime(list.stream().map(MesCollectRealtimeHistoryDO::getOt)
                    .filter(Objects::nonNull).reduce(BigDecimal.ZERO, BigDecimal::add));
            MesCollectRealtimeHistoryDO last = list.stream()
                    .max(Comparator.comparing(MesCollectRealtimeHistoryDO::getCollectTime,
                            Comparator.nullsFirst(Comparator.naturalOrder()))).orElse(null);
            if (last != null) {
                run.setLastCollectTime(last.getCollectTime());
                run.setLastRunStatus(last.getSts());
            }
            run.setAlarmCount(alarmMapper.selectCount(new LambdaQueryWrapperX<MesCollectAlarmDO>()
                    .eq(MesCollectAlarmDO::getTaskId, taskId)
                    .eq(MesCollectAlarmDO::getMachineryId, e.getKey())));
            deviceRuns.add(run);
        }
        resp.setDeviceRuns(deviceRuns);

        // 物料消耗
        List<MesProTaskIssueDO> issues = taskIssueMapper.selectList(
                new LambdaQueryWrapperX<MesProTaskIssueDO>().eq(MesProTaskIssueDO::getTaskId, taskId));
        Set<Long> itemIds = issues.stream().map(MesProTaskIssueDO::getItemId)
                .filter(Objects::nonNull).collect(Collectors.toSet());
        Map<Long, MesMdItemDO> itemMap = itemIds.isEmpty() ? Map.of()
                : itemMapper.selectBatchIds(itemIds).stream()
                    .collect(Collectors.toMap(MesMdItemDO::getId, i -> i, (a, b) -> a));
        Set<Long> unitIds = itemMap.values().stream().map(MesMdItemDO::getUnitMeasureId)
                .filter(Objects::nonNull).collect(Collectors.toSet());
        Map<Long, String> unitNameMap = unitIds.isEmpty() ? Map.of()
                : unitMeasureMapper.selectBatchIds(unitIds).stream()
                    .collect(Collectors.toMap(MesMdUnitMeasureDO::getId, MesMdUnitMeasureDO::getName, (a, b) -> a));
        Map<Long, MesProTaskExecutionRespVO.MaterialConsumption> consumptionMap = new LinkedHashMap<>();
        for (MesProTaskIssueDO issue : issues) {
            if (issue.getItemId() == null) continue;
            var mc = consumptionMap.computeIfAbsent(issue.getItemId(), id -> {
                var item = new MesProTaskExecutionRespVO.MaterialConsumption();
                item.setItemId(id);
                MesMdItemDO md = itemMap.get(id);
                if (md != null) {
                    item.setItemCode(md.getCode());
                    item.setItemName(md.getName());
                    if (md.getUnitMeasureId() != null) item.setUnit(unitNameMap.get(md.getUnitMeasureId()));
                }
                item.setQuantity(BigDecimal.ZERO);
                return item;
            });
            BigDecimal used = issue.getUsedQuantity() != null ? issue.getUsedQuantity()
                    : (issue.getIssuedQuantity() != null ? issue.getIssuedQuantity() : BigDecimal.ZERO);
            mc.setQuantity(mc.getQuantity().add(used));
        }
        resp.setMaterialConsumptions(new ArrayList<>(consumptionMap.values()));

        // 交期偏差
        boolean delayed = false;
        Long delayDays = null;
        LocalDateTime reference = task.getLastFeedbackTime() != null ? task.getLastFeedbackTime() : LocalDateTime.now();
        if (task.getFinishDate() != null && reference.isAfter(task.getFinishDate())) {
            delayed = true;
            delayDays = Duration.between(task.getFinishDate(), reference).toDays();
        }
        resp.setDelayed(delayed);
        resp.setDelayDays(delayDays);

        // 延期原因（可观测信号）
        List<String> causes = new ArrayList<>();
        if (delayed) {
            if (deviceRuns.stream().anyMatch(r -> r.getAlarmCount() != null && r.getAlarmCount() > 0))
                causes.add("执行期间存在设备告警，可能影响进度");
            if (task.getFirstFeedbackTime() == null)
                causes.add("任务尚未首次报工，实际开工时间缺失");
            else if (task.getStartTime() != null && task.getFirstFeedbackTime().isAfter(task.getStartTime().plusDays(1)))
                causes.add("首次报工时间明显晚于计划开始时间");
            boolean hasShortage = issues.stream().anyMatch(i ->
                    i.getIssuedQuantity() != null && i.getUsedQuantity() != null
                            && i.getUsedQuantity().compareTo(i.getIssuedQuantity()) >= 0);
            if (hasShortage) causes.add("投料量已用尽，存在缺料停工可能");
            if (deviceRuns.isEmpty()) causes.add("无设备采集数据，无法判断设备侧影响");
            if (task.getDuration() != null && resp.getActualDuration() != null
                    && resp.getActualDuration() > task.getDuration())
                causes.add(String.format("实际耗时 %d 分钟超过计划 %d 分钟", resp.getActualDuration(), task.getDuration()));
        }
        resp.setDelayCauses(causes);
        return resp;
    }
}