package cn.iocoder.yudao.module.mes.service.pd.knowledge;

import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.knowledge.KnowledgeDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.knowledge.KnowledgeStandardDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.knowledge.KnowledgeResourceDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.knowledge.KnowledgeReferenceDO;
import cn.iocoder.yudao.module.mes.dal.mysql.pd.knowledge.KnowledgeMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pd.knowledge.KnowledgeStandardMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pd.knowledge.KnowledgeResourceMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pd.knowledge.KnowledgeReferenceMapper;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdProductBomDO;
import cn.iocoder.yudao.module.mes.service.md.item.MesMdItemService;
import cn.iocoder.yudao.module.mes.service.md.item.MesMdProductBomService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Objects;
import java.util.stream.Collectors;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.invalidParamException;

/** 已发布知识的条件匹配；草稿和停用版本不参与推荐。 */
@Service
public class KnowledgeSearchService {
    @Resource private KnowledgeMapper knowledgeMapper;
    @Resource private KnowledgeStandardMapper standardMapper;
    @Resource private KnowledgeResourceMapper resourceMapper;
    @Resource private KnowledgeReferenceMapper referenceMapper;
    @Resource private MesMdItemService itemService;
    @Resource private MesMdProductBomService bomService;

    public PageResult<KnowledgeDO> page(PageParam page, String name) {
        return knowledgeMapper.selectPage(page, new LambdaQueryWrapperX<KnowledgeDO>()
                .likeIfPresent(KnowledgeDO::getName, name).orderByDesc(KnowledgeDO::getId));
    }

    public Detail get(Long id) {
        KnowledgeDO record = knowledgeMapper.selectById(id);
        if (record == null) return null;
        List<String> standards = standardMapper.selectList(new LambdaQueryWrapperX<KnowledgeStandardDO>()
                .eq(KnowledgeStandardDO::getKnowledgeId, id)).stream()
                .map(KnowledgeStandardDO::getStandardCode).toList();
        List<KnowledgeResourceDO> resources = resourceMapper.selectList(new LambdaQueryWrapperX<KnowledgeResourceDO>()
                .eq(KnowledgeResourceDO::getKnowledgeId, id));
        List<KnowledgeReferenceDO> references = referenceMapper.selectList(new LambdaQueryWrapperX<KnowledgeReferenceDO>()
                .eq(KnowledgeReferenceDO::getKnowledgeId, id));
        return new Detail(record, standards, resources, references);
    }

    public record Detail(KnowledgeDO knowledge, List<String> standards, List<KnowledgeResourceDO> resources, List<KnowledgeReferenceDO> references) {}

    public List<KnowledgeDO> match(KnowledgeMatch.Request request) {
        if (request.bomId() != null && request.productId() == null) throw invalidParamException("请选择 BOM 明细所属的物料");
        if (request.productId() != null) itemService.validateItemExists(request.productId());
        Set<Long> productBomItems;
        if (request.productId() != null) {
            productBomItems = bomService.getProductBomListByItemId(request.productId()).stream()
                    .filter(bom -> Objects.equals(bom.getItemId(), request.productId()) && Objects.equals(bom.getStatus(), 0)).map(MesMdProductBomDO::getBomItemId)
                    .filter(Objects::nonNull).collect(Collectors.toSet());
        } else productBomItems = Set.of();
        if (request.bomId() != null && !productBomItems.contains(request.bomId()))
            throw invalidParamException("所选 BOM 子物料不存在、未启用或不属于该物料");
        Set<Long> candidateBomItems = request.bomId() == null ? productBomItems : Set.of(request.bomId());
        List<KnowledgeDO> records = knowledgeMapper.selectList(new LambdaQueryWrapperX<KnowledgeDO>()
                .eq(KnowledgeDO::getStatus, 1).orderByDesc(KnowledgeDO::getId));
        if (records.isEmpty()) return List.of();
        List<Long> ids = records.stream().map(KnowledgeDO::getId).toList();
        Map<Long, Set<String>> standards = standardMapper.selectList(new LambdaQueryWrapperX<KnowledgeStandardDO>()
                        .in(KnowledgeStandardDO::getKnowledgeId, ids)).stream()
                .collect(Collectors.groupingBy(KnowledgeStandardDO::getKnowledgeId,
                        Collectors.mapping(KnowledgeStandardDO::getStandardCode, Collectors.toSet())));
        return records.stream().filter(record -> {
            if (record.getBomId() != null && !candidateBomItems.contains(record.getBomId())) return false;
            // 已按 BOM 子物料比对，向纯规则传递当前知识对应的约束。
            var resolvedRequest = new KnowledgeMatch.Request(request.productId(), record.getBomId(), request.voltage(), request.market(), request.standards());
            return KnowledgeMatch.matches(new KnowledgeMatch.Criteria(record.getProductItemId(), record.getBomId(),
                    record.getVoltageMin(), record.getVoltageMax(), record.getMarket(),
                    standards.getOrDefault(record.getId(), Set.of())), resolvedRequest);
        }).toList();
    }
}