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

import cn.hutool.crypto.digest.DigestUtil;
import cn.iocoder.yudao.module.mes.controller.admin.qc.indicator.vo.MesQcIndicatorSaveReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.template.vo.MesQcTemplateSaveReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.template.vo.indicator.MesQcTemplateIndicatorSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.indicator.MesQcIndicatorDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.template.MesQcTemplateDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.template.MesQcTemplateIndicatorDO;
import cn.iocoder.yudao.module.mes.dal.mysql.qc.indicator.MesQcIndicatorMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.qc.template.MesQcTemplateIndicatorMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.qc.template.MesQcTemplateMapper;
import cn.iocoder.yudao.module.mes.service.qc.indicator.MesQcIndicatorService;
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.AgentPrincipal;
import cn.iocoder.yudao.module.system.service.agent.imports.SystemAgentGenericImportService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Component;

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

/**
 * 质检方案导入：按检测项名称复用现有主数据；缺失项作为副作用提案，用户确认预检后才创建。
 */
@Component
public class MesQcTemplateImportAdapter implements AgentImportModuleAdapter {

    public static final String MODULE_ID = "mes.qc-template";

    @Resource private MesQcTemplateMapper templateMapper;
    @Resource private MesQcTemplateService templateService;
    @Resource private MesQcIndicatorMapper indicatorMapper;
    @Resource private MesQcIndicatorService indicatorService;
    @Resource private MesQcTemplateIndicatorMapper templateIndicatorMapper;
    @Resource private MesQcTemplateIndicatorService templateIndicatorService;

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

    @Override
    public String permission() {
        return "mes:qc-template:create";
    }

    @Override
    public List<String> permissions() {
        return List.of("mes:qc-template:create", "mes:qc-indicator:create");
    }

    @Override
    public AgentImportPreflightRespVO preflight(AgentPrincipal principal, AgentImportPreflightReqVO request) {
        List<AgentImportPreflightRespVO.Row> plannedRows = new ArrayList<>();
        List<Map<String, Object>> resolvedPayload = new ArrayList<>();
        Set<String> fileKeys = new HashSet<>();
        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 templateCode = value(row, "code");
            String templateName = value(row, "name");
            String indicatorName = value(row, "indicatorName");
            if (templateCode.isEmpty()) blockers.add(issue("TEMPLATE_CODE_REQUIRED", "code", "方案编号不能为空"));
            if (templateName.isEmpty()) blockers.add(issue("TEMPLATE_NAME_REQUIRED", "name", "方案名称不能为空"));
            if (indicatorName.isEmpty()) blockers.add(issue("INDICATOR_NAME_REQUIRED", "indicatorName", "检测项不能为空"));

            List<Integer> types = parseTypes(value(row, "types"), blockers);
            Integer status = parseInteger(value(row, "status"), 0, "status", blockers);
            Integer indicatorType = parseInteger(value(row, "indicatorType"), 5, "indicatorType", blockers);
            Integer resultType = parseInteger(value(row, "resultType"), 1, "resultType", blockers);
            BigDecimal thresholdMax = decimal(value(row, "thresholdMax"), "thresholdMax", blockers);
            BigDecimal thresholdMin = decimal(value(row, "thresholdMin"), "thresholdMin", blockers);

            MesQcIndicatorDO indicator = findIndicator(value(row, "indicatorCode"), indicatorName);
            String indicatorCode = indicator == null ? proposedCode(indicatorName) : indicator.getCode();
            String indicatorAction = indicator == null ? "CREATE_AFTER_REVIEW" : "REUSE";
            if (indicator == null && !indicatorName.isEmpty()) {
                warnings.add(issue("INDICATOR_WILL_CREATE", "indicatorName",
                        "系统不存在检测项“" + indicatorName + "”；确认导入后将先新增检测项 " + indicatorCode));
            }
            if (!value(row, "unitCode").isEmpty()) {
                warnings.add(issue("UNIT_REQUIRES_REVIEW", "unitCode",
                        "计量单位“" + value(row, "unitCode") + "”暂以原文保留，请复核系统单位关联"));
            }

            MesQcTemplateDO template = templateCode.isEmpty() ? null : templateMapper.selectByCode(templateCode);
            MesQcTemplateIndicatorDO relation = template == null || indicator == null ? null
                    : templateIndicatorMapper.selectListByTemplateId(template.getId()).stream()
                    .filter(item -> Objects.equals(item.getIndicatorId(), indicator.getId())).findFirst().orElse(null);
            String fileKey = templateCode + "\u0000" + indicatorName;
            String action;
            Long targetId = null;
            if (!blockers.isEmpty()) {
                action = "BLOCKED";
                blocked++;
            } else if (!fileKeys.add(fileKey)) {
                blockers.add(issue("DUPLICATE_IN_FILE", "indicatorName", "文件内检测项重复，请保留一条"));
                action = "BLOCKED";
                blocked++;
            } else if (relation != null) {
                action = "SKIP";
                targetId = relation.getId();
                skip++;
                warnings.add(issue("TEMPLATE_INDICATOR_EXISTS", "indicatorName", "方案已关联该检测项，已跳过"));
            } else {
                action = "CREATE";
                create++;
            }

            Map<String, Object> resolved = new LinkedHashMap<>();
            resolved.put("code", templateCode);
            resolved.put("name", templateName);
            resolved.put("types", types);
            resolved.put("status", status);
            resolved.put("indicatorCode", indicatorCode);
            resolved.put("indicatorName", indicatorName);
            resolved.put("indicatorType", indicatorType);
            resolved.put("resultType", resultType);
            resolved.put("indicatorAction", indicatorAction);
            resolved.put("thresholdMax", thresholdMax);
            resolved.put("thresholdMin", thresholdMin);
            resolved.put("standardValue", value(row, "standardValue"));
            resolved.put("unitCode", value(row, "unitCode"));
            resolved.put("action", action);
            resolvedPayload.add(resolved);

            plannedRows.add(AgentImportPreflightRespVO.Row.builder()
                    .candidateId(row.getCandidateId()).rowNo(row.getRowNo()).action(action)
                    .resolved(resolved).blockers(blockers).warnings(warnings).targetId(targetId).build());
        }
        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(plannedRows.size()).create(create).skip(skip).blocked(blocked).build())
                .canCommit(blocked == 0)
                .sideEffects(List.of(
                        "按方案编号创建质检方案（检测种类使用系统 mes_qc_type）",
                        "复用同名检测项；缺失检测项经本次人工确认后新增",
                        "创建方案与检测项关联，不覆盖现有检测项主数据"))
                .rows(plannedRows).blockingItems(List.of()).build();
    }

    @Override
    public AgentImportRowReceipt commitRow(AgentPrincipal principal, AgentImportCommitReqVO request,
                                           AgentImportPreflightRespVO.Row planned,
                                           AgentImportPreflightReqVO.Row row) {
        MesQcTemplateDO template = templateMapper.selectByCode(value(row, "code"));
        if (template == null) {
            MesQcTemplateSaveReqVO create = new MesQcTemplateSaveReqVO();
            create.setCode(value(row, "code"));
            create.setName(value(row, "name"));
            create.setTypes(parseTypes(value(row, "types"), new ArrayList<>()));
            create.setStatus(parseInteger(value(row, "status"), 0, "status", new ArrayList<>()));
            create.setRemark("来源：工业智能体文档补录；已由用户确认");
            Long id = templateService.createTemplate(create);
            template = templateService.getTemplate(id);
        }

        String indicatorName = value(row, "indicatorName");
        MesQcIndicatorDO indicator = findIndicator(value(row, "indicatorCode"), indicatorName);
        if (indicator == null) {
            MesQcIndicatorSaveReqVO create = new MesQcIndicatorSaveReqVO();
            create.setCode(proposedCode(indicatorName));
            create.setName(indicatorName);
            create.setType(parseInteger(value(row, "indicatorType"), 5, "indicatorType", new ArrayList<>()));
            create.setItemType(1);
            create.setParentId(0L);
            create.setResultType(parseInteger(value(row, "resultType"), 1, "resultType", new ArrayList<>()));
            create.setRemark("来源：工业智能体从已授权 SOP 提取；经用户审核新增");
            Long id = indicatorService.createIndicator(create);
            indicator = indicatorService.getIndicator(id);
        }

        Long indicatorId = indicator.getId();
        MesQcTemplateIndicatorDO existing = templateIndicatorMapper.selectListByTemplateId(template.getId()).stream()
                .filter(item -> Objects.equals(item.getIndicatorId(), indicatorId)).findFirst().orElse(null);
        if (existing != null) {
            return AgentImportRowReceipt.created(existing.getId(), value(row, "code"), indicatorName);
        }
        MesQcTemplateIndicatorSaveReqVO create = new MesQcTemplateIndicatorSaveReqVO();
        create.setTemplateId(template.getId());
        create.setIndicatorId(indicatorId);
        create.setThresholdMax(decimal(value(row, "thresholdMax"), "thresholdMax", new ArrayList<>()));
        create.setThresholdMin(decimal(value(row, "thresholdMin"), "thresholdMin", new ArrayList<>()));
        String standard = value(row, "standardValue");
        String unit = value(row, "unitCode");
        create.setRemark("原文标准：" + standard + (unit.isEmpty() ? "" : "；单位：" + unit));
        Long relationId = templateIndicatorService.createTemplateIndicator(create);
        return AgentImportRowReceipt.created(relationId, value(row, "code"), indicatorName);
    }

    private MesQcIndicatorDO findIndicator(String code, String name) {
        if (!code.isEmpty()) {
            MesQcIndicatorDO found = indicatorMapper.selectByCode(code);
            if (found != null) return found;
        }
        if (name.isEmpty()) return null;
        return indicatorService.getIndicatorList().stream()
                .filter(item -> name.equalsIgnoreCase(item.getName().trim())).findFirst().orElse(null);
    }

    private static String proposedCode(String name) {
        return "AI-QI-" + DigestUtil.sha256Hex(name == null ? "" : name.trim()).substring(0, 12).toUpperCase(Locale.ROOT);
    }

    private static List<Integer> parseTypes(String raw, List<AgentImportPreflightRespVO.Issue> blockers) {
        List<Integer> values = new ArrayList<>();
        for (String part : raw.replace("[", "").replace("]", "").split("[,，]")) {
            if (part.isBlank()) continue;
            try {
                int value = Integer.parseInt(part.trim());
                if (value < 1 || value > 4) throw new NumberFormatException();
                values.add(value);
            } catch (NumberFormatException ex) {
                blockers.add(issue("INVALID_QC_TYPE", "types", "检测种类必须使用系统字典值 1/2/3/4"));
            }
        }
        if (values.isEmpty()) blockers.add(issue("QC_TYPE_REQUIRED", "types", "检测种类不能为空"));
        return values;
    }

    private static Integer parseInteger(String raw, int defaultValue, String field,
                                        List<AgentImportPreflightRespVO.Issue> blockers) {
        if (raw.isEmpty()) return defaultValue;
        try {
            return Integer.valueOf(raw);
        } catch (NumberFormatException ex) {
            blockers.add(issue("INVALID_INTEGER", field, field + " 必须是整数"));
            return defaultValue;
        }
    }

    private static BigDecimal decimal(String raw, String field,
                                      List<AgentImportPreflightRespVO.Issue> blockers) {
        if (raw.isEmpty()) return null;
        try {
            return new BigDecimal(raw);
        } catch (NumberFormatException ex) {
            blockers.add(issue("INVALID_DECIMAL", field, field + " 必须是数字"));
            return null;
        }
    }

    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 AgentImportPreflightRespVO.Issue issue(String code, String field, String message) {
        return AgentImportPreflightRespVO.Issue.builder()
                .code(code).field(field).message(message).retryable(false).build();
    }
}