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

import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
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.service.dv.machinery.MesDvMachineryService;
import cn.iocoder.yudao.module.mes.service.md.workstation.MesMdWorkstationService;
import cn.iocoder.yudao.module.mes.service.pro.process.MesProProcessService;
import cn.iocoder.yudao.module.mes.service.md.item.MesMdItemService;
import cn.iocoder.yudao.module.mes.service.md.item.MesMdProductBomService;
import cn.iocoder.yudao.module.mes.service.pro.route.MesProRouteService;
import cn.iocoder.yudao.module.mes.service.pd.processparamtemplate.MesPdProcessParamTemplateService;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import jakarta.annotation.Resource;
import lombok.Data;
import org.springframework.stereotype.Service;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.invalidParamException;

@Service
public class KnowledgeWriteService {
    @Resource private KnowledgeMapper knowledgeMapper;
    @Resource private KnowledgeStandardMapper standardMapper;
    @Resource private KnowledgeResourceMapper resourceMapper;
    @Resource private KnowledgeReferenceMapper referenceMapper;
    @Resource private MesDvMachineryService machineryService;
    @Resource private MesMdWorkstationService workstationService;
    @Resource private MesProProcessService processService;
    @Resource private MesMdItemService itemService;
    @Resource private MesMdProductBomService bomService;
    @Resource private MesProRouteService routeService;
    @Resource private MesPdProcessParamTemplateService templateService;

    @Data
    public static class SaveRequest {
        private Long id;
        private String code;
        private String name;
        private Long productItemId;
        private Long bomId;
        private BigDecimal voltageMin;
        private BigDecimal voltageMax;
        private String market;
        private Long routeId;
        private Long templateId;
        private String description;
        private List<String> standards;
        private List<ResourceInput> resources;
    }

    @Data
    public static class ResourceInput {
        private Long processId;
        private String resourceType;
        private Long resourceId;
        private String capabilityDescription;
    }

    @Transactional(rollbackFor = Exception.class)
    public Long create(SaveRequest input) {
        validate(input);
        String code = input.getCode().trim();
        if (!knowledgeMapper.selectList(new LambdaQueryWrapperX<KnowledgeDO>()
                .eq(KnowledgeDO::getCode, code).eq(KnowledgeDO::getVersion, 1)).isEmpty()) {
            throw invalidParamException("知识编码已存在");
        }
        var record = new KnowledgeDO();
        record.setCode(code); record.setVersion(1); record.setStatus(0);
        copyFields(record, input);
        try {
            knowledgeMapper.insert(record);
        } catch (DuplicateKeyException e) {
            throw invalidParamException("知识编码已存在");
        }
        saveStandards(record.getId(), input.getStandards());
        saveResources(record.getId(), input.getResources());
        return record.getId();
    }

    @Transactional(rollbackFor = Exception.class)
    public void update(SaveRequest input) {
        KnowledgeDO existing = input == null || input.getId() == null ? null : knowledgeMapper.selectById(input.getId());
        if (existing == null || !Integer.valueOf(0).equals(existing.getStatus())) {
            throw invalidParamException("知识不存在或不是可编辑的草稿");
        }
        validate(input);
        if (!existing.getCode().equals(input.getCode().trim())) throw invalidParamException("知识编码不可修改");
        var update = new LambdaUpdateWrapper<KnowledgeDO>()
                .eq(KnowledgeDO::getId, existing.getId()).eq(KnowledgeDO::getStatus, 0)
                .set(KnowledgeDO::getName, input.getName().trim())
                .set(KnowledgeDO::getProductItemId, input.getProductItemId()).set(KnowledgeDO::getBomId, input.getBomId())
                .set(KnowledgeDO::getVoltageMin, input.getVoltageMin()).set(KnowledgeDO::getVoltageMax, input.getVoltageMax())
                .set(KnowledgeDO::getMarket, input.getMarket()).set(KnowledgeDO::getRouteId, input.getRouteId())
                .set(KnowledgeDO::getTemplateId, input.getTemplateId()).set(KnowledgeDO::getDescription, input.getDescription());
        if (knowledgeMapper.update(null, update) != 1) throw invalidParamException("知识状态已变化，请刷新后重试");
        if (input.getStandards() != null) {
            standardMapper.delete(new LambdaQueryWrapperX<KnowledgeStandardDO>().eq(KnowledgeStandardDO::getKnowledgeId, existing.getId()));
            saveStandards(existing.getId(), input.getStandards());
        }
        if (input.getResources() != null) {
            resourceMapper.delete(new LambdaQueryWrapperX<KnowledgeResourceDO>().eq(KnowledgeResourceDO::getKnowledgeId, existing.getId()));
            saveResources(existing.getId(), input.getResources());
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void publish(Long id) {
        KnowledgeDO record = id == null ? null : knowledgeMapper.selectById(id);
        if (record == null || !Integer.valueOf(0).equals(record.getStatus()))
            throw invalidParamException("知识不存在或不是草稿");
        if (record.getRouteId() == null) throw invalidParamException("发布前请选择工艺路线");
        routeService.validateRouteExists(record.getRouteId());
        if (record.getTemplateId() != null) templateService.validateProcessParamTemplateExists(record.getTemplateId());
        var update = new LambdaUpdateWrapper<KnowledgeDO>().eq(KnowledgeDO::getId, id)
                .eq(KnowledgeDO::getStatus, 0).eq(KnowledgeDO::getRouteId, record.getRouteId());
        if (record.getTemplateId() == null) update.isNull(KnowledgeDO::getTemplateId);
        else update.eq(KnowledgeDO::getTemplateId, record.getTemplateId());
        if (knowledgeMapper.update(null, update.set(KnowledgeDO::getStatus, 1)) != 1)
            throw invalidParamException("知识状态已变化，请刷新后重试");
        // 同一编码只保留当前发布版本，旧版仍可作为引用快照追溯。
        knowledgeMapper.update(null, new LambdaUpdateWrapper<KnowledgeDO>()
                .eq(KnowledgeDO::getCode, record.getCode()).eq(KnowledgeDO::getStatus, 1)
                .lt(KnowledgeDO::getVersion, record.getVersion()).set(KnowledgeDO::getStatus, 2));
    }

    @Transactional(rollbackFor = Exception.class)
    public Long revise(Long id) {
        KnowledgeDO source = id == null ? null : knowledgeMapper.selectById(id);
        if (source == null || !Integer.valueOf(1).equals(source.getStatus()))
            throw invalidParamException("只能从已发布的知识创建新版本");
        List<KnowledgeDO> versions = knowledgeMapper.selectList(new LambdaQueryWrapperX<KnowledgeDO>()
                .eq(KnowledgeDO::getCode, source.getCode()).orderByDesc(KnowledgeDO::getVersion));
        if (versions.stream().anyMatch(version -> Integer.valueOf(0).equals(version.getStatus())))
            throw invalidParamException("该知识已有未发布的草稿版本");
        int nextVersion = versions.stream().map(KnowledgeDO::getVersion).max(Integer::compareTo).orElse(0) + 1;
        var draft = new KnowledgeDO();
        draft.setCode(source.getCode()); draft.setVersion(nextVersion); draft.setStatus(0); draft.setName(source.getName());
        draft.setProductItemId(source.getProductItemId()); draft.setBomId(source.getBomId());
        draft.setVoltageMin(source.getVoltageMin()); draft.setVoltageMax(source.getVoltageMax()); draft.setMarket(source.getMarket());
        draft.setRouteId(source.getRouteId()); draft.setTemplateId(source.getTemplateId()); draft.setDescription(source.getDescription());
        try { knowledgeMapper.insert(draft); }
        catch (DuplicateKeyException e) { throw invalidParamException("版本已变化，请刷新后重试"); }
        List<String> standards = standardMapper.selectList(new LambdaQueryWrapperX<KnowledgeStandardDO>()
                .eq(KnowledgeStandardDO::getKnowledgeId, source.getId())).stream().map(KnowledgeStandardDO::getStandardCode).toList();
        saveStandards(draft.getId(), standards);
        List<KnowledgeResourceDO> resources = resourceMapper.selectList(new LambdaQueryWrapperX<KnowledgeResourceDO>()
                .eq(KnowledgeResourceDO::getKnowledgeId, source.getId()));
        for (KnowledgeResourceDO resource : resources) {
            var copy = new KnowledgeResourceDO(); copy.setKnowledgeId(draft.getId());
            copy.setProcessId(resource.getProcessId()); copy.setResourceType(resource.getResourceType());
            copy.setResourceId(resource.getResourceId()); copy.setCapabilityDescription(resource.getCapabilityDescription());
            resourceMapper.insert(copy);
        }
        return draft.getId();
    }

    /** 记录参考关系，不修改目标路线或复制路线内容。 */
    @Transactional(rollbackFor = Exception.class)
    public void referenceRoute(Long knowledgeId, Long targetRouteId) {
        if (knowledgeId == null || targetRouteId == null) throw invalidParamException("请选择知识及目标工艺路线");
        KnowledgeDO source = knowledgeMapper.selectOne(new LambdaQueryWrapperX<KnowledgeDO>()
                .eq(KnowledgeDO::getId, knowledgeId).last("FOR UPDATE"));
        if (source == null || !Integer.valueOf(1).equals(source.getStatus()))
            throw invalidParamException("只能参考当前已发布的知识");
        routeService.validateRouteExists(targetRouteId);
        var reference = new KnowledgeReferenceDO(); reference.setKnowledgeId(source.getId());
        reference.setKnowledgeVersion(source.getVersion()); reference.setTargetType("ROUTE"); reference.setTargetId(targetRouteId);
        try { referenceMapper.insert(reference); }
        catch (DuplicateKeyException e) { throw invalidParamException("该路线已参考此知识版本"); }
    }

    private void validate(SaveRequest input) {
        if (input == null || input.getCode() == null || input.getCode().isBlank() || input.getCode().length() > 64
                || input.getName() == null || input.getName().isBlank() || input.getName().length() > 200)
            throw invalidParamException("请填写有效的知识编码和名称");
        if (input.getMarket() == null || !Set.of("ALL", "DOMESTIC", "EXPORT").contains(input.getMarket())) throw invalidParamException("内外销类型不正确");
        if ((input.getVoltageMin() != null && input.getVoltageMin().signum() < 0)
                || (input.getVoltageMax() != null && input.getVoltageMax().signum() < 0)
                || (input.getVoltageMin() != null && input.getVoltageMax() != null && input.getVoltageMin().compareTo(input.getVoltageMax()) > 0))
            throw invalidParamException("电压范围不正确");
        if (input.getProductItemId() != null) itemService.validateItemExists(input.getProductItemId());
        if (input.getBomId() != null) {
            if (input.getProductItemId() == null) throw invalidParamException("选择 BOM 明细前请先选择适用物料");
            boolean found = bomService.getProductBomListByItemId(input.getProductItemId()).stream()
                    .anyMatch(bom -> Objects.equals(bom.getItemId(), input.getProductItemId())
                            && Objects.equals(bom.getBomItemId(), input.getBomId()) && Objects.equals(bom.getStatus(), 0));
            if (!found) throw invalidParamException("所选 BOM 子物料不存在、未启用或不属于该物料");
        }
        if (input.getRouteId() != null) routeService.validateRouteExists(input.getRouteId());
        if (input.getTemplateId() != null) templateService.validateProcessParamTemplateExists(input.getTemplateId());
        if (input.getStandards() != null && input.getStandards().stream().anyMatch(s -> s == null || s.isBlank() || s.trim().length() > 128))
            throw invalidParamException("标准编码不能为空或超过 128 字符");
        if (input.getResources() != null) for (ResourceInput resource : input.getResources()) {
            if (resource == null || resource.getResourceType() == null || !Set.of("MACHINE", "WORKSTATION", "OTHER").contains(resource.getResourceType()))
                throw invalidParamException("资源类型不正确");
            if (resource.getCapabilityDescription() == null || resource.getCapabilityDescription().isBlank()
                    || resource.getCapabilityDescription().length() > 500) throw invalidParamException("请填写不超过 500 字的资源能力说明");
            if (resource.getProcessId() != null) processService.validateProcessExists(resource.getProcessId());
            if ("MACHINE".equals(resource.getResourceType())) {
                if (resource.getResourceId() == null) throw invalidParamException("请选择设备");
                machineryService.validateMachineryExists(resource.getResourceId());
            } else if ("WORKSTATION".equals(resource.getResourceType())) {
                if (resource.getResourceId() == null) throw invalidParamException("请选择工作站");
                workstationService.validateWorkstationExists(resource.getResourceId());
            } else if (resource.getResourceId() != null) throw invalidParamException("其他资源不能指定设备或工作站编号");
        }
    }

    private void copyFields(KnowledgeDO record, SaveRequest input) {
        record.setName(input.getName().trim()); record.setProductItemId(input.getProductItemId()); record.setBomId(input.getBomId());
        record.setVoltageMin(input.getVoltageMin()); record.setVoltageMax(input.getVoltageMax()); record.setMarket(input.getMarket());
        record.setRouteId(input.getRouteId()); record.setTemplateId(input.getTemplateId()); record.setDescription(input.getDescription());
    }

    private void saveStandards(Long id, List<String> standards) {
        if (standards == null) return;
        standards.stream().map(String::trim).distinct().forEach(code -> {
            var standard = new KnowledgeStandardDO(); standard.setKnowledgeId(id); standard.setStandardCode(code);
            standardMapper.insert(standard);
        });
    }

    private void saveResources(Long id, List<ResourceInput> resources) {
        if (resources == null) return;
        for (ResourceInput resource : resources) {
            var item = new KnowledgeResourceDO(); item.setKnowledgeId(id); item.setProcessId(resource.getProcessId());
            item.setResourceType(resource.getResourceType()); item.setResourceId(resource.getResourceId());
            item.setCapabilityDescription(resource.getCapabilityDescription().trim()); resourceMapper.insert(item);
        }
    }
}