require "internal_api"
require "log"
require "sys"
require "utils"
require "patch"
require "fs"
siganl = require 'posix.signal'
syswait = require 'posix.sys.wait'
unistd = require 'posix.unistd'
mqtt=require "mosquitto"
lpack=require("lua_pack")
base64=require("base64")
dyutils=require("dyutils")
math=require("math")
cjson=require("cjson")
require"lsqlite3"

RACK_PATH = "/app/rack/"
DB_FILE = RACK_PATH .. "racks.db"

LOG_LEVEL = log.LOGLEVEL_TRACE
-------------------------[全局参数定义]-------------------------
BATT_TEMP_COUNT = 64
BATT_VOL_COUNT = 64

RETRANS_INTERVAL= 30        --重传间隔
DB_CLEAN_INTERVAL=60*60        --计算间隔
-- DEVICE_OFFLINE_TIME = 20*60
DEVICE_OFFLINE_TIME = 20*60 -- 判断离线时间


cluster_obj={}

pack_status_obj={}
pack_data_obj={}
pack_alarm_obj={}

alarm_tab=
{
    {"BMU硬件故障","BMUHWFault",9},
    {"BCU硬件故障","BCUHWFault",9},
    {"熔断器故障","FuseProtectorFault",9},
    {"接触器粘连故障","ContactorAdhesionFault",9},
    {"BMU通信故障","BMUCommFault",9},
    {"BAU通信故障","BAUCommFault",9},
    {"电流传感器故障","CurrentSensorFault",9},
    {"绝缘监测设备故障","IMDFault",9},
    {"隔开开关异常断开","DisconnectorOpen",9},
    {"总电压过压一级报警","RackVolHighWarm",1},
    {"总电压欠压一级报警","RackVolLowWarm",1},
    {"单体过压一级报警","CellVolHighWarm",1},
    {"单体电压欠压一级报警","CellVolLowWarm",1},
    {"放电电流过大一级报警","DsgOverCurrWarn",1},
    {"充电电流过大一级报警","ChgOverCurrWarn",1},
    {"放电电池过温一级报警","DsgTempHighWarn",1},
    {"放电电池欠温一级报警","DsgTempLowWarn",1},
    {"充电电池过温一级报警","ChgTempHighWarn",1},
    {"充电电池欠温一级报警","ChgTempLowWarn",1},
    {"绝缘阻值过低一级报警","InsulationLowWarn",1},
    {"极柱温度过高一级报警","TerminalTempHighWarm",1},
    {"高压箱连接器温度过高一级报警","HVBTempHighWarm",1},
    {"总电压过压二级报警","RackVolHighAlarm",2},
    {"总电压欠压二级报警","RackVolLowAlarm",2},
    {"单体过压二级报警","CellVolHighAlarm",2},
    {"单体欠压二级报警","CellVolLowAlarm",2},
    {"放电电流过大二级报警","DsgOverCurrAlarm",2},
    {"充电电流过大二级报警","ChgOverCurrAlarm",2},
    {"放电电池过温二级报警","DsgTempHighAlarm",2},
    {"放电电池欠温二级报警","DsgTempLowAlarm",2},
    {"充电电池过温二级报警","ChgTempHighAlarm",2},
    {"充电电池欠温二级报警","ChgTempLowAlarm",2},
    {"绝缘阻值过低二级报警","InsulationLowAlarm",2},
    {"极柱温度过高二级报警","TerminalTempHighWarn",2},
    {"高压箱连接器温度过高二级报警","HVBTempHighAlarm",2},
    {"总电压过压三级报警","RackVolHighCriticalAlarm",3},
    {"总电压欠压三级报警","RackVolLowCriticalAlarm",3},
    {"单体过压三级报警","CellVolHighCriticalAlarm",3},
    {"单体欠压三级报警","CellVolLowCriticalAlarm",3},
    {"放电电流过大三级报警","DsgOverCurrCriticalAlarm",3},
    {"充电电流过大三级报警","ChgOverCurrCriticalAlarm",3},
    {"放电电池过温三级报警","DsgTempHighCriticalAlarm",3},
    {"放电电池欠温三级报警","DsgTempLowCriticalAlarm",3},
    {"充电电池过温三级报警","ChgTempHighCriticalAlarm",3},
    {"充电电池欠温三级报警","ChgTempLowCriticalAlarm",3},
    {"绝缘阻值过低三级报警","InsulationLowCriticalAlarm",3},
    {"极柱温度过高三级报警","TerminalTempHighCriticalAlarm",3},
    {"高压箱连接器温度过高三级报警","HVBTempHighCriticalAlarm",3}
}

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

local function replyRackListRequest(gw_sn,dev_sn,port,identifier,param,mi)
    local obj={Racks={}}
    for k,v in pairs(pack_data_obj) do
        if v then
            local tags={}
            tags.RackRunState = v.RackRunState
            tags.RackTotalVoltage = v.RackTotalVoltage
            tags.RackTotalCurrent = v.RackTotalCurrent
            tags.RackSoc = v.RackSoc
            tags.RackSoh = v.RackSoh
            tags.RackChargeState = v.RackChargeState
            tags.PositiveContactorState = v.PositiveContactorState
            tags.PreContactorState = v.PreContactorState
            table.insert(obj.Racks,{sn=k,tags=tags})
        end
    end
    internal_api.service_response(gw_sn,dev_sn,port,identifier,obj,mi)
end

local function replyImmediateAlarm(gw_sn,dev_sn,port,identifier,param,mi)
    local obj={alarmlist={}}
    local sql
    sql = string.format("SELECT sn,rackid,settime,clrtime,alarmid FROM alarm where clrtime is null group by rackid,alarmid order by id desc limit 0,200")
    log.info("db fetch history sql:",sql)
    for dev_sn,rackid,st,ct,alarmid in db:urows(sql) do
        if not rackid or not st or not alarmid then
            log.error("db",db:errcode(),db:errmsg())
            break
        end
        local desc= string.format("Rack %d %s",rackid,alarm_tab[alarmid][1])
        table.insert(obj.alarmlist,{sn=dev_sn,settime=st,description=desc})
    end
    internal_api.service_response(gw_sn,dev_sn,port,identifier,obj,mi)
end

local function replyHistoryAlarm(gw_sn,dev_sn,port,identifier,param,mi)
    local obj={alarmlist={}}
    local sql
    sql = string.format("SELECT sn,rackid,settime,clrtime,alarmid FROM alarm where clrtime > 0  group by rackid,alarmid order by id desc limit 0,200")
    log.info("db fetch history sql:",sql)
    for dev_sn,rackid,st,ct,alarmid in db:urows(sql) do
        if not rackid or not st or not ct or not alarmid then
            log.error("db",db:errcode(),db:errmsg())
            break
        end
        local desc= string.format("Rack %d %s",rackid,alarm_tab[alarmid][1])
        table.insert(obj.alarmlist,{sn=dev_sn,settime=st,clrtime=ct,description=desc})
    end
    internal_api.service_response(gw_sn,dev_sn,port,identifier,obj,mi)
end

local function db_autoclean()
    db:exec('delete from alarm where settime<strftime("%s","now", "-7 days")')
    -- db.exec('delete from realdata where time<strftime("%s","now", "-7 days")')
end

local function db_realdata_insert(stmt,dev_sn,rack_id,time,identifier,param)
    if not dev_sn or not rack_id or not identifier or not param then
        log.error("realdata","param failed",dev_sn,rack_id,identifier,param)
        return
    end
    local str = cjson.encode(param)
    log.info("realdata ",dev_sn,rack_id,identifier,param)
    stmt:bind_values(dev_sn,rack_id,time,identifier,0,str)
    if db:errmsg() == sqlite3.ERROR then log.error("db_init",db:errmsg()) return end
    stmt:step()
    if db:errmsg() == sqlite3.ERROR then log.error("db_init",db:errmsg()) return end
    stmt:reset()
end

local function db_alarm_status_insert(stmt,dev_sn,rack_id,index,errormsg)
    if not dev_sn or not rack_id or not errormsg then
        log.error("alarm","param failed",dev_sn,rack_id,index,errormsg)
        return
    end
    log.info("alarm","Rack",rack_id,"update",errormsg)
    stmt:bind_values(dev_sn,rack_id,os.time(),nil,0,index)
    stmt:step()
    if db:errmsg() == sqlite3.ERROR then log.error("db_init",db:errmsg()) return end
    stmt:reset()
end

local function db_alarm_status_update(stmt,dev_sn,rack_id,index,errormsg) --更新数据库结束时间
    if not dev_sn or not rack_id or not index then
        log.error("alarm","param failed",dev_sn,rack_id,index,errormsg)
        return
    end
    log.info("alarm","Rack",rack_id,"update",errormsg)
    stmt:bind_values(os.time(),rack_id,index)
    stmt:step()
    if db:errmsg() == sqlite3.ERROR then log.error("db_init",db:errmsg()) return end
    stmt:reset()
end



local function db_init(path)
    db = sqlite3.open(path)
    if not db then log.info("db_init","db open fail") return end
    db:busy_timeout(5000)
    db:exec('CREATE TABLE alarm(id INTEGER PRIMARY KEY,sn VARCHAR(32),rackid INTEGER,settime INTEGER,clrtime INTEGER,count INTEGER,alarmid INTEGER)')

    stmt_insert_alarm = db:prepare('INSERT INTO alarm VALUES (NULL,?,?,?,?,?,?)')
    -- log.error("db_init",db:errmsg())
    stmt_update_alarm = db:prepare('update alarm SET clrtime = ? WHERE id = (select MAX(id) AS max_id from alarm where rackid = ? and alarmid = ? and clrtime IS NULL)')

    db:exec('CREATE TABLE realdata(id INTEGER PRIMARY KEY,sn VARCHAR(32),rackid INTEGER,time INTEGER,identifier VARCHAR(64),report INTEGER,msg TEXT)')
    stmt_insert_data = db:prepare('INSERT INTO realdata VALUES (NULL,?,?,?,?,?,?)')

end

local function alarm_status(dev_sn,rack_id,tags)
    for index,row in ipairs(alarm_tab) do
        -- 从后向前查,后面权重高
        if not pack_alarm_obj[rack_id] then pack_alarm_obj[rack_id]= {} end
        if not pack_alarm_obj[rack_id][row[2]] then
            pack_alarm_obj[rack_id][row[2]] = 0 end
        if tags[row[2]] and tags[row[2]] ~= pack_alarm_obj[rack_id][row[2]] then
            pack_alarm_obj[rack_id][row[2]] = tags[row[2]]
            if tags[row[2]] == 0 then --如果是清除报警
                db_alarm_status_update(stmt_update_alarm,dev_sn,rack_id,index,row[2])
            elseif tags[row[2]] == 1 then --如果是设置报警
                db_alarm_status_insert(stmt_insert_alarm,dev_sn,rack_id,index,row[2])
            end
        end
    end
end

local function iot2app(topic,payload)
    local result,gw_sn,dev_sn,port=internal_api.topic_spilt(topic)
    if not result or not payload or #payload == 0 then return end
    if dev_sn == cluster_sn then
        local param,identifier,mi = internal_api.payload_spilt(topic,payload)
        if identifier == "RackListRequest" then
            replyRackListRequest(gw_sn,dev_sn,port,identifier,param,mi)
        elseif identifier == "ImmediateAlarm" then
            replyImmediateAlarm(gw_sn,dev_sn,port,identifier,param,mi)
        elseif identifier == "HistoryAlarm" then
            replyHistoryAlarm(gw_sn,dev_sn,port,identifier,param,mi,starttime,endtime)
        end
    end
end

local function pp2app(topic,payload)
    local result,gw_sn,dev_sn,port,identifier=internal_api.topic_spilt(topic)
    if not result or not payload or #payload == 0 then return end
    if port == rack_port and  dev_sn ~= cluster_sn then
        if not pack_status_obj[dev_sn] then pack_status_obj[dev_sn]={} end
        pack_status_obj[dev_sn].rack_id = tonumber(string.sub(dev_sn,#gw_sn+1)) - 1
        pack_status_obj[dev_sn].time = os.time()
        local param =internal_api.payload_spilt(topic,payload)
        if identifier == "RackInformationRequest" then
            if param then
                pack_data_obj[dev_sn] = param
                -- db_realdata_insert(stmt_insert_data,dev_sn,pack_status_obj[dev_sn].rack_id,pack_status_obj[dev_sn].time,identifier,param)
            end
        elseif identifier == "RackAlarmRequest" then
            if param then
                alarm_status(dev_sn,pack_status_obj[dev_sn].rack_id,param)
            end
        elseif identifier == "RackCell1_216VolQuery" then
            if param then
                -- db_realdata_insert(stmt_insert_data,dev_sn,pack_status_obj[dev_sn].rack_id,pack_status_obj[dev_sn].time,identifier,param)
            end
        elseif identifier == "RackCell1_108TempQuery" then
            if param then
                -- db_realdata_insert(stmt_insert_data,dev_sn,pack_status_obj[dev_sn].rack_id,pack_status_obj[dev_sn].time,identifier,param)
            end
        end
    end
end


function main(nodes_cfg,sn)
    -- local last_used_TOU
    log.info("calculate", "=============== GUO DIAN TOU BMS ============")
    siganl.signal(siganl.SIGKILL,handler)
    siganl.signal(siganl.SIGHUP,handler)
    -- local client = internal_api.local_mqtt_session("localhost",1883,nil,nil,subscribe,on_mqtt_msg)
    -- gw_sn = system_reply("/lib/dyiot/bin/factory get | grep SN | awk -F = '{print $2}' | tr '\\n' '\\0'")
    gw_sn = io.getGatewayID()
    cluster_sn = string.format( "%s01",gw_sn)
    local sub_dev_sn = {}
    table.insert(sub_dev_sn,cluster_sn)
    for i=2,2 do
        table.insert(sub_dev_sn,string.format("%s%02d",gw_sn,i))
    end
    rack_port = "RS485_1"
    cluster_port = "RS485_1"
    internal_api.local_mqtt_session(sub_dev_sn,"APP",iot2app,pp2app)

    db_init(DB_FILE)
    -- calculate ang data report
    sys.taskInit(function()
        local last_time = 0
        local report_time = 0
        while true do
            sys.wait(1000)

            if os.difftime(os.time(),report_time) >= DB_CLEAN_INTERVAL then
                db_autoclean()
            end
        end
    end)

    --启动系统框架
    sys.init(0, 0)
    sys.run()
end

main(arg[1],arg[2])