package cn.iocoder.yudao.module.mes.service.md.unitmeasure;

import cn.hutool.core.collection.CollUtil;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
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.md.unitmeasure.vo.MesMdUnitMeasurePageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.md.unitmeasure.vo.MesMdUnitMeasureSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.unitmeasure.MesMdUnitMeasureDO;
import cn.iocoder.yudao.module.mes.dal.mysql.md.unitmeasure.MesMdUnitMeasureMapper;
import cn.iocoder.yudao.module.mes.service.md.item.MesMdItemService;
import cn.iocoder.yudao.module.mes.service.pro.task.MesProTaskIssueService;
import cn.iocoder.yudao.module.mes.service.qc.ipqc.MesQcIpqcLineService;
import cn.iocoder.yudao.module.mes.service.qc.iqc.MesQcIqcLineService;
import cn.iocoder.yudao.module.mes.service.qc.oqc.MesQcOqcLineService;
import cn.iocoder.yudao.module.mes.service.qc.rqc.MesQcRqcLineService;
import cn.iocoder.yudao.module.mes.service.qc.template.MesQcTemplateIndicatorService;
import cn.iocoder.yudao.module.mdm.api.unit.MdmUnitMeasureApi;
import cn.iocoder.yudao.module.mdm.api.unit.dto.MdmUnitMeasureRespDTO;
import org.springframework.context.annotation.Lazy;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;

import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
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.*;

/**
 * MES 计量单位 Service 实现类
 *
 * 注意：查询操作统一使用 MDM API 获取数据，保持与 MDM 主数据一致
 *
 * @author 芋道源码
 */
@Service
@Validated
public class MesMdUnitMeasureServiceImpl implements MesMdUnitMeasureService {

    @Resource
    private MdmUnitMeasureApi unitMeasureApi;

    @Resource
    private MesMdUnitMeasureMapper unitMeasureMapper;

    @Resource
    @Lazy
    private MesMdItemService itemService;
    @Resource
    @Lazy
    private MesProTaskIssueService taskIssueService;
    @Resource
    @Lazy
    private MesQcTemplateIndicatorService templateIndicatorService;
    @Resource
    @Lazy
    private MesQcIqcLineService iqcLineService;
    @Resource
    @Lazy
    private MesQcOqcLineService oqcLineService;
    @Resource
    @Lazy
    private MesQcIpqcLineService ipqcLineService;
    @Resource
    @Lazy
    private MesQcRqcLineService rqcLineService;

    @Override
    public Long createUnitMeasure(MesMdUnitMeasureSaveReqVO createReqVO) {
        // 校验编码唯一
        validateUnitMeasureCodeUnique(null, createReqVO.getCode());

        // 插入
        MesMdUnitMeasureDO unitMeasure = BeanUtils.toBean(createReqVO, MesMdUnitMeasureDO.class);
        unitMeasureMapper.insert(unitMeasure);
        return unitMeasure.getId();
    }

    @Override
    public void updateUnitMeasure(MesMdUnitMeasureSaveReqVO updateReqVO) {
        // 校验存在
        validateUnitMeasureExists(updateReqVO.getId());
        // 校验编码唯一
        validateUnitMeasureCodeUnique(updateReqVO.getId(), updateReqVO.getCode());

        // 更新
        MesMdUnitMeasureDO updateObj = BeanUtils.toBean(updateReqVO, MesMdUnitMeasureDO.class);
        unitMeasureMapper.updateById(updateObj);
    }

    @Override
    public void deleteUnitMeasure(Long id) {
        // 校验存在
        validateUnitMeasureExists(id);
        // 校验是否存在以此为主单位的辅单位
        if (unitMeasureMapper.selectCountByPrimaryId(id) > 0) {
            throw exception(MD_UNIT_MEASURE_HAS_SECONDARY);
        }
        // 校验是否被物料引用
        if (itemService.getItemCountByUnitMeasureId(id) > 0) {
            throw exception(MD_UNIT_MEASURE_HAS_ITEM);
        }
        // 校验是否被生产任务投料引用
        if (taskIssueService.getTaskIssueCountByUnitMeasureId(id) > 0) {
            throw exception(MD_UNIT_MEASURE_HAS_TASK_ISSUE);
        }
        // 校验是否被质检方案指标项引用
        if (templateIndicatorService.getTemplateIndicatorCountByUnitMeasureId(id) > 0) {
            throw exception(MD_UNIT_MEASURE_HAS_QC_TEMPLATE_INDICATOR);
        }
        // 校验是否被质检单据行引用（IQC/OQC/IPQC/RQC）
        if (iqcLineService.getIqcLineCountByUnitMeasureId(id) > 0
                || oqcLineService.getOqcLineCountByUnitMeasureId(id) > 0
                || ipqcLineService.getIpqcLineCountByUnitMeasureId(id) > 0
                || rqcLineService.getRqcLineCountByUnitMeasureId(id) > 0) {
            throw exception(MD_UNIT_MEASURE_HAS_QC_LINE);
        }

        // 删除
        unitMeasureMapper.deleteById(id);
    }

    private void validateUnitMeasureExists(Long id) {
        if (unitMeasureMapper.selectById(id) == null) {
            throw exception(MD_UNIT_MEASURE_NOT_EXISTS);
        }
    }

    private void validateUnitMeasureCodeUnique(Long id, String code) {
        MesMdUnitMeasureDO unitMeasure = unitMeasureMapper.selectByCode(code);
        if (unitMeasure == null) {
            return;
        }
        // 如果 id 为空，说明不用比较是否为相同 id 的记录
        if (id == null) {
            throw exception(MD_UNIT_MEASURE_CODE_DUPLICATE);
        }
        if (!Objects.equals(unitMeasure.getId(), id)) {
            throw exception(MD_UNIT_MEASURE_CODE_DUPLICATE);
        }
    }

    @Override
    public MesMdUnitMeasureDO getUnitMeasure(Long id) {
        // 优先从 MDM API 获取
        CommonResult<MdmUnitMeasureRespDTO> result = unitMeasureApi.getUnitMeasure(id);
        if (result != null && result.isSuccess() && result.getData() != null) {
            return convertToDo(result.getData());
        }
        // 如果 MDM API 失败，回退到本地数据库
        MesMdUnitMeasureDO local = unitMeasureMapper.selectById(id);
        if (local != null) {
            return local;
        }
        return null;
    }

    @Override
    public PageResult<MesMdUnitMeasureDO> getUnitMeasurePage(MesMdUnitMeasurePageReqVO pageReqVO) {
        // 使用本地数据库分页查询（MDM API 不支持分页参数）
        return unitMeasureMapper.selectPage(pageReqVO);
    }

    @Override
    public List<MesMdUnitMeasureDO> getUnitMeasureListByStatus(Integer status) {
        // 使用本地数据库查询（MDM API 不支持按状态过滤）
        return unitMeasureMapper.selectListByStatus(status);
    }

    @Override
    public List<MesMdUnitMeasureDO> getUnitMeasureList(Collection<Long> ids) {
        if (CollUtil.isEmpty(ids)) {
            return Collections.emptyList();
        }
        // 优先从 MDM API 获取
        CommonResult<List<MdmUnitMeasureRespDTO>> result = unitMeasureApi.getUnitMeasureList(ids);
        if (result != null && result.isSuccess() && result.getData() != null) {
            return result.getData().stream()
                    .map(this::convertToDo)
                    .collect(Collectors.toList());
        }
        // 如果 MDM API 失败，回退到本地数据库
        return unitMeasureMapper.selectByIds(ids);
    }

    @Override
    public MesMdUnitMeasureDO getUnitMeasureByCode(String code) {
        // 优先从 MDM API 获取
        CommonResult<MdmUnitMeasureRespDTO> result = unitMeasureApi.getUnitMeasureByCode(code);
        if (result != null && result.isSuccess() && result.getData() != null) {
            return convertToDo(result.getData());
        }
        // 如果 MDM API 失败，回退到本地数据库
        MesMdUnitMeasureDO local = unitMeasureMapper.selectByCode(code);
        if (local != null) {
            return local;
        }
        return null;
    }

    /**
     * 将 MDM DTO 转换为 MES DO
     */
    private MesMdUnitMeasureDO convertToDo(MdmUnitMeasureRespDTO dto) {
        MesMdUnitMeasureDO doObj = new MesMdUnitMeasureDO();
        doObj.setId(dto.getId());
        doObj.setCode(dto.getCode());
        doObj.setName(dto.getName());
        doObj.setPrimaryFlag(dto.getPrimaryFlag());
        doObj.setPrimaryId(dto.getPrimaryId());
        doObj.setChangeRate(dto.getChangeRate());
        doObj.setStatus(dto.getStatus());
        return doObj;
    }

}