package jnpf.audit.diff;

import com.alibaba.fastjson.JSON;
import jnpf.util.JsonUtil;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

/**
 * 审计事件的泛化字段 diff——**层 0 与层 1 共用的数据契约**（B3 建立，C1 下沉共享）。
 *
 * <p>住在 {@code jnpf-audit-entity} 而不是某一层的实现包里，是因为它产出的正是
 * {@code audit_events.field_diffs} 这一列的形状：两层各写一份就必然漂移，而
 * {@code field_diffs} 一旦跨层不同构，查询侧与前端就得按层分支渲染，审计数据也不再可比。
 *
 * <p>与 lims 既有的 {@code LimsFieldDiff} 是**同一套输出形状**（{@code VisualLogModel[]}：
 * field / fieldName / oldData / newData / type），前端渲染可以直接复用；区别在于本类面对的是
 * 「两张按列名/字段名索引的 Map」而非实体类：
 * <ul>
 *   <li>比较的是**数据库列**（层 1，列全集来自 {@code SELECT *}）或**表单字段**（层 0，
 *       来自在线表单事件的 newData），新加的列/字段自动纳入；</li>
 *   <li>{@code fieldName} 默认回落成列名，可由 {@code labels} 参数补中文标签。
 *       <b>标签的来源必须是元数据而不是手写配置</b>——66 张 lims 表手写要上千条、且必然与表结构
 *       漂移，那是「看起来做完了、其实没有」的典型。层 0 的标签取自在线表单事件自带的
 *       {@code listLog}（表单模型元数据，随表单发布自动更新）；层 1 暂无元数据来源，
 *       故传 null 走列名回落。</li>
 * </ul>
 *
 * <h3>为什么要做类型归一（L006 的层 1 版本）</h3>
 * <p>before-image 与 after-image 虽然都来自 JDBC，但**同一列在两次查询里可能拿到不同的 Java 类型**
 * ——最典型的是数值列（{@code BigDecimal} vs {@code Integer} vs {@code Long}，取决于驱动与列定义）
 * 与时间列（{@code Timestamp} vs {@code Date}）。直接 {@code equals} 会把「没改过」判成「改了」，
 * 产出一堆假 diff，审计数据的可信度就毁了。故：数值一律按 {@link BigDecimal#compareTo} 比、
 * 时间一律按 epoch 毫秒比、字节数组按内容比。
 *
 * <h3>脱敏</h3>
 * <p>命中脱敏列（层 1 来自 {@code AuditTableRegistry#maskedColumns}，层 0 来自 Nacos 表单注册表）
 * 时**只记「已变更」不记值**——
 * 新旧值都写占位符。注意占位符要**成对出现**：只脱敏新值会让旧值把秘密漏出去。
 */
public final class AuditFieldDiff {

    /** 脱敏占位符：前端直接展示这个串，语义是「变了，但内容不予记录」。 */
    public static final String MASKED = "***";

    /** 前端按 {@code jnpfKey=='table'} 渲染子表行级变更入口。 */
    public static final String JNPF_KEY_TABLE = "table";

    private AuditFieldDiff() {
    }

    /**
     * 单个字段的**展示元数据**（不是值）。来源必须是表单模型元数据，不是手写配置。
     *
     * <p>D1 门禁查出：新 {@code field_diffs} 比 lims 旧 {@code data_log} 少四个键，
     * 而**每一个都有前端消费方**（`FormExtraPanel/DataLogList.vue` 的四条渲染分支）。
     * 本类补上其中两个——它们与已在用的 {@code fieldName} 同源同性质（都取自事件自带的
     * {@code listLog}，是**元数据不是值**，故不受 L003「平台 oldData 不可信」约束）：
     *
     * <ul>
     *   <li>{@link #nameModified}——<b>这一个是有实际危害的那条</b>。前端在它为 true 时
     *       只渲染「已修改」、**不打印值**。缺了它，字典/动态字段会把**存储原值**
     *       （雪花 ID / 字典码）当明文渲染出来：既没有可读性，又把不该直接示人的原值摆到了页面上。
     *       D1 实测旧数据 318 个 diff 项中 <b>63 项</b>为 true（select 42 + userSelect 21）。</li>
     *   <li>{@link #jnpfKey}——控件类型，驱动分支渲染：{@code sign}/{@code signature} 渲染成
     *       可点开的旧/新签名图片预览，其余走明文新旧值。缺了它签名会退化成一串 URL 文本。</li>
     * </ul>
     *
     * <h3>子表（{@code chidData} / {@code chidField}）由调用方追加</h3>
     * <p>这两个键同样在 {@code listLog} 里，但不是普通标量字段：
     * <ul>
     *   <li>普通字段仍由本类比较主表快照；子表必须按子表主键匹配行，不能把整段 JSON 当标量。</li>
     *   <li>visualdev 在业务写入前后读取数据库，并用原生日志算法生成完整的
     *       {@code chidData/chidField}；统一审计监听器校验两者同时存在后原样追加。</li>
     *   <li>旧事件或非标准发布方缺少可信 {@code listLog} 时，调用方继续写
     *       {@code extra.subTableUndecidable}，不构造伪差异。</li>
     * </ul>
     * <p>本类只承载子表控件元数据；行级结构由监听器追加，避免破坏层 1 的数据库列 diff 契约。
     */
    public static final class FieldMeta {
        private final String label;
        private final String jnpfKey;
        private final Boolean nameModified;
        private final String valueType;
        private final String componentType;
        private final String format;
        private final Map<String, String> optionLabels;
        private final String dictionaryType;
        private final Boolean hidden;

        public FieldMeta(String label, String jnpfKey, Boolean nameModified) {
            this(label, jnpfKey, nameModified, null, null, null, null, null, null);
        }

        public FieldMeta(String label, String jnpfKey, Boolean nameModified,
                         String valueType, String componentType, String format,
                         Map<String, String> optionLabels) {
            this(label, jnpfKey, nameModified, valueType, componentType, format,
                    optionLabels, null, null);
        }

        public FieldMeta(String label, String jnpfKey, Boolean nameModified,
                         String valueType, String componentType, String format,
                         Map<String, String> optionLabels, String dictionaryType,
                         Boolean hidden) {
            this.label = label;
            this.jnpfKey = jnpfKey;
            this.nameModified = nameModified;
            this.valueType = valueType;
            this.componentType = componentType;
            this.format = format;
            this.optionLabels = optionLabels == null || optionLabels.isEmpty()
                    ? Collections.emptyMap()
                    : Collections.unmodifiableMap(new LinkedHashMap<>(optionLabels));
            this.dictionaryType = dictionaryType;
            this.hidden = hidden;
        }

        public String label() {
            return label;
        }

        public String jnpfKey() {
            return jnpfKey;
        }

        public Boolean nameModified() {
            return nameModified;
        }

        public String valueType() {
            return valueType;
        }

        public String componentType() {
            return componentType;
        }

        public String format() {
            return format;
        }

        public Map<String, String> optionLabels() {
            return optionLabels;
        }

        public String dictionaryType() {
            return dictionaryType;
        }

        public Boolean hidden() {
            return hidden;
        }

        /** 使用表单在事件发生时携带的 options 生成展示快照；无法完整解析时返回 null。 */
        public String optionDisplay(String raw) {
            if (raw == null || raw.trim().isEmpty() || optionLabels.isEmpty()) {
                return raw == null || raw.trim().isEmpty() ? "" : null;
            }
            List<String> values = optionValues(raw);
            if (values.isEmpty()) {
                return null;
            }
            List<String> labels = new ArrayList<>(values.size());
            for (String value : values) {
                String label = optionLabels.get(value);
                if (label == null) {
                    return null;
                }
                labels.add(label);
            }
            return String.join("、", labels);
        }

        @SuppressWarnings("unchecked")
        private static List<String> optionValues(String raw) {
            String trimmed = raw.trim();
            if (!trimmed.startsWith("[")) {
                return Collections.singletonList(trimmed);
            }
            try {
                Object parsed = JSON.parse(trimmed);
                if (!(parsed instanceof Collection)) {
                    return Collections.emptyList();
                }
                List<String> values = new ArrayList<>();
                for (Object value : (Collection<Object>) parsed) {
                    if (value != null) {
                        values.add(String.valueOf(value));
                    }
                }
                return values;
            } catch (Throwable ignored) {
                return Collections.emptyList();
            }
        }
    }

    /**
     * 计算 before → after 的字段级 diff（无标签来源，{@code fieldName} 回落列名）。
     *
     * @param before before-image 行（DELETE 场景传删除前的行，after 传 null）
     * @param after  after-image 行（INSERT 场景传插入后的行，before 传 null）
     * @param masked 脱敏列（小写列名）
     * @return {@code VisualLogModel[]} 形状的 JSON 字符串；无差异时返回 {@code "[]"}（不返回 null）
     */
    public static String diff(Map<String, Object> before, Map<String, Object> after, Set<String> masked) {
        return diff(before, after, masked, null);
    }

    /**
     * 计算 before → after 的字段级 diff，并用 {@code meta} 补展示元数据。
     *
     * @param meta 字段名 → {@link FieldMeta}（中文标签 / 控件类型 / 是否只显示「已修改」）。
     *             null 或查不到的字段：{@code fieldName} 回落成字段名本身，
     *             {@code jnpfKey}/{@code nameModified} 两个键**整个不出现**。
     *             <p><b>「查不到就不出这个键」是刻意的，不是省事</b>：层 1 没有元数据来源
     *             （它面对的是数据库列，没有表单模型），恒传 null。若无条件补上
     *             {@code "jnpfKey":null} 之类，层 1 的 190 条既有断言会因形状变化而红，
     *             而它的语义一点没变——那是纯粹的自伤。缺席即「本层给不出」，
     *             前端按 key 存在与否分支，天然兼容。
     *             <p>元数据**不参与比较、不影响是否记录**，所以它缺失最坏只是显示得糙一点，
     *             绝不会让一处真实变更消失。
     */
    public static String diff(Map<String, Object> before, Map<String, Object> after,
                              Set<String> masked, Map<String, FieldMeta> meta) {
        List<Map<String, Object>> items = new ArrayList<>();
        for (String column : unionColumns(before, after)) {
            Object oldValue = before == null ? null : before.get(column);
            Object newValue = after == null ? null : after.get(column);
            if (valuesEqual(oldValue, newValue)) {
                continue;
            }
            FieldMeta fm = fieldMeta(meta, column);
            boolean hide = isMasked(column, masked) || isCredentialMetadata(fm);
            Map<String, Object> item = new LinkedHashMap<>();
            item.put("field", column);
            String label = fm == null ? null : fm.label();
            item.put("fieldName", label == null || label.isEmpty() ? column : label);
            // 顺序对齐 lims 旧 VisualLogModel，方便与旧 data_log 逐项对照；前端按 key 取，不依赖顺序。
            if (fm != null && fm.jnpfKey() != null && !fm.jnpfKey().isEmpty()) {
                item.put("jnpfKey", fm.jnpfKey());
            }
            String oldData = hide ? MASKED : stringify(oldValue);
            String newData = hide ? MASKED : stringify(newValue);
            item.put("oldData", oldData);
            item.put("newData", newData);
            if (fm != null && fm.valueType() != null) {
                item.put("valueType", fm.valueType());
            }
            if (fm != null && fm.componentType() != null) {
                item.put("componentType", fm.componentType());
            }
            if (fm != null && fm.format() != null) {
                item.put("format", fm.format());
            }
            if (fm != null && fm.dictionaryType() != null) {
                item.put("dictionaryType", fm.dictionaryType());
            }
            if (!hide && fm != null) {
                String oldDisplay = fm.optionDisplay(oldData);
                String newDisplay = fm.optionDisplay(newData);
                if (oldDisplay != null) {
                    item.put("oldDisplay", oldDisplay);
                }
                if (newDisplay != null) {
                    item.put("newDisplay", newDisplay);
                }
            }
            // nameModified=true 时前端只渲染「已修改」不打印值。**脱敏列上照样带**——
            // 两者不冲突：脱敏管的是「值不记」，nameModified 管的是「值不展示」，
            // 同时成立时前端显示「已修改」而不是 `***`，语义更准。
            if (fm != null && fm.nameModified() != null) {
                item.put("nameModified", fm.nameModified());
            }
            // 与 LimsFieldDiff 同义：0=从无到有（新增），1=修改。
            // **脱敏列恒记 1**（B5 评审 M-3）：type=0 等于告诉读者「这列此前没有值」——
            // 内容没漏，存在性漏了半格（「初始密码是第一次设置」本身就是信息）。
            // 脱敏的承诺是「只记已变更」，那就连这半格也不给。
            item.put("type", !hide && isEmpty(oldValue) ? 0 : 1);
            items.add(item);
        }
        return JsonUtil.getObjectToString(items);
    }

    /**
     * 表单 vModel 保留 camelCase，而 PostgreSQL 未加引号的列名会折叠为小写。
     * 元数据注册表统一存小写键，因此先精确匹配，再按小写键回退。
     */
    private static FieldMeta fieldMeta(Map<String, FieldMeta> meta, String column) {
        if (meta == null || column == null) {
            return null;
        }
        FieldMeta exact = meta.get(column);
        return exact != null ? exact : meta.get(column.toLowerCase(Locale.ROOT));
    }

    /**
     * 整行快照（落 {@code data_snapshot}）。DELETE 用 before、其余用 after——
     * 快照的意义是「这次操作之后这行长什么样」，删除则是「删掉的是什么」。
     */
    public static String snapshot(Map<String, Object> row, Set<String> masked) {
        return snapshot(row, masked, null);
    }

    /** 整行快照，额外使用字段元数据识别非固定列名的签名控件。 */
    public static String snapshot(Map<String, Object> row, Set<String> masked,
                                  Map<String, FieldMeta> meta) {
        if (row == null) {
            return null;
        }
        Map<String, Object> out = new LinkedHashMap<>();
        for (Map.Entry<String, Object> entry : row.entrySet()) {
            String column = entry.getKey();
            FieldMeta fm = fieldMeta(meta, column);
            out.put(column, isMasked(column, masked) || isCredentialMetadata(fm)
                    ? MASKED : stringify(entry.getValue()));
        }
        return JsonUtil.getObjectToString(out);
    }

    /** 签名控件的脱敏由元数据决定，不依赖字段名约定。 */
    public static boolean isCredentialMetadata(FieldMeta meta) {
        if (meta == null) {
            return false;
        }
        String valueType = lower(meta.valueType());
        String componentType = lower(meta.componentType());
        String jnpfKey = lower(meta.jnpfKey());
        return "masked".equals(valueType)
                || "sign".equals(componentType)
                || "signature".equals(componentType)
                || "sign".equals(jnpfKey)
                || "signature".equals(jnpfKey);
    }

    private static String lower(String value) {
        return value == null ? null : value.trim().toLowerCase(Locale.ROOT);
    }

    /** after 的列在前、before 独有的列补在后：输出顺序对人读 diff 更友好，且稳定可断言。 */
    private static Set<String> unionColumns(Map<String, Object> before, Map<String, Object> after) {
        Set<String> columns = new LinkedHashSet<>();
        if (after != null) {
            columns.addAll(after.keySet());
        }
        if (before != null) {
            columns.addAll(before.keySet());
        }
        return columns;
    }

    private static boolean isMasked(String column, Set<String> masked) {
        return masked != null && column != null && masked.contains(column.toLowerCase(Locale.ROOT));
    }

    /**
     * 归一化比较。**顺序有讲究**：先处理 null，再按「数值 / 时间 / 字节数组」三类归一，
     * 最后才退回 equals——反过来写会让 {@code BigDecimal("1.0")} 与 {@code 1} 判成不等。
     *
     * <p><b>整段包 try（B3 评审 I-1）</b>：比较单个值时抛出的异常曾能穿出 {@code diff()}，
     * 被 emitter 的总兜底吃掉，结果是**该行连同其后所有行的事件全部静默消失**——
     * 漏记真实变更比记错更严重。现在退化成「按不相等处理」：最坏是多记一条字段变更，
     * 不会让整条事件消失。
     */
    public static boolean valuesEqual(Object a, Object b) {
        try {
            if (isEmpty(a) && isEmpty(b)) {
                return true;
            }
            if (a == null || b == null) {
                return a == null && b == null;
            }
            if (a instanceof Number && b instanceof Number) {
                return numbersEqual((Number) a, (Number) b);
            }
            if (a instanceof Date && b instanceof Date) {
                // 用 compareTo 而非 getTime()（评审 M-3）：java.sql.Timestamp 的纳秒精度不在
                // getTime() 里，亚毫秒差异会被判成"没变"——那是漏记真实变更。
                // Timestamp.compareTo(Date) 与 Date.compareTo 都按各自完整精度比。
                return compareDates((Date) a, (Date) b);
            }
            if (a instanceof byte[] && b instanceof byte[]) {
                // 字节数组的 equals 是引用比较，不归一会让每次 diff 都把 BLOB 列报成「已变更」
                return Arrays.equals((byte[]) a, (byte[]) b);
            }
            return Objects.equals(a, b);
        } catch (Throwable t) {
            return false;   // 比较不了就当"变了"：宁可多记一条，也不让整条事件消失
        }
    }

    /**
     * 数值比较。**先挡住非有限值**（NaN / ±Infinity）：它们是 PG float8/real 的合法值，
     * 而 {@code BigDecimal.valueOf(NaN)} 直接抛 {@code NumberFormatException}（评审 I-1 实证，
     * 连 {@code NaN vs NaN} 都炸）。非有限值一律退回 {@code Double.compare} 的语义——
     * 它把 {@code NaN == NaN} 判为相等、{@code NaN != 1.0} 判为不等，正是审计想要的。
     */
    private static boolean numbersEqual(Number a, Number b) {
        if (isNonFinite(a) || isNonFinite(b)) {
            return Double.compare(a.doubleValue(), b.doubleValue()) == 0;
        }
        return toBigDecimal(a).compareTo(toBigDecimal(b)) == 0;
    }

    private static boolean isNonFinite(Number number) {
        if (number instanceof Double || number instanceof Float) {
            double value = number.doubleValue();
            return Double.isNaN(value) || Double.isInfinite(value);
        }
        return false;
    }

    /** {@code Timestamp} 与 {@code Date} 混比时以 Timestamp 一侧的完整精度为准。 */
    private static boolean compareDates(Date a, Date b) {
        if (a instanceof java.sql.Timestamp || b instanceof java.sql.Timestamp) {
            java.sql.Timestamp left = a instanceof java.sql.Timestamp
                    ? (java.sql.Timestamp) a : new java.sql.Timestamp(a.getTime());
            java.sql.Timestamp right = b instanceof java.sql.Timestamp
                    ? (java.sql.Timestamp) b : new java.sql.Timestamp(b.getTime());
            return left.compareTo(right) == 0;
        }
        return a.getTime() == b.getTime();
    }

    private static BigDecimal toBigDecimal(Number number) {
        if (number instanceof BigDecimal) {
            return (BigDecimal) number;
        }
        if (number instanceof Double || number instanceof Float) {
            return BigDecimal.valueOf(number.doubleValue());
        }
        if (number instanceof java.math.BigInteger) {
            return new BigDecimal((java.math.BigInteger) number);   // 别经 longValue() 截断
        }
        return BigDecimal.valueOf(number.longValue());
    }

    /** 展示用字符串。null → 空串（与 LimsFieldDiff 一致，前端按空串判「无值」）。 */
    public static String stringify(Object value) {
        if (value == null) {
            return "";
        }
        if (value instanceof Date) {
            return new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format((Date) value);
        }
        if (value instanceof byte[]) {
            return "byte[" + ((byte[]) value).length + "]";   // 不把二进制塞进审计文本
        }
        return String.valueOf(value);
    }

    private static boolean isEmpty(Object value) {
        if (value == null) {
            return true;
        }
        if (value instanceof CharSequence) {
            return value.toString().trim().isEmpty();
        }
        if (value instanceof Collection) {
            return ((Collection<?>) value).isEmpty();
        }
        return value instanceof Map && ((Map<?, ?>) value).isEmpty();
    }
}