package cn.iocoder.yudao.module.mes.service.qc.template;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.common.enums.CommonStatusEnum;
import cn.iocoder.yudao.framework.common.exception.ServiceException;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.controller.admin.qc.ipqc.vo.MesQcIpqcTemplateProcessRespVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.template.vo.MesQcTemplateProcessSaveByTemplateReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.template.vo.MesQcTemplateProcessSaveListReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.template.vo.MesQcTemplateProcessSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.indicator.MesQcIndicatorDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.template.MesQcTemplateDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.template.MesQcTemplateIndicatorDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.template.MesQcTemplateProcessDO;
import cn.iocoder.yudao.module.mes.dal.mysql.qc.template.MesQcTemplateProcessMapper;
import cn.iocoder.yudao.module.mes.enums.qc.MesQcTypeEnum;
import cn.iocoder.yudao.module.mes.service.pro.process.MesProProcessService;
import cn.iocoder.yudao.module.mes.service.qc.indicator.MesQcIndicatorService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import java.util.*;

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

/**
 * MES 质检方案-工序绑定 Service 实现类
 *
 * @author 超级管理员
 */
@Service
@Validated
public class MesQcTemplateProcessServiceImpl implements MesQcTemplateProcessService {

    @Resource
    private MesQcTemplateProcessMapper templateProcessMapper;
    @Resource
    private MesProProcessService processService;
    @Resource
    private MesQcTemplateService templateService;
    @Resource
    private MesQcTemplateIndicatorService templateIndicatorService;
    @Resource
    private MesQcIndicatorService indicatorService;

    @Override
    public List<MesQcTemplateProcessDO> getListByProcessId(Long processId) {
        if (processId == null) {
            return Collections.emptyList();
        }
        return templateProcessMapper.selectListByProcessId(processId);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveList(MesQcTemplateProcessSaveListReqVO reqVO) {
        processService.validateProcessExists(reqVO.getProcessId());
        List<MesQcTemplateProcessSaveReqVO> list = reqVO.getList() == null
                ? Collections.emptyList() : reqVO.getList();
        validateList(reqVO.getProcessId(), list);

        List<MesQcTemplateProcessDO> existingList = templateProcessMapper.selectListByProcessId(reqVO.getProcessId());
        Set<Long> existingIds = convertSet(existingList, MesQcTemplateProcessDO::getId);
        Set<Long> retainedIds = new HashSet<>();
        for (MesQcTemplateProcessSaveReqVO item : list) {
            MesQcTemplateProcessDO binding = BeanUtils.toBean(item, MesQcTemplateProcessDO.class)
                    .setProcessId(reqVO.getProcessId())
                    .setDefaultFlag(Boolean.TRUE.equals(item.getDefaultFlag()))
                    .setStatus(item.getStatus() != null ? item.getStatus() : CommonStatusEnum.ENABLE.getStatus())
                    .setSort(item.getSort() != null ? item.getSort() : 0);
            if (binding.getId() == null) {
                templateProcessMapper.insert(binding);
            } else {
                if (!existingIds.contains(binding.getId())) {
                    throw exception(QC_TEMPLATE_PROCESS_NOT_EXISTS);
                }
                templateProcessMapper.updateById(binding);
            }
            retainedIds.add(binding.getId());
            // 同一工序、同一质检种类只允许一个默认方案
            if (Boolean.TRUE.equals(binding.getDefaultFlag())) {
                clearOtherDefaults(reqVO.getProcessId(), binding.getQcType(), binding.getId());
            }
        }
        for (Long existingId : existingIds) {
            if (!retainedIds.contains(existingId)) {
                templateProcessMapper.deleteById(existingId);
            }
        }
    }

    @Override
    public List<MesQcTemplateProcessDO> getListByTemplateId(Long templateId) {
        if (templateId == null) {
            return Collections.emptyList();
        }
        return templateProcessMapper.selectListByTemplateId(templateId);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveByTemplate(MesQcTemplateProcessSaveByTemplateReqVO reqVO) {
        // 1. 校验方案与质检种类
        MesQcTemplateDO template = templateService.getTemplate(reqVO.getTemplateId());
        if (template == null) {
            throw new ServiceException(QC_TEMPLATE_PROCESS_NOT_EXISTS.getCode(),
                    StrUtil.format("质检方案 ID={} 不存在；请刷新质检方案列表后重新选择", reqVO.getTemplateId()));
        }
        if (CollUtil.isNotEmpty(template.getTypes())
                && !template.getTypes().contains(reqVO.getQcType())) {
            throw new ServiceException(QC_TEMPLATE_PROCESS_NOT_EXISTS.getCode(),
                    StrUtil.format("质检方案[{}]的检测种类为{}，不包含[{}]；请先在质检方案中维护该检测种类",
                            template.getName(), template.getTypes(), qcTypeName(reqVO.getQcType())));
        }
        List<MesQcTemplateProcessSaveByTemplateReqVO.ProcessItem> list = reqVO.getList() == null
                ? Collections.emptyList() : reqVO.getList();
        Map<Long, MesQcTemplateProcessSaveByTemplateReqVO.ProcessItem> requestedMap = new LinkedHashMap<>();
        for (MesQcTemplateProcessSaveByTemplateReqVO.ProcessItem item : list) {
            if (requestedMap.putIfAbsent(item.getProcessId(), item) != null) {
                throw new ServiceException(QC_TEMPLATE_PROCESS_DUPLICATE.getCode(),
                        StrUtil.format("质检方案[{}]重复选择了工序 ID={}；请删除重复的工序后重试",
                                template.getName(), item.getProcessId()));
            }
        }

        // 2. 以「已有绑定工序 ∪ 本次选择工序」为范围，逐工序重算绑定列表
        List<MesQcTemplateProcessDO> existingList = templateProcessMapper.selectListByTemplateId(reqVO.getTemplateId());
        Set<Long> processIds = new LinkedHashSet<>(convertSet(existingList, MesQcTemplateProcessDO::getProcessId));
        processIds.addAll(requestedMap.keySet());
        for (Long processId : processIds) {
            List<MesQcTemplateProcessDO> processBindings = templateProcessMapper.selectListByProcessId(processId);
            List<MesQcTemplateProcessSaveReqVO> targetList = new ArrayList<>();
            for (MesQcTemplateProcessDO binding : processBindings) {
                // 本方案 + 本质检种类的旧绑定由本次请求整体替换
                if (ObjUtil.equal(binding.getTemplateId(), reqVO.getTemplateId())
                        && ObjUtil.equal(binding.getQcType(), reqVO.getQcType())) {
                    continue;
                }
                targetList.add(BeanUtils.toBean(binding, MesQcTemplateProcessSaveReqVO.class));
            }
            MesQcTemplateProcessSaveByTemplateReqVO.ProcessItem requested = requestedMap.get(processId);
            if (requested == null && targetList.isEmpty()) {
                continue;
            }
            if (requested != null) {
                targetList.add(new MesQcTemplateProcessSaveReqVO()
                        .setProcessId(processId)
                        .setTemplateId(reqVO.getTemplateId())
                        .setQcType(reqVO.getQcType())
                        .setDefaultFlag(Boolean.TRUE.equals(requested.getDefaultFlag()))
                        .setSort(requested.getSort() != null ? requested.getSort() : 0));
            }
            MesQcTemplateProcessSaveListReqVO saveReqVO = new MesQcTemplateProcessSaveListReqVO();
            saveReqVO.setProcessId(processId);
            saveReqVO.setList(targetList);
            saveList(saveReqVO);
        }
    }

    @Override
    public Long resolveTemplateId(Long processId, Integer qcType) {
        if (processId == null || qcType == null) {
            return null;
        }
        return templateProcessMapper.selectListByProcessId(processId).stream()
                .filter(binding -> ObjUtil.equal(binding.getQcType(), qcType))
                .filter(binding -> ObjUtil.equal(binding.getStatus(), CommonStatusEnum.ENABLE.getStatus()))
                .sorted(Comparator
                        .comparing((MesQcTemplateProcessDO binding) -> Boolean.TRUE.equals(binding.getDefaultFlag()))
                        .reversed()
                        .thenComparing(binding -> binding.getSort() != null ? binding.getSort() : 0)
                        .thenComparing(MesQcTemplateProcessDO::getId))
                .map(MesQcTemplateProcessDO::getTemplateId)
                .findFirst().orElse(null);
    }

    @Override
    public MesQcIpqcTemplateProcessRespVO resolveTemplate(Long processId, Integer qcType) {
        MesQcIpqcTemplateProcessRespVO resp = new MesQcIpqcTemplateProcessRespVO()
                .setProcessId(processId).setQcType(qcType);
        Long templateId = resolveTemplateId(processId, qcType);
        if (templateId == null) {
            return resp;
        }
        MesQcTemplateDO template = templateService.getTemplate(templateId);
        if (template == null) {
            return resp;
        }
        resp.setTemplateId(template.getId()).setTemplateCode(template.getCode()).setTemplateName(template.getName());
        List<MesQcTemplateIndicatorDO> templateIndicators =
                templateIndicatorService.getTemplateIndicatorListByTemplateId(templateId);
        if (CollUtil.isEmpty(templateIndicators)) {
            resp.setIndicators(Collections.emptyList());
            return resp;
        }
        Map<Long, MesQcIndicatorDO> indicatorMap = indicatorService.getIndicatorMap(
                convertSet(templateIndicators, MesQcTemplateIndicatorDO::getIndicatorId));
        List<MesQcIpqcTemplateProcessRespVO.IndicatorItem> items = new ArrayList<>(templateIndicators.size());
        for (MesQcTemplateIndicatorDO templateIndicator : templateIndicators) {
            MesQcIndicatorDO indicator = indicatorMap.get(templateIndicator.getIndicatorId());
            items.add(new MesQcIpqcTemplateProcessRespVO.IndicatorItem()
                    .setTemplateIndicatorId(templateIndicator.getId())
                    .setIndicatorId(templateIndicator.getIndicatorId())
                    .setIndicatorCode(indicator != null ? indicator.getCode() : null)
                    .setIndicatorName(indicator != null ? indicator.getName() : null)
                    .setItemType(indicator != null ? indicator.getItemType() : null)
                    .setResultType(indicator != null ? indicator.getResultType() : null)
                    .setResultSpecification(indicator != null ? indicator.getResultSpecification() : null)
                    .setUnitText(indicator != null ? indicator.getUnitText() : null)
                    .setTool(indicator != null ? indicator.getTool() : null)
                    .setCheckMethod(templateIndicator.getCheckMethod())
                    .setStandardValue(templateIndicator.getStandardValue())
                    .setUnitMeasureId(templateIndicator.getUnitMeasureId())
                    .setThresholdMax(templateIndicator.getThresholdMax())
                    .setThresholdMin(templateIndicator.getThresholdMin()));
        }
        resp.setIndicators(items);
        return resp;
    }

    @Override
    public void deleteListByTemplateId(Long templateId) {
        List<MesQcTemplateProcessDO> list = templateProcessMapper.selectListByTemplateId(templateId);
        if (CollUtil.isEmpty(list)) {
            return;
        }
        templateProcessMapper.deleteBatch(MesQcTemplateProcessDO::getId,
                convertSet(list, MesQcTemplateProcessDO::getId));
    }

    private void clearOtherDefaults(Long processId, Integer qcType, Long keepId) {
        templateProcessMapper.selectListByProcessId(processId).stream()
                .filter(binding -> ObjUtil.equal(binding.getQcType(), qcType))
                .filter(binding -> Boolean.TRUE.equals(binding.getDefaultFlag()))
                .filter(binding -> !ObjUtil.equal(binding.getId(), keepId))
                .forEach(binding -> templateProcessMapper.updateById(
                        new MesQcTemplateProcessDO().setId(binding.getId()).setDefaultFlag(false)));
    }

    private static String qcTypeName(Integer qcType) {
        return Arrays.stream(MesQcTypeEnum.values())
                .filter(item -> ObjUtil.equal(item.getType(), qcType))
                .map(MesQcTypeEnum::getName).findFirst().orElse("未知(" + qcType + ")");
    }

    private void validateList(Long processId, List<MesQcTemplateProcessSaveReqVO> list) {
        if (CollUtil.isEmpty(list)) {
            return;
        }
        Set<String> keys = new HashSet<>();
        Set<String> defaultKeys = new HashSet<>();
        for (MesQcTemplateProcessSaveReqVO item : list) {
            if (!Arrays.asList(MesQcTypeEnum.ARRAYS).contains(item.getQcType())) {
                throw new ServiceException(QC_TEMPLATE_PROCESS_NOT_EXISTS.getCode(),
                        StrUtil.format("工序绑定的质检种类[{}]不合法；期望 1-来料检验 / 2-过程检验 / 3-出货检验 / 4-退货检验，请重新选择",
                                item.getQcType()));
            }
            if (templateService.getTemplate(item.getTemplateId()) == null) {
                throw new ServiceException(QC_TEMPLATE_PROCESS_NOT_EXISTS.getCode(),
                        StrUtil.format("工序 ID={} 绑定的质检方案 ID={} 不存在；请刷新质检方案后重新选择",
                                processId, item.getTemplateId()));
            }
            String key = item.getQcType() + ":" + item.getTemplateId();
            if (!keys.add(key)) {
                throw new ServiceException(QC_TEMPLATE_PROCESS_DUPLICATE.getCode(),
                        StrUtil.format("工序 ID={} 在质检种类[{}]下重复绑定了质检方案 ID={}；请删除重复行后重试",
                                processId, qcTypeName(item.getQcType()), item.getTemplateId()));
            }
            if (Boolean.TRUE.equals(item.getDefaultFlag())) {
                String defaultKey = String.valueOf(item.getQcType());
                if (!defaultKeys.add(defaultKey)) {
                    throw new ServiceException(QC_TEMPLATE_PROCESS_DUPLICATE.getCode(),
                            StrUtil.format("工序 ID={} 在质检种类[{}]下只能设置一个默认方案；请取消多余的默认标记后重试",
                                    processId, qcTypeName(item.getQcType())));
                }
            }
        }
    }

}