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

import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.module.mes.controller.admin.md.item.vo.bom.MesMdProductBomSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdItemDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdProductBomDO;
import cn.iocoder.yudao.module.mes.dal.mysql.md.item.MesMdProductBomMapper;
import cn.iocoder.yudao.module.system.api.agent.imports.AgentImportCommitReqVO;
import cn.iocoder.yudao.module.system.api.agent.imports.AgentImportModuleAdapter;
import cn.iocoder.yudao.module.system.api.agent.imports.AgentImportPreflightReqVO;
import cn.iocoder.yudao.module.system.api.agent.imports.AgentImportPreflightRespVO;
import cn.iocoder.yudao.module.system.api.agent.imports.AgentImportRowReceipt;
import cn.iocoder.yudao.module.system.framework.agent.AgentBridgeException;
import cn.iocoder.yudao.module.system.framework.agent.AgentPrincipal;
import cn.iocoder.yudao.module.system.service.agent.imports.SystemAgentGenericImportService;
import jakarta.annotation.Resource;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.util.*;

/**
 * BOM 导入：父/子物料必须已同步到 MES；已存在父子组合跳过，只新建不更新。
 */
@Component
public class MesBomImportAdapter implements AgentImportModuleAdapter {

    public static final String MODULE_ID = "mes.bom";
    private static final String PERMISSION = "mes:md-item:create";

    @Resource
    private MesMdItemService itemService;
    @Resource
    private MesMdProductBomService productBomService;
    @Resource
    private MesMdProductBomMapper productBomMapper;

    @Override
    public String moduleId() {
        return MODULE_ID;
    }

    @Override
    public String permission() {
        return PERMISSION;
    }

    @Override
    public AgentImportPreflightRespVO preflight(AgentPrincipal principal, AgentImportPreflightReqVO request) {
        // 1. 现有 BOM 图与父子组合索引，用于跳过与环检测
        Map<Long, Set<Long>> graph = new HashMap<>();
        Map<String, Long> pairs = new HashMap<>();
        for (MesMdProductBomDO bom : productBomMapper.selectAll()) {
            graph.computeIfAbsent(bom.getItemId(), key -> new HashSet<>()).add(bom.getBomItemId());
            pairs.put(pairKey(bom.getItemId(), bom.getBomItemId()), bom.getId());
        }

        Map<String, Optional<MesMdItemDO>> itemCache = new HashMap<>();
        Set<String> filePairs = new HashSet<>();
        List<AgentImportPreflightRespVO.Row> rows = new ArrayList<>();
        List<Map<String, Object>> resolvedPayload = new ArrayList<>();
        int create = 0;
        int skip = 0;
        int blocked = 0;

        for (AgentImportPreflightReqVO.Row row : request.getRows()) {
            List<AgentImportPreflightRespVO.Issue> blockers = new ArrayList<>();
            List<AgentImportPreflightRespVO.Issue> warnings = new ArrayList<>();
            String parentCode = value(row, "parentCode");
            String componentCode = value(row, "componentCode");
            if (parentCode.isEmpty()) {
                blockers.add(issue("PARENT_CODE_REQUIRED", "parentCode", "父项物料编码不能为空"));
            }
            if (componentCode.isEmpty()) {
                blockers.add(issue("COMPONENT_CODE_REQUIRED", "componentCode", "子项物料编码不能为空"));
            }
            BigDecimal quantity = parseQuantity(row.getValues().get("quantity"), blockers);
            Integer status = parseStatus(row.getValues().get("status"), blockers);

            MesMdItemDO parent = parentCode.isEmpty() ? null : lookup(itemCache, parentCode);
            MesMdItemDO component = componentCode.isEmpty() ? null : lookup(itemCache, componentCode);
            if (!parentCode.isEmpty() && parent == null) {
                blockers.add(issue("MES_ITEM_NOT_SYNCED", "parentCode",
                        "父项物料编码 " + parentCode + " 在 MES 物料中不存在，请先导入并同步物料"));
            }
            if (!componentCode.isEmpty() && component == null) {
                blockers.add(issue("MES_ITEM_NOT_SYNCED", "componentCode",
                        "子项物料编码 " + componentCode + " 在 MES 物料中不存在，请先导入并同步物料"));
            }

            String action;
            Long targetId = null;
            if (!blockers.isEmpty()) {
                action = "BLOCKED";
                blocked++;
            } else {
                String key = pairKey(parent.getId(), component.getId());
                if (parent.getId().equals(component.getId())) {
                    blockers.add(issue("BOM_SELF_REFERENCE", "componentCode", "父项与子项不能是同一物料"));
                    action = "BLOCKED";
                    blocked++;
                } else if (pairs.containsKey(key)) {
                    action = "SKIP";
                    targetId = pairs.get(key);
                    skip++;
                    warnings.add(issue("BOM_EXISTS", "componentCode",
                            "该父子物料组合已存在 BOM，已跳过且不会更新用量"));
                } else if (filePairs.contains(key)) {
                    blockers.add(issue("DUPLICATE_IN_FILE", "componentCode",
                            "文件内父项与子项组合重复，请核实用量版本"));
                    action = "BLOCKED";
                    blocked++;
                } else if (reaches(graph, component.getId(), parent.getId())) {
                    blockers.add(issue("BOM_CYCLE", "componentCode",
                            "新增后 BOM 将形成循环引用，请调整父子关系"));
                    action = "BLOCKED";
                    blocked++;
                } else {
                    action = "CREATE";
                    create++;
                    filePairs.add(key);
                    graph.computeIfAbsent(parent.getId(), item -> new HashSet<>()).add(component.getId());
                }
            }

            Map<String, Object> resolved = new LinkedHashMap<>();
            resolved.put("candidate_id", row.getCandidateId());
            resolved.put("parent_item_id", parent == null ? null : parent.getId());
            resolved.put("component_item_id", component == null ? null : component.getId());
            resolved.put("quantity", quantity);
            resolved.put("status", status);
            resolved.put("action", action);
            resolved.put("target_id", targetId);
            resolvedPayload.add(resolved);

            Map<String, Object> resolvedValues = new LinkedHashMap<>();
            resolvedValues.put("parentCode", parentCode);
            resolvedValues.put("componentCode", componentCode);
            resolvedValues.put("quantity", quantity);
            resolvedValues.put("status", status);
            rows.add(AgentImportPreflightRespVO.Row.builder()
                    .candidateId(row.getCandidateId())
                    .rowNo(row.getRowNo())
                    .action(action)
                    .resolved(resolvedValues)
                    .blockers(blockers)
                    .warnings(warnings)
                    .targetId(targetId)
                    .build());
        }

        int total = rows.size();
        return AgentImportPreflightRespVO.builder()
                .moduleId(MODULE_ID)
                .preflightHash(SystemAgentGenericImportService.preflightHash(MODULE_ID, request, resolvedPayload))
                .source(AgentImportPreflightRespVO.Source.builder()
                        .attachmentId(request.getAttachmentId())
                        .sessionId(request.getSessionId())
                        .sourceSha256(request.getSourceSha256())
                        .proposalRevision(request.getProposalRevision())
                        .build())
                .summary(AgentImportPreflightRespVO.Summary.builder()
                        .total(total).create(create).skip(skip).blocked(blocked).build())
                .canCommit(blocked == 0)
                .sideEffects(List.of("创建 BOM 父子用料关系", "不更新已存在的 BOM"))
                .rows(rows)
                .blockingItems(List.of())
                .build();
    }

    @Override
    public AgentImportRowReceipt commitRow(AgentPrincipal principal, AgentImportCommitReqVO request,
                                           AgentImportPreflightRespVO.Row planned,
                                           AgentImportPreflightReqVO.Row row) {
        String parentCode = value(row, "parentCode");
        String componentCode = value(row, "componentCode");
        MesMdItemDO parent = itemService.getItemByCode(parentCode);
        MesMdItemDO component = itemService.getItemByCode(componentCode);
        if (parent == null || component == null) {
            throw new AgentBridgeException(HttpStatus.CONFLICT, "MES_ITEM_NOT_SYNCED",
                    "物料在 MES 中已不存在，请重新同步后重试", true, null);
        }
        BigDecimal quantity = new BigDecimal(value(row, "quantity"));
        if (quantity.signum() <= 0) {
            throw new AgentBridgeException(HttpStatus.UNPROCESSABLE_ENTITY, "INVALID_QUANTITY",
                    "用量必须大于 0", false, null);
        }

        MesMdProductBomSaveReqVO saveReqVO = new MesMdProductBomSaveReqVO();
        saveReqVO.setItemId(parent.getId());
        saveReqVO.setBomItemId(component.getId());
        saveReqVO.setQuantity(quantity);
        saveReqVO.setStatus(parseStatus(row.getValues().get("status"), null));
        saveReqVO.setRemark(StrUtil.blankToDefault(row.getValues().get("remark"), null));

        Long id = productBomService.createProductBom(saveReqVO);
        return AgentImportRowReceipt.created(id, parentCode, componentCode);
    }

    private MesMdItemDO lookup(Map<String, Optional<MesMdItemDO>> cache, String code) {
        return cache.computeIfAbsent(code,
                key -> Optional.ofNullable(itemService.getItemByCode(key))).orElse(null);
    }

    /** 沿已有（含本次已接受的）父子边从 start 出发，判断能否到达 target。 */
    private static boolean reaches(Map<Long, Set<Long>> graph, Long start, Long target) {
        Deque<Long> stack = new ArrayDeque<>();
        Set<Long> visited = new HashSet<>();
        stack.push(start);
        while (!stack.isEmpty()) {
            Long node = stack.pop();
            if (!visited.add(node)) {
                continue;
            }
            if (node.equals(target)) {
                return true;
            }
            for (Long next : graph.getOrDefault(node, Set.of())) {
                stack.push(next);
            }
        }
        return false;
    }

    private static String pairKey(Long parentId, Long componentId) {
        return parentId + ":" + componentId;
    }

    private static AgentImportPreflightRespVO.Issue issue(String code, String field, String message) {
        return AgentImportPreflightRespVO.Issue.builder()
                .code(code).field(field).message(message).retryable(false).build();
    }

    private static String value(AgentImportPreflightReqVO.Row row, String key) {
        String raw = row.getValues() == null ? null : row.getValues().get(key);
        return raw == null ? "" : raw.trim();
    }

    private static BigDecimal parseQuantity(String raw, List<AgentImportPreflightRespVO.Issue> blockers) {
        if (StrUtil.isBlank(raw)) {
            if (blockers != null) {
                blockers.add(issue("INVALID_QUANTITY", "quantity", "用量必须是大于 0 的数字"));
            }
            return null;
        }
        try {
            BigDecimal quantity = new BigDecimal(raw.trim());
            if (quantity.signum() <= 0) {
                if (blockers != null) {
                    blockers.add(issue("INVALID_QUANTITY", "quantity", "用量必须大于 0"));
                }
                return quantity;
            }
            return quantity;
        } catch (NumberFormatException ex) {
            if (blockers != null) {
                blockers.add(issue("INVALID_QUANTITY", "quantity", "用量必须是大于 0 的数字"));
            }
            return null;
        }
    }

    private static Integer parseStatus(String raw, List<AgentImportPreflightRespVO.Issue> blockers) {
        if (StrUtil.isBlank(raw)) {
            return 0;
        }
        String value = raw.trim();
        if ("0".equals(value) || "1".equals(value)) {
            return Integer.valueOf(value);
        }
        if (blockers != null) {
            blockers.add(issue("INVALID_STATUS", "status", "状态只能是 0（启用）或 1（禁用）"));
        }
        return 0;
    }
}