package cn.iocoder.yudao.module.qcreport.service.aiimport.llm;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import cn.iocoder.yudao.module.qcreport.controller.admin.aiimport.vo.QcReportAiDraftRespVO;
import cn.iocoder.yudao.module.qcreport.controller.admin.aiimport.vo.QcReportComponentSpecVO;

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/**
 * 把模型解析出来的草稿归一成「只含合法组件、合法属性」的清单。
 * <p>
 * 三级防线的第三级，也是既有范式（ERP / CRM / MES 的 AI 调用）<b>没有</b>的一段。
 * 那三处是扁平单层结构、字段写死在代码里，错了就是错了；这次要喂给不可信的模型去产出嵌套结构，
 * 少这一层就会出现「模型编了个组件类型，前端装配器跳过它，用户看到的画布和预览对不上」。
 *
 * <h3>原则：单个元素坏掉不能让整个请求失败</h3>
 * 坏元素进 warnings、其余的照常返回。整体失败只在服务层判断（最终一项都不剩 → DRAFT_EMPTY），
 * 因为「大部分识别对了」和「全都没识别出来」对用户的含义完全不同。
 *
 * <h3>为什么后端也要过滤一遍（前端装配器已经过滤了）</h3>
 * 前端过滤发生在装配那一刻，用户看到的是「我上传了 5 个组件，画布上只出来 3 个」——没有解释。
 * 后端在预览阶段就把「哪一项被丢了、为什么」讲出来，用户才知道该补什么。
 * 这不是重复防线，是把静默失败变成可见失败。
 */
public class QcReportAiDraftNormalizer {

    private QcReportAiDraftNormalizer() {
    }

    /**
     * 归一结果。
     *
     * @param components 过滤后的组件，可能为空（空的最终由服务层报 DRAFT_EMPTY）
     * @param warnings   需要展示给用户的软提示
     */
    public record Result(List<QcReportAiDraftRespVO.DraftComponent> components, List<String> warnings) {
    }

    /**
     * 归一一次模型回复得到的组件。
     *
     * @param raw         解析出来的原始组件，允许含 null 元素
     * @param catalog     可用组件清单，决定哪些 type 与 prop key 合法
     * @param sourceLabel 来源标签（文件名 / 文件名+页码），会拼进提示文案
     */
    public static Result normalize(List<QcReportAiDraftRespVO.DraftComponent> raw,
                                   List<QcReportComponentSpecVO> catalog,
                                   String sourceLabel) {
        Map<String, QcReportComponentSpecVO> specByType = new TreeMap<>();
        for (QcReportComponentSpecVO spec : catalog) {
            if (spec != null && StrUtil.isNotBlank(spec.getType())) {
                specByType.put(spec.getType(), spec);
            }
        }
        List<QcReportAiDraftRespVO.DraftComponent> kept = new ArrayList<>();
        List<String> warnings = new ArrayList<>();
        String prefix = StrUtil.isBlank(sourceLabel) ? "" : sourceLabel + "：";

        if (raw == null) {
            return new Result(kept, warnings);
        }
        for (int i = 0; i < raw.size(); i++) {
            QcReportAiDraftRespVO.DraftComponent item = raw.get(i);
            int no = i + 1;
            if (item == null) {
                warnings.add(prefix + "第 " + no + " 项不是一个有效的组件对象，已忽略");
                continue;
            }
            String type = item.getType();
            if (StrUtil.isBlank(type)) {
                warnings.add(prefix + "第 " + no + " 项缺少组件类型，已忽略");
                continue;
            }
            QcReportComponentSpecVO spec = specByType.get(type);
            if (spec == null) {
                warnings.add(prefix + "AI 输出了组件清单外的组件类型「" + type + "」，已忽略");
                continue;
            }
            Map<String, Object> props = item.getProps();
            if (props == null || props.isEmpty()) {
                warnings.add(prefix + "组件「" + displayName(spec) + "」未识别出任何属性，已忽略");
                continue;
            }
            Map<String, Object> filtered = filterProps(props, spec, prefix, warnings);
            if (filtered.isEmpty()) {
                warnings.add(prefix + "组件「" + displayName(spec)
                        + "」的属性都不在清单声明范围内，已忽略");
                continue;
            }
            warnMissingRequired(filtered, spec, prefix, warnings);
            QcReportAiDraftRespVO.DraftComponent draft = new QcReportAiDraftRespVO.DraftComponent();
            draft.setType(type);
            draft.setProps(filtered);
            kept.add(draft);
        }
        return new Result(kept, warnings);
    }

    /**
     * 合并多次调用的结果并去重，最后按上限截断。
     * <p>
     * 去重是多页扫描件的必需品：页眉、报告标题、表头在每一页都会出现，逐页识别就会得到 N 份，
     * 不去重的话画布上会有 5 个一样的抬头。判定同一是
     * {@code (type, props 的稳定 JSON)}——props 先按 key 排序，因为不同页返回的 key 顺序
     * 不保证一致，直接比原始顺序会把同一个组件当成两个。
     *
     * @param perCallResults 各次调用归一后的结果，按执行顺序
     * @param maxComponents  组件总数上限，超出截断
     */
    public static Result mergeAndDedup(List<Result> perCallResults, int maxComponents) {
        List<QcReportAiDraftRespVO.DraftComponent> merged = new ArrayList<>();
        Set<String> seen = new LinkedHashSet<>();
        for (Result result : perCallResults) {
            for (QcReportAiDraftRespVO.DraftComponent component : result.components()) {
                if (seen.add(dedupKey(component))) {
                    merged.add(component);
                }
            }
        }
        int total = merged.size();
        List<String> warnings = new ArrayList<>();
        for (Result result : perCallResults) {
            warnings.addAll(result.warnings());
        }
        if (perCallResults.size() > 1 && total < countRaw(perCallResults)) {
            warnings.add(StrUtil.format(
                    "多页识别共得到 {} 项组件，其中有 {} 项在其它页已出现（页眉、标题、表头等重复内容），已合并",
                    countRaw(perCallResults), countRaw(perCallResults) - total));
        }
        if (maxComponents > 0 && total > maxComponents) {
            warnings.add(StrUtil.format("识别出的组件共 {} 项，超过单次上限 {} 项，已保留前 {} 项，其余请手工补充",
                    total, maxComponents, maxComponents));
            merged = new ArrayList<>(merged.subList(0, maxComponents));
        }
        return new Result(merged, warnings);
    }

    private static int countRaw(List<Result> results) {
        return results.stream().mapToInt(r -> r.components().size()).sum();
    }

    /**
     * 丢掉清单未声明的 prop key。
     * <p>
     * {@code fields} 为 <b>null</b>（清单压根没声明）与为 <b>空列表</b>（明确声明「这个组件不吃任何属性」）
     * 是两回事：前者无从判断，原样放行；后者才是真的要一个个丢掉。
     * 混为一谈会在前端漏传 fields 时把用户识别出来的属性静默抹平。
     */
    private static Map<String, Object> filterProps(Map<String, Object> props, QcReportComponentSpecVO spec,
                                                   String prefix, List<String> warnings) {
        if (spec.getFields() == null) {
            return props;
        }
        Set<String> allowed = new LinkedHashSet<>();
        for (QcReportComponentSpecVO.Field field : spec.getFields()) {
            if (field != null && StrUtil.isNotBlank(field.getKey())) {
                allowed.add(field.getKey());
            }
        }
        Map<String, Object> filtered = new TreeMap<>();
        List<String> dropped = new ArrayList<>();
        for (Map.Entry<String, Object> entry : props.entrySet()) {
            if (allowed.contains(entry.getKey())) {
                filtered.put(entry.getKey(), entry.getValue());
            } else {
                dropped.add(entry.getKey());
            }
        }
        if (!dropped.isEmpty()) {
            warnings.add(prefix + "组件「" + displayName(spec) + "」中不属于该组件的属性 "
                    + String.join("、", dropped) + " 已丢弃");
        }
        return filtered;
    }

    private static void warnMissingRequired(Map<String, Object> props, QcReportComponentSpecVO spec,
                                            String prefix, List<String> warnings) {
        if (spec.getFields() == null) {
            return;
        }
        for (QcReportComponentSpecVO.Field field : spec.getFields()) {
            if (field == null || !Boolean.TRUE.equals(field.getRequired())) {
                continue;
            }
            if (isBlankValue(props.get(field.getKey()))) {
                warnings.add(prefix + "组件「" + displayName(spec) + "」缺少必填属性「"
                        + fieldLabel(field) + "」，请在设计器属性面板中补上后再保存");
            }
        }
    }

    private static boolean isBlankValue(Object value) {
        if (value == null) {
            return true;
        }
        if (value instanceof CharSequence cs) {
            return StrUtil.isBlank(cs.toString());
        }
        return value instanceof Collection<?> collection && collection.isEmpty();
    }

    /**
     * 去重键：type + props 的稳定序列化。
     * <p>
     * props 先按 key 排序再用 {@link TreeMap}，保证「同样的组件、不同的 key 顺序」也能判为同一个。
     */
    private static String dedupKey(QcReportAiDraftRespVO.DraftComponent component) {
        Map<String, Object> props = component.getProps();
        return component.getType() + "" + JSONUtil.toJsonStr(props == null ? Map.of() : new TreeMap<>(props));
    }

    private static String displayName(QcReportComponentSpecVO spec) {
        return StrUtil.isNotBlank(spec.getLabel()) ? spec.getLabel() : spec.getType();
    }

    private static String fieldLabel(QcReportComponentSpecVO.Field field) {
        return StrUtil.isNotBlank(field.getLabel()) ? field.getLabel() : field.getKey();
    }

}