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

import cn.hutool.core.collection.CollUtil;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.controller.admin.pro.workorder.vo.process.MesProWorkOrderProcessPageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.workorder.vo.process.MesProWorkOrderProcessSaveReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pro.workorder.vo.process.MesProWorkOrderProcessSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.route.MesProRouteProcessDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.workorder.MesProWorkOrderBomDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.workorder.MesProWorkOrderProcessDO;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.workorder.MesProWorkOrderBomMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pro.workorder.MesProWorkOrderProcessMapper;
import cn.iocoder.yudao.module.mes.service.pro.process.MesProProcessService;
import cn.iocoder.yudao.module.mes.service.pro.route.MesProRouteProcessService;
import jakarta.annotation.Resource;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Set;

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

/**
 * MES 生产工单工序 Service 实现类
 *
 * @author 芋道源码
 */
@Service
@Validated
public class MesProWorkOrderProcessServiceImpl implements MesProWorkOrderProcessService {

    @Resource
    private MesProWorkOrderProcessMapper workOrderProcessMapper;

    @Resource
    @Lazy
    private MesProWorkOrderService workOrderService;
    @Resource
    private MesProProcessService processService;
    @Resource
    private MesProRouteProcessService routeProcessService;
    @Resource
    @Lazy
    private MesProWorkOrderBomService workOrderBomService;
    @Resource
    private MesProWorkOrderBomMapper workOrderBomMapper;

    @Override
    public Long createWorkOrderProcess(MesProWorkOrderProcessSaveReqVO createReqVO) {
        // 1. 校验数据
        validateWorkOrderProcessSaveData(createReqVO);

        // 2. 插入数据
        MesProWorkOrderProcessDO workOrderProcess = BeanUtils.toBean(createReqVO, MesProWorkOrderProcessDO.class);
        workOrderProcessMapper.insert(workOrderProcess);

        // 3. 重建工序链
        rebuildProcessChain(createReqVO.getWorkOrderId());
        return workOrderProcess.getId();
    }

    @Override
    public void updateWorkOrderProcess(MesProWorkOrderProcessSaveReqVO updateReqVO) {
        // 1. 校验存在 + 数据
        validateWorkOrderProcessExists(updateReqVO.getId());
        validateWorkOrderProcessSaveData(updateReqVO);

        // 2. 更新数据
        MesProWorkOrderProcessDO updateObj = BeanUtils.toBean(updateReqVO, MesProWorkOrderProcessDO.class);
        workOrderProcessMapper.updateById(updateObj);

        // 3. 重建工序链
        rebuildProcessChain(updateReqVO.getWorkOrderId());
    }

    @Override
    public void deleteWorkOrderProcess(Long id) {
        // 1. 校验存在
        MesProWorkOrderProcessDO workOrderProcess = validateWorkOrderProcessExists(id);

        // 2. 删除
        workOrderProcessMapper.deleteById(id);

        // 3. 重建工序链
        rebuildProcessChain(workOrderProcess.getWorkOrderId());
    }

    @Override
    public MesProWorkOrderProcessDO getWorkOrderProcess(Long id) {
        return workOrderProcessMapper.selectById(id);
    }

    @Override
    public PageResult<MesProWorkOrderProcessDO> getWorkOrderProcessPage(MesProWorkOrderProcessPageReqVO pageReqVO) {
        return workOrderProcessMapper.selectPage(pageReqVO);
    }

    @Override
    public List<MesProWorkOrderProcessDO> getWorkOrderProcessListByWorkOrderId(Long workOrderId) {
        return workOrderProcessMapper.selectListByWorkOrderId(workOrderId);
    }

    @Override
    public void deleteWorkOrderProcessByWorkOrderId(Long workOrderId) {
        workOrderProcessMapper.deleteByWorkOrderId(workOrderId);
    }

    @Override
    public List<MesProWorkOrderProcessDO> getProcessListByProductId(Long productId) {
        // 根据产品获取工艺路线工序列表（不保存，用于前端预填）
        List<MesProRouteProcessDO> routeProcessList = routeProcessService.getRouteProcessListByProductId(productId);
        if (CollUtil.isEmpty(routeProcessList)) {
            return Collections.emptyList();
        }
        // 转换为工单工序 DO（不设置 workOrderId，前端保存时再设置）
        List<MesProWorkOrderProcessDO> processList = new ArrayList<>(routeProcessList.size());
        for (MesProRouteProcessDO routeProcess : routeProcessList) {
            processList.add(MesProWorkOrderProcessDO.builder()
                    .processId(routeProcess.getProcessId())
                    .sort(routeProcess.getSort())
                    .nextProcessId(routeProcess.getNextProcessId())
                    .linkType(routeProcess.getLinkType())
                    .prepareTime(routeProcess.getPrepareTime())
                    .waitTime(routeProcess.getWaitTime())
                    .colorCode(routeProcess.getColorCode())
                    .keyFlag(routeProcess.getKeyFlag())
                    .checkFlag(routeProcess.getCheckFlag())
                    .backflushFlag(routeProcess.getBackflushFlag())
                    .outputItemId(routeProcess.getOutputItemId())
                    .remark(routeProcess.getRemark())
                    .build());
        }
        return processList;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void batchSaveWorkOrderProcess(List<MesProWorkOrderProcessSaveReqVO> list) {
        if (CollUtil.isEmpty(list)) {
            return;
        }
        // 获取工单 ID
        Long workOrderId = list.get(0).getWorkOrderId();
        if (workOrderId == null) {
            throw exception(PRO_WORK_ORDER_NOT_EXISTS);
        }
        // 校验工单存在
        workOrderService.validateWorkOrderExists(workOrderId);

        // 1. 获取数据库中现有的工序
        List<MesProWorkOrderProcessDO> existingList = workOrderProcessMapper.selectListByWorkOrderId(workOrderId);
        Set<Long> existingIds = existingList.stream().map(MesProWorkOrderProcessDO::getId).collect(java.util.stream.Collectors.toSet());

        // 2. 找出需要删除的 ID（数据库存在但请求中没有）
        Set<Long> requestIds = list.stream()
                .filter(item -> item.getId() != null)
                .map(MesProWorkOrderProcessSaveReqVO::getId)
                .collect(java.util.stream.Collectors.toSet());
        for (Long existingId : existingIds) {
            if (!requestIds.contains(existingId)) {
                workOrderProcessMapper.deleteById(existingId);
            }
        }

        // 3. 处理新增和更新
        for (MesProWorkOrderProcessSaveReqVO item : list) {
            if (item.getId() == null) {
                // 新增
                MesProWorkOrderProcessDO process = BeanUtils.toBean(item, MesProWorkOrderProcessDO.class);
                workOrderProcessMapper.insert(process);
            } else {
                // 更新
                MesProWorkOrderProcessDO updateObj = BeanUtils.toBean(item, MesProWorkOrderProcessDO.class);
                workOrderProcessMapper.updateById(updateObj);
            }
        }

        // 4. 保存工单 BOM 投料（合并所有工序的 bomItems，按 itemId 去重）
        saveWorkOrderBomFromProcesses(workOrderId, list);

        // 5. 重建工序链
        rebuildProcessChain(workOrderId);
    }

    /**
     * 从工序列表中提取 BOM 投料，合并去重后保存到工单 BOM 表
     */
    private void saveWorkOrderBomFromProcesses(Long workOrderId, List<MesProWorkOrderProcessSaveReqVO> list) {
        // 收集所有工序的 bomItems，按 itemId 去重（保留第一个出现的 quantity）
        java.util.Map<Long, MesProWorkOrderProcessSaveReqVO.BomItem> merged = new java.util.LinkedHashMap<>();
        for (MesProWorkOrderProcessSaveReqVO item : list) {
            if (CollUtil.isNotEmpty(item.getBomItems())) {
                for (MesProWorkOrderProcessSaveReqVO.BomItem bomItem : item.getBomItems()) {
                    if (bomItem.getItemId() != null) {
                        merged.putIfAbsent(bomItem.getItemId(), bomItem);
                    }
                }
            }
        }
        // 删除旧 BOM，批量插入新 BOM
        workOrderBomService.deleteWorkOrderBomByWorkOrderId(workOrderId);
        if (CollUtil.isNotEmpty(merged)) {
            List<MesProWorkOrderBomDO> bomList = new ArrayList<>(merged.size());
            for (MesProWorkOrderProcessSaveReqVO.BomItem bomItem : merged.values()) {
                bomList.add(MesProWorkOrderBomDO.builder()
                        .workOrderId(workOrderId)
                        .itemId(bomItem.getItemId())
                        .quantity(bomItem.getQuantity())
                        .remark(bomItem.getRemark())
                        .build());
            }
            workOrderBomMapper.insertBatch(bomList);
        }
    }

    // ==================== 私有方法 ====================

    private MesProWorkOrderProcessDO validateWorkOrderProcessExists(Long id) {
        MesProWorkOrderProcessDO workOrderProcess = workOrderProcessMapper.selectById(id);
        if (workOrderProcess == null) {
            throw exception(PRO_WORK_ORDER_PROCESS_NOT_EXISTS);
        }
        return workOrderProcess;
    }

    private void validateWorkOrderProcessSaveData(MesProWorkOrderProcessSaveReqVO reqVO) {
        // 1. 校验工单存在
        workOrderService.validateWorkOrderExists(reqVO.getWorkOrderId());
        // 2. 校验工序存在
        processService.validateProcessExists(reqVO.getProcessId());
        // 3. 校验同一工单内序号唯一
        List<MesProWorkOrderProcessDO> list = workOrderProcessMapper.selectListByWorkOrderId(reqVO.getWorkOrderId());
        for (MesProWorkOrderProcessDO process : list) {
            // 排除自身
            if (reqVO.getId() != null && reqVO.getId().equals(process.getId())) {
                continue;
            }
            if (process.getSort().equals(reqVO.getSort())) {
                throw exception(PRO_WORK_ORDER_PROCESS_SORT_DUPLICATE);
            }
            if (process.getProcessId().equals(reqVO.getProcessId())) {
                throw exception(PRO_WORK_ORDER_PROCESS_DUPLICATE);
            }
        }
        // 4. 校验关键工序唯一
        if (Boolean.TRUE.equals(reqVO.getKeyFlag())) {
            for (MesProWorkOrderProcessDO process : list) {
                if (reqVO.getId() != null && reqVO.getId().equals(process.getId())) {
                    continue;
                }
                if (Boolean.TRUE.equals(process.getKeyFlag())) {
                    throw exception(PRO_WORK_ORDER_PROCESS_KEY_DUPLICATE);
                }
            }
        }
    }

    /**
     * 重建工序链（更新所有工序的 nextProcessId）
     */
    private void rebuildProcessChain(Long workOrderId) {
        List<MesProWorkOrderProcessDO> list = workOrderProcessMapper.selectListByWorkOrderId(workOrderId);
        if (CollUtil.isEmpty(list)) {
            return;
        }
        // 按 sort 排序
        list.sort(Comparator.comparing(MesProWorkOrderProcessDO::getSort));
        for (int i = 0; i < list.size(); i++) {
            MesProWorkOrderProcessDO item = list.get(i);
            if (i + 1 < list.size()) {
                item.setNextProcessId(list.get(i + 1).getProcessId());
            } else {
                item.setNextProcessId(null);
            }
            workOrderProcessMapper.updateById(item);
        }
    }

}