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

import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.feedback.MesProFeedbackDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.task.MesProTaskDO;
import cn.iocoder.yudao.module.mes.dal.mysql.dv.machinery.MesDvMachineryMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.feedback.MesProFeedbackMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.task.MesProTaskMapper;
import cn.iocoder.yudao.module.mes.enums.pro.MesProFeedbackStatusEnum;
import cn.iocoder.yudao.module.mes.enums.pro.MesProTaskStatusEnum;
import cn.iocoder.yudao.module.mes.service.md.workstation.MesMdWorkstationService;
import cn.iocoder.yudao.module.mes.service.pro.task.schedule.MesProScheduleGuardService;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;

import java.time.*;
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_FEEDBACK_EQUIPMENT_INVALID;

/** 报工与设备状态联动；调用入口必须处于事务中，与排产共用资源锁。 */
@Service
public class MesProFeedbackEquipmentService {
    @Resource private MesProScheduleGuardService guard;
    @Resource private MesProTaskMapper taskMapper;
    @Resource private MesProFeedbackMapper feedbackMapper;
    @Resource private MesDvMachineryMapper machineryMapper;
    @Resource private MesMdWorkstationService workstationService;
    private Clock clock = Clock.system(ZoneId.of("Asia/Shanghai"));
    private final ThreadLocal<Integer> historicalDepth = ThreadLocal.withInitial(() -> 0);

    public interface ApprovalScope extends AutoCloseable { @Override void close(); }

    /** 历史报工可能触发整单自动完工，整个调用链都不改写实时设备状态。 */
    public ApprovalScope beginApproval(MesProFeedbackDO feedback) {
        if (!historical(feedback)) return () -> { };
        int previous = historicalDepth.get();
        historicalDepth.set(previous + 1);
        return () -> {
            if (previous == 0) historicalDepth.remove(); else historicalDepth.set(previous);
        };
    }

    public void lock() { guard.lock(); }
    public void resetSnapshot(Long id) {
        feedbackMapper.update(null, new LambdaUpdateWrapper<MesProFeedbackDO>()
                .eq(MesProFeedbackDO::getId, id).set(MesProFeedbackDO::getMachineryIds, null));
    }
    private LocalDateTime now() { return LocalDateTime.now(clock); }
    private boolean historical(MesProFeedbackDO f) {
        return f.getFeedbackTime() != null && f.getFeedbackTime().toLocalDate().isBefore(now().toLocalDate());
    }

    /** 草稿保存不校验实时设备状态，不切换设备；提交时才固定设备快照。 */
    public void validateSubmission(MesProFeedbackDO feedback) { validate(feedback, true); }

    /** 审批有延迟时，不用审批时的维护状态否认已提交的生产事实。 */
    public void validateApproval(MesProFeedbackDO feedback) { validate(feedback, feedback.getMachineryIds() == null); }

    private void validate(MesProFeedbackDO feedback, boolean checkCurrentEquipment) {
        var task = taskMapper.selectById(feedback.getTaskId());
        if (task == null || task.getStatus() == null || !MesProTaskStatusEnum.canFeedback(task.getStatus())) {
            fail("任务不存在、已结束或已停工");
        }
        if (!Objects.equals(task.getWorkstationId(), feedback.getWorkstationId())
                || !Objects.equals(task.getWorkOrderId(), feedback.getWorkOrderId())
                || !Objects.equals(task.getProcessId(), feedback.getProcessId())
                || !Objects.equals(task.getRouteId(), feedback.getRouteId())) {
            fail("任务关联已变更，请重新编辑报工单");
        }
        if (feedback.getFeedbackTime() == null || feedback.getFeedbackTime().isAfter(now().plusMinutes(5))) {
            fail("请填写实际报工时间，不能提前报工");
        }
        // 补录往日生产不校验当前维护状态，也不补造历史使用设备，不改变实时设备状态。
        if (historical(feedback) || !checkCurrentEquipment) return;
        var station = task.getWorkstationId() == null ? null : workstationService.getWorkstation(task.getWorkstationId());
        if (station == null || !Objects.equals(station.getStatus(), 0)
                || !Objects.equals(station.getProcessId(), task.getProcessId())) {
            fail("工作站不存在、已停用或与任务工序不符");
        }
        if (feedback.getMachineryIds() == null) {
            String existing = taskSnapshot(task.getId());
            feedback.setMachineryIds(existing != null ? existing : availableMachines(task.getWorkstationId()));
        }
        Set<Long> ids = ids(feedback.getMachineryIds());
        if (ids.isEmpty()) fail("工作站未配置设备，请先绑定设备");
        var machines = machineryMapper.selectByIds(ids);
        if (machines.size() != ids.size()) fail("关联设备已删除，请核对报工单");
        for (var machine : machines) {
            if (!Objects.equals(machine.getStatus(), 1) && !Objects.equals(machine.getStatus(), 2)) {
                fail("设备「" + machine.getName() + "」维护中或状态无效");
            }
        }
        Set<Long> occupied = occupiedMachines(task.getId(), true);
        if (!Collections.disjoint(occupied, ids)) fail("关联设备仍被其他生产任务占用，请先完工或停工后再报工");
        if (feedback.getId() != null) {
            feedbackMapper.updateById(new MesProFeedbackDO().setId(feedback.getId()).setMachineryIds(feedback.getMachineryIds()));
        }
    }

    public void afterApproved(MesProFeedbackDO feedback) {
        var task = taskMapper.selectById(feedback.getTaskId());
        if (task != null && task.getQuantity() != null && task.getQuantity().signum() > 0
                && task.getProducedQuantity() != null && task.getProducedQuantity().compareTo(task.getQuantity()) >= 0
                && !MesProTaskStatusEnum.isEndStatus(task.getStatus())) {
            // 单道工序报满即可释放生产资源，质检仍独立保持待检验状态。
            taskMapper.updateById(new MesProTaskDO().setId(task.getId()).setStatus(MesProTaskStatusEnum.FINISHED.getStatus())
                    .setFinishDate(feedback.getFeedbackTime()));
        } else if (!historical(feedback) && task != null && remaining(task)
                && (Objects.equals(task.getStatus(), MesProTaskStatusEnum.PREPARE.getStatus())
                    || Objects.equals(task.getStatus(), MesProTaskStatusEnum.PRODUCING.getStatus()))) {
            taskMapper.updateById(new MesProTaskDO().setId(task.getId()).setStatus(MesProTaskStatusEnum.PARTIAL_FINISHED.getStatus()));
        }
        if (historical(feedback)) return;
        refresh(ids(feedback.getMachineryIds()));
    }

    /** 变更任务状态后重算共享设备；快照不随工作站重新绑定设备而漂移。 */
    public void afterTaskStateChanged(Collection<MesProTaskDO> tasks) {
        if (historicalDepth.get() > 0) return;
        Set<Long> affected = new TreeSet<>();
        var mapping = guard.machineIdsByStation();
        for (var task : tasks) {
            boolean hasSnapshot = false;
            for (var f : feedbackMapper.selectListByTaskId(task.getId())) {
                if (Objects.equals(f.getStatus(), MesProFeedbackStatusEnum.FINISHED.getStatus())
                        || Objects.equals(f.getStatus(), MesProFeedbackStatusEnum.UNCHECK.getStatus())) {
                    hasSnapshot |= f.getMachineryIds() != null && !f.getMachineryIds().isBlank();
                    affected.addAll(ids(f.getMachineryIds()));
                }
            }
            if (!hasSnapshot && (task.getFirstFeedbackTime() != null
                    || Objects.equals(task.getStatus(), MesProTaskStatusEnum.PRODUCING.getStatus())
                    || Objects.equals(task.getStatus(), MesProTaskStatusEnum.PARTIAL_FINISHED.getStatus())
                    || (Objects.equals(task.getStatus(), MesProTaskStatusEnum.PAUSED.getStatus())
                        && task.getProducedQuantity() != null && task.getProducedQuantity().signum() > 0))) {
                affected.addAll(mapping.getOrDefault(task.getWorkstationId(), Set.of()));
            }
        }
        refresh(affected);
    }

    /** 复工之前先校验实时设备，避免恢复维护中或其他任务占用的设备。 */
    public void validateResume(MesProTaskDO task) {
        var f = new MesProFeedbackDO().setTaskId(task.getId()).setWorkOrderId(task.getWorkOrderId())
                .setRouteId(task.getRouteId()).setProcessId(task.getProcessId()).setWorkstationId(task.getWorkstationId())
                .setFeedbackTime(now());
        // 调用方先恢复任务状态，校验失败时同事务回滚。
        validateSubmission(f);
    }

    private boolean remaining(MesProTaskDO t) {
        return t.getProducedQuantity() != null && t.getProducedQuantity().signum() > 0
                && t.getQuantity() != null && t.getProducedQuantity().compareTo(t.getQuantity()) < 0;
    }

    private boolean unfinished(MesProTaskDO t) {
        return t.getQuantity() == null || (t.getQuantity().signum() > 0
                && (t.getProducedQuantity() == null || t.getProducedQuantity().compareTo(t.getQuantity()) < 0));
    }

    private String taskSnapshot(Long taskId) {
        return feedbackMapper.selectListByTaskId(taskId).stream()
                .filter(f -> f.getMachineryIds() != null && (Objects.equals(f.getStatus(), MesProFeedbackStatusEnum.FINISHED.getStatus())
                        || Objects.equals(f.getStatus(), MesProFeedbackStatusEnum.UNCHECK.getStatus())))
                .max(Comparator.comparing(MesProFeedbackDO::getId)).map(MesProFeedbackDO::getMachineryIds).orElse(null);
    }

    private String availableMachines(Long stationId) {
        var assigned = guard.machineIdsByStation().getOrDefault(stationId, Set.of());
        if (assigned.isEmpty()) fail("工作站未配置设备，请先绑定设备");
        // 与排产一致：同一工作站可有多台设备，维护中的设备不加入新的报工范围。
        // 已经提交过的任务使用原设备快照，其设备转为维护时仍必须拦截。
        var usable = machineryMapper.selectByIds(assigned).stream()
                .filter(m -> Objects.equals(m.getStatus(), 1) || Objects.equals(m.getStatus(), 2))
                .map(MesDvMachineryDO::getId).sorted().map(String::valueOf).collect(Collectors.joining(","));
        if (usable.isEmpty()) fail("工作站没有可用设备，关联设备维护中、已删除或状态无效");
        return usable;
    }

    private Set<Long> occupiedMachines(Long exceptTaskId, boolean includePending) {
        var tasks = taskMapper.selectSchedulingTasks().stream()
                .filter(t -> !Objects.equals(t.getId(), exceptTaskId))
                .filter(t -> !Objects.equals(t.getStatus(), MesProTaskStatusEnum.PAUSED.getStatus()))
                .filter(this::unfinished).toList();
        Set<Long> occupied = new HashSet<>();
        if (tasks.isEmpty()) return occupied;
        var latest = new HashMap<Long, MesProFeedbackDO>();
        for (var f : feedbackMapper.selectListByTaskIds(tasks.stream().map(MesProTaskDO::getId).toList())) {
            if (!Objects.equals(f.getStatus(), MesProFeedbackStatusEnum.FINISHED.getStatus())
                    && !Objects.equals(f.getStatus(), MesProFeedbackStatusEnum.UNCHECK.getStatus())
                    && !(includePending && Objects.equals(f.getStatus(), MesProFeedbackStatusEnum.APPROVING.getStatus())
                        && f.getFeedbackTime() != null && !historical(f))) continue;
            latest.merge(f.getTaskId(), f, (a,b) -> a.getId() > b.getId() ? a : b);
        }
        var mapping = guard.machineIdsByStation();
        for (var t : tasks) {
            var f = latest.get(t.getId());
            boolean active = Objects.equals(t.getStatus(), MesProTaskStatusEnum.PRODUCING.getStatus())
                    || Objects.equals(t.getStatus(), MesProTaskStatusEnum.PARTIAL_FINISHED.getStatus())
                    || (f != null && f.getFeedbackTime() != null && !historical(f));
            if (active) occupied.addAll(f != null && f.getMachineryIds() != null
                    ? ids(f.getMachineryIds()) : mapping.getOrDefault(t.getWorkstationId(), Set.of()));
        }
        return occupied;
    }

    private void refresh(Set<Long> affected) {
        if (affected.isEmpty()) return;
        Set<Long> occupied = occupiedMachines(null, false);
        for (var machine : machineryMapper.selectByIds(affected)) {
            if (!Objects.equals(machine.getStatus(), 1) && !Objects.equals(machine.getStatus(), 2)) continue;
            int target = occupied.contains(machine.getId()) ? 2 : 1;
            if (Objects.equals(machine.getStatus(), target)) continue;
            int changed = machineryMapper.update(null, new LambdaUpdateWrapper<MesDvMachineryDO>()
                    .eq(MesDvMachineryDO::getId, machine.getId()).eq(MesDvMachineryDO::getStatus, machine.getStatus())
                    .set(MesDvMachineryDO::getStatus, target));
            if (changed == 0 && target == 2) fail("设备状态已变化，请重新核对设备后提交");
        }
    }

    private Set<Long> ids(String csv) {
        if (csv == null || csv.isBlank()) return Set.of();
        try {
            Set<Long> ids = Arrays.stream(csv.split(",")).map(String::trim).map(Long::valueOf)
                    .collect(Collectors.toCollection(TreeSet::new));
            if (ids.stream().anyMatch(id -> id <= 0)) fail("设备快照包含无效编号");
            return ids;
        } catch (NumberFormatException error) { throw exception(PRO_FEEDBACK_EQUIPMENT_INVALID, "设备快照格式异常"); }
    }
    private void fail(String message) { throw exception(PRO_FEEDBACK_EQUIPMENT_INVALID, message); }
}