module(..., package.seeall)

require("procps")
require("getopts")
require("fs")

local configdir
local datafile
local configfiles = {}
local configitems = {}

local processname = "tinydns"
local configfile = "/etc/conf.d/" .. processname
local initdoptions = getopts.getoptsfromfile_onperline("/etc/init.d/" .. processname)
if (initdoptions) then
	configdir = initdoptions.DATADIR
	datafile = initdoptions.ROOT .. "/data" or "/var/cache/data"
else
	configdir = "/etc/" .. processname
	datafile = "/var/cache/data"
end

-- ################################################################################
-- LOCAL FUNCTIONS

local function get_version()
	local cmd_output_result, cmd_output_error
	local cmd = "/sbin/apk_version -vs " .. processname .." 2>/dev/null"
	local f = io.popen( cmd )
	local cmdresult = f:read("*l")
	if (cmdresult) and (#cmdresult > 0) then
		cmd_output_result = string.match(cmdresult,"^%S*") or "Unknown"
	else
		cmd_output_error = "Program not installed"
	end	
	f:close()
	return cmd_output_result,cmd_output_error
end

--[[
-- This function could be used to check that valid parameters are used in different places
local function check_signs(sign)
	local output = {}
	local output = {prefix={"Z", "&", "=", "+", "@", "C",}}
	output = output[sign]
	return output
end
--]]

-- Return a table with the config-content of a file
-- Commented/Blank lines are ignored
local function get_value_from_file(file)
	local output = {}
	local filecontent = fs.read_file_as_array(file)
	for i=1,table.maxn(filecontent) do
		local l = filecontent[i]
		if not (string.find ( l, "^[;#].*" )) and not (string.find (l, "^%s*$")) then
			table.insert(output, string.match(l,"(.-)%s*$"))
		end
	end
	if (#output > 0) then
		return true, output
	else
		return false, output
	end

end

-- Function to recursively inserts all filenames in a dir into an array
local function recursedir(path, filearray)
	local k,v
	for k,v in pairs(posix.dir(path) or {}) do
		-- Ignore files that begins with a '.'
		if not string.match(v, "^%.") then
			local f = path .. "/" .. v
			-- If subfolder exists, list files in this subfolder
			if (posix.stat(f).type == "directory") then
				recursedir(f, filearray)
			else
				table.insert(filearray, f)
			end
		end
	end
end

-- Feed the configfiles table with list of all availage configfiles
local function searchforconfigfiles()
	local cnffile = {}
	recursedir(configdir, cnffile)
	for k,v in pairs(cnffile) do
		local configcontent = get_value_from_file(v)
		if (configcontent) then
			table.insert(configfiles, v)
		end
	end
end
searchforconfigfiles()
-- ################################################################################
-- PUBLIC FUNCTIONS

-- Present some general status
function getstatus()
	local status = {}
	local version,versionerrtxt = get_version()
	status.version = cfe({ name = "version",
		label="Program version",
		value=version,
		errtxt=versionerrtxt,
		 })
	status.status = cfe({ name="status",
		label="Program status",
		value=procps.pidof(processname),
		})
	return status
end

-- Return config-information
function getconfig()
	local config = {}
	local version,versionerrtxt = get_version()
	local listenaddr = getopts.getoptsfromfile_onperline(configfile,"IP") or {}
	config.listen = cfe({ 
		name = "listen",
		label="IP address to listen on",
		value=listenaddr.IP or "",
		 })

	return config
end


-- ################################################################################
-- DEBUG INFORMATION (Everything below will be deleted in the future)

function getdebug()
	local debug = {}

--[[
	local signs = get_available_signs("prefix") or {}
	debug.debugprefixes = cfe({ 
		name = "debugprefixes",
		label="Available prefixes",
		option=signs,
		type="select",
		size=table.maxn(signs)+1,
		 })

	local signs = get_available_signs("suffix") or {}
	debug.debugsuffixes = cfe({ 
		name = "debugsuffixes",
		label="Available suffixes",
		option=signs,
		type="select",
		size=table.maxn(signs)+1,
		 })
--]]
	debug.configdir = cfe({ 
		name = "configdir",
		label="configdir",
		value=configdir,
		 })
	debug.datafile = cfe({ 
		name = "datafile",
		label="datafile",
		value=datafile,
		 })

	for k,v in pairs(configfiles) do
		local cnfcontent
		fake, cnfcontent = get_value_from_file(v)
		for kk,vv in pairs(cnfcontent) do
			table.insert(configitems,vv)
		end
	end
	debug.configitems = cfe({ 
		name = "configitems",
		label="configitems",
		option=configitems,
		type="select",
		 })

	debug.configfiles = cfe({ 
		name = "configfiles",
		label="configfiles",
		option=configfiles,
		type="select",
		 })

	return debug
end