require "sys"
require "utils"
require "patch"
cjson=require("cjson")
MQTT=require("mqtt_library")
base64=require("base64")
dyutils=require("dyutils") 
bit=require("bit") 
lpack=require("lua_pack") 
syslog=require("syslog")     
bcd=require("bcd") 
require "internal_api"
bnot = bit.bnot 
band, bor, bxor = bit.band, bit.bor, bit.bxor 

lshift, rshift, rol = bit.lshift, bit.rshift, bit.rol

local UPGRADE_TYPE = "upgrade"
local CMD_TYPE = "cmdType"
local RESET_STRING = "reset"
local SHOW_VERSIONG = "ShowVersion"
local SHOW_VERSION_REPLAY = "Show_version"
local UPGRADE_START = "StartPrg"
local STARTPRG_READY = "Ready"
local STARTPRG_BUSY = "Busy"
local UPGRADE_END = "EndPrg"
local ENDPRG_SUCCESS="Success"
local ENDPRG_FAILED = "Failed"
local UPGRADE_CMD_STATE = "State"
local UPGRADE_PROGRESS = "UpgradeProgress"
local UPGRADE_DOING = "Upgrade_doing"
local UPGRADE_FINISH = "Upgrade_finish"
local UPGRADE_ERROR = "Upgrade_error"
local FILE_NOT_EXIST = "File not exsit"
local TOPIC_SEND_RGLT_SIGNAL_RAW_DATA="Set_Rglt_Raw"
local BINARY_CMD_TOPIC ="binary_cmd"
local UPGRADE_CMD = 0xD0
local UPGRADE_REQUEST = 0
local UPGRADE_REPLY = 0XFF
local BROADCAST_FLAG = 0x8000
local LAYER_3_OFFSET  = 12   
local LAYER_2_OFFSET = 7     
local MAX_BCU_NUM  =32
local BLOCK_SIZE  = 128
local LAYER_BAU =3
local LAYER_BCU = 2
local LAYER_BMU = 1
local CAN_PORT = "CANBUS_0"
local FRAME_DOWN = 0x6
local FRAME_UP = 0x7
local FRAME_OFFSET = 3
local QOS_LEVEL0= 0
local QOS_LEVEL1=1
local QOS_LEVEL2=2
-- 3 总控
-- 2 主控
-- 1 从控 
local BAU_upgrade_cfg = {}
local BCU_upgrade_cfg = {}
local BCU_upgrade_sub = {
        id = 0,
        replay_flag = 0,
}
local cmd_state = {
    identifier = "",
    type = "",
    destaddr = 0,
    id = 0
}
local currentupgradeinfo = nil
local XIENNG_upgrade_cfg = {}
local gw_sn = nil
local dev_sn = nil
local mqttclient = nil
local function BAUinit()
    dev_sn = string.format("%s%02d",gw_sn,1)
    BAU_upgrade_cfg = {
        identifier = "",
        file = "",
        offset = 0,
        state = 0,
        timer = 0,
        layer = LAYER_BAU,
        file_data = nil,
        filecrc =0,
        type = 0,
        id = 0
    }
    BCU_upgrade_cfg = {
        identifier = "",
        file = "",
        offset = 0,
        state = 0,
        timer = 0,
        layer = LAYER_BCU,
        file_data = nil,
        filecrc =0,
        type = 0,
        id = 0,
        subinfo = {}
    }
    XIENNG_upgrade_cfg[LAYER_BAU]= BAU_upgrade_cfg
    XIENNG_upgrade_cfg[LAYER_BCU]= BCU_upgrade_cfg
end


--  注：广播模式lay3是指的是层级号 -- 3 总控
--                                 -- 2 主控
--                                 -- 1 从控 

local function getDest(broadcast,lay3id,lay2id,lay1id)
    local desaddr = 0
    if broadcast == 1 then
        desaddr = BROADCAST_FLAG
        desaddr =  bor(desaddr,lshift(lay3id, LAYER_3_OFFSET))
        desaddr =  bor(desaddr,lay1id)
    else
        desaddr =  bor(desaddr,lshift(lay3id, LAYER_3_OFFSET))
        desaddr =  bor(desaddr,lshift(lay2id, LAYER_2_OFFSET))
        desaddr =  bor(desaddr,lay1id)
    end
    return desaddr
end

local function readfile(filename)
    local file = io.open(filename, "r")
    if not file then
        return nil,nil
    end
    local bin_buf = file:read("*a")

    io.close(file)
    local reminder = #bin_buf%4
    while (reminder ~= 0)
    do
      reminder=reminder-1
      bin_buf=bpack("AC", bin_buf, 0)
    end

    local crc32 = dyutils.CalculateXorCrc(bin_buf, #bin_buf)

    return bin_buf,crc32
end

local function header_analy(header)
    local cmdtype =  rshift(header,13)
    local frameid = band(0x3f,rshift(header,7))
    local devid = band(0x7f,header)
    print(string.format("0x%x 0x%x 0x%x",cmdtype,frameid,devid))
    return cmdtype,frameid,devid
end



local function attack_frame(desData,data,flag)
   
    if flag == 1 then
        desData = bpack("AA",desData,string.sub(data,FRAME_OFFSET+1,-1))
    else
        desData = bpack("AA",desData,string.sub(data,FRAME_OFFSET,-1))   
    end
    return desData
end

local function get_pack_header_len(data)
    local _,header,len= bunpack(data, "<SC");
    return header,len
end

local function get_upgrade_reply_info(data)
    local _,cmd,addr,type,len,id,offset= bunpack(data, "C<SCCC<I");
    return cmd,addr,type,len,id,offset
end


local function split_frame(data)
    local offset  = 0 
    local index = 0
    local split_data =nil
    local frame_data = ""
    while offset <= #data 
    do    
        local header = lshift(FRAME_DOWN, 13)
        header = bor(header, lshift(index, 7))
        if(currentupgradeinfo == nil) then
            header = bor(header, cmd_state.id)
        else
            header = bor(header, currentupgradeinfo.id)
        end
        if index == 0 then
            split_data = string.sub(data, offset+1, offset+5)
            split_data = bpack("CA",#data,split_data)
        else
            split_data = string.sub(data, offset, offset+5)
        end
        offset = offset + #split_data
        index = index+1
        split_data = bpack("<SA",header,split_data)
        print(string.toHex(split_data))
        frame_data = bpack("AA",frame_data,split_data)
    end

    local reminder= #frame_data%8 
    while reminder ~= 8 
    do
        frame_data = bpack("AC",frame_data,0)
        reminder = reminder + 1 
    end
    return frame_data
end

local function send_to_can_bus(gw_sn,port,data)
    local topic = string.format( "to_dev/%s/%s/data/"..TOPIC_SEND_RGLT_SIGNAL_RAW_DATA,gw_sn,port)
    -- log.info("send to can bus:",topic,string.toHex(data))
    local framedata = split_frame(data)
    framedata =  bpack("CCC>S>SA",0,0,0,0,#framedata,framedata)
    -- print(string.toHex(framedata))
    mqttclient:publish(topic, framedata,QOS_LEVEL0)
end

   
local function upgrade_send_data(buf,offset,block_size,dst)
    local block_data = string.sub(buf, offset+1, offset+block_size)
    local block_pkt = bpack("<IA",offset, block_data);
    -- print(string.toHex(block_pkt))
    block_pkt = bpack("<CCA",UPGRADE_REQUEST,#block_pkt, block_pkt);
    -- print(string.toHex(block_pkt))   
    block_pkt = bpack("<CSA",UPGRADE_CMD,dst, block_pkt);
    -- print(string.toHex(block_pkt))
    local crc16 = dyutils.CRC16(block_pkt, #block_pkt)
    block_pkt = bpack("A>S",block_pkt,crc16);
    -- print(string.toHex(block_pkt))
    send_to_can_bus(gw_sn,CAN_PORT,block_pkt)
    offset= offset + #block_data
    return offset
    -- print(string.format("0x%x, 0x%x",offset,#bin_buf))
end

local function upgrade_finish_send(len,crc32,dst)
    local  end_data = string.char(0xFF,0xFF,0xFF,0xFF)
    end_data = bpack("<AII",end_data, len,crc32);
    end_data = bpack("<CCA",UPGRADE_REQUEST,#end_data, end_data);
    end_data = bpack("<CSA",UPGRADE_CMD,dst, end_data);
    local crc16 = dyutils.CRC16(end_data, #end_data)
    end_data = bpack("A>S",end_data,crc16);
    send_to_can_bus(gw_sn,CAN_PORT,end_data)
    -- print(string.toHex(end_data))
end


local function cmdSend(dst,cmd)
    local cmd = string.format("0x%X %s",dst,cmd)
    -- print(cmd)
    local send_data = bpack("<A",cmd);
    -- print(string.toHex(send_data))
    send_to_can_bus(gw_sn,CAN_PORT,send_data)
end

local function handler()
    local pid, status, code = syswait.wait(-1, syswait.WNOHANG)
    log.error('system exit', pid, status, code) --打印不出来
    os.exit(0)
end

-- while offset < #bin_buf 
-- do
--     offset = upgrade_send_data(bin_buf,offset,block_size,destaddr)
-- end

-- upgrade_finish_send(#bin_buf,crc32,destaddr)
-- cmdSend(destaddr,RESET_STRING)


local function table_show(table)
    log.info("show table:",type(table))
    for k, v in pairs(table) do
        log.info(k,v)
        if type(v) == "table" then
            for kk, vv in pairs(v) do
                log.info(kk,vv)
            end
        end
    end
end

local function upgradeSend()
    if (#currentupgradeinfo.file_data - currentupgradeinfo.offset) < BLOCK_SIZE then
        currentupgradeinfo.offset = upgrade_send_data(currentupgradeinfo.file_data,currentupgradeinfo.offset,#currentupgradeinfo.file_data - currentupgradeinfo.offset,currentupgradeinfo.destaddr)
    else
        currentupgradeinfo.offset = upgrade_send_data(currentupgradeinfo.file_data,currentupgradeinfo.offset,BLOCK_SIZE,currentupgradeinfo.destaddr)
    end
end

local function upgradefineshSend()
    upgrade_finish_send(#currentupgradeinfo.file_data,currentupgradeinfo.filecrc,currentupgradeinfo.destaddr)
end

local function service_response_send(type,info,identifier,addr,len)
    -- log.info("service_response_send:",string.format("%s addr:0x%x",info,addr))
    local param = {
        status = info,
        filelen = len,
        offset = addr
    }
    if type  == UPGRADE_TYPE then
        internal_api.event(gw_sn,dev_sn,CAN_PORT,identifier,param)
    else
        internal_api.service_response(gw_sn,dev_sn,CAN_PORT,identifier,param)
    end
end


local function upgrade_notify_to_dev(notifymode,port)
    local topic = string.format( "to_dev/%s/%s/data/Notify_Upgrade",gw_sn,port)
    mqttclient:publish(topic, notifymode)
end

local function Upgrade_start(obj)
    if obj.URL == nil or obj.mode.lay3 == nil then
        log.info("Upgrade_start","upgrade info error!")
        return
    end 
    if currentupgradeinfo == nil then
        if obj.mode.broadcast == 1 then
            if  obj.mode.devnum == nil or obj.mode.devnum == 0 then
                log.info("Upgrade_start","broadcast layer error:%d,devnum:%d",obj.mode.lay3,obj.mode.devnum)
                return
            else
                if obj.mode.lay3 == LAYER_BAU then
                    currentupgradeinfo = XIENNG_upgrade_cfg[LAYER_BAU]
                     currentupgradeinfo.id = LAYER_BAU
                elseif obj.mode.lay3 == LAYER_BCU then
                    currentupgradeinfo = XIENNG_upgrade_cfg[LAYER_BCU]
                     currentupgradeinfo.id = LAYER_BCU
                else
                    log.info("Upgrade_start","broadcast layer error:%d",obj.mode.lay3)
                    return 
                end

            end
        else
            if obj.mode.lay2 == 0 then
                currentupgradeinfo = XIENNG_upgrade_cfg[LAYER_BAU]
                currentupgradeinfo.id = obj.mode.lay3
            elseif obj.mode.lay1 == 0 then 
                currentupgradeinfo = XIENNG_upgrade_cfg[LAYER_BCU]
                currentupgradeinfo.id = obj.mode.lay2
            else
                log.info("Upgrade_start","uncast layer error:",obj.mode.lay3,obj.mode.lay2,obj.mode.lay1)
                return 
            end
        end
        currentupgradeinfo.identifier = obj.identifier
        currentupgradeinfo.file= obj.URL
        currentupgradeinfo.file_data,currentupgradeinfo.filecrc = readfile(obj.URL)
        if currentupgradeinfo.file_data == nil then
            log.info("Upgrade_start","the file %s not exist!",obj.URL)
            currentupgradeinfo.identifier = ""
            currentupgradeinfo.id= 0
            currentupgradeinfo.file= ""
            service_response_send(UPGRADE_TYPE,FILE_NOT_EXIST,UPGRADE_PROGRESS,0,0)
            return 
        end
        
        currentupgradeinfo.mode = obj.mode
        currentupgradeinfo.destaddr = getDest(currentupgradeinfo.mode.broadcast,currentupgradeinfo.mode.lay3,currentupgradeinfo.mode.lay2,currentupgradeinfo.mode.lay1)
        currentupgradeinfo.state = 1
        upgrade_notify_to_dev("start_upgrade",CAN_PORT)
        
        currentupgradeinfo.offset = 0
        currentupgradeinfo.type = UPGRADE_DOING
        service_response_send(UPGRADE_TYPE,UPGRADE_DOING,UPGRADE_PROGRESS,currentupgradeinfo.offset,#currentupgradeinfo.file_data)
        upgradeSend()

        -- cmdSend(currentupgradeinfo.destaddr,UPGRADE_START)
        -- currentupgradeinfo.type = UPGRADE_START

    else
        log.info("Upgrade_start","upgrade doing !!!!")
    end 
end

local function Upgrade_stop(obj)
    if currentupgradeinfo == nil then
        log.info("Upgrade_stop","upgrade not start")
        return
    end
    cmdSend(currentupgradeinfo.destaddr,UPGRADE_END)
    upgrade_notify_to_dev("stop_upgrade",CAN_PORT)
    currentupgradeinfo.type = ""
    currentupgradeinfo.offset = 0
    currentupgradeinfo.URL= ""
    currentupgradeinfo.state = 0
    currentupgradeinfo.destaddr = 0
    currentupgradeinfo.file_data = nil
    currentupgradeinfo.file = ""
    currentupgradeinfo.filecrc = 0
    currentupgradeinfo = nil
end

local function Show_version(obj)
    if currentupgradeinfo ~= nil then
        log.info("Show_version","upgrade  doing !!!!")
        return
    end
    obj.mode.broadcast = 0

    if obj.mode.broadcast == 1 then
        if obj.mode.lay3 == LAYER_BAU then

        elseif obj.mode.lay3 == LAYER_BCU then

        else
            log.info("Upgrade_start","broadcast layer error:%d",obj.mode.lay3)
            return 
        end
    else
        if obj.mode.lay2 == 0 then
            cmd_state.id = obj.mode.lay3
        elseif obj.mode.lay1 == 0 then 
            cmd_state.id = obj.mode.lay2
        else
            log.info("Upgrade_start","uncast layer error:",obj.mode.lay3,obj.mode.lay2,obj.mode.lay1)
            return 
        end
    end
    local destaddr = getDest(obj.mode.broadcast,obj.mode.lay3,obj.mode.lay2,obj.mode.lay1)
    cmd_state.type = SHOW_VERSIONG
    cmd_state.desaddr = destaddr
    cmdSend(destaddr,SHOW_VERSIONG)
end

local function Reset_dev(obj)
    if currentupgradeinfo ~= nil then
        log.info("Reset_dev","upgrade  doing !!!!")
        return
    end
    if obj.mode.broadcast == 1 then
        if obj.mode.lay3 == LAYER_BAU then
            cmd_state.id = LAYER_BAU
        elseif obj.mode.lay3 == LAYER_BCU then
            cmd_state.id = LAYER_BCU
        else
            log.info("Upgrade_start","broadcast layer error:%d",obj.mode.lay3)
            return 
        end
    else
        if obj.mode.lay2 == 0 then
            cmd_state.id = obj.mode.lay3
        elseif obj.mode.lay1 == 0 then 
            cmd_state.id = obj.mode.lay2
        else
            log.info("Upgrade_start","uncast layer error:",obj.mode.lay3,obj.mode.lay2,obj.mode.lay1)
            return 
        end
    end
    local destaddr = getDest(obj.mode.broadcast,obj.mode.lay3,obj.mode.lay2,obj.mode.lay1)
    cmdSend(destaddr,RESET_STRING)
    cmd_state.type = RESET_STRING
    cmd_state.desaddr = destaddr
end

local function iot2pp(json_str, len)
    log.info("iot2pp","input:"..json_str)
    local obj = cjson.decode(json_str)
    if obj.identifier == "DevUpgrade" then
        if obj.active == "start" then
            if currentupgradeinfo ~= nil and  currentupgradeinfo.state == 1 then
                log.info("on_mqtt_msg","Upgrading!!!!!")
                return
            end
            Upgrade_start(obj)
        end
        if obj.active == "stop" then
            Upgrade_stop(obj)
        end
    elseif obj.identifier == "Show_version" then
        Show_version(obj)
    elseif obj.identifier == "Reset" then
        Reset_dev(obj)
    end
end

local function check_broadcast_upgrade()
    local recnum = 0
    local offsettale = {}
    for k, subinfo in pairs(currentupgradeinfo.subinfo) do
        if subinfo.frame ~= nil then
            if subinfo.frame[subinfo.fnumber] ~= nil then
                local flag = 1
                local frame_info = ""
                for  i=1,subinfo.fnumber do
                    -- print(i,subinfo.frame[i])
                    frame_info  = attack_frame(frame_info,subinfo.frame[i],flag)
                    flag = 0
                end
                local cmd,addr,type,replylen,id,offset = get_upgrade_reply_info(frame_info)
                table.insert(offsettale,offset)
                recnum = recnum + 1
            end
        end
    end
    if currentupgradeinfo.mode.devnum == recnum then
        currentupgradeinfo.subinfo = {}
        table.sort(offsettale,function(a,b)
            return a < b
        end)
        return 1,offsettale[1]
    else
        return 0,0
    end
end

local function upgrade_start_reply(data,frameid,devid,len)
    local frame_info = ""
    if currentupgradeinfo == nil then
        log.info("on_mqtt_msg","currentupgradeinfo is nil")
        return
    end
    if currentupgradeinfo.mode.broadcast == 1 then
        if frameid == 0 then
            currentupgradeinfo.subinfo[devid] = { frame = {} }
            currentupgradeinfo.subinfo[devid].frame[frameid+1] = data
            currentupgradeinfo.subinfo[devid].fnumber = math.ceil((len+1)/6)
            currentupgradeinfo.subinfo[devid].flen = len
        else
            if frameid +1 < currentupgradeinfo.subinfo[devid].fnumber then
                currentupgradeinfo.subinfo[devid].frame[frameid+1] = data
            else
                currentupgradeinfo.subinfo[devid].frame[frameid+1] = data
                local flag = 1 
                for  i=1,currentupgradeinfo.subinfo[devid].fnumber do
                    frame_info  = attack_frame(frame_info,currentupgradeinfo.subinfo[devid].frame[i],flag)
                    flag = 0
                end
                if string.find(frame_info,STARTPRG_READY) then
                    currentupgradeinfo.subinfo[devid].replay = 1
                end
            end
        end
    else
        if currentupgradeinfo.id == devid then
            if frameid == 0 then
                currentupgradeinfo.frame = {}
                currentupgradeinfo.frame[frameid+1] = data
                currentupgradeinfo.fnumber = math.ceil((len+1)/6)
                currentupgradeinfo.flen = len
            else
                if frameid +1 < currentupgradeinfo.fnumber then
                    currentupgradeinfo.frame[frameid+1] = data
                else
                    currentupgradeinfo.frame[frameid+1] = data
                    local flag = 1 
                    for i=1,currentupgradeinfo.fnumber do
                        frame_info  = attack_frame(frame_info,currentupgradeinfo.frame[i],flag)
                        flag = 0
                    end
                    if string.find(frame_info,STARTPRG_READY) then
                        currentupgradeinfo.replay = 1
                        currentupgradeinfo.type = UPGRADE_DOING
                        service_response_send(UPGRADE_TYPE,UPGRADE_DOING,UPGRADE_PROGRESS,currentupgradeinfo.offset,#currentupgradeinfo.file_data)
                        upgradeSend()
                    end
                end
            end
        end
    end
end

local function upgrade_end_reply(data,frameid,devid,len)
    local frame_info = ""
    if currentupgradeinfo == nil then
        log.info("on_mqtt_msg","currentupgradeinfo is nil")
        return
    end
    if currentupgradeinfo.mode.broadcast == 1 then
        if frameid == 0 then
            currentupgradeinfo.subinfo[devid] = { frame = {} }
            currentupgradeinfo.subinfo[devid].frame[frameid+1] = data
            currentupgradeinfo.subinfo[devid].fnumber = math.ceil((len+1)/6)
            currentupgradeinfo.subinfo[devid].flen = len
        else
            if frameid +1 < currentupgradeinfo.subinfo[devid].fnumber then
                currentupgradeinfo.subinfo[devid].frame[frameid+1] = data
            else
                currentupgradeinfo.subinfo[devid].frame[frameid+1] = data
                local flag = 1 
                for i=1,currentupgradeinfo.fnumber do
                    frame_info  = attack_frame(frame_info,currentupgradeinfo.frame[frameid],flag)
                    flag = 0
                end
                if string.find(frame_info,ENDPRG_SUCCESS) then
                    currentupgradeinfo.subinfo[devid].replay = 1
                    upgrade_notify_to_dev("stop_upgrade",CAN_PORT)
                    service_response_send(UPGRADE_TYPE,UPGRADE_FINISH,UPGRADE_PROGRESS,currentupgradeinfo.offset,#currentupgradeinfo.file_data)

                    cmd_state.type = RESET_STRING
                    cmd_state.desaddr = currentupgradeinfo.destaddr
                    cmd_state.id = LAYER_BCU
                    cmdSend(currentupgradeinfo.destaddr,RESET_STRING)
                end
            end
        end
    else
        if currentupgradeinfo.id == devid then
            if frameid == 0 then
                currentupgradeinfo.frame={}
                currentupgradeinfo.frame[frameid+1] = data
                currentupgradeinfo.fnumber = math.ceil((len+1)/6)
                currentupgradeinfo.flen = len
            else
                if frameid +1 < currentupgradeinfo.fnumber then
                    currentupgradeinfo.frame[frameid+1] = data
                else
                    currentupgradeinfo.frame[frameid+1] = data
                    local flag = 1 
                    for i=1,currentupgradeinfo.fnumber do
                        frame_info  = attack_frame(frame_info,currentupgradeinfo.frame[i],flag)
                        flag = 0
                    end
                    if string.find(frame_info,ENDPRG_SUCCESS) then
                        upgrade_notify_to_dev("stop_upgrade",CAN_PORT)
                        service_response_send(UPGRADE_TYPE,UPGRADE_FINISH,UPGRADE_PROGRESS,currentupgradeinfo.offset,#currentupgradeinfo.file_data)
                        cmd_state.type = RESET_STRING
                        cmd_state.desaddr = currentupgradeinfo.destaddr
                        cmd_state.id = LAYER_BCU
                        cmdSend(currentupgradeinfo.destaddr,RESET_STRING)
                        currentupgradeinfo.type=""
                        currentupgradeinfo.URL= ""
                        currentupgradeinfo.offset = 0
                        currentupgradeinfo.state = 0
                        currentupgradeinfo.destaddr = 0
                        currentupgradeinfo.file_data = nil
                        currentupgradeinfo.file = ""
                        currentupgradeinfo.filecrc = 0
                        currentupgradeinfo = nil
                    end
                end
            end
        end
    end
end

local function show_version_reply(data,frameid,devid,len)
    local frame_info = ""
    if currentupgradeinfo ~= nil then
        log.info("show_version_reply","upgrading!!!")
        return
    end
    if cmd_state.id == devid then
        if frameid == 0 then
            cmd_state.frame = {}
            cmd_state.frame[frameid+1] = data
            cmd_state.fnumber = math.ceil((len+1)/6)
            cmd_state.flen = len
        else
            if frameid +1 < cmd_state.fnumber then
                cmd_state.frame[frameid+1] = data
            else
                cmd_state.frame[frameid+1] = data
                local flag = 1
                for  i=1,cmd_state.fnumber do
                    frame_info  = attack_frame(frame_info,cmd_state.frame[i],flag)
                    flag = 0
                end
                cmd_state.type = ""
                -- local version = string.sub(frame_info,4,-1)
                -- log.info("show_version_reply:",version)
                print(frame_info)
                service_response_send(CMD_TYPE,frame_info,SHOW_VERSION_REPLAY)
            end
        end
    end
end

local function reset_reply(data,frameid,devid,len)
    if currentupgradeinfo ~= nil then
        log.info("on_mqtt_msg","upgrading!!!")
        return
    end
    cmd_state.type = ""
end

local function upgrade_doing_reply(data,frameid,devid,len)
    local frame_info = ""
    if currentupgradeinfo == nil then
        log.info("upgrade_doing_reply","currentupgradeinfo is nil")
        return
    end
    if currentupgradeinfo.mode.broadcast == 1 then
        if frameid == 0 then
            currentupgradeinfo.subinfo[devid] = { frame = {} }
            currentupgradeinfo.subinfo[devid].frame[frameid+1] = data
            currentupgradeinfo.subinfo[devid].fnumber = math.ceil((len+1)/6)
            currentupgradeinfo.subinfo[devid].flen = len
        else
            if frameid+1 < currentupgradeinfo.subinfo[devid].fnumber then
                currentupgradeinfo.subinfo[devid].frame[frameid+1] = data
            else
                currentupgradeinfo.subinfo[devid].frame[frameid+1] = data
                local flag ,offset = check_broadcast_upgrade()
                print("------------->",flag,offset)
                if flag == 1 then
                    if offset == currentupgradeinfo.offset then
                        currentupgradeinfo.replay = 1
                        if currentupgradeinfo.offset <= #currentupgradeinfo.file_data then
                            upgradeSend()

                        else
                            upgradefineshSend()

                            currentupgradeinfo.type = UPGRADE_FINISH
                        end
                        currentupgradeinfo.replay = 0
                    else
                        if offset < #currentupgradeinfo.file_data then
                            currentupgradeinfo.offset = offset
                            upgradeSend()

                        else
                            upgradefineshSend()
                            
                            currentupgradeinfo.type = UPGRADE_FINISH
                        end
                        log.info("broadcast upgrade_doing_reply:",offset)
                    end
                    service_response_send(UPGRADE_TYPE,UPGRADE_DOING,UPGRADE_PROGRESS,currentupgradeinfo.offset,#currentupgradeinfo.file_data)
                end
            end
        end
    else
        if currentupgradeinfo.id == devid then
            if frameid == 0 then
                currentupgradeinfo.frame = {}
                currentupgradeinfo.frame[frameid+1] = data
                currentupgradeinfo.fnumber = math.ceil((len+1)/6)
                currentupgradeinfo.flen = len
            else
                if frameid+1 < currentupgradeinfo.fnumber then
                    currentupgradeinfo.frame[frameid+1] = data
                else
                    currentupgradeinfo.frame[frameid+1] = data
                    local flag = 1
                    for i=1,currentupgradeinfo.fnumber do
                        frame_info  = attack_frame(frame_info,currentupgradeinfo.frame[i],flag)
                        flag = 0
                    end
                    local cmd,addr,type,replylen,id,offset = get_upgrade_reply_info(frame_info)
                    print("offset ---->",offset,currentupgradeinfo.offset,#currentupgradeinfo.file_data)
                    if offset == currentupgradeinfo.offset then
                        currentupgradeinfo.replay = 1
                        if currentupgradeinfo.offset <= #currentupgradeinfo.file_data then

                            upgradeSend()
                        else
                            upgradefineshSend()

                            currentupgradeinfo.type = UPGRADE_FINISH
                        end
                        currentupgradeinfo.replay = 0
                    else
                        if offset < #currentupgradeinfo.file_data then
                            currentupgradeinfo.offset = offset
                            upgradeSend()
                        else
                            upgradefineshSend()
                            currentupgradeinfo.type = UPGRADE_FINISH
                        end

                        -- log.info("upgrade_doing_reply:",cmd,addr,type,replylen,id,offset)
                    end
                    service_response_send(UPGRADE_TYPE,UPGRADE_DOING,UPGRADE_PROGRESS,currentupgradeinfo.offset,#currentupgradeinfo.file_data)
                end
            end
        end
    end
end

local function upgrade_finish_reply(data,frameid,devid,len)
    local frame_info = ""
    if currentupgradeinfo == nil then
        log.info("upgrade_finish_reply","currentupgradeinfo is nil")
        return
    end
    if currentupgradeinfo.mode.broadcast == 1 then
        if frameid == 0 then
            currentupgradeinfo.subinfo[devid] = { frame = {} }
            currentupgradeinfo.subinfo[devid].frame[frameid+1] = data
            currentupgradeinfo.subinfo[devid].fnumber = math.ceil((len+1)/6)
            currentupgradeinfo.subinfo[devid].flen = len
        else
            if frameid +1 < currentupgradeinfo.subinfo[devid].fnumber then
                currentupgradeinfo.subinfo[devid].frame[frameid+1] = data
            else
                currentupgradeinfo.subinfo[devid].frame[frameid+1] = data
                local flag,offset = check_broadcast_upgrade()
                upgrade_notify_to_dev("stop_upgrade",CAN_PORT)
                if 0 == offset then
                    currentupgradeinfo.replay = 1
                    service_response_send(UPGRADE_TYPE,UPGRADE_FINISH,UPGRADE_PROGRESS)
                else
                    service_response_send(UPGRADE_TYPE,UPGRADE_ERROR,UPGRADE_PROGRESS)
                    log.info("upgrade_finish_reply:",offset)
                end

                cmd_state.type = RESET_STRING
                cmd_state.desaddr = currentupgradeinfo.destaddr
                cmd_state.id = LAYER_BCU
                currentupgradeinfo.type=""
                currentupgradeinfo.URL= ""
                currentupgradeinfo.state = 0
                currentupgradeinfo.offset = 0
                currentupgradeinfo.destaddr = 0
                currentupgradeinfo.file_data = nil
                currentupgradeinfo.file = ""
                currentupgradeinfo.filecrc = 0
                currentupgradeinfo.replay = 0
                currentupgradeinfo = nil
                cmdSend(cmd_state.desaddr,RESET_STRING)
            --     local flag = 1
            --     for  i=1,currentupgradeinfo.subinfo[devid].fnumber do
            --         frame_info  = attack_frame(frame_info,currentupgradeinfo.subinfo[devid].frame[i],flag)
            --         flag = 0
            --     end
            --    local cmd,addr,type,replylen,id,offset = get_upgrade_reply_info(frame_info)
            --    if offset == 0 then
            --         currentupgradeinfo.subinfo[devid].replay = 1
            --    end
            end
        end
    else
        if currentupgradeinfo.id == devid then
            if frameid == 0 then
                currentupgradeinfo.frame = {}
                currentupgradeinfo.frame[frameid+1] = data
                currentupgradeinfo.fnumber = math.ceil((len+1)/6)
                currentupgradeinfo.flen = len
            else
                if frameid +1 < currentupgradeinfo.fnumber then
                    currentupgradeinfo.frame[frameid+1] = data
                else
                    currentupgradeinfo.frame[frameid+1] = data
                    local flag = 1
                    for i=1,currentupgradeinfo.fnumber do
                        frame_info  = attack_frame(frame_info,currentupgradeinfo.frame[i],flag)
                        flag = 0
                    end
                    local cmd,addr,type,replylen,id,offset = get_upgrade_reply_info(frame_info)
                    upgrade_notify_to_dev("stop_upgrade",CAN_PORT)
                    if 0 == offset then
                        currentupgradeinfo.replay = 1
                        service_response_send(UPGRADE_TYPE,UPGRADE_FINISH,UPGRADE_PROGRESS)
                        currentupgradeinfo.replay = 0
                    else
                        service_response_send(UPGRADE_TYPE,UPGRADE_ERROR,UPGRADE_PROGRESS)
                        log.info("upgrade_finish_reply:",cmd,addr,type,replylen,id,offset)
                    end
                    cmd_state.type = RESET_STRING
                    cmd_state.desaddr = currentupgradeinfo.destaddr
                    cmd_state.id = currentupgradeinfo.id
                    cmdSend(cmd_state.desaddr,RESET_STRING)
                    currentupgradeinfo.type=""
                    currentupgradeinfo.URL= ""
                    currentupgradeinfo.offset =0
                    currentupgradeinfo.state = 0
                    currentupgradeinfo.destaddr = 0
                    currentupgradeinfo.file_data = nil
                    currentupgradeinfo.file = ""
                    currentupgradeinfo.filecrc = 0
                    currentupgradeinfo.replay = 0
                    currentupgradeinfo = nil

                    -- cmdSend(currentupgradeinfo.destaddr,UPGRADE_END)
                    -- currentupgradeinfo.type = UPGRADE_END
                   
                end
            end
        end
    end
end

local function get_can_data(data)
   local _,dev_lev,addr,func,regaddr,len =bunpack(data, "CCC<S<S");
   local data1 = string.sub(data,8,-3)
   log.info("get_can_data",string.toHex(data1))
   return data1
end

local function port2pp(framedata,lenth)
   local data =  get_can_data(framedata)
    local header,len = get_pack_header_len(data)
    local cmdtype,frameid,devid = header_analy(header)
    if cmdtype  == FRAME_UP then
        if currentupgradeinfo ~= nil then
            if  currentupgradeinfo.type == UPGRADE_START then
                    upgrade_start_reply(data,frameid,devid,len)
            elseif currentupgradeinfo.type == UPGRADE_END then
                    upgrade_end_reply(data,frameid,devid,len)
            elseif currentupgradeinfo.type == UPGRADE_FINISH then
                    upgrade_finish_reply(data,frameid,devid,len)
            elseif currentupgradeinfo.type == UPGRADE_DOING then
                    upgrade_doing_reply(data,frameid,devid,len)
            else
                log.info("port2pp","upgradeing state:",currentupgradeinfo.type)
                log.info("port2pp:",string.toHex(data))
            end
        else 
            if cmd_state.type == SHOW_VERSIONG then
                show_version_reply(data,frameid,devid,len)
            elseif cmd_state.type == RESET_STRING then
                reset_reply(data,frameid,devid,len)
            else
                log.info("port2pp","cmd state:",cmd_state.type)
                log.info("port2pp:",string.toHex(data))
            end
        end
    else
        log.info("port2pp","rev packet err:",string.format("cmdtype:0x%x,frameid:%d,devid:%d",cmdtype,frameid,devid))
    end
end


local function on_mqtt_msg(topic, payload)
    if string.find(topic,"data/Set_Rglt/") then
        local ret,err = pcall(iot2pp,payload,#payload)
        if not ret then
            log.warn("mqtt.recv",err)
        end
    elseif string.find(topic,"data/binary_cmd") then
        local ret,err = pcall(port2pp,payload,#payload)
        if not ret then
            log.warn("mqtt.recv",err)
        end
    elseif string.find(topic,"ipc/system/actions") then
        if string.find(topic,"update_config") then
            os.execute("/app/hmi4rack/update_config.sh")
        end
    else
        log.info("due message:",topic, payload)
    end
end

local function LoopTimer(curr)
    if currentupgradeinfo ~= nil then
        table_show(currentupgradeinfo)
    elseif cmd_state.type == "" then
        table_show(cmd_state)
    end
end

local function main(sn)
    gw_sn = sn
    if not gw_sn then
        gw_sn = io.getGatewayID()
        -- gw_sn = "21012C00FFFF"
        log.info("main_loop",  string.format("Try Run At Shell\nsn='%s'\n",gw_sn or "NOT SN"))
    end
    siganl.signal(siganl.SIGKILL,handler)
    siganl.signal(siganl.SIGHUP,handler)

    BAUinit()

    local subscribe={"ipc/system/actions/#","ipc/+/+/device/+/data/Set_Rglt/DevUpgrade","ipc/+/+/device/+/data/Set_Rglt/Show_version","ipc/+/+/device/+/data/Set_Rglt/Reset",string.format("dev/+/%s/data/binary_cmd",CAN_PORT)}

    mqttclient  = internal_api.mqtt_session("localhost",1883,nil,nil,subscribe,on_mqtt_msg)

    -- timerLoop  = sys.timerLoopStart(LoopTimer,5000,currentupgradeinfo)
    sys.init(0, 0)
    sys.run()
end

main(arg[1])