#!/usr/bin/env lua

local json = require "luci.jsonc"
local fs   = require "nixio.fs"

local function readfile(path)
    local s = fs.readfile(path)
    return s and (s:gsub("^%s+", ""):gsub("%s+$", ""))
end

local methods = {
    getSnmpSysObject = {
        call = function()
        local sys = require "luci.sys"
        local res = {}

        local name=luci.sys.exec("cat /usr/lib/snmp/snmpd.conf | grep '^psysname' | sed -e 's/psysname//g'") or ""
        local contact=luci.sys.exec("cat /usr/lib/snmp/snmpd.conf | grep '^psyscontact' | sed -e 's/psyscontact//g' ") or ""
        local location=luci.sys.exec("cat /usr/lib/snmp/snmpd.conf | grep 'psyslocation'  | sed -e 's/psyslocation//g'") or ""
        local descr=luci.sys.exec("uname -s -n -r -v -m") or ""
        res.name=name
        res.contact=contact
        res.location=location
        res.descr=descr
        return { result = res }
    end
    },
    getSnmpEngineObject = {
                call = function()
                local sys = require "luci.sys"
                local res = {}

                local engineid=luci.sys.exec("cat /usr/lib/snmp/snmpd.conf | grep '^oldEngineID' | sed -e 's/oldEngineID//g'") or ""
                res.engineid=engineid
                return { result = res }
        end
        }
}



local function parseInput()                                                                                      
    local parse = json.new()                                                                                 
    local done, err                                                                                                                     
    
    while true do                                                                                                              
        local chunk = io.read(4096)                                                                                                 
        if not chunk then                                                                                                           
            break                                                                                                               
        elseif not done and not err then                                                                                            
            done, err = parse:parse(chunk)                                                                                      
        end                                                                                                                         
    end                                                                                                                                 
    
    if not done then                                                                                                                    
        print(json.stringify({ error = err or "Incomplete input" }))                                                                
        os.exit(1)                                                                                                                  
    end                                                                                                                                 
    
    return parse:get()                                                                                                                  
end


local function validateArgs(func, uargs)                                          
    local method = methods[func]                                                             
    if not method then                                                         
        print(json.stringify({ error = "Method not found" }))                 
        os.exit(1)                                                                                                                  
    end                                                                         
    
    if type(uargs) ~= "table" then                                                                                           
        print(json.stringify({ error = "Invalid arguments" }))        
        os.exit(1)                                                               
    end                                                                     
    
    uargs.ubus_rpc_session = nil                                                           
    
    local k, v                                                                                
    local margs = method.args or {}                                                                        
    for k, v in pairs(uargs) do                                                                                                              
        if margs[k] == nil or                                                                         
         (v ~= nil and type(v) ~= type(margs[k]))                                                      
         then                                                                                        
            print(json.stringify({ error = "Invalid arguments" }))                                         
            os.exit(1)                                          
        end                                                          
    end                                                                              
    
    return method                                                        
end                                                                     

if arg[1] == "list" then                                                             
    local _, method, rv = nil, nil, {}                             
    for _, method in pairs(methods) do rv[_] = method.args or {} end                       
    print((json.stringify(rv):gsub(":%[%]", ":{}")))                                                            
elseif arg[1] == "call" then                                                        
    local args = parseInput()                                               
    local method = validateArgs(arg[2], args)                                                     
    local result, code = method.call(args)                                                              
    print((json.stringify(result):gsub("^%[%]$", "{}")))       
    os.exit(code or 0)                                                         
end
