-- Lua 示例：展示 Trace 形成
local function sum_array(arr)
    local sum = 0
    for i = 1, #arr do
        sum = sum + arr[i]
    end
    return sum
end

-- 热循环会被录制为 Trace
local arr = {}
for i = 1, 10000 do
    arr[i] = i
end

-- 预热：触发 Trace 录制
for _ = 1, 100 do
    sum_array(arr)
end

-- 后续调用使用编译后的 Trace
local result = sum_array(arr)
print(result)

# 查看 Trace 录制
luajit -jv -e "
local sum = 0
for i = 1, 100000 do
    sum = sum + i
end
print(sum)
"

# 输出示例:
# [TRACE 1 test.lua:3 loop]
# [TRACE 2 test.lua:3 loop]

-- 类型特化示例
local function add(a, b)
    return a + b
end

-- 第一次调用：整数
add(1, 2)        -- 生成整数加法的 Trace

-- 第二次调用：浮点数
add(1.5, 2.5)    -- 生成浮点数加法的 Trace

-- 第三次调用：字符串
add("hello", " world")  -- 生成字符串连接的 Trace

-- 概念上的 Trace
-- function add(a, b)
--   guard(type(a) == NUMBER)    ← 类型检查
--   guard(type(b) == NUMBER)    ← 类型检查
--   result = a + b
--   return result

-- 如果 Guard 失败，退出 Trace，回退到解释器

-- LuaJIT 会推断变量类型
local function compute(n)
    local x = 0          -- 推断为整数
    for i = 1, n do      -- i 推断为整数
        x = x + i        -- 整数加法
    end
    return x
end

-- n 保持为整数时，整条 Trace 都使用整数运算
-- 如果传入 n = 10.5，会产生新的 Trace

-- FFI 基本用法
local ffi = require("ffi")

-- 声明 C 函数
ffi.cdef[[
    int printf(const char *fmt, ...);
    double sin(double x);
    double cos(double x);
    void *malloc(size_t size);
    void free(void *ptr);
]]

-- 直接调用 C 函数
ffi.C.printf("Hello from C! %d\n", 42)
local result = ffi.C.sin(3.14159)
print(result)  -- ~0

-- 性能对比
-- 调用 C.sin 比 Lua 的 math.sin 快得多

local ffi = require("ffi")

-- 创建 C 类型
ffi.cdef[[
    typedef struct {
        double x;
        double y;
        double z;
    } Vec3;
    
    typedef struct {
        int id;
        char name[64];
        Vec3 position;
    } Entity;
]]

-- 创建实例
local v = ffi.new("Vec3", 1.0, 2.0, 3.0)
print(v.x, v.y, v.z)  -- 1.0  2.0  3.0

-- 数组
local arr = ffi.new("int[1000]")
for i = 0, 999 do
    arr[i] = i * 2
end

-- 结构体
local entity = ffi.new("Entity")
entity.id = 42
entity.position.x = 10.0

local ffi = require("ffi")

-- 加载动态库
ffi.cdef[[
    // POSIX 函数
    int getpid(void);
    int usleep(unsigned int usec);
    
    // 线程相关
    typedef void* pthread_t;
    int pthread_create(pthread_t *thread, const void *attr,
                       void *(*start_routine)(void*), void *arg);
    int pthread_join(pthread_t thread, void **retval);
    
    // 文件操作
    typedef struct FILE FILE;
    FILE *fopen(const char *path, const char *mode);
    int fclose(FILE *fp);
    size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
]]

-- 使用示例
print("PID:", ffi.C.getpid())

-- 高性能文件读取
local function read_file(path)
    local f = ffi.C.fopen(path, "rb")
    if f == nil then return nil end
    
    -- 获取文件大小
    ffi.C.fseek(f, 0, 2)  -- SEEK_END
    local size = ffi.C.ftell(f)
    ffi.C.rewind(f)
    
    -- 读取内容
    local buf = ffi.new("char[?]", size)
    ffi.C.fread(buf, 1, size, f)
    ffi.C.fclose(f)
    
    return ffi.string(buf, size)
end

local ffi = require("ffi")

ffi.cdef[[
    typedef void (*callback_t)(int, const char*);
    void register_callback(callback_t cb);
    void trigger_callbacks(void);
]]

-- 实际使用中，将 C 回调映射到 Lua 函数
-- 这是 FFI 的高级用法
local lib = ffi.load("mylib")

local lua_callback = ffi.cast("callback_t", function(id, msg)
    print(string.format("Callback: id=%d, msg=%s", id, ffi.string(msg)))
end)

lib.register_callback(lua_callback)
lib.trigger_callbacks()

-- 记得释放回调
lua_callback:free()

-- 性能对比：FFI vs 纯 Lua vs C 绑定
local ffi = require("ffi")
local N = 1000000

ffi.cdef[[
    double sin(double x);
]]

-- 方式1：纯 Lua
local function bench_lua()
    local sum = 0
    for i = 1, N do
        sum = sum + math.sin(i * 0.001)
    end
    return sum
end

-- 方式2：FFI 直接调用
local function bench_ffi()
    local sum = 0
    for i = 1, N do
        sum = sum + ffi.C.sin(i * 0.001)
    end
    return sum
end

-- 典型结果:
-- Lua math.sin:  ~120ms
-- FFI C.sin:     ~25ms   (约 5 倍提升)

-- 以下操作不会被 Trace 编译，会触发 Trace 中断

-- 1. 协程（coroutine）
local co = coroutine.create(function()
    coroutine.yield(1)
end)
-- 会导致新 Trace 开始

-- 2. pcall（某些情况）
-- pcall(f) 在某些情况下会中断 Trace

-- 3. 复杂的表操作
local t = {}
setmetatable(t, {__index = function() return 0 end})
-- 元方法可能中断 Trace

-- 4. string 库（部分函数）
-- string.find 使用复杂模式时可能中断

# 使用 -jv 查看 Trace 编译信息
luajit -jv -e "
local t = {}
for i = 1, 100000 do
    t[i] = i
end
"

# 使用 -jdump 查看详细 IR
luajit -jdump -e "
local sum = 0
for i = 1, 10000 do
    sum = sum + i
end
print(sum)
"

# 输出包括:
# ---- TRACE 1 IR ----
# 0001 >  int SLOAD  #1    C
# 0002 >  int LE     0001  +10000
# 0003    int ADD    0001  +1
# ...

-- 游戏 AI 行为树示例
local ffi = require("ffi")

-- C 结构体定义
ffi.cdef[[
    typedef struct {
        float x, y, z;
    } Vector3;
    
    typedef struct {
        int id;
        int health;
        int maxHealth;
        Vector3 position;
        Vector3 velocity;
    } Entity;
]]

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

function BT.sequence(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(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_health_low(entity)
    return entity.health < entity.maxHealth * 0.3
end

local function flee_from_enemy(entity, dt)
    -- 计算逃跑方向
    entity.velocity.x = -entity.velocity.x
    entity.velocity.y = -entity.velocity.y
    entity.position.x = entity.position.x + entity.velocity.x * dt
    entity.position.y = entity.position.y + entity.velocity.y * dt
    return true
end

local function attack_nearest(entity, dt)
    -- 攻击最近的敌人
    return true
end

-- 组装行为树
local ai_behavior = BT.selector({
    -- 优先：血量低时逃跑
    BT.sequence({
        BT.condition(is_health_low),
        BT.action(flee_from_enemy),
    }),
    -- 否则：攻击
    BT.action(attack_nearest),
})

-- 使用
local entity = ffi.new("Entity")
entity.health = 100
entity.maxHealth = 100

ai_behavior(entity, 0.016)  -- 60 FPS

# nginx.conf 中使用 LuaJIT
http {
    lua_package_path "/usr/local/openresty/lualib/?.lua;;";
    
    server {
        listen 8080;
        
        location /api/data {
            content_by_lua_block {
                local cjson = require("cjson")
                local redis = require("resty.redis")
                
                -- 连接 Redis
                local red = redis:new()
                red:connect("127.0.0.1", 6379)
                
                -- 获取数据
                local data = red:get("mydata")
                
                -- 返回 JSON
                ngx.say(cjson.encode({
                    status = "ok",
                    data = data
                }))
            }
        }
    }
}

-- 1. 保持类型稳定
-- ❌ 不好的做法
local function process(data)
    if type(data) == "number" then
        return data * 2
    else
        return tostring(data)
    end
end

-- ✅ 好的做法：分离不同类型
local function process_number(data)
    return data * 2
end

local function process_string(data)
    return tostring(data)
end

-- 2. 避免在热路径创建闭包
-- ❌
for i = 1, 100000 do
    local f = function() return i end  -- 每次创建新闭包
    f()
end

-- ✅
local function make_counter()
    local i = 0
    return function()
        i = i + 1
        return i
    end
end

-- 3. 使用 FFI 替代纯 Lua 数据结构
-- ❌
local points = {}
for i = 1, 10000 do
    points[i] = {x = i, y = i * 2}
end

-- ✅
ffi.cdef[[
    typedef struct { double x; double y; } Point;
]]
local points = ffi.new("Point[10000]")
for i = 0, 9999 do
    points[i].x = i
    points[i].y = i * 2
end

-- 4. 使用局部变量缓存全局查找
-- ❌
for i = 1, 100000 do
    table.insert(t, i)  -- 每次查找 table.insert
end

-- ✅
local insert = table.insert
for i = 1, 100000 do
    insert(t, i)
end

-- 使用 LuaJIT 性能分析工具
local profile = require("jit.profile")

-- CPU 分析
profile.start("l", function(th, samples, vmstate)
    local info = profile.dumpstack(th, "pl;", 10)
    print(string.format("Samples: %d, State: %s\n%s", 
          samples, vmstate, info))
end)

-- 运行需要分析的代码
local function heavy_computation()
    local sum = 0
    for i = 1, 10000000 do
        sum = sum + math.sin(i) * math.cos(i)
    end
    return sum
end

heavy_computation()

profile.stop()