package jnpf.bizcommon.audit.service;

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

import java.lang.reflect.Method;
import java.util.Map;

/**
 * 层 0 负缓存的**失败分类**探针（C1 二轮评审 I-3 的证据脚本）。
 *
 * <p>为什么必须实测而不能推：{@code AuditFormRegistry.deterministicParseFailure} 决定
 * 「这次解析失败要不要进负缓存」。判错的代价不对称——把**瞬时**失败判成确定性，该表单
 * 从此静默不被审计直到重启（缓存是进程级、无过期的）；反过来只是多查一次库。
 * L061 ① 记的就是这个坑，而它当时正是**推**出来的黑名单被实证推翻的。
 *
 * <p>本探针喂各种畸形输入给 {@code JsonUtil.getJsonToList}（层 0 反查主表用的正是它），
 * 打印真实异常链，再让 {@code deterministicParseFailure} 对它做判定，逐条断言。
 *
 * <p>退出码：0 = 全绿 / 1 = 有断言失败。**不连库、不起容器**，秒级。
 */
public final class AuditL0ParseFailureProbe {

    private static int passed;
    private static int failed;

    public static void main(String[] args) throws Exception {
        Method decide = AuditFormRegistry.class
                .getDeclaredMethod("deterministicParseFailure", Throwable.class);
        decide.setAccessible(true);

        System.out.println("=== 层0 解析失败分类探针（fastjson 实测链形 + 白名单判定）===");

        // ① 各类语法错误：应抛 JSONException → 确定性 → 可缓存
        expect(decide, "截断的 JSON", "[{\"table\":\"lims_x\"", true);
        expect(decide, "顶层非数组", "{\"table\":\"lims_x\"}", true);
        expect(decide, "元素非对象", "[1,2,3]", true);
        expect(decide, "空串以外的纯垃圾", "not json at all", true);

        // ② 畸形 Unicode 转义：**实测抛裸的 NumberFormatException、不被包装成 JSONException**
        //    （codex 独立复核发现，本探针独立复核其发现）。它同样是文本的固有属性 → 确定性。
        expect(decide, "畸形 Unicode 转义 \\uZZZZ", "[{\"table\":\"\\uZZZZ\"}]", true);

        // ③ 瞬时故障：**绝不能**判成确定性
        assertDecide(decide, "StackOverflowError（深层嵌套的真实形态）",
                new StackOverflowError(), false);
        assertDecide(decide, "OutOfMemoryError", new OutOfMemoryError(), false);
        assertDecide(decide, "线程中断", new InterruptedException(), false);
        assertDecide(decide, "包了一层的 SOE（池线程形态）",
                new RuntimeException(new StackOverflowError()), false);

        // ④ 自环 cause 链不能把遍历卡死（L061 的写法要求）。
        //    注意**不能**用 `e.initCause(e)` 构造——JDK 直接抛 IllegalArgumentException:
        //    Self-causation not permitted（本探针第一版就这么写的，当场炸了）。
        //    真实的自环只可能来自覆盖了 getCause() 的自定义异常，所以照那个形态造。
        assertDecide(decide, "自环 cause 链不死循环（覆盖 getCause 的形态）",
                new SelfCausedException(), false);

        System.out.println();
        System.out.printf("=== 层0 失败分类断言：%d 通过 / %d 失败 ===%n", passed, failed);
        if (failed > 0) {
            System.exit(1);
        }
    }

    /** 真喂一段畸形 JSON，打印它实际抛的异常链，再断言白名单的判定。 */
    private static void expect(Method decide, String label, String json, boolean deterministic) {
        Throwable caught = null;
        try {
            JsonUtil.getJsonToList(json, Map.class);
        } catch (Throwable t) {
            caught = t;
        }
        if (caught == null) {
            // 没抛异常也是有效信息（说明 fastjson 宽容地接受了它），不算失败，但要打印出来
            System.out.printf("  [INFO] %s → 未抛异常（fastjson 接受了这段输入）%n", label);
            return;
        }
        System.out.printf("  链形 %-28s → %s%n", label, chain(caught));
        assertDecide(decide, label, caught, deterministic);
    }

    private static void assertDecide(Method decide, String label, Throwable t, boolean expected) {
        boolean actual;
        try {
            actual = (Boolean) decide.invoke(null, t);
        } catch (Exception e) {
            System.out.printf("  [FAIL] %s → 判定方法自身抛异常：%s%n", label, e);
            failed++;
            return;
        }
        if (actual == expected) {
            System.out.printf("  [PASS] %s → %s%n", label,
                    expected ? "确定性（可负缓存）" : "瞬时（不缓存）");
            passed++;
        } else {
            System.out.printf("  [FAIL] %s → 判为%s，应为%s%s%n", label,
                    actual ? "确定性" : "瞬时", expected ? "确定性" : "瞬时",
                    expected ? "" : "  ← 危险方向：瞬时失败被永久负缓存 = 该表单静默不再被审计");
            failed++;
        }
    }

    private static String chain(Throwable t) {
        StringBuilder sb = new StringBuilder();
        for (Throwable c = t; c != null; c = (c.getCause() == c ? null : c.getCause())) {
            if (sb.length() > 0) {
                sb.append(" ← ");
            }
            sb.append(c.getClass().getSimpleName());
            if (c instanceof JSONException || c instanceof NumberFormatException) {
                sb.append("*");   // * = 命中白名单的那一环
            }
        }
        return sb.toString();
    }

    /** 唯一能造出自环 cause 的形态：覆盖 getCause() 返回自己。 */
    private static final class SelfCausedException extends RuntimeException {
        @Override
        public synchronized Throwable getCause() {
            return this;
        }
    }

    private AuditL0ParseFailureProbe() {
    }
}