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

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
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.qc.indicatorresult.vo.MesQcIndicatorResultPageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.indicatorresult.vo.MesQcIndicatorResultSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.indicator.MesQcIndicatorDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.indicatorresult.MesQcIndicatorResultDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.indicatorresult.MesQcIndicatorResultDetailDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.ipqc.MesQcIpqcDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.iqc.MesQcIqcDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.oqc.MesQcOqcDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.rqc.MesQcRqcDO;
import cn.iocoder.yudao.module.mes.dal.mysql.qc.indicatorresult.MesQcIndicatorResultMapper;
import cn.iocoder.yudao.module.mes.enums.qc.MesQcResultValueTypeEnum;
import cn.iocoder.yudao.module.mes.enums.qc.MesQcTypeEnum;
import cn.iocoder.yudao.module.mes.service.qc.indicator.MesQcIndicatorService;
import cn.iocoder.yudao.module.mes.service.qc.ipqc.MesQcIpqcService;
import cn.iocoder.yudao.module.mes.service.qc.iqc.MesQcIqcService;
import cn.iocoder.yudao.module.mes.service.qc.oqc.MesQcOqcService;
import cn.iocoder.yudao.module.mes.service.qc.rqc.MesQcRqcService;
import cn.iocoder.yudao.module.system.api.dict.DictDataApi;
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.math.BigDecimal;
import java.net.URI;
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 MesQcIndicatorResultServiceImpl implements MesQcIndicatorResultService {

    @Resource
    private MesQcIndicatorResultMapper resultMapper;

    @Resource
    private MesQcIndicatorResultDetailService resultDetailService;
    @Resource
    private MesQcIndicatorService indicatorService;
    @Resource
    private MesQcIqcService iqcService;
    @Resource
    @Lazy
    private MesQcIpqcService ipqcService;
    @Resource
    @Lazy
    private MesQcOqcService oqcService;
    @Resource
    @Lazy
    private MesQcRqcService rqcService;

    @Resource
    private DictDataApi dictDataApi;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createIndicatorResult(MesQcIndicatorResultSaveReqVO createReqVO) {
        // 1.1 根据 qcType 查询源质检单，获取 itemId
        Long itemId = getItemIdFromQcDoc(createReqVO.getQcId(), createReqVO.getQcType());
        // 1.2 校验明细数据（indicatorId 存在性 + 值格式）
        validateItemsSaveData(createReqVO.getItems());

        // 2.1 插入主表
        MesQcIndicatorResultDO result = BeanUtils.toBean(createReqVO, MesQcIndicatorResultDO.class);
        result.setItemId(itemId);
        resultMapper.insert(result);
        // 2.2 批量插入明细
        List<MesQcIndicatorResultDetailDO> details = BeanUtils.toBean(createReqVO.getItems(),
                MesQcIndicatorResultDetailDO.class);
        details.forEach(detail -> detail.setResultId(result.getId()));
        resultDetailService.createDetailList(details);
        return result.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateIndicatorResult(MesQcIndicatorResultSaveReqVO updateReqVO) {
        // 1.1 校验存在
        validateIndicatorResultExists(updateReqVO.getId());
        // 1.2 校验明细数据（indicatorId 存在性 + 值格式）
        validateItemsSaveData(updateReqVO.getItems());

        // 2.1 更新主表（锁定 qcId/qcType/itemId，不允许改挂到其他质检单）
        MesQcIndicatorResultDO updateObj = BeanUtils.toBean(updateReqVO, MesQcIndicatorResultDO.class);
        updateObj.setQcId(null).setQcType(null).setItemId(null);
        resultMapper.updateById(updateObj);
        // 2.2 批量更新明细
        List<MesQcIndicatorResultDetailDO> details = BeanUtils.toBean(updateReqVO.getItems(),
                MesQcIndicatorResultDetailDO.class);
        resultDetailService.createOrUpdateDetailList(details);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteIndicatorResult(Long id) {
        // 1. 校验存在
        validateIndicatorResultExists(id);

        // 2.1 级联删除明细
        resultDetailService.deleteDetailByResultId(id);
        // 2.2 删除主表
        resultMapper.deleteById(id);
    }

    @Override
    public MesQcIndicatorResultDO getIndicatorResult(Long id) {
        return resultMapper.selectById(id);
    }

    @Override
    public PageResult<MesQcIndicatorResultDO> getIndicatorResultPage(MesQcIndicatorResultPageReqVO pageReqVO) {
        return resultMapper.selectPage(pageReqVO);
    }

    @Override
    public List<MesQcIndicatorResultDetailDO> getIndicatorResultDetailListByResultId(Long resultId) {
        return resultDetailService.getDetailListByResultId(resultId);
    }

    @Override
    public Long getIndicatorResultCountByQcIdAndType(Long qcId, Integer qcType) {
        return resultMapper.selectCountByQcIdAndType(qcId, qcType);
    }

    @Override
    public void validateIndicatorResultExistsByQcIdAndType(Long qcId, Integer qcType) {
        Long resultCount = getIndicatorResultCountByQcIdAndType(qcId, qcType);
        if (resultCount == 0) {
            throw exception(QC_FINISH_INDICATOR_RESULT_REQUIRED);
        }
    }

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

    private MesQcIndicatorResultDO validateIndicatorResultExists(Long id) {
        MesQcIndicatorResultDO result = resultMapper.selectById(id);
        if (result == null) {
            throw exception(QC_RESULT_NOT_EXISTS);
        }
        return result;
    }

    /**
     * 校验明细保存数据（indicatorId 存在性 + 值格式）
     */
    private void validateItemsSaveData(List<MesQcIndicatorResultSaveReqVO.Item> items) {
        // 校验所有明细的 indicatorId 是否存在
        Map<Long, MesQcIndicatorDO> indicatorMap = validateIndicatorIds(items);
        // 校验明细值格式是否符合指标的 resultType
        validateDetailValues(items, indicatorMap);
    }

    /**
     * 校验所有明细的 indicatorId 是否存在
     *
     * @return indicatorId -> MesQcIndicatorDO 映射，供后续值格式校验使用
     */
    private Map<Long, MesQcIndicatorDO> validateIndicatorIds(List<MesQcIndicatorResultSaveReqVO.Item> items) {
        if (CollUtil.isEmpty(items)) {
            return Collections.emptyMap();
        }
        Set<Long> indicatorIds = convertSet(items, MesQcIndicatorResultSaveReqVO.Item::getIndicatorId);
        return indicatorService.validateIndicatorListExists(indicatorIds);
    }

    /**
     * 按检测项的 resultType 校验明细值格式
     *
     * <p>FLOAT → 必须可解析为 BigDecimal；INTEGER → 必须可解析为整数；
     * DICT → 必须属于字典值域；FILE → 必须为 http/https URL；TEXT → 放行
     */
    private void validateDetailValues(List<MesQcIndicatorResultSaveReqVO.Item> items,
                                      Map<Long, MesQcIndicatorDO> indicatorMap) {
        if (CollUtil.isEmpty(items)) {
            return;
        }
        for (MesQcIndicatorResultSaveReqVO.Item item : items) {
            if (item.getIndicatorId() == null || StrUtil.isBlank(item.getValue())) {
                continue;
            }
            MesQcIndicatorDO indicator = indicatorMap.get(item.getIndicatorId());
            if (indicator == null || indicator.getResultType() == null) {
                continue;
            }
            Integer resultType = indicator.getResultType();
            if (Objects.equals(resultType, MesQcResultValueTypeEnum.FLOAT.getType())) {
                try {
                    new BigDecimal(item.getValue());
                } catch (NumberFormatException e) {
                    throw exception(QC_RESULT_VALUE_FORMAT_INVALID,
                            "检测项[" + indicator.getName() + "]要求浮点数，实际值=" + item.getValue());
                }
            } else if (Objects.equals(resultType, MesQcResultValueTypeEnum.INTEGER.getType())) {
                try {
                    Long.parseLong(item.getValue());
                } catch (NumberFormatException e) {
                    throw exception(QC_RESULT_VALUE_FORMAT_INVALID,
                            "检测项[" + indicator.getName() + "]要求整数，实际值=" + item.getValue());
                }
            }
            // DICT：校验值属于对应字典类型
            if (Objects.equals(resultType, MesQcResultValueTypeEnum.DICT.getType())) {
                String dictType = indicator.getResultSpecification();
                if (StrUtil.isNotBlank(dictType)) {
                    dictDataApi.validateDictDataList(dictType, Collections.singleton(item.getValue()));
                }
            }
            if (Objects.equals(resultType, MesQcResultValueTypeEnum.FILE.getType())
                    && !isHttpUrl(item.getValue())) {
                throw exception(QC_RESULT_VALUE_FORMAT_INVALID,
                        "检测项[" + indicator.getName() + "]要求文件 URL，实际值=" + item.getValue());
            }
            // TEXT 不做格式校验
        }
    }

    private boolean isHttpUrl(String value) {
        try {
            URI uri = URI.create(value);
            String scheme = uri.getScheme();
            return StrUtil.isNotBlank(uri.getHost())
                    && ("http".equalsIgnoreCase(scheme) || "https".equalsIgnoreCase(scheme));
        } catch (IllegalArgumentException e) {
            return false;
        }
    }

    /**
     * 根据 qcType 查询源质检单，获取 itemId
     */
    private Long getItemIdFromQcDoc(Long qcId, Integer qcType) {
        if (Objects.equals(qcType, MesQcTypeEnum.IQC.getType())) {
            MesQcIqcDO iqc = iqcService.validateIqcExists(qcId);
            return iqc.getItemId();
        } else if (Objects.equals(qcType, MesQcTypeEnum.IPQC.getType())) {
            MesQcIpqcDO ipqc = ipqcService.validateIpqcExists(qcId);
            return ipqc.getItemId();
        } else if (Objects.equals(qcType, MesQcTypeEnum.OQC.getType())) {
            MesQcOqcDO oqc = oqcService.validateOqcExists(qcId);
            return oqc.getItemId();
        } else if (Objects.equals(qcType, MesQcTypeEnum.RQC.getType())) {
            MesQcRqcDO rqc = rqcService.validateRqcExists(qcId);
            return rqc.getItemId();
        }
        throw new IllegalArgumentException("暂不支持 qcType=" + qcType);
    }

}