┌─────────────────────────────────────────────────────────┐
│  业务层  Platform / Listener / ...                       │
│         只管叫“人话”（如 getBlockState），不关心底层名字    │
├─────────────────────────────────────────────────────────┤
│  反射层  ReflectionUtils                                 │
│         提供 forName / call / findMethod / ...          │
│         内置缓存、父类回退、参数扫描                      │
├─────────────────────────────────────────────────────────┤
│  常量层  ReflectionConstants                             │
│         集中管理所有类名/方法名/字段名，负责不同映射间的转换  │
└─────────────────────────────────────────────────────────┘

private static final boolean IS_NAMED_RUNTIME;
static {
    FabricLoader fl = FabricLoader.getInstance();
    boolean namedRt = false;
    try {
        // MC 26+ 上 named 类是运行时类；1.18–1.21 只有 intermediary 的 class_NNNN
        Class.forName("net.minecraft.world.level.Level");
        namedRt = true;
    } catch (ClassNotFoundException ignored) {}
    IS_NAMED_RUNTIME = namedRt;
}

static Class<?> forName(String namedClassName) {
    Object cached = classCache.get(namedClassName);
    if (cached != null) return unwrap(cached);

    Class<?> cls = tryLoad(namedClassName);          // 1) 先试 named 名
    if (cls != null) { classCache.put(namedClassName, cls); return cls; }

    // NAMED_TO_INTER 是一张硬编码的表，记录了常用类的 intermediary 映射
    String inter = Constants.toIntermediaryClass(namedClassName);
    if (inter != null && !inter.equals(namedClassName)) {
        cls = tryLoad(inter);                        // 2) 不行就试 intermediary 名
        if (cls != null) { classCache.put(namedClassName, cls); return cls; }
    }
    classCache.put(namedClassName, NOT_FOUND);
    return null;
}

static final String M_GET_UUID = im("net.minecraft.world.entity.Entity", "getUUID",
    "()Ljava/util/UUID;", "method_5667"); // 5667 -> UUID, 5845 -> String

putM("getPlayerList",       M_GET_PLAYER_LIST);
putM("getPlayerManager",    M_GET_PLAYER_LIST);    // 1.18 的叫法
putM("getWorld",            M_GET_LEVEL);          // 1.18 的别名
putM("refreshPositionAfterTeleport", M_SET_POS);   // MC 26 的别名

private static void registerEvent(String eventClassName, String fieldName,
                                  String listenerInterfaceName, CallbackAdapter handler) {
    Class<?> eventCls = forName(eventClassName);
    Object eventObj = eventCls.getField(fieldName).get(null);

    Class<?> listenerInterface = forName(listenerInterfaceName);
    final Method abstractMethod = findAbstractMethod(listenerInterface); // 找到那个唯一的事件回调方法

    Object proxy = Proxy.newProxyInstance(
        eventCls.getClassLoader(),
        new Class<?>[]{listenerInterface},
        (proxyObj, method, args) -> {
            // equals, hashCode 那些不管，只管事件方法
            if (!method.equals(abstractMethod)) return handleObjectMethods(proxyObj, method, args);
            // 把原始参数 args 全打成 Object[] 丢给业务层自己用反射慢慢拆
            return handler.handle(args);   
        });

    registerMethod.invoke(eventObj, proxy);
}

static boolean checkPermission(Object source, String node) {
    for (Method m : findAllCheckMethods()) {          // 取出所有 check() 的重载
        Class<?> sourceType = m.getParameterTypes()[0];
        if (!sourceType.isInstance(source)) continue; // 匹配当前 source 的真实类型
        try {
            return (Boolean) m.invoke(null, source, node);
        } catch (Throwable t) { ... }
    }
    return false;
}

private static String getBlockId(Object blockState) {
    Object block = call(blockState, "getBlock");
    if (block == null) return "minecraft:air";
    
    // 策略 1：老老实实用 toString() 抠字符串。
    // Block.toString() 往往会吐出 "Block{minecraft:diorite}"，所有版本都通用且可靠！
    String s = block.toString();
    int brace = s.indexOf('{');
    int close = s.indexOf('}');
    if (brace >= 0 && close > brace) return s.substring(brace + 1, close);
    
    // 策略 2：反射注册表（这里还得兼容 BuiltInRegistries 和老版的 Registries）
    String id = getFromRegistry(block);
    if (id != null) return id;
    
    return "minecraft:air";
}

private static final Object NOT_FOUND = new Object();
// 找不着就存它，下次看见它直接绕道走