package cn.iocoder.yudao.module.mes.service.pro.task.schedule;

import cn.iocoder.yudao.module.mes.dal.dataobject.pro.task.MesProTaskDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.workorder.MesProWorkOrderDO;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.task.MesProTaskMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.md.workstation.MesMdWorkstationMachineMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.dv.machinery.MesDvMachineryMapper;
import cn.iocoder.yudao.module.mes.enums.pro.MesProTaskStatusEnum;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionSynchronizationManager;

import java.math.BigDecimal;
import java.util.*;

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

@Service
public class MesProScheduleGuardService {
    @Resource private MesProTaskMapper taskMapper;
    @Resource private MesMdWorkstationMachineMapper workstationMachineMapper;
    @Resource private MesDvMachineryMapper machineryMapper;
    @Resource private MesProScheduleQuantityService quantityService;

    public void lock() {
        if (!TransactionSynchronizationManager.isActualTransactionActive()) {
            throw new IllegalStateException("排产锁必须在事务内获取");
        }
        taskMapper.lockSchedulingResources();
    }

    public Map<Long, Set<Long>> machineIdsByStation() {
        Map<Long, Set<Long>> map = new HashMap<>();
        for (var relation : workstationMachineMapper.selectList()) {
            if (relation.getWorkstationId() != null && relation.getMachineryId() != null) {
                map.computeIfAbsent(relation.getWorkstationId(), id -> new TreeSet<>()).add(relation.getMachineryId());
            }
        }
        for (var machine : machineryMapper.selectList()) {
            if (machine.getWorkstationId() != null) {
                map.computeIfAbsent(machine.getWorkstationId(), id -> new TreeSet<>()).add(machine.getId());
            }
        }
        return map;
    }

    public void validate(MesProWorkOrderDO order, MesProTaskDO candidate, Long exceptTaskId) {
        if (!Objects.equals(order.getType(), cn.iocoder.yudao.module.mes.enums.pro.MesProWorkOrderTypeEnum.SELF.getType())) {
            throw exception(PRO_TASK_SCHEDULE_INVALID, "仅支持自行生产工单排产");
        }
        if (candidate.getQuantity() == null || candidate.getQuantity().signum() <= 0 || order.getQuantity() == null) {
            throw exception(PRO_TASK_SCHEDULE_INVALID, "排产数量必须大于0");
        }
        List<MesProTaskDO> existing = taskMapper.selectListByWorkOrderId(order.getId());
        if (existing.stream().anyMatch(task -> !Objects.equals(task.getId(), exceptTaskId)
                && !Objects.equals(task.getStatus(), MesProTaskStatusEnum.CANCELED.getStatus())
                && Objects.equals(task.getProcessId(), candidate.getProcessId())
                && (task.getQuantity() == null || task.getQuantity().signum() <= 0))) {
            throw exception(PRO_TASK_SCHEDULE_INVALID, "当前工序已有任务数量无效，请先修正历史任务数量");
        }
        BigDecimal assigned = existing.stream()
                .filter(task -> !Objects.equals(task.getId(), exceptTaskId)
                        && !Objects.equals(task.getStatus(), MesProTaskStatusEnum.CANCELED.getStatus())
                        && Objects.equals(task.getProcessId(), candidate.getProcessId()))
                .map(task -> task.getQuantity() == null ? BigDecimal.ZERO : task.getQuantity())
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        BigDecimal targetQuantity = quantityService.targetQuantity(order, candidate.getRouteId(), candidate.getProcessId());
        if (assigned.add(candidate.getQuantity()).compareTo(targetQuantity) > 0) {
            throw exception(PRO_TASK_SCHEDULE_INVALID, "工单" + order.getCode() + "的当前工序累计排产数量超过工序目标产量" + targetQuantity.stripTrailingZeros().toPlainString());
        }
        var start = candidate.getStartTime();
        var end = candidate.getEndTime();
        if (start == null && end == null) return; // 允许手工维护待完善的草稿；自动排产会阻止未知资源占用。
        if (start == null || end == null || !end.isAfter(start)) {
            throw exception(PRO_TASK_SCHEDULE_INVALID, "请填写完整的计划起止时间，结束时间必须晚于开始时间");
        }
        if (candidate.getWorkstationId() == null) {
            throw exception(PRO_TASK_SCHEDULE_INVALID, "有时间计划的任务必须指定工作站");
        }
        var resources = machineIdsByStation();
        Set<Long> machines = resources.getOrDefault(candidate.getWorkstationId(), Set.of());
        for (var task : taskMapper.selectSchedulingTasks()) {
            if (Objects.equals(task.getId(), exceptTaskId) || MesProTaskStatusEnum.isEndStatus(task.getStatus())
                    || task.getWorkstationId() == null) continue;
            var busy = new MesProScheduleEngine.Busy(task.getWorkstationId(),
                    resources.getOrDefault(task.getWorkstationId(), Set.of()), task.getStartTime(), task.getEndTime());
            if (!MesProScheduleEngine.sharesResources(candidate.getWorkstationId(), machines, busy)) continue;
            if (busy.start() == null || busy.end() == null || !busy.end().isAfter(busy.start())) {
                throw exception(PRO_TASK_SCHEDULE_INVALID, "同一工作站或共享设备存在未完善时间的任务" + task.getCode());
            }
            if (MesProScheduleEngine.overlaps(start, end, busy)) {
                throw exception(PRO_TASK_SCHEDULE_INVALID, "工作站或共享设备与任务" + task.getCode() + "的计划时间冲突");
            }
        }
    }
}