local moon = require("moon")

--- 非函数类upvalue会保留为最初的版本
local a = 100
local b = 200

local switch = {}

-- table类型的upvalue, 要求table的value都是function类型(__index除外)，function会被替换成新版本
switch[1] = function()
    moon.warn("f1", b)
end

-- 函数类型的upvalue, 会被替换成新版本
local function tmp(self)
    self.n=self.n+1000+a
end

---模块的定义
local M = {}

M.__index = M

-- 模块中的函数会被替换为新版本
function M.new()
    local obj = {
        n = 0,
        m = "hello"
    }
    return setmetatable(obj,M)
end

-- 模块中的函数会被替换为新版本
function M:func()
    switch[1]()
    tmp(self)
    print("before", self.n, self.m, a-b)
    moon.sleep(1000)
end

---需要返回模块
return M

-- 步骤 1: 收集旧模块的 upvalue 信息
-- 返回: {upvalue_name -> {func, index, id, value}}
local upvalues = {
    ["shared_count"] = {
        func = old_function,  -- 拥有这个 upvalue 的函数
        index = 1,            -- 在该函数中的索引位置
        id = 0x12345,         -- 唯一标识符
        value = 100           -- 当前值
    }
}

-- 步骤 2: 对于新函数的每个 upvalue，通过名称查找
local uvname = "shared_count"
local old_uv = upvalues[uvname]  -- 返回 {func, index, id, value}

-- 步骤 3: 使用 upvaluejoin 连接到旧函数的 upvalue
debug.upvaluejoin(
    new_function, 2,        -- 新函数的第 2 个 upvalue
    old_uv.func, old_uv.index  -- 旧函数的第 1 个 upvalue
)
-- 注意：索引 2 和 1 不同，但名称都是 "shared_count"

local upvalues = collect_all_uv(old_module)

local diff, new_functions = hotfix.diff(old_loader, new_loader)

local new_function_names = parse_module_functions(new_source_file)

for each function in (modified_functions + new_functions) do
    for i, uvname in enumerate(function_upvalues) do
        -- 1. 查找：通过名称在旧模块中查找 upvalue 信息
        local old_uv = upvalues[uvname]

        -- 2. 连接：让新函数的 upvalue 引用旧函数的 upvalue
        if old_uv then
            debug.upvaluejoin(new_function, i, old_uv.func, old_uv.index)
        end
    end

    -- 3. 替换：更新模块表中的函数引用
    Module[function_name] = new_function
end

local origin_functions = setmetatable({}, { __mode = "k" })  -- 弱键表

-- 第一次热更新: v1 -> v2
origin_functions[v2] = v1
Module.foo = v2

-- 第二次热更新: v2 -> v3
origin_functions[v3] = v1  -- 注意：还是指向 v1，不是 v2
Module.foo = v3

-- 结果：
-- v3: 被 Module.foo 强引用（存活）
-- v1: 被 origin_functions[v3] 强引用（存活）
-- v2: 只被 origin_functions 的键弱引用（可被 GC）

local M = {}

-- 旧模块的局部变量
local shared_count = 100
local shared_prefix = "[Old] "

function M.hello()
    return "Hello, World!"
end

function M.add(a, b)
    shared_count = shared_count + 1
    return a + b
end

function M.getSharedCount()
    return shared_prefix .. tostring(shared_count)
end

return M

local M = {}

-- 旧模块的局部变量（必须保留声明）
local shared_count = 100  -- ⚠️ 这个值会被忽略，实际使用旧模块的值 100
local shared_prefix = "[New] "  -- ⚠️ 这个值会被忽略，实际使用旧模块的值 "[Old] "

function M.hello()
    return "Hello, Hotfix!"  -- 修改现有函数
end

-- 已有函数新增upvalue
function M.add(a, b)
    shared_count = shared_count + 1
    print(shared_prefix .. tostring(shared_count)) -- ✅ 访问旧模块的 upvalue
    return a + b
end

function M.getSharedCount()
    return shared_prefix .. tostring(shared_count)
end

-- 新增函数 - 引用旧模块的局部变量 shared_count
function M.subtract(a, b)
    shared_count = shared_count + 1  -- ✅ 访问旧模块的 upvalue
    return a - b
end

-- 新增函数 - 引用旧模块的局部变量
function M.multiply(a, b)
    shared_count = shared_count + 1  -- ✅ 访问旧模块的 upvalue
    return a * b
end

-- 新增函数 - 格式化输出
function M.formatCount()
    return shared_prefix .. "Count: " .. tostring(shared_count)
end

return M

local M = {}

local shared_count = 100
local shared_prefix = "[Old] "

-- ❌ 新增的局部变量
local new_counter = 0  -- 旧模块中不存在

function M.add(a, b)
    shared_count = new_counter + 1  -- ❌ 热更新会失败！
    -- 错误原因：new_counter 在旧模块中不存在
    return a + b
end

function M.newFunc()
    shared_count = shared_count + 1  -- ✅ 可以访问（旧模块有）
    new_counter = new_counter + 1     -- ❌ 热更新会失败！
    -- 错误: New function 'newFunc' references upvalue(s) not exist in old module: new_counter
end

return M

-- 对于 M.newFunc 函数
local new_func_upvalues = {"shared_count", "new_counter"}

-- 检查每个 upvalue
for _, uvname in ipairs(new_func_upvalues) do
    if not old_upvalues[uvname] then
        error("New function 'newFunc' references upvalue(s) not exist in old module: " .. uvname)
    end
end

local hotfix = require "hotfix"

-- 1. 设置脚本加载器
hotfix.addsearcher(function(name)
    if name == "mymodule" then
        return load(io.readfile("mymodule_v1.lua")) -- 直接读文件避免使用缓存
    end
end)

local mymodule = hotfix.require("mymodule")
print(mymodule.hello())           -- 输出: Hello, World!
print(mymodule.add(1, 2))          -- 输出: 3
print(mymodule.getSharedCount())   -- 输出: [Old] 101

-- 注意：此时 shared_count = 101（不是初始值 100）

-- 2. 热更新到 v2（新增函数，访问旧模块 upvalue）
local ok, result = hotfix.update("mymodule")
if ok then
    print("Hotfix success!")
    -- 输出: hotfix: added 3 new fields: subtract, multiply, formatCount

    -- ✅ 函数行为改变了
    print(mymodule.hello())  -- 输出: Hello, Hotfix!

    -- ✅ 状态变量的值没有改变（还是 101，不是重置为 100）
    print(mymodule.getSharedCount())    -- 输出: [Old] 101

    -- 新增函数访问旧模块的 shared_count（从 101 继续计数）
    print(mymodule.subtract(5, 3))      -- 输出: 2
    print(mymodule.getSharedCount())    -- 输出: [Old] 102 (shared_count 继续累加!)

    -- 新增函数继续访问旧变量
    print(mymodule.multiply(4, 3))      -- 输出: 12
    print(mymodule.formatCount())       -- 输出: [Old] Count: 103

    -- 旧函数也能继续访问 shared_count
    print(mymodule.add(10, 20))         -- 输出: 30
    print(mymodule.getSharedCount())    -- 输出: [Old] 104
else
    print("Hotfix failed:", result)
    -- 如果新函数引用了不存在的 upvalue，会输出错误：
    -- New function 'xxx' references upvalue(s) not exist in old module: xxx
end

-- 热更新前: shared_count = 101
-- 热更新后: shared_count 还是 101（不是 100）
-- 这证明了：只更新了函数，状态变量的值没有被修改

-- v1.lua
local M = {}

local function helper()
    return "old helper"
end

local handlers = {}
handlers.process = function()
    return helper()  -- 引用 helper 函数
end

function M.run()
    return handlers.process()
end

return M

-- v2.lua - 修改嵌套函数
local M = {}

local function helper()
    return "new helper"  -- ✅ helper 函数会被更新
end

local handlers = {}
handlers.process = function()
    return helper() .. " v2"  -- ✅ handlers.process 也会被更新
end

function M.run()
    return handlers.process()  -- 输出: "new helper v2"
end

return M

-- 第 1 轮: v1 -> v2
hotfix.update("mymodule")  -- 成功
-- origin_functions[v2] = v1
-- Module.func = v2

-- 第 2 轮: v2 -> v3
hotfix.update("mymodule")  -- 成功
-- origin_functions[v3] = v1  (注意：还是 v1)
-- Module.func = v3
-- v2 可以被 GC（如果没有其他引用）

-- 第 3 轮: v3 -> v4
hotfix.update("mymodule")  -- 成功
-- origin_functions[v4] = v1
-- Module.func = v4
-- v3 可以被 GC

local ok, result = hotfix.update("mymodule")
if not ok then
    print("Error:", result)
    -- 错误信息示例：
    -- "New function 'func_name' references upvalue(s) not exist in old module: var_name"
    -- "function 'func_name' can't remove"
end