// 简单规则引擎 - 使用 Java 编译 API 动态编译规则
import javax.tools.*;
import java.util.*;

public class RuleEngine {
    
    private final JavaCompiler compiler;
    private final Map<String, Class<?>> ruleCache = new HashMap<>();
    
    public RuleEngine() {
        this.compiler = ToolProvider.getSystemJavaCompiler();
    }
    
    // 编译规则
    public Class<?> compileRule(String ruleName, String ruleCode) {
        if (ruleCache.containsKey(ruleName)) {
            return ruleCache.get(ruleName);
        }
        
        String fullCode = String.format("""
            import java.util.Map;
            
            public class %s implements Rule {
                @Override
                public boolean evaluate(Map<String, Object> context) {
                    %s
                }
            }
            """, ruleName, ruleCode);
        
        // 编译
        JavaFileObject source = new JavaSourceFromString(ruleName, fullCode);
        compiler.getTask(null, null, null, null, null, List.of(source)).call();
        
        // 加载
        try {
            ClassLoader cl = new DynamicClassLoader();
            Class<?> clazz = cl.loadClass(ruleName);
            ruleCache.put(ruleName, clazz);
            return clazz;
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
    
    // 执行规则
    public boolean evaluate(String ruleName, Map<String, Object> context) {
        try {
            Class<?> ruleClass = compileRule(ruleName, getRuleCode(ruleName));
            Rule rule = (Rule) ruleClass.getDeclaredConstructor().newInstance();
            return rule.evaluate(context);
        } catch (Exception e) {
            throw new RuntimeException("Rule execution failed", e);
        }
    }
    
    // 使用示例
    public static void main(String[] args) {
        RuleEngine engine = new RuleEngine();
        
        // 定义规则
        engine.compileRule("discount_rule",
            """
            double amount = (double) context.get("amount");
            int age = (int) context.get("age");
            return amount > 1000 && age > 18;
            """);
        
        // 执行规则
        Map<String, Object> context = Map.of(
            "amount", 1500.0,
            "age", 25
        );
        
        boolean result = engine.evaluate("discount_rule", context);
        System.out.println("折扣资格: " + result);
    }
}

interface Rule {
    boolean evaluate(Map<String, Object> context);
}

// 使用 GraalVM Polyglot 支持多种语言规则
import org.graalvm.polyglot.*;

public class PolyglotRuleEngine {
    
    private final Context polyglotContext;
    
    public PolyglotRuleEngine() {
        this.polyglotContext = Context.newBuilder("js", "python")
            .allowAllAccess(true)
            .build();
    }
    
    // JavaScript 规则
    public boolean evaluateJSRule(String rule, Map<String, Object> data) {
        polyglotContext.getBindings("js").putMember("data", data);
        return polyglotContext.eval("js", rule).asBoolean();
    }
    
    // Python 规则
    public boolean evaluatePythonRule(String rule, Map<String, Object> data) {
        polyglotContext.getBindings("python").putMember("data", data);
        return polyglotContext.eval("python", rule).asBoolean();
    }
    
    public static void main(String[] args) {
        PolyglotRuleEngine engine = new PolyglotRuleEngine();
        
        Map<String, Object> order = Map.of(
            "amount", 1500.0,
            "customer_type", "VIP",
            "items", List.of("laptop", "mouse")
        );
        
        // JavaScript 规则
        boolean jsResult = engine.evaluateJSRule(
            "data.get('amount') > 1000 && data.get('customer_type') === 'VIP'",
            order
        );
        
        // Python 规则
        boolean pyResult = engine.evaluatePythonRule(
            "data['amount'] > 1000 and 'laptop' in data['items']",
            order
        );
    }
}

// Drools 是成熟的 Java 规则引擎，使用 Rete 算法
import org.kie.api.runtime.KieSession;

public class DroolsExample {
    
    public static void main(String[] args) {
        KieSession kSession = getKieSession();
        
        // 插入事实
        Customer customer = new Customer("VIP", 25);
        Order order = new Order(1500.0, customer);
        
        kSession.insert(customer);
        kSession.insert(order);
        
        // 执行规则
        kSession.fireAllRules();
        
        // 规则会自动修改 order 的 discount 字段
        System.out.println("折扣: " + order.getDiscount());
    }
}

// DRL 规则文件 (rules.drl)
// package com.example
//
// rule "VIP Discount"
//     when
//         $customer: Customer(type == "VIP", age > 18)
//         $order: Order(amount > 1000, customer == $customer)
//     then
//         $order.setDiscount(0.2);
//         update($order);
// end

// 自定义表达式编译器
public class ExpressionCompiler {
    
    // 表达式 DSL 示例:
    // "price * quantity * (1 - discount)"
    // "age >= 18 && income > 50000"
    // "score > 90 ? 'A' : score > 80 ? 'B' : 'C'"
    
    // 使用 ANTLR4 解析表达式
    public Expression parse(String expr) {
        ExprLexer lexer = new ExprLexer(CharStreams.fromString(expr));
        ExprParser parser = new ExprParser(new CommonTokenStream(lexer));
        
        ExprParser.ExprContext tree = parser.expr();
        
        // 生成 JVM 字节码
        return compileToBytecode(tree);
    }
    
    // 使用 ASM 字节码生成库
    private Expression compileToBytecode(ExprParser.ExprContext tree) {
        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
        
        cw.visit(V1_8, ACC_PUBLIC, "CompiledExpr", null,
            "java/lang/Object", new String[]{"Expression"});
        
        // 生成 evaluate 方法
        MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "evaluate",
            "(Ljava/util/Map;)Ljava/lang/Object;", null, null);
        
        mv.visitCode();
        // 遍历 AST 生成字节码
        generateCode(tree, mv);
        mv.visitMaxs(0, 0);
        mv.visitEnd();
        
        // 加载并实例化
        byte[] bytecode = cw.toByteArray();
        ExpressionClassLoader loader = new ExpressionClassLoader();
        Class<?> clazz = loader.defineClass("CompiledExpr", bytecode);
        
        return (Expression) clazz.getDeclaredConstructor().newInstance();
    }
    
    // 使用示例
    public static void main(String[] args) {
        ExpressionCompiler compiler = new ExpressionCompiler();
        
        // 编译表达式
        Expression expr = compiler.compile(
            "price * quantity * (1 - discount)"
        );
        
        // 执行（比解释执行快 10-100 倍）
        Map<String, Object> context = Map.of(
            "price", 100.0,
            "quantity", 5,
            "discount", 0.1
        );
        
        double result = (double) expr.evaluate(context);
        System.out.println("总价: " + result);  // 450.0
    }
}

// 使用 Groovy 动态编译表达式
import groovy.lang.GroovyShell;
import groovy.lang.Script;

public class GroovyExpressionEngine {
    
    private final GroovyShell shell;
    private final Map<String, Class<?>> cache = new ConcurrentHashMap<>();
    
    public GroovyExpressionEngine() {
        CompilerConfiguration config = new CompilerConfiguration();
        config.setOptimizationOptions(Map.of(
            "indy", true,        // 启用 invokedynamic
            "int", false         // 不将 int 转为 Integer
        ));
        this.shell = new GroovyShell(config);
    }
    
    // 编译并缓存表达式
    public Object evaluate(String expression, Map<String, Object> context) {
        Class<?> scriptClass = cache.computeIfAbsent(expression,
            expr -> shell.parse(expr).getClass());
        
        try {
            Script script = (Script) scriptClass.getDeclaredConstructor().newInstance();
            context.forEach(script::setProperty);
            return script.run();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    public static void main(String[] args) {
        GroovyExpressionEngine engine = new GroovyExpressionEngine();
        
        Map<String, Object> ctx = Map.of(
            "price", 100,
            "quantity", 5,
            "discount", 0.1
        );
        
        // Groovy 表达式（编译后执行）
        Object result = engine.evaluate(
            "price * quantity * (1 - discount)", ctx
        );
        System.out.println("结果: " + result);
    }
}

// Spring Expression Language (SpEL)
import org.springframework.expression.*;
import org.springframework.expression.spel.standard.*;
import org.springframework.expression.spel.support.*;

public class SpELDemo {
    
    private final ExpressionParser parser = new SpelExpressionParser();
    
    // 基本表达式
    public void basicExpressions() {
        // 简单求值
        int result = parser.parseExpression("2 + 3").getValue(Integer.class);
        
        // 属性访问
        String name = parser.parseExpression("name")
            .getValue(context, String.class);
        
        // 方法调用
        boolean matches = parser.parseExpression("email matches '.*@gmail.com'")
            .getValue(context, Boolean.class);
        
        // 三元表达式
        String grade = parser.parseExpression(
            "score > 90 ? 'A' : score > 80 ? 'B' : 'C'"
        ).getValue(context, String.class);
    }
    
    // 使用缓存提升性能
    private final Map<String, Expression> expressionCache = new ConcurrentHashMap<>();
    
    public Object evaluate(String expressionString, Object rootObject) {
        Expression expr = expressionCache.computeIfAbsent(expressionString,
            str -> parser.parseExpression(str));
        
        StandardEvaluationContext context = new StandardEvaluationContext(rootObject);
        return expr.getValue(context);
    }
    
    // 批量规则评估
    public Map<String, Object> evaluateRules(
            List<String> rules, Object data) {
        Map<String, Object> results = new LinkedHashMap<>();
        
        for (String rule : rules) {
            results.put(rule, evaluate(rule, data));
        }
        
        return results;
    }
}

// 基于 JIT 的流式数据处理器
public class StreamProcessor<T> {
    
    private final List<PipelineStage<T, ?>> stages = new ArrayList<>();
    
    // 添加处理阶段
    public <R> StreamProcessor<R> map(Function<T, R> mapper) {
        stages.add(new MapStage<>(mapper));
        return (StreamProcessor<R>) this;
    }
    
    public StreamProcessor<T> filter(Predicate<T> predicate) {
        stages.add(new FilterStage<>(predicate));
        return this;
    }
    
    // JIT 编译整个管线
    public CompiledPipeline<T> compile() {
        // 将所有阶段编译为一个高效的执行函数
        // JVM 会自动进行内联和优化
        return new CompiledPipeline<>(stages);
    }
    
    // 使用示例
    public static void main(String[] args) {
        StreamProcessor<String> processor = new StreamProcessor<>();
        
        // 定义管线
        CompiledPipeline<String> pipeline = processor
            .filter(s -> s.length() > 3)        // 阶段1: 过滤
            .map(String::toUpperCase)            // 阶段2: 转换
            .map(s -> s + "!")                   // 阶段3: 追加
            .compile();                          // 编译管线
        
        // 高效处理数据
        List<String> input = List.of("hi", "hello", "hey", "world");
        List<String> output = pipeline.execute(input);
        // 输出: ["HELLO!", "WORLD!"]
    }
}

// 列式处理 - 类似 Spark DataFrame 的 JIT 优化
public class ColumnProcessor {
    
    // 列式数据存储
    static class ColumnarData {
        int[] intColumns;
        double[] doubleColumns;
        String[] stringColumns;
        int rowCount;
    }
    
    // JIT 友好的列式操作
    public static double[] multiplyColumn(
            double[] column, double scalar) {
        double[] result = new double[column.length];
        // 这个循环会被 JIT 向量化
        for (int i = 0; i < column.length; i++) {
            result[i] = column[i] * scalar;
        }
        return result;
    }
    
    // 聚合操作
    public static double sumColumn(double[] column) {
        double sum = 0;
        // JIT 会优化这个循环
        for (int i = 0; i < column.length; i++) {
            sum += column[i];
        }
        return sum;
    }
    
    // 过滤操作
    public static int[] filterIndices(
            double[] column, double threshold) {
        // 第一遍：计数
        int count = 0;
        for (int i = 0; i < column.length; i++) {
            if (column[i] > threshold) count++;
        }
        
        // 第二遍：收集
        int[] indices = new int[count];
        int idx = 0;
        for (int i = 0; i < column.length; i++) {
            if (column[i] > threshold) {
                indices[idx++] = i;
            }
        }
        return indices;
    }
    
    // SIMD 向量化示例 (Java Vector API)
    public static double sumVectorized(double[] column) {
        int i = 0;
        double sum = 0;
        
        // 使用 Vector API 自动向量化
        int upperBound = VectorSpecies.ofPreferred(double.class)
            .loopBound(column.length);
        
        for (; i < upperBound; i += 4) {
            var v = DoubleVector.fromArray(
                DoubleVector.SPECIES_256, column, i);
            sum += v.reduceLanes(VectorOperators.ADD);
        }
        
        // 处理尾部
        for (; i < column.length; i++) {
            sum += column[i];
        }
        return sum;
    }
}

// 实时指标计算引擎
public class MetricEngine {
    
    private final Map<String, CompiledMetric> metrics = new ConcurrentHashMap<>();
    
    // 定义指标（DSL）
    public void defineMetric(String name, String expression) {
        // 编译指标表达式
        ExpressionCompiler compiler = new ExpressionCompiler();
        Expression expr = compiler.compile(expression);
        
        metrics.put(name, new CompiledMetric(name, expr, new WindowBuffer(60)));
    }
    
    // 处理事件
    public void onEvent(Map<String, Object> event) {
        long timestamp = (long) event.get("timestamp");
        
        for (var metric : metrics.values()) {
            // 更新窗口
            metric.window.add(event, timestamp);
            
            // 计算指标
            Object value = metric.expr.evaluate(
                metric.window.getContext()
            );
            
            // 发送指标
            emitMetric(metric.name, value, timestamp);
        }
    }
    
    // 使用示例
    public static void main(String[] args) {
        MetricEngine engine = new MetricEngine();
        
        // 定义指标
        engine.defineMetric("avg_response_time",
            "mean(response_time)");
        
        engine.defineMetric("error_rate",
            "count(status >= 500) / count(*)");
        
        engine.defineMetric("p99_latency",
            "percentile(response_time, 0.99)");
        
        // 处理事件流
        eventStream.subscribe(event -> engine.onEvent(event));
    }
}

// 复杂事件处理引擎
public class CEPEngine {
    
    // 事件模式 DSL
    // "A -> B within 5s where A.amount > 100 and B.status == 'failed'"
    
    public CompiledPattern compilePattern(String patternDsl) {
        // 1. 解析模式 DSL
        PatternAST ast = parsePattern(patternDsl);
        
        // 2. 编译为状态机
        StateMachine sm = compileToStateMachine(ast);
        
        // 3. JIT 编译匹配函数
        MatchFunction matcher = compileMatchFunction(sm);
        
        return new CompiledPattern(sm, matcher);
    }
    
    public static void main(String[] args) {
        CEPEngine cep = new CEPEngine();
        
        // 检测失败登录模式
        CompiledPattern pattern = cep.compilePattern(
            """
            LOGIN_FAILED -> LOGIN_FAILED -> LOGIN_SUCCESS 
            within 60s
            where count(LOGIN_FAILED) >= 3
            """
        );
        
        // 处理事件流
        eventStream.subscribe(event -> {
            List<Match> matches = pattern.match(event);
            for (Match match : matches) {
                alert("检测到可疑登录", match);
            }
        });
    }
}

-- 游戏 AI 行为树脚本
-- 使用 LuaJIT JIT 编译实现高性能 AI

local ffi = require("ffi")

ffi.cdef[[
    typedef struct {
        float x, y, z;
    } Vector3;
    
    typedef struct {
        int id;
        float health;
        float maxHealth;
        Vector3 position;
        Vector3 velocity;
        int state;
    } Entity;
]]

-- 行为树节点库
local BT = {}

function BT.sequence(...)
    local children = {...}
    return function(entity, dt)
        for _, child in ipairs(children) do
            if not child(entity, dt) then
                return false
            end
        end
        return true
    end
end

function BT.selector(...)
    local children = {...}
    return function(entity, dt)
        for _, child in ipairs(children) do
            if child(entity, dt) then
                return true
            end
        end
        return false
    end
end

function BT.condition(check)
    return function(entity, dt)
        return check(entity)
    end
end

function BT.action(exec)
    return function(entity, dt)
        return exec(entity, dt)
    end
end

-- 条件判断
local function is_low_health(entity)
    return entity.health < entity.maxHealth * 0.3
end

local function has_enemy_nearby(entity)
    -- 实际实现中会查询空间索引
    return true
end

-- 动作实现
local function flee(entity, dt)
    local speed = 5.0
    entity.velocity.x = -entity.velocity.x * speed
    entity.velocity.z = -entity.velocity.z * speed
    entity.position.x = entity.position.x + entity.velocity.x * dt
    entity.position.z = entity.position.z + entity.velocity.z * dt
    return true
end

local function attack(entity, dt)
    -- 攻击逻辑
    return true
end

local function patrol(entity, dt)
    -- 巡逻逻辑
    entity.position.x = entity.position.x + math.sin(entity.id + dt) * dt
    entity.position.z = entity.position.z + math.cos(entity.id + dt) * dt
    return true
end

-- 组装行为树（会被 LuaJIT JIT 编译）
local enemy_ai = BT.selector(
    -- 优先：低血量时逃跑
    BT.sequence(
        BT.condition(is_low_health),
        BT.action(flee)
    ),
    -- 其次：有敌人时攻击
    BT.sequence(
        BT.condition(has_enemy_nearby),
        BT.action(attack)
    ),
    -- 默认：巡逻
    BT.action(patrol)
)

-- 游戏主循环
local function game_loop(entities, dt)
    for i = 0, 999 do
        local entity = entities[i]
        enemy_ai(entity, dt)
    end
end

-- 初始化实体
local entities = ffi.new("Entity[1000]")
for i = 0, 999 do
    entities[i].id = i
    entities[i].health = 100
    entities[i].maxHealth = 100
    entities[i].position.x = math.random() * 100
    entities[i].position.z = math.random() * 100
end

-- 运行（LuaJIT 会自动 JIT 编译热点代码）
for frame = 1, 6000 do  -- 60fps * 100秒
    game_loop(entities, 0.016)
end

-- 配置热更新系统
-- 支持运行时修改游戏配置而无需重启

local config_cache = {}

function load_config(path)
    -- 读取配置文件
    local f = io.open(path, "r")
    if not f then return nil end
    local code = f:read("*a")
    f:close()
    
    -- 编译为函数（LuaJIT 会优化）
    local chunk = loadstring(code)
    if chunk then
        local config = chunk()
        config_cache[path] = {
            config = config,
            mtime = lfs.attributes(path, "modification")
        }
        return config
    end
    return nil
end

function get_config(path)
    local cached = config_cache[path]
    if cached then
        -- 检查文件是否更新
        local mtime = lfs.attributes(path, "modification")
        if mtime > cached.mtime then
            return load_config(path)
        end
        return cached.config
    end
    return load_config(path)
end

-- 使用
local function game_update()
    local config = get_config("game_config.lua")
    
    -- 配置内容（Lua 代码，会被 JIT 编译）
    -- return {
    --     player_speed = 10,
    --     enemy_damage = 25,
    --     spawn_rate = 2.5,
    --     difficulty_curve = function(level)
    --         return 1 + level * 0.1
    --     end
    -- }
    
    -- 热更新配置
    local difficulty = config.difficulty_curve(current_level)
    player.speed = config.player_speed * difficulty
end

// SQL WHERE 子句编译器
public class SQLWhereCompiler {
    
    // 将 SQL WHERE 子句编译为 Java Predicate
    public Predicate<Map<String, Object>> compile(String whereClause) {
        // 1. 解析 SQL WHERE
        WhereAST ast = parseWhere(whereClause);
        
        // 2. 生成字节码
        byte[] bytecode = generateBytecode(ast);
        
        // 3. 加载并返回
        Class<?> clazz = loadClass("CompiledWhere", bytecode);
        return (Predicate<Map<String, Object>>) clazz
            .getDeclaredConstructor().newInstance();
    }
    
    // 字节码生成
    private byte[] generateBytecode(WhereAST ast) {
        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
        cw.visit(V1_8, ACC_PUBLIC, "CompiledWhere", null,
            "java/lang/Object", new String[]{"java/util/function/Predicate"});
        
        MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "test",
            "(Ljava/util/Map;)Z", null, null);
        mv.visitCode();
        
        // 生成测试逻辑
        generateWhereCode(ast, mv);
        
        mv.visitInsn(IRETURN);
        mv.visitMaxs(0, 0);
        mv.visitEnd();
        
        return cw.toByteArray();
    }
    
    private void generateWhereCode(WhereAST node, MethodVisitor mv) {
        switch (node.type) {
            case COMPARISON:
                // 加载字段值
                mv.visitVarInsn(ALOAD, 1);  // load map
                mv.visitLdcInsn(node.field);
                mv.visitMethodInsn(INVOKEINTERFACE, "java/util/Map",
                    "get", "(Ljava/lang/Object;)Ljava/lang/Object;", true);
                mv.visitTypeInsn(CHECKCAST, "java/lang/Double");
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Double",
                    "doubleValue", "()D", false);
                
                // 加载比较值
                mv.visitLdcInsn(node.value);
                
                // 比较
                generateComparisonOp(node.operator, mv);
                break;
                
            case AND:
                generateWhereCode(node.left, mv);
                generateWhereCode(node.right, mv);
                mv.visitInsn(IAND);
                break;
                
            case OR:
                generateWhereCode(node.left, mv);
                generateWhereCode(node.right, mv);
                mv.visitInsn(IOR);
                break;
        }
    }
    
    // 使用示例
    public static void main(String[] args) {
        SQLWhereCompiler compiler = new SQLWhereCompiler();
        
        // 编译 WHERE 子句
        Predicate<Map<String, Object>> filter = compiler.compile(
            "age > 18 AND salary > 50000 AND department = 'Engineering'"
        );
        
        // 批量过滤（编译后比解释执行快 10-50 倍）
        List<Map<String, Object>> employees = getEmployees();
        List<Map<String, Object>> filtered = employees.stream()
            .filter(filter)
            .collect(Collectors.toList());
    }
}