local posix   = require('posix')
local time    = require('posix.time')
local siganl  = require('posix.signal')
--local sem     = require('posix.sem')
local bit     = require('bit')
local cjson   = require('cjson')
local base64  = require('base64')
local dyutils = require('dyutils')
local lpack   = require('lua_pack')

local band, bor, bxor, bnot = bit.band, bit.bor, bit.bxor, bit.bnot
local lshift, rshift, rol   = bit.lshift, bit.rshift, bit.rol

local bpack   = string.pack
local bunpack = string.unpack

local TIMEOUT_MS = 3000

-- 注意：firmware_info.mode = 1 -- 升级模式: 并行升级  由lua脚本自行通过http post等方式推送升级文件给下挂设备，严禁调用send_command()\receive_data()等串行升级接口
-- 并行升级参数可在脚本中定义，也可在扩展参数中获取
local firmware_info = {}
local extend_info = nil

-- log Level
local	LOG_EMERG	= 0	--/* system is unusable */
local	LOG_ALERT	= 1	--/* action must be taken immediately */
local	LOG_CRIT	= 2	--/* critical conditions */
local	LOG_ERR		= 3	--/* error conditions */
local	LOG_WARNING	= 4	--/* warning conditions */
local	LOG_NOTICE	= 5	--/* normal but significant condition */
local	LOG_INFO	= 6	--/* informational */
local	LOG_DEBUG	= 7	--/* debug-level messages */

local pipes_table = {
    ["command"] = {fd = -1, path = "/tmp/command"},  -- Lua → C
    ["response"] = {fd = -1, path = "/tmp/response"},-- C → Lua
    ["progress"] = {fd = -1, path = "/tmp/progress"},-- Lua → C
    ["log"] = {fd = -1, path = "/tmp/log"},  -- Lua → C
}
--local mysem, err = sem.open("/otasem")

local function open_pipes()
    local flags = bor(posix.O_RDONLY, posix.O_NONBLOCK)

    pipes_table["command"].fd  = posix.open(pipes_table["command"].path, posix.O_WRONLY)
    pipes_table["progress"].fd = posix.open(pipes_table["progress"].path, posix.O_WRONLY)
    pipes_table["log"].fd      = posix.open(pipes_table["log"].path, posix.O_WRONLY)
    pipes_table["response"].fd = posix.open(pipes_table["response"].path, flags)
end

local update_log
local function close_pipes(pipes)
    for name, pipe_info in pairs(pipes) do
        if pipe_info.fd ~= -1 then
            local ok, err = pcall(posix.close, pipe_info.fd)
            if ok then
                pipe_info.fd = -1
                update_log(LOG_INFO, string.format("success closed fd=%d for pipe '%s'", pipe_info.fd, name))
            else
                update_log(LOG_ERR, string.format("fail to close fd=%d for pipe '%s': %s", pipe_info.fd, name, err))
            end
        end
    end
end

-- 接收C返回LUA的响应帧（带超时时间ms，返回0 此帧无应答 返回 1 正常解析数据）
local function receive_data()
    local fd_Id = pipes_table["response"].fd
    if fd_Id == -1 then
        update_log(LOG_ERR, "fd_Id is -1 (already closed)")
        return -1, nil
    end

    local fds = {
        [fd_Id] = {
            events = {
                IN = true,  -- 数据可读
                HUP = true, -- 挂断事件
                ERR = true  -- 错误事件
            }
        }
    }

    local poll = require 'posix.poll'

    local ret = poll.poll(fds, TIMEOUT_MS)
    if ret == 0 then
        update_log(LOG_INFO, "timeout, no data received")
        return 0, nil
    elseif ret == -1 then
        update_log(LOG_WARNING, "poll call failed, reason: " .. tostring(posix.errno()))
        return -1, nil
    else
        for fd in pairs(fds) do
            if fds[fd].revents.IN then
                local data, err = posix.read(fd, 1024)
                if data then
                    --update_log(LOG_INFO, string.format("RX[%d]: %s", #data, string.toHex(data," ")))
                    return 1, data
                else
                    return -1, nil
                end
            elseif fds[fd].revents.HUP then
                update_log(LOG_ERR, "pipe closed (HUP)")
                posix.close(fd)  -- 关闭 fd
                fd = -1          -- 标记为已关闭
                pipes_table["response"].fd = -1
                return -2, nil
            elseif fds[fd].revents.ERR then
                update_log(LOG_ERR, "pipe error (ERR)")
                posix.close(fd)
                fd = -1
                pipes_table["response"].fd = -1
                return -3, nil
            end
        end
    end
end

-- 发送命令/固件包 --(每包数据可指定超时时间)
local function send_command(timeout_ms, data)
    --mysem:wait()
    local block_pkt = bpack("C<SCA", 0xAA, timeout_ms, #data, data)
    local crc = dyutils.CRC16(block_pkt, #block_pkt)
    local bin_str = bpack("A<S", block_pkt, crc)
    update_log(LOG_INFO, string.format("send %d byte", #bin_str))
    return posix.write(pipes_table["command"].fd, bin_str)
    --mysem:post()
end

local indx = 0
local MAX_LEN = 128
local SUCCESS, FAIL, PROGRESS = 1, 2, 3
local ACK_ERROR_OR_TIMEOUT, VER_CHECK_FAIL = 419, 420  -- 失败原因
-- 发送进度
local function send_progress(data)
    local result = string.rep('\0', MAX_LEN)
    local bin_str = bpack("C<fCA", PROGRESS, data, indx, result)
    return posix.write(pipes_table["progress"].fd, bin_str)
end

local function send_update_fail(err_code)
    local result = string.rep('\0', MAX_LEN)
    local bin_str = bpack("C<fCA", FAIL, err_code, indx, result)
    return posix.write(pipes_table["progress"].fd, bin_str)
end

local function send_update_success(str)
    local result = string.sub(str .. string.rep('\0', 128), 1, 128)
    local bin_str = bpack("C<fCA", SUCCESS, 0, indx, result)
    return posix.write(pipes_table["progress"].fd, bin_str)
end

-- syslog
update_log = function(log_levl, str)
    local msg = tostring(log_levl) .. str .. "\n"
    return posix.write(pipes_table["log"].fd, msg)
end
-----------------------------------------------------------------------------------------------------------------
-- 模拟固件数据
local firmware_chunks = {
    "FIRMWARE_PART_1_" .. string.rep("A", 20),
    "FIRMWARE_PART_2_" .. string.rep("B", 30),
    "FIRMWARE_PART_3_" .. string.rep("C", 40),
    "FIRMWARE_PART_4_" .. string.rep("D", 50),
    "FIRMWARE_PART_5_" .. string.rep("E", 60),
    "FIRMWARE_PART_6_" .. string.rep("F", 70),
    "FIRMWARE_PART_7_" .. string.rep("G", 80),
    "FIRMWARE_PART_8_" .. string.rep("H", 90),
    "FIRMWARE_PART_1_" .. string.rep("A", 20),
    "FIRMWARE_PART_2_" .. string.rep("B", 30),
    "FIRMWARE_PART_3_" .. string.rep("C", 40),
    "FIRMWARE_PART_4_" .. string.rep("D", 50),
    "FIRMWARE_PART_5_" .. string.rep("E", 60),
    "FIRMWARE_PART_6_" .. string.rep("F", 70),
    "FIRMWARE_PART_7_" .. string.rep("G", 80),
    "FIRMWARE_PART_8_" .. string.rep("H", 90),
}

-- posix.sleep(1) -- 秒级 1s
-- time.nanosleep({tv_sec=0, tv_nsec=500000000})  -- 纳秒级 500ms

-- 执行升级函数
function perform_upgrade(dev_no, addr, fri_str, ext_str)
    open_pipes()
    posix.sleep(1)

    local err_code = 0
    local _addr = tonumber(addr)
    local currTime = os.time()
    update_log(LOG_INFO, string.format("dev_no: %s, addr: %d, fri_str: %s, ext_str: %s", dev_no, _addr, fri_str, ext_str))

    local obj = cjson.decode(fri_str)
    if not obj.mode or not obj.num or not obj.info then
        update_log(LOG_ERR, "Invalid firmware mode or num or info")
        return
    end
    firmware_info.mode = obj.mode  -- 0:串行升级 1:并行升级(此参数不使用，固化0)
    firmware_info.num  = obj.num   -- 升级文件个数
    firmware_info.info = obj.info

    for i, path in ipairs(firmware_info.info) do
        update_log(LOG_INFO, string.format("info[%d]: %s", i, path))
    end

    extend_info = cjson.decode(ext_str)
    if not extend_info then
        update_log(LOG_ERR, "Invalid extend argv")
        return
    end

    for key, value in pairs(extend_info) do
        update_log(LOG_INFO, string.format("argv %s: %s", key, value))
    end

    -- siganl.signal(siganl.SIGKILL, handler)
    -- siganl.signal(siganl.SIGHUP, handler)
    local success = true
-------------------------------------------------------------------------
    -- 1. 若需要版本校验，需在升级文件名里包含版本信息，解析升级文件名获取版本信息



    -- 2. 获取下挂设备版本信息



    -- 3. 对比，若版本一致，则返回success = true，否则进入升级流程
    -- update_log(LOG_INFO, "firmware same version，no upgrade")


    update_log(LOG_INFO, "Starting firmware upgrade process...")
    indx = 0 -- 升级文件索引，升级第二个固件 indx = 1，以此类推（此变量必须被更新）

    local total = #firmware_chunks
    -- 4. 普通报文 send data(数据包) 
    for i, chunk in ipairs(firmware_chunks) do
        update_log(LOG_INFO, string.format("Preparing to send chunk %d/%d", i, total))

        -- 发送命令
        send_command(2000, chunk)

        -- 等待响应 （可添加每包发送后，应答失败的重试机制）
        local val, response = receive_data()
        if not response then
            update_log(LOG_INFO, "Timeout waiting for device response")
            success = false
            err_code = ACK_ERROR_OR_TIMEOUT
            break
        end
        update_log(LOG_INFO, string.format("receive %d byte", #response))

        local progress = (i / total) * 100
        send_progress(progress)  -- 发送实时进度

        --posix.sleep(2)
        time.nanosleep({tv_sec=0, tv_nsec=500000000})
    end

    -- 延时等待下挂设备新固件运行
    -- 5. 获取设备版本，进行版本校验，判断是否升级成功

    local ver = "v1.2.3" -- 升级成功传入设备版本，若协议不支持版本获取，则为""即可
    if success then
        send_update_success(ver)
        update_log(LOG_INFO, "Firmware upgrade completed success")
    else
        send_update_fail(err_code)
        update_log(LOG_INFO, "Firmware upgrade failed!!!")
    end

    posix.sleep(2)
    close_pipes(pipes_table)
    --mysem:close()
    return success
end

local SIGTERM = 15
-- 允许进程在退出前执行清理操作（如关闭文件、释放资源）,替代 kill -9 <PID>
posix.signal(posix.SIGTERM, function(sig)
    print(string.format("[signal %d] received the termination request, cleanup...", sig))
    close_pipes(pipes_table)
    os.exit(128 + SIGTERM)
end)

local ok, err = pcall(perform_upgrade, arg[1], arg[2], arg[3], arg[4])
if not ok then
    print("Fatal error: " .. tostring(err)) -- print to stdout，提示lua语法错误/崩溃信息 ---语、运行时法错误错误、或主动调用的 error()
    close_pipes(pipes_table)
    os.exit(1)
end

os.exit(0)