package jnpf.bizcommon.audit.service.title;

import jnpf.bizcommon.audit.entity.AuditEventEntity;
import jnpf.audit.diff.AuditFieldDiff;
import jnpf.bizcommon.audit.entity.model.AuditFieldDiffViewVO;
import jnpf.bizcommon.audit.service.AuditFieldDiffViewService;
import jnpf.util.JsonUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

/**
 * 把表单勾选渲染成人可读的「操作记录标题」。
 *
 * <p><b>用展示值不用存储值</b>：字典/引用/枚举字段的存储值是雪花 ID 或字典码，直接拼进标题
 * 就是一串数字。这里复用 {@link AuditFieldDiffViewService#build}——也就是 {@code field_diffs}
 * 走的<b>同一条</b>展示解析路径，保证标题与字段明细里的同一个字段显示成同一个值。
 *
 * <p><b>三类字段绝不进标题</b>（顺序即优先级）：
 * <ol>
 *   <li>调用方传入的 {@code excludedFields}——脱敏列与判定为签名字段的列。
 *       标题是列表明文列，凭证/敏感值进去就洗不掉（审计表 append-only 保留 10 年）；</li>
 *   <li>展示解析后仍被标记 {@code masked} 的——双保险，防调用方漏传；</li>
 *   <li>值为空的——跳过而不是留一个空的 {@code /} 段。</li>
 * </ol>
 */
@Slf4j
@Component
public class AuditRecordTitleBuilder {

    /** 字段间分隔符。业务口径：a/b/c。 */
    public static final String SEPARATOR = "/";

    /** 单行标题的字符上限。主表行落 varchar(500)，留出余量；子表行同口径避免 extra 无限膨胀。 */
    private static final int MAX_LINE = 400;

    /**
     * 子表**标题条数**上限（产出侧）。超出的丢弃——列表只显示前 3 行，全量给详情。
     * 2026-08-05 起丢弃这件事会如实留痕（{@link AuditRecordTitle#SCOPE_ROWS_TRUNCATED}），
     * 此前是悄悄截的：读的人看到 200 条会以为那就是全部。
     */
    private static final int MAX_SUB_ROWS = 200;

    /**
     * 子表**扫描行数**上限（输入侧，2026-08-03 合批后新增）。
     *
     * <p>比 {@link #MAX_SUB_ROWS} 大一档：整行标题字段为空的行渲染不出标题却仍要占一个扫描名额，
     * 两者同值时「前 200 行恰好全空」就会让 recordSubTitles 直接空掉（Codex 终审缺陷 6）。
     * 放大到 4 倍是权衡——够吸收常见的空行比例，又把合成 diff 的规模钉在常数级。
     *
     * <p>2026-08-05 起它同时是<b>物化预算</b>：{@link #subRows} 按剩余额度截断复制，
     * 外层名额用尽直接 break 掉剩余子表（Codex 复审 Medium④）。此前它只挡渲染、挡不住复制。
     */
    private static final int MAX_SUB_SCAN = MAX_SUB_ROWS * 4;

    @Autowired
    private AuditFieldDiffViewService fieldDiffViewService;

    public AuditRecordTitle build(AuditTitleSpec spec,
                                  Map<String, Object> row,
                                  AuditEventEntity valueContext,
                                  Map<String, AuditFieldDiff.FieldMeta> labels,
                                  Set<String> excludedFields) {
        return build(spec, row, valueContext, labels, excludedFields,
                Collections.<String, String>emptyMap());
    }

    public AuditRecordTitle build(AuditTitleSpec spec,
                                  Map<String, Object> row,
                                  AuditEventEntity valueContext,
                                  Map<String, AuditFieldDiff.FieldMeta> labels,
                                  Set<String> excludedFields,
                                  Map<String, String> frontendDisplayValues) {
        if (spec == null || spec.isEmpty() || row == null || row.isEmpty()) {
            return AuditRecordTitle.EMPTY;
        }
        try {
            // ── 主表 + 全部子表行**一次解析**（2026-08-03，Codex 终审 Low：查询放大）────────
            // 原先每行各调一次 displayValues，而解析链里的 JnpfUserFieldValueResolver 每次一条
            // SQL——200 个子表行就是 201 次查询，全压在 MQ 消费线程上。解析器本身早就是批量的
            // （整批一次 IN），放大来自「按行切碎了喂给它」。这里先把所有待渲染的行攒齐，
            // 合成**一份** diff 交给同一条解析路径，再按位置分发回各行。
            List<List<String>> lineFields = new ArrayList<List<String>>();
            List<Map<String, Object>> lineRows = new ArrayList<Map<String, Object>>();
            lineFields.add(spec.mainFields());
            lineRows.add(row);                     // 下标 0 恒为主表行

            String subTable = null;
            boolean unavailable = false;
            // 输入侧没看全（额度耗尽）。**必须留痕**（2026-08-05 Codex 复审 Low）：额度耗尽后
            // 整张子表都不碰，连「事件里没带这批数据」都测不出来，unavailable 恒为 false——
            // 「判不了」就被伪装成了「没发生」（L075）。补看的代价正是资源上界刚拆掉的那笔，
            // 所以选择如实说「我没看全」，而不是花钱看全。
            boolean scanTruncated = false;
            for (AuditTitleSpec.SubTableSpec sub : spec.subTables()) {
                if (sub.fields().isEmpty()) {
                    continue;
                }
                // 🔴 上限**下推到取行那一步**（2026-08-05 Codex 复审 Medium④）：原先这道闸只挡住
                // 「进入渲染的行数」，而 subRows() 已经把整个子表反序列化并复制完了，外层达到
                // 上限之后还会继续把后面每一张子表都解析一遍——真正的资源上界从来没建立起来。
                // 现在名额用尽就 break，剩下的子表连碰都不碰；名额没用尽的传剩余额度进去，
                // 由 subRows 在物化时截断。
                int remaining = MAX_SUB_SCAN - (lineRows.size() - 1);
                if (remaining <= 0) {
                    scanTruncated = true;
                    break;
                }
                subTable = sub.tableName() != null ? sub.tableName() : sub.vModel();
                // **多要一行当哨兵**：拿回 remaining+1 行就说明这张子表还有没读的。
                // 只按 remaining 要则 rows.size()==remaining 时分不清「恰好读完」与「被截断」，
                // 而这两者对读的人是完全不同的两件事。多物化的那一行是 O(1)，换来精确判定。
                List<Map<String, Object>> rows = subRows(row, sub.vModel(), remaining + 1);
                if (rows != null && rows.size() > remaining) {
                    scanTruncated = true;
                    rows = rows.subList(0, remaining);
                }
                if (rows == null) {
                    // 表单配了子表标题字段，事件里却没有这批数据。**如实留痕**——
                    // 静默当成"没有子表"会把"判不了"伪装成"本来就没有"（同 subTableUndecidable 惯例）。
                    unavailable = true;
                    continue;
                }
                for (Map<String, Object> subRow : rows) {
                    lineFields.add(sub.fields());
                    lineRows.add(subRow);
                }
            }
            // 🔴 两道上限，口径不同，缺一不可（2026-08-03 Codex 终审缺陷 6）：
            //   · MAX_SUB_SCAN 限**参与解析的原始行数**——合批后行数直接决定合成 diff 的大小，
            //     没有它就得把所有行都塞进去才知道够不够，那正是要防的膨胀；
            //   · MAX_SUB_ROWS 限**产出的非空标题条数**——这是改动前的既有口径，必须保住。
            // 只留前者会退化：子表前 200 行标题字段恰好全空时，第 201 行起的有效标题全被丢掉，
            // recordSubTitles 直接空掉。所以扫描窗口开大一档，产出仍按老口径截断。
            List<String> lines = renderLines(lineFields, lineRows, valueContext, labels,
                    excludedFields, frontendDisplayValues);
            List<String> subTitles = new ArrayList<String>();
            // 产出侧截断同样留痕：这道上限从改动前就是**悄悄**截的，读的人看到 200 条
            // 会以为那就是全部（2026-08-05 Codex 复审 Low 顺带覆盖）。
            boolean rowsTruncated = false;
            // ⚠️ 先跳空行再判上限，顺序不能反：反过来的话「剩下的行恰好全渲染不出标题」
            // 也会被报成 truncated——那是把「看全了、只是没内容」说成了「没看全」，
            // 与 L075 骂的「两种缺席共用一个表示」是同一个错，只是方向相反。
            for (int i = 1; i < lines.size(); i++) {
                if (lines.get(i) == null) {
                    continue;
                }
                if (subTitles.size() >= MAX_SUB_ROWS) {
                    rowsTruncated = true;
                    break;
                }
                subTitles.add(lines.get(i));
            }
            // scanTruncated 优先：输入侧就没看全时，产出侧截没截已不是最重要的信息。
            String subScope = scanTruncated ? AuditRecordTitle.SCOPE_SCAN_TRUNCATED
                    : (rowsTruncated ? AuditRecordTitle.SCOPE_ROWS_TRUNCATED : null);
            return new AuditRecordTitle(lines.get(0), subTitles, subTable, unavailable, subScope);
        } catch (Throwable t) {
            // 标题渲染失败只该让标题缺席，不该让整条事件缺席（L002 的同款取舍，但作用域更小）
            log.warn("[AUDIT-L0] 记录标题渲染失败，本次事件不带标题：{}", t.toString());
            return AuditRecordTitle.EMPTY;
        }
    }

    /**
     * 表单未启用任何审计标题字段时，以当前业务记录的 {@code f_id} 作为标题。
     * 事件里的 {@code dataId} 是创建场景的可靠回退，因为提交原始数据不一定回填主键。
     */
    public String resolveMainTitle(AuditTitleSpec spec, AuditRecordTitle title,
                                   Map<String, Object> row, String dataId) {
        if (spec != null && !spec.isEmpty()) {
            return title == null ? null : title.mainTitle();
        }
        Object rowId = valueOf(row, "f_id");
        String recordId = rowId == null ? null : String.valueOf(rowId).trim();
        if (recordId == null || recordId.isEmpty()) {
            recordId = dataId == null ? null : dataId.trim();
        }
        if (recordId == null || recordId.isEmpty()) {
            return null;
        }
        return recordId.length() <= MAX_LINE ? recordId : recordId.substring(0, MAX_LINE);
    }

    /**
     * 多行**一次解析**：所有行的字段合成一份 diff 交给 {@link AuditFieldDiffViewService#build}，
     * 再按位置切回各行。返回值与入参逐位对应，渲染不出内容的行为 {@code null}。
     *
     * <p><b>为什么按位置分发而不是按字段名</b>：字段名在跨行时会重复（每个子表行都有同一批列），
     * 按名字建 Map 会互相覆盖。{@code build} 逐项等长返回且保序——它只在 {@code field} 缺席时
     * 丢项，而这里每一项都带非空 field，所以位置是可靠的键。
     *
     * <p><b>等长前提一旦不成立就退回逐行解析</b>：多查几次只是慢，而错位会把 A 行的值显示到
     * B 行的标题上——{@code record_title} 是 append-only 存十年的明文列，写错洗不掉。
     */
    private List<String> renderLines(List<List<String>> lineFields,
                                     List<Map<String, Object>> lineRows,
                                     AuditEventEntity valueContext,
                                     Map<String, AuditFieldDiff.FieldMeta> labels,
                                     Set<String> excludedFields,
                                     Map<String, String> frontendDisplayValues) {
        List<Map<String, Object>> items = new ArrayList<Map<String, Object>>();
        List<Integer> starts = new ArrayList<Integer>();
        for (int i = 0; i < lineRows.size(); i++) {
            starts.add(items.size());
            appendItems(items, lineFields.get(i), lineRows.get(i), excludedFields);
        }
        List<String> out = new ArrayList<String>(lineRows.size());
        if (items.isEmpty()) {
            for (int i = 0; i < lineRows.size(); i++) {
                out.add(null);
            }
            return out;
        }
        List<AuditFieldDiffViewVO> views = fieldDiffViewService.build(
                valueContext, JsonUtil.getObjectToString(items), labels);
        if (views == null || views.size() != items.size()) {
            log.warn("[AUDIT-L0] 标题合批解析返回 {} 项、期望 {} 项，退回逐行解析",
                    views == null ? -1 : views.size(), items.size());
            for (int i = 0; i < lineRows.size(); i++) {
                out.add(renderLine(lineFields.get(i), lineRows.get(i), valueContext,
                        labels, excludedFields, i == 0 ? frontendDisplayValues : null));
            }
            return out;
        }
        for (int i = 0; i < lineRows.size(); i++) {
            int from = starts.get(i);
            int to = i + 1 < starts.size() ? starts.get(i + 1) : items.size();
            Map<String, String> displays = toDisplays(views.subList(from, to));
            if (i == 0) {
                mergeFrontendDisplays(displays, lineFields.get(i), excludedFields,
                        frontendDisplayValues);
            }
            out.add(displays.isEmpty() ? null : assembleLine(lineFields.get(i), displays));
        }
        return out;
    }

    /** 渲染一行；全部字段为空或全被排除时返回 null（不产出空行）。合批前提不成立时的退路。 */
    private String renderLine(List<String> fields, Map<String, Object> row,
                              AuditEventEntity valueContext,
                              Map<String, AuditFieldDiff.FieldMeta> labels,
                              Set<String> excludedFields,
                              Map<String, String> frontendDisplayValues) {
        Map<String, String> displays = displayValues(fields, row, valueContext, labels, excludedFields);
        mergeFrontendDisplays(displays, fields, excludedFields, frontendDisplayValues);
        if (displays.isEmpty()) {
            return null;
        }
        return assembleLine(fields, displays);
    }

    private void mergeFrontendDisplays(Map<String, String> displays,
                                       List<String> configuredFields,
                                       Set<String> excludedFields,
                                       Map<String, String> frontendDisplayValues) {
        if (frontendDisplayValues == null || frontendDisplayValues.isEmpty()) {
            return;
        }
        for (String field : configuredFields) {
            String normalized = field.toLowerCase(Locale.ROOT);
            if (containsIgnoreCase(excludedFields, normalized)) {
                continue;
            }
            String value = frontendDisplayValues.get(normalized);
            if (value == null || value.trim().isEmpty()) {
                continue;
            }
            displays.put(normalized, truncate(value.trim(), MAX_LINE));
        }
    }

    /** 把解析好的展示值按字段顺序拼成 a/b/c；全空返回 null。 */
    private String assembleLine(List<String> fields, Map<String, String> displays) {
        StringBuilder sb = new StringBuilder();
        for (String field : fields) {
            String display = displays.get(field.toLowerCase(Locale.ROOT));
            if (display == null || display.isEmpty()) {
                continue;   // 空值跳过，不产生 a//c
            }
            if (sb.length() > 0) {
                sb.append(SEPARATOR);
            }
            sb.append(display);
            if (sb.length() >= MAX_LINE) {
                return sb.substring(0, MAX_LINE);
            }
        }
        return sb.length() == 0 ? null : sb.toString();
    }

    /**
     * 走 {@code field_diffs} 的同一条展示解析：把待渲染字段包成一份合成 diff，
     * 交给 {@link AuditFieldDiffViewService#build} 解析出 {@code newDisplay}。
     *
     * <p>{@code "type": 0} 是 field_diffs 契约里的"新增"，让解析侧只看 newData 那一侧。
     */
    private Map<String, String> displayValues(List<String> fields, Map<String, Object> row,
                                              AuditEventEntity valueContext,
                                              Map<String, AuditFieldDiff.FieldMeta> labels,
                                              Set<String> excludedFields) {
        List<Map<String, Object>> items = new ArrayList<Map<String, Object>>();
        appendItems(items, fields, row, excludedFields);
        if (items.isEmpty()) {
            return Collections.emptyMap();
        }
        return toDisplays(fieldDiffViewService.build(
                valueContext, JsonUtil.getObjectToString(items), labels));
    }

    /**
     * 把一行里待渲染的字段追加成合成 diff 的项。**每一项的 field 必然非空**——
     * 这是 {@link #renderLines} 按位置分发的前提（{@code build} 只在 field 缺席时丢项）。
     */
    private static void appendItems(List<Map<String, Object>> items, List<String> fields,
                                    Map<String, Object> row, Set<String> excludedFields) {
        if (fields == null || row == null) {
            return;
        }
        for (String field : fields) {
            if (field == null) {
                continue;
            }
            String lower = field.toLowerCase(Locale.ROOT);
            if (lower.isEmpty()) {
                continue;
            }
            if (excludedFields != null && excludedFields.contains(lower)) {
                continue;
            }
            String raw = AuditFieldDiff.stringify(valueOf(row, lower));
            if (raw.trim().isEmpty()) {
                continue;
            }
            Map<String, Object> item = new LinkedHashMap<String, Object>();
            item.put("field", lower);
            item.put("newData", raw);
            item.put("type", 0);
            items.add(item);
        }
    }

    /** 解析结果 → 字段名到展示值的映射。**调用方须保证这批 view 来自同一行**（字段名会跨行重复）。 */
    private static Map<String, String> toDisplays(List<AuditFieldDiffViewVO> views) {
        Map<String, String> out = new LinkedHashMap<String, String>();
        if (views == null) {
            return out;
        }
        for (AuditFieldDiffViewVO view : views) {
            if (view.getField() == null || Boolean.TRUE.equals(view.getMasked())) {
                continue;   // 双保险：解析侧判定为凭证的，即使调用方漏排除也不进标题
            }
            String display = view.getNewDisplay() != null && !view.getNewDisplay().isEmpty()
                    ? view.getNewDisplay() : view.getNewData();
            if (display != null && !display.trim().isEmpty()) {
                out.put(view.getField().toLowerCase(Locale.ROOT), display.trim());
            }
        }
        return out;
    }

    /**
     * 取子表行；键缺席或形态不对返回 null（= 不可得），空数组返回空列表（= 确实没有子记录）。
     *
     * <p><b>{@code limit} 是本方法的资源上界</b>（2026-08-05 Codex 复审 Medium④）：**物化时就截断**，
     * 不是先全量复制再交给调用方挑。调用方那道 {@link #MAX_SUB_SCAN} 只管得住「渲染几行」，
     * 管不住这里复制几行——一张 5000 行的子表照样会被整份搬进内存，而 MQ 消费线程上
     * 每条事件都要走一遍。
     *
     * <p><b>没被 limit 覆盖的那一半</b>：值是 JSON 字符串时 Jackson 仍要把整个数组解析完
     * （流式解析要换掉 {@link JsonUtil} 的入口，代价不成比例）。但那份原始文本本来就随事件
     * 报文一起在内存里了，真正会二次放大的是这里的对象复制与后续的合成 diff，两者都已按 limit 收住。
     */
    @SuppressWarnings("unchecked")
    private List<Map<String, Object>> subRows(Map<String, Object> row, String vModel, int limit) {
        Object raw = valueOf(row, vModel == null ? null : vModel.toLowerCase(Locale.ROOT));
        if (raw == null) {
            return null;
        }
        Object parsed = raw;
        if (raw instanceof String) {
            String text = ((String) raw).trim();
            if (text.isEmpty()) {
                return Collections.emptyList();
            }
            try {
                parsed = JsonUtil.getJsonToList(text, Map.class);
            } catch (Throwable t) {
                return null;
            }
        }
        if (!(parsed instanceof List)) {
            return null;
        }
        List<Map<String, Object>> out = new ArrayList<Map<String, Object>>();
        for (Object item : (List<?>) parsed) {
            if (out.size() >= limit) {
                break;   // 名额用尽：物化即止，不把整张子表搬进内存
            }
            if (item instanceof Map) {
                out.add((Map<String, Object>) item);
            }
        }
        return out;
    }

    private static Object valueOf(Map<String, Object> row, String lowerField) {
        if (row == null || lowerField == null) {
            return null;
        }
        for (Map.Entry<String, Object> entry : row.entrySet()) {
            if (entry.getKey() != null
                    && lowerField.equals(entry.getKey().toLowerCase(Locale.ROOT))) {
                return entry.getValue();
            }
        }
        return null;
    }

    private static boolean containsIgnoreCase(Set<String> values, String expected) {
        if (values == null || expected == null) {
            return false;
        }
        for (String value : values) {
            if (value != null && expected.equals(value.toLowerCase(Locale.ROOT))) {
                return true;
            }
        }
        return false;
    }

    private static String truncate(String value, int maxLength) {
        return value.length() <= maxLength ? value : value.substring(0, maxLength);
    }
}