module("meizu.nwfs", package.seeall)
--network functions

local cjson = require "cjson"
local lfs   = require "lfs"
local bfs   = require "meizu.bfs"
local RC    = require "meizu.r10config"
local dbfs  = require "meizu.dbfs"

local bind_router          = bfs.bind_router
local data_to_json         = bfs.data_to_json
local exec_cmd_in_sh       = bfs.exec_cmd_in_sh
local exec_reboot          = bfs.exec_reboot
local get_device_SN        = bfs.get_device_SN
local get_device_version   = bfs.get_device_version
local get_https_data       = bfs.get_https_data
local rts_get_access_token = bfs.rts_get_access_token
local set_passwd           = bfs.set_passwd
local silent_upgrade       = bfs.silent_upgrade
local strsplit             = bfs.strsplit
local b64dec               = bfs.b64dec
local b64enc               = bfs.b64enc
local report_router_config = bfs.report_router_config

local lue                  = require("luci.util").exec

function wifi_network(wifi_device_name)
	local network = require "luci.model.network".init()
	local wifi_net = network:get_wifinet(wifi_device_name)
	if wifi_net then
		local dev = wifi_net:get_device()
		if dev then
			return {
			id         = wifi_device_name,
			name       = wifi_net:shortname(),
			up         = wifi_net:is_up(),
	                	mode       = wifi_net:active_mode(),
	                	ssid       = wifi_net:active_ssid(),
	                	bssid      = wifi_net:active_bssid(),
	                	encryption = wifi_net:active_encryption(),
	                	encryption_src = wifi_net:get("encryption"),
	                	frequency  = wifi_net:frequency(),
	                	bitrate    = wifi_net:bitrate(),
	                	ifname     = wifi_net:ifname(),
	                	assoclist  = wifi_net:assoclist(),
	                	country    = wifi_net:country(),
	                	key        = wifi_net:get("key"),
	                	key1	   = wifi_net:get("key1"),
	                	hidden     = wifi_net:get("hidden"),
	                	device     = {
	                    up     = dev:is_up(),
	                    device = dev:name(),
	                    name   = dev:get_i18n()
	                }
	            }
	        end
	end
	return {}
end

function wifi_networks()
	local result = {}
	local network = require "luci.model.network".init()
	local dev
	for _, dev in ipairs(network:get_wifidevs()) do
		local rd = {
		up       = dev:is_up(),
		device   = dev:name(),
		name     = dev:get_i18n(),
		networks = {}
	        }
	        local wifi_net
	        for _, wifi_net in ipairs(dev:get_wifinets()) do
	            rd.networks[#rd.networks+1] = {
	                name       = wifi_net:shortname(),
	                up         = wifi_net:is_up(),
	                mode       = wifi_net:active_mode(),
	                ssid       = wifi_net:active_ssid(),
	                bssid      = wifi_net:active_bssid(),
	                encryption = wifi_net:active_encryption(),
	                frequency  = wifi_net:frequency(),
	                channel    = wifi_net:channel(),
	                signal     = wifi_net:signal(),
	                quality    = wifi_net:signal_percent(),
	                noise      = wifi_net:noise(),
	                bitrate    = wifi_net:bitrate(),
	                ifname     = wifi_net:ifname(),
	                assoclist  = wifi_net:assoclist(),
	                country    = wifi_net:country(),
	                key	   	   = wifi_net:get("key"),
	                key1	   = wifi_net:get("key1"),
	                encryption_src = wifi_net:get("encryption"),
	                hidden = wifi_net:get("hidden"),
	            }
	        end
	        result[#result+1] = rd
	end
	return result
end

function nw_get_wifi_settings()
	luci.http.prepare_content("application/json")
	local app_version = luci.http.formvalue("appVer")
	if app_version == nil then
		app_version = 0
	end
	local list = get_wifi_settings(app_version)
	luci.http.write(list)
end

function ww_get_wifi_settings(app_version)
	local list = get_wifi_settings(app_version)
	--return data_to_json(list)
	return list
end

function get_wifi_settings(app_version)
    	local network = require "luci.model.network".init()
    	local info_list = {}
    	local wifis = wifi_networks()
    	for i,wifi_net in ipairs(wifis) do
        	local item = {}
        	local index = 1

	    	if wifi_net.device == "mt7628" then
	        	local wifi_net_wl0 = network:get_wifinet('mt7628.network1')
		    	item["ssid"] = wifi_net_wl0:get("ssid")
			if wifi_net_wl0:get("disabled") == "1" then
                		item["status"] = "false"
			else
                		item["status"] = "true"
			end
		end

	    	if wifi_net.device == "mt7610e" then
	        	local wifi_net_wl1 = network:get_wifinet('mt7610e.network1')
			item["ssid"] = wifi_net_wl1:get("ssid")
		    	if wifi_net_wl1:get("disabled") == "1" then
                		item["status"] = "false"
			else
                		item["status"] = "true"
			end
		end

        	local encryption = wifi_net.networks[index].encryption_src
        	local key = wifi_net.networks[index].key
        	if encryption == "wep-open" then
            		key = wifi_net.networks[index].key1
            		if key:len()>4 and key:sub(0,2)=="s:" then
                		key = key:sub(3)
            		end
        	end
        	local name = "wl0";
        	if "rai0" == wifi_net.networks[index].ifname then
        		name = "wl1"
        	end
        	item["name"] = name
		--item["ssid"] = wifi_net.networks[index].ssid
		if key == nil then
	   		key = ""
		end
        	item["password"] = key
        	item["encryption"] = encryption
        	info_list[#wifis+1-i] = item
    	end
    	require "MZLog".log(3, debug.getinfo(1).currentline)
    	require "MZLog".log(3, info_list)
    	if tonumber(app_version) >= 5 then
        	return b64enc(cjson.encode(info_list))
    	else
        	return cjson.encode(info_list)
    	end
end

function get_wifi_ssids()
	local wifis = wifi_networks()
	local ssid1 = ""
	local ssid2 = ""
	for i, wifi_net in ipairs(wifis) do
		if i == 1 then
			ssid1 = wifi_net.networks[1].ssid
		end
		if i == 2 then
			ssid2 = wifi_net.networks[1].ssid
		end
	end

	return ssid1, ssid2
end

function nw_wifi_settings()

    	luci.http.prepare_content("application/json")
    	local data = luci.http.formvalue("data")
    	local app_version = luci.http.formvalue("appVer")
    	if app_version == nil then
        	app_version = 0
    	end
    	local switch_2g = nil
    	local switch_5g = nil
    	local ssid_2g = nil
    	local ssid_5g = nil
    	local pwd_2g = nil
    	local pwd_5g = nil
    	local encry_2g = nil
    	local encry_5g = nil

    	if tonumber(app_version) >= 5 then
        	local data = b64dec(data)
	    	data = cjson.decode(data)

        	for k, v in pairs(data) do
            		if v.name == "wl0" then
        			switch_2g = v.on
        			ssid_2g = v.ssid
        			pwd_2g = v.pwd
        			encry_2g = v.encryption
        			require "MZLog".log(3, debug.getinfo(1).currentline)
        			require "MZLog".log(3, debug.getinfo(1).currentline)
    			elseif v.name == "wl1" then
                		switch_5g = v.on
                		ssid_5g = v.ssid
                		pwd_5g = v.pwd
                		encry_5g = v.encryption
            		end
        	end
    	else
		switch_2g = luci.http.formvalue("on1")
		ssid_2g = luci.http.formvalue("ssid1")
		pwd_2g = luci.http.formvalue("pwd1")
		encry_2g = luci.http.formvalue("encryption1")

		switch_5g = luci.http.formvalue("on2")
		ssid_5g = luci.http.formvalue("ssid2")
		pwd_5g = luci.http.formvalue("pwd2")
		encry_5g = luci.http.formvalue("encryption2")

    	end

	dbfs.init_ssid_table()
	local dbssid = dbfs.fetch_ssid()
	if nil == dbssid or #dbssid == 0 then
		dbfs.add_ssid(ssid_2g, ssid_5g)
	else
		dbfs.update_ssid(ssid_2g, ssid_5g)
	end

    	local res = wifi_settings(switch_2g, ssid_2g, pwd_2g, encry_2g, switch_5g, ssid_5g, pwd_5g, encry_5g)
    	luci.http.write_json(res)
end

function wifi_settings(on1, ssid1, pwd1, encry1, on2, ssid2, pwd2, encry2)
    	local result = {}
	local res = {}
    	local code = 0
    	local code1 = 0
    	local code2 = 0
    	local details = {}
    	local code1 = check_ssid(ssid1, 31)
    	local code2 = check_ssid(ssid2, 31)
    	local succeed1 = false
    	local succeed2 = false
    	if on1 == "false" then
	    	require "MZLog".log(3, debug.getinfo(1).currentline)
        	succeed1 = set_wifi_basic_info(1, nil, nil, nil, on1)
    	else
        	if code1 == 1 then
            		succeed1 = set_wifi_basic_info(1, ssid1, pwd1, encry1, on1)
        	end
    	end

    	if on2 == "false" then
        	succeed2 = set_wifi_basic_info(2, nil, nil, nil, on2)
    	else
        	if code2 == 1 then
            		succeed2 = set_wifi_basic_info(2, ssid2, pwd2, encry2, on2)
        	end
    	end

	if code == 0 and code1 ~= 0 and code2 ~= 0 and succeed1 ~= false and succeed2 ~= false then
		res["result"] = true
            	fork_restart_wifi()
	else
		res["result"] = false
    	end

	return res
end

function set_wifi_basic_info(wifi_index, ssid, password, encryption, on)

	local network = require "luci.model.network".init()
	if wifi_index == 1 then
		wifi_net = network:get_wifinet('mt7628.network1')
		wifi_dev = network:get_wifidev('mt7628')
	end

	if wifi_index == 2 then
		wifi_net = network:get_wifinet('mt7610e.network1')
		wifi_dev = network:get_wifidev('mt7610e')
	end

	if wifi_net == nil then
		return false
	end

	if wifi_dev then
		if on == "true" then
			wifi_net:set("disabled", "0")
		elseif on == "false" then
			wifi_net:set("disabled", "1")
		end
	end

	if not is_str_nil(ssid) and check_ssid(ssid) then
		wifi_net:set("ssid",ssid)
	end

	local code = check_wifi_passwd(password,encryption)
	if code == 0 then
		wifi_net:set("encryption",encryption)
		wifi_net:set("key",password)
		if encryption == "none" then
			wifi_net:set("key","")
		elseif encryption == "wep-open" then
			wifi_net:set("key1","s:"..password)
			wifi_net:set("key",1)
		end
	elseif code > 1502 then
		return false
	end

	network:save("wireless")
	network:commit("wireless")
	return true
end

function is_str_nil(str)
	return (str == nil or str == "")
end

function check_ssid(ssid)
	if is_str_nil(ssid) then
		return 0
	end

	return 1
end

function check_wifi_passwd(passwd,encryption)
	if is_str_nil(encryption) or (encryption and encryption ~= "none" and is_str_nil(passwd)) then
		return 1502
	end
	if encryption == "psk" or encryption == "psk2" then
	        if  passwd:len() < 8 then
			return 1520
	        end
	elseif encryption == "mixed-psk" then
	        if  passwd:len()<8 or passwd:len()>63 then
			return 1521
	        end
	elseif encryption == "wep-open" then
	        if  passwd:len()~=5 and passwd:len()~=13 then
			return 1522
	        end
	end
	return 0
end

function fork_restart_wifi()
	local FORK_RESTART_WIFI = "sleep 1; /sbin/wifi >/dev/null 2>/dev/null;"
	exec_cmd_in_sh(FORK_RESTART_WIFI)
end

function fork_restart_network()
	local FORK_RESTART_WORK= "/etc/init.d/network restart"
	exec_cmd_in_sh(FORK_RESTART_WORK)
end



function set_wifi_up()
    --local cmd = "/sbin/wifi up".. wnet
    local cmd = "/sbin/wifi up ".. "mt7628"
    exec_cmd_in_sh(cmd)
    luci.http.write_json("true")
end

function set_wifi_down()
    local cmd = "/sbin/wifi down ".."mt7628"
    --local cmd = "/sbin/wifi down"..wnet
    exec_cmd_in_sh(cmd)
    luci.http.write_json("true")
end

--set
function fork_smart_wifi_updown(wnet, close_hour, close_min, open_hour, open_min, week_repeat)
    if week_repeat == "non-repeat" then               
        week_repeat = "0,1,2,3,4,5,6"
        cmd_close = "/sbin/smart_wifi "..close_min.." "..close_hour.." "..week_repeat
        cmd_open = "/sbin/smart_wifi "..open_min.." "..open_hour.." "..week_repeat
    else
        cmd_close = "echo '"..close_min.." "..close_hour.." * * "..week_repeat.." /sbin/wifi down "..wnet.."; #"
            ..close_min..close_hour..open_min..open_hour..week_repeat
            .."' >> /etc/crontabs/root; crontab /etc/crontabs/root;"
        
        cmd_open = "echo '"..open_min.." "..open_hour.." * * "..week_repeat.." /sbin/wifi up "..wnet.."; #"
            ..close_min..close_hour..open_min..open_hour..week_repeat
            .."' >> /etc/crontabs/root; echo ''>>/etc/crontabs/root;  crontab /etc/crontabs/root;"
    end                                               
    luci.http.write_json(cmd_close)
    luci.http.write_json(cmd_open)

    exec_cmd_in_sh(cmd_close)                               
    posix.sleep(1)
    exec_cmd_in_sh(cmd_open)                               
end

--stop
function set_smart_wifi_stop(update_flag)
    local cmd = "sed -i '/"..update_flag.."/d' /etc/crontabs/root; crontab /etc/crontabs/root"
    exec_cmd_in_sh(cmd)
    luci.http.write_json(cmd)
end


--function:     定时wifi开关shell形式
--author：      rh_Jameson
function set_smart_wifi_updown()

    --get para
    --wnet = luci.http.formvalue("wnet")
    --close_hour = luci.http.formvalue("close_hour")
    --close_min = luci.http.formvalue("close_min")
    --open_hour = luci.http.formvalue("open_hour")
    --open_min = luci.http.formvalue("open_min")
    --repeat_var_from_http = luci.http.formvalue("repeat_var")
    --func = luci.http.write_json("func")

    --test normal    
    local wnet = 'mt7628'
    local close_hour = "08"
    local close_min = "11"
    local open_hour = "08"
    local open_min = "12"
    local repeat_var_from_http = "1111111"
    local func = luci.http.formvalue("func")
     --para err manage
    if string.len(repeat_var_from_http) ~= 7 then
        luci.http.write_json("len error")
        return
    end
    
    --get repeat
    local week_repeat = ""
    for i = 0, #repeat_var_from_http do
        tmp = string.sub(repeat_var_from_http, i, i)
        if tmp == "1" then
            if i == #repeat_var_from_http then
                week_repeat = week_repeat..0
                break
            end
            week_repeat = week_repeat..tostring(i)..","
        end
    end
    if week_repeat == "" then
        week_repeat = "non-repeat"
    end

    --exec
    if func == "set" then
        fork_smart_wifi_updown(wnet, close_hour, close_min, open_hour, open_min, week_repeat)
    elseif func == "stop" or func == "update" then
        local update_flag = luci.http.formvalue("flag")
        set_smart_wifi_stop(update_flag)
        
        if func == "update" then
            posix.sleep(1)
            fork_smart_wifi_updown(wnet, close_hour, close_min, open_hour, open_min, week_repeat)
        end
    end
end


function get_lan_ip()
	local uci = require("luci.model.uci").cursor()
	local lan = uci:get_all("network", "lan")
	return lan.ipaddr
end

function macFormat(mac)
	if mac then
		return string.upper(string.gsub(mac, "-", ":"))
	else
		return ""
	end
end

function getAllWifiConnetDeviceDict()
	local result = {}
	for index = 1,2 do
	        local wifilist = getWifiConnectDeviceList(index)
	        for _, mactime in pairs(wifilist) do
	            local item = {}
	            item["wifiIndex"] = index
	            item["time"] = mactime["time"]
	            item["rx"] = mactime["rx"]
	            item["tx"] = mactime["tx"]
	            item["rxspeed"] = mactime["rxspeed"]
	            item["txspeed"] = mactime["txspeed"]
	            result[macFormat(mactime["mac"])] = item
	        end
	end
	return result
end

function getWifiConnectDeviceList(wifiIndex)
	local dlist = {}
	local macfile = nil
    	local uci = require("luci.model.uci").cursor()
    	if tonumber(wifiIndex) == 1 then
    		local disable_2g = uci.get("wireless", "mt7628iface", "disabled")
    		if "1" ~= disable_2g then
	    		local cmd = [[iwpriv ra0 get_mac_table]]
	    		macfile = io.popen(cmd)
    		end
    	elseif tonumber(wifiIndex) == 2 then
        	local disable_5g = uci.get("wireless", "mt7610eiface", "disabled")
    		if "1" ~= disable_5g then
	    		local cmd = [[iwpriv rai0 get_mac_table]]
	    		macfile = io.popen(cmd)
    		end
    	end
    	local tmplinenumber = 0
    	if nil ~= macfile then
    		for line in macfile:lines() do
    			if 0 ~= tmplinenumber and "" ~= line then
    				local item = {}
    				local mactime = strsplit(line, " ")
    				item["mac"] = macFormat(mactime[1])
    				item["time"] = mactime[2]
    				item["rx"] = mactime[3]
    				item["tx"] = mactime[4]
    				item["rxspeed"] = mactime[5]
    				item["txspeed"] = mactime[6]
    				table.insert(dlist,item)
    			end
    			tmplinenumber = tmplinenumber + 1
		end
		macfile:close()
    	end
    	return dlist
end

function getDHCPLists()
	local NixioFs = require("nixio.fs")
	local LuciUci = require("luci.model.uci")
	local uci =  LuciUci.cursor()
	local result = {}
	local leasefile = "/var/dhcp.leases"
	uci:foreach("dhcp", "dnsmasq",
	function(s)
		if s.leasefile and NixioFs.access(s.leasefile) then
			leasefile = s.leasefile
			return false
		end
	end)
	local dhcp = io.open(leasefile, "r")
	if dhcp then
        for line in dhcp:lines() do
		if line then
	                local ts, mac, ip, name = line:match("^(%d+) (%S+) (%S+) (%S+)")
	                if name == "*" then
				name = ""
	                end
	                if ts and mac and ip and name then
				result[#result+1] = {
					mac  = macFormat(mac),
					ip   = ip,
					name = name,
					sp = 0
				}
	                end
		end
        end
        dhcp:close()
        return result
	else
		return false
	end
end

function getDHCPDict()
	local dhcpDict = {}
	local dhcpList = getDHCPLists()
	for _,value in ipairs(dhcpList) do
		dhcpDict[value.mac] = value
	end
	return dhcpDict
end

function getDHCPIpDicts()
	local dhcpDict = {}
	local dhcpList = getDHCPLists()
	for _,value in ipairs(dhcpList) do
		dhcpDict[value.ip] = value
	end
	return dhcpDict
end

function getDeviceInfoFromDB()
	local result = {}
	local deviceList = dbfs.fetchAllDeviceInfo()
	if #deviceList > 0 then
		for _, device in ipairs(deviceList) do
		result[device.mac] = device
        end
	end
	return result
end

function is_device_online(ip)
	local lu = require("luci.util")
	local cmd = "ping -W 2 -c 1 " .. ip .. " > /dev/null ;echo -n $?"
	local pingresult = lu.exec(cmd)

	local res = nil
	if pingresult == "0" then
		res = true
	else
		res = false

	end

	return res
end

function get_connect_device_list_router()
	local devicelist = {}
	dbfs.init_arp_table()
	local dbarp = dbfs.fetch_all_arp()
	
	local deviceDBDict = getDeviceInfoFromDB()
	local dhcpDeviceDict = getDHCPDict()
	local blacklist0 = dbfs.fetch_all_deny_mac()
	local wifiDeviceDict = getAllWifiConnetDeviceDict()
	
	local cmd = [[cat /proc/net/arp |grep br-lan|awk '{print $1","$4}']]
	local ipmacs = {}
	local devs = lue(cmd)
	if devs ~= "" then
		local ipmacstr = strsplit(devs, '\n')
		ipmacstr[#ipmacstr] = nil
		for k, v in pairs(ipmacstr) do
			local ipmac = strsplit(v, ',')
			ipmacs[string.upper(ipmac[2])] = ipmac
		end
	end
	
	for k, v in pairs(dbarp) do
		local item = {}
		local mac = string.upper(v["mac"])
		if "00:00:00:00:00:00" ~= mac then
			local devflag = false
			local im = ipmacs[mac]
			local wf = v["wifi"]
			if wf == 0 then
				item["type"] = "wire"
			elseif wf == 1 then
				item["type"] = "2.4G"
			elseif wf == 2 then
				item["type"] = "5G"
			end
			if nil ~= im then
				item["ip"] = im[1]
				item["mac"] = string.upper(im[2])
			else
				item["ip"] = v["ip"]
				item["mac"] = mac
			end
			
			local deviceDB = deviceDBDict[mac]
			local dhcpinfo = dhcpDeviceDict[mac]
			if deviceDB ~= nil then
				item["devicename"] = deviceDB.orgname
				if deviceDB.devicename ~= '' then
					item["devicename"] = deviceDB.devicename
				end
			elseif dhcpinfo ~= nil then
				item["devicename"] = dhcpinfo.name
				dbfs.saveDeviceInfo(mac, dhcpinfo.name, "", dhcpinfo.ip)
			else
				item["devicename"] = "unknown"
			end
			
			local isblack = false
			if nil ~= blacklist0 then
				for k, v in pairs(blacklist0) do
					if v.mac == mac then
						isblack = true
					end
				end
			end
			if isblack == false then
				item["enable"] = true
			else
				item["enable"] = false
			end
			
			local wifi = wifiDeviceDict[mac]
			
			item["online"] = false
			if wf == 0 and nil ~= im then
				item["online"] = true
			end
			if wifi ~= nil then
				item["online"] = true
				if wifi.wifiIndex == 1 then
					item["type"] = "2.4G"
				elseif wifi.wifiIndex == 2 then
					item["type"] = "5G"
				end
			end
			if nil == item["type"] or false == item["online"] then
				item["type"] = "unknown"
			end
			table.insert(devicelist,item)
		end
	end
	return devicelist
end

function get_connect_device_list()
	local uci = require("luci.model.uci").cursor()
        local apc = uci.get("network", "lan", "apclient")
	local devicelist = {}
        if nil == apc or "" == apc then
		--mode router
		devicelist = get_connect_device_list_router()
	else
		--mode apclient
		if "mt7628" == apc then
		
		elseif "mt7610e" == apc then
			
		end
		devicelist = get_connect_device_list_router()
        end
        return devicelist
end

function ww_get_connect_device_list()
	local result = get_connect_device_list()
	return result
end

function nw_get_connect_device_list()
	luci.http.prepare_content("application/json")
	local result = get_connect_device_list()
	luci.http.write_json(result)
end

function nw_set_device_name()
	local mac = luci.http.formvalue("mac")
	local devicename = luci.http.formvalue("devicename")
	set_device_name(mac,devicename)
end

function set_device_name(mac,devicename)
	local code = 0
	local deviceList = {}

	if is_str_nil(mac) or is_str_nil(devicename) then
		code = 1502
	else
		code = save_device_name(mac,devicename)
	end
	return code
end

function save_device_name(mac,name)
	local code = 0
	local code = dbfs.updateDeviceNickname(macFormat(mac),name)
	if code == 0 then
		return true
	else
		return false
	end
end

function set_wan_switch(mac, mode, enable)
	local result = {}
    	local code = false
    	if is_str_nil(mac) then
        	return
    	else
        	mac = macFormat(mac)
        	enable = tonumber(enable)
    	end
    	
    	local dbdenymac = dbfs.fetch_all_deny_mac()
    	local macstr = ""
    	local deny = false
	if enable == 0 then
		if nil == dbdenymac then
			dbfs.add_deny_mac(mac)
			macstr = mac
		else
			if #dbdenymac >= 60 then
				return "black person reach max"
			end
			for _, macaddr in ipairs(dbdenymac) do
				if mac == macaddr.mac then
					return "same black"
				else
					macstr = macstr.." "..macaddr.mac
				end
			end
			dbfs.add_deny_mac(mac)
			macstr = macstr.." "..mac
		end
	else
		if nil == dbdenymac then
			return
		end
		for _, macaddr in ipairs(dbdenymac) do
			if mac == macaddr.mac then
				dbfs.delete_deny_mac(mac)
				if #dbdenymac == 1 then
					deny = true
				end
			else
				macstr = macstr.." "..macaddr.mac
			end
		end
	end
	local cmd = [[wireless-ban.sh ]]
	if deny == true then
		cmd = cmd.."none"
	else
		cmd = cmd.."deny "..macstr
	end
	exec_cmd_in_sh(cmd)
	code = true
	result["result"] = code

	return result
end

function nw_set_wan_switch()
	local result = {}
	local code = false
	local mac = luci.http.formvalue("mac")
	local mode = luci.http.formvalue("mode")
	local enable = luci.http.formvalue("enable")

	code = set_wan_switch(mac,mode,enable)
	result["result"] = code
	luci.http.write_json(result)
end

function getNetConnect(ip)
	local sys = require "luci.sys"
	local res = {}
	res["bytes"] = 0
	local conn = sys.net.conntrack()
	    require "MZLog".log(3, debug.getinfo(1).currentline)
	    require "MZLog".log(3, debug.getinfo(1).currentline)
	    require "MZLog".log(3, conn)
	for _, value in pairs(conn) do
	    if value.src == ip then
		    res["bytes"] = value.bytes + res["bytes"]
		end
	end
	return res
end

function get_net_device()
	local ntm = require "luci.model.network".init()
	local dev
	local devices = { }
	for _, dev in luci.util.vspairs(luci.sys.net.devices()) do
		if dev ~= "lo" and not ntm:ignore_interface(dev) then
			devices[#devices+1] = dev
		end
    	end
	local curdev = luci.dispatcher.context.requestpath
	curdev = curdev[#curdev] ~= "bandwidth" and curdev[#curdev] or devices[1]
	luci.http.write_json(devices)
end

function nw_check_sys_password()
	local password = luci.http.formvalue("password")
	check_sys_password(password)
end

function check_sys_password(password)
	local result={}
	if not is_str_nil(password) then
		local check = check_sys_pwd(password)
        if check then
		code = true
        else
		code = false
	        end
	end
	result["result"] = code
	luci.http.write_json(result)
end

function get_wan_type()
    	local LuciNetwork = require("luci.model.network").init()
    	local uci = require("luci.model.uci").cursor()
        local apc = uci.get("network", "lan", "apclient")
	local wanNetwork = LuciNetwork:get_network("wan")
   	local wanDetails = {}
	if wanNetwork then
		if nil ~= apc and "" ~= apc then
			wanDetails["type"] = "apclient"
			local uci = require("luci.model.uci").cursor()
			local ssid = uci.get("wireless", apc, "apclissid")
			wanDetails["ssid"] = ssid
		else
        			local wanType = wanNetwork:proto()

	      		if wanType == "static" then
            			wanDetails["ipaddr"] = wanNetwork:get_option_value("ipaddr")
	            		wanDetails["netmask"] = wanNetwork:get_option_value("netmask")
        	    			wanDetails["gateway"] = wanNetwork:get_option_value("gateway")
        			elseif wanType == "pppoe" then
	            		wanDetails["type"] = "pppoe"
		            	wanDetails["pppoeName"] = wanNetwork:get_option_value("username")
        	    			wanDetails["pppoePwd"] = wanNetwork:get_option_value("password")
        			elseif wanType == "dhcp" then
            			wanDetails["type"] = "dhcp"
	            		wanDetails["pppoeName"] = ""
        	    			wanDetails["pppoePwd"] = ""
        			end
		end
		return wanDetails
    	else
        		return nil
    	end
end

function ww_get_wan_type()
	local result = get_wan_type()
	return data_to_json(result)
end

function nw_get_wan_type()
	local result = get_wan_type()
	luci.http.write_json(result)
end
function nw_set_wan_type()
    	local wan_type = luci.http.formvalue("type")
    	if "apclient" == wan_type then
    		local channel  = luci.http.formvalue("channel")
		local ssid     = luci.http.formvalue("ssid")
		local mac      = luci.http.formvalue("mac")
		local sec      = luci.http.formvalue("sec")
		local extch    = luci.http.formvalue("extch")
		local wl_type_val = luci.http.formvalue("aptype")
		local key = luci.http.formvalue("key")
		set_ap_client(channel, ssid, mac, sec, extch, wl_type_val, key)
    	else
	    	local pppoe_name = luci.http.formvalue("pppoeName")
		local pppoe_pwd = luci.http.formvalue("pppoePwd")
		set_wan_type(wan_type, pppoe_name, pppoe_pwd)
	end
end

function set_wan_type(wan_type, pppoe_name, pppoe_pwd)
	local result = {}
        local code = true
        local needRestartWifi = false
        if not is_str_nil(wan_type) then
                local succeed
                if wan_type == "pppoe" and not is_str_nil(pppoe_name) and not is_str_nil(pppoe_pwd) then
                        succeed = setWanPPPoE(pppoe_name, pppoe_pwd)
                elseif wan_type == "dhcp" then
                        succeed = setWanDHCP()
                end
                if not succeed then
                        code = false
                else
			cancelapclient()
                        needRestartWifi = true
                end
        end
        result["result"] = code
        local dbssid = dbfs.fetch_ssid()
	if nil ~= dbssid then
		for k, v in pairs(dbssid) do
			result["ssid"] = v.ssid24
		end
	end
        local macaddrcmd = "eth_mac r wl0"
	local macaddr = lue(macaddrcmd)
	if macaddr ~= "" then
		local ipmacstr = strsplit(macaddr, '\n')
		ipmacstr[#ipmacstr] = nil
		for k, v in pairs(ipmacstr) do
			result["mac"] = v
		end
	end
        luci.http.write_json(result)

        if needRestartWifi then
                cmd = [[sleep 1;apcli_connect.sh restart &]]
                exec_cmd_in_sh(cmd)
                --fork_restart_network()
        end
        luci.http.close()
end

function set_ap_client(channel, ssid, mac, sec, extch, wl_type_val, key)
	cancelapclient()
	local sec_alg = "TKIP"
	if string.find(sec, "AES") then
		sec_alg = "AES"
	end
	if string.find(sec, "WPA2") then
		sec = "WPA2PSK"
	else
		if string.find(sec, "WPA") then
			sec = "WPA1PSK"
		else
			sec = "NONE"
		end
	end
	local wl_type = "ra0"
	if wl_type_val == "5G" then
		wl_type = "rai0"
	end
	local cmd = [[apcli_connect.sh ]]..wl_type.." "..channel.." "..ssid.." "..sec
	if sec ~= "NONE" then
		cmd = cmd.." "..sec_alg.." "..key
	end
	lue(cmd)
	require "MZLog".log(3, cmd)
	local ret = {}
	ret["result"] = true
        local ssid5,ssid2 = get_wifi_ssids()
        local macaddrcmd = ""
        if wl_type_val == "2.4G" then
		ret["ssid"] = ssid2
		macaddrcmd = "eth_mac r wl0"
	else
		ret["ssid"] = ssid5
		macaddrcmd = "eth_mac r wl1"
	end
	local macaddr = lue(macaddrcmd)
	if macaddr ~= "" then
		local ipmacstr = strsplit(macaddr, '\n')
		ipmacstr[#ipmacstr] = nil
		for k, v in pairs(ipmacstr) do
			ret["mac"] = v
		end
	end
	luci.http.prepare_content("application/json")
	luci.http.write_json(ret)
	local cmd = [[sleep 1;apcli_connect.sh restart &]]
	exec_cmd_in_sh(cmd)
	luci.http.close()
end

function cancelapclient()
	local uci = require("luci.model.uci").cursor()
        local apc = uci.get("network", "lan", "apclient")
	if nil ~= apc then
	        	local dbssid = dbfs.fetch_ssid()
	        	local ssid_2g = ""
	        	local ssid_5g = ""
	        	if nil ~= dbssid then
	        		for k, v in pairs(dbssid) do
	        			ssid_2g = v.ssid24
	        			ssid_5g = v.ssid5
	        		end
	        	end
	        local cmd = [[apcli_connect.sh disable]]
	        if "" ~= ssid_2g and "" ~= ssid_5g then
	        		cmd = cmd.." "..ssid_2g.." "..ssid_5g
	        end
	        lue(cmd)
        end
end

function setWanPPPoE(name, password)
	local LuciNetwork = require("luci.model.network").init()
	local uci = require("luci.model.uci").cursor()
	local iface = "wan"
	local ifname = getWanEth()
	local oldconf = uci:get_all("network", "wan") or {}
	local wanrestart = true
	if oldconf.username == name and oldconf.password == password then
		wanrestart = false
	end
	local wanNet = LuciNetwork:del_network(iface)
	local mtuvalue = 1480
	wanNet = LuciNetwork:add_network(
		iface, {
			proto    ="pppoe",
			ifname   = ifname,
			username = name,
			password = password,
			mtu      = mtuvalue
		})
	if wanNet then
		LuciNetwork:save("network")
		LuciNetwork:commit("network")
		if wanrestart then
			wanRestart()
		end
        		return true
	else
		return false
    	end
end

function setWanDHCP()
	local LuciNetwork = require("luci.model.network").init()
	local uci = require("luci.model.uci").cursor()
	local oldconf = uci:get_all("network", "wan") or {}
	local iface = "wan"
	local ifname = getWanEth()
	local wanrestart = true

	local wanNet = LuciNetwork:del_network(iface)
	if oldconf.proto == "dhcp" then
		wanrestart = false
	end
	local network = {
		proto   = "dhcp",
		ifname  = ifname
        }
	wanNet = LuciNetwork:add_network(iface, network)
	if wanNet then
        		LuciNetwork:save("network")
		LuciNetwork:commit("network")
		if wanrestart then
			wanRestart()
		end
		return true
	else
        		return false
	end
end

function check_sys_pwd(oldPassword)
	local LuciSys = require("luci.sys")
	return LuciSys.user.checkpasswd("admin", oldPassword)
end

function getWanEth()
	local LuciNetwork = require("luci.model.network").init()
	local wanNetwork = LuciNetwork:get_network("wan")
	return wanNetwork:get_option_value("ifname")
end

function wanRestart()
	local LuciUtil = require("luci.util")
	LuciUtil.exec("env -i /sbin/ifup wan")
end

function netspeed_channel(cmd)
	local speed_table = {}
	local speed_file = io.popen(cmd)
	for line in speed_file:lines() do
		table.insert(speed_table, line)
	end
	speed_file:close()
	
	local rx = 0
	local tx = 0
	local speed, tb, rxb, txb
	local n = 0
	for k, v in ipairs(speed_table) do
		speed = strsplit(v, ',')
		if (k == 1) then
			tb  = tonumber(speed[1])
			rxb = tonumber(speed[2])
			txb = tonumber(speed[4])
		else
			n = n + 1
			local tmp
			local td
			tmp = tonumber(speed[1])
			td = tmp - tb
			tb = tmp

			tmp = tonumber(speed[2])
			rx = rx + (tmp - rxb) / td
			rxb = tmp

			tmp = tonumber(speed[4])
			tx = tx + (tmp - txb) / td
			txb = tmp
		end
	end
    	rx = string.format("%6.2f", rx/n)
	tx = string.format("%6.2f", tx/n)
	return rx, tx
end

function real_time_net_speed()
	local res = {}
	--local cmd = [[luci-bwc -i eth0.2|tail -n 5|sed -e 's#.*\[\s*\(.*\)\s*\].*#\1#']]
	local uci = require("luci.model.uci").cursor()
        local apclient = uci.get("network", "lan", "apclient")

	local cmd = nil
	local rx = 0
	local tx = 0
	if nil == apclient then
		cmd = [[luci-bwc -i eth0.2 |tail -n 5 |sed -e 's#.*\[\s*\(.*\)\s*\].*#\1#']]
	else
		if "mt7628" == apclient then
			cmd = [[luci-bwc -i apcli0 |tail -n 5 |sed -e 's#.*\[\s*\(.*\)\s*\].*#\1#']]
		elseif "mt7610e" == apclient then
			cmd = [[luci-bwc -i apclii0 |tail -n 5 |sed -e 's#.*\[\s*\(.*\)\s*\].*#\1#']]
		end
	end

	rx, tx = netspeed_channel(cmd)
	
    	res["rx"] = rx
	res["tx"] = tx

    	return res
end

function get_device_details(mac)
    	dbfs.change_maclist_table()
	local item = {}
	mac = string.upper(mac)
	local deviceDBDict = getDeviceInfoFromDB()
	local dhcpDeviceDict = getDHCPDict()
	local blacklist0 = dbfs.fetch_all_deny_mac()
	local wifiDeviceDict = getAllWifiConnetDeviceDict()
	
	local cmd = [[cat /proc/net/arp |grep br-lan|awk '{print $1","$4}']]
	local ipmacs = {}
	local devs = lue(cmd)
	if devs ~= "" then
		local ipmacstr = strsplit(devs, '\n')
		ipmacstr[#ipmacstr] = nil
		for k, v in pairs(ipmacstr) do
			local ipmac = strsplit(v, ',')
			ipmacs[string.upper(ipmac[2])] = ipmac
		end
	end

	item["diskaccess"] = false
	item["speed"] = 0
	item["upload"] = 0
	item["download"] = 0
	item["time"] = 0
	
	local rtxsl = get_speed_limit(mac)
	item["rxlimit"] = rtxsl["rx"]
	item["txlimit"] = rtxsl["tx"]

	local isblack = false
	if nil ~= blacklist0 then
		for k, v in pairs(blacklist0) do
			if v.mac == mac then
				isblack = true
			end
		end
	end
	if isblack == false then
		item["enable"] = true
	else
		item["enable"] = false
	end

	local dbarp = dbfs.fetch_arp(mac)
	if nil ~= dbarp then
		for k, v in pairs(dbarp) do
			local im = ipmacs[mac]
			local wf = v["wifi"]
			if wf == 0 then
				item["type"] = "wire"
			elseif wf == 1 then
				item["type"] = "2.4G"
			elseif wf == 2 then
				item["type"] = "5G"
			end
			if nil ~= im then
				item["ip"] = im[1]
				item["mac"] = string.upper(im[2])
			else
				item["ip"] = v["ip"]
				item["mac"] = mac
			end
			
			local deviceDB = deviceDBDict[mac]
			local dhcpinfo = dhcpDeviceDict[mac]
			if deviceDB ~= nil then
				item["devicename"] = deviceDB.orgname
				if deviceDB.devicename ~= '' then
					item["devicename"] = deviceDB.devicename
				end
			else
				item["devicename"] = dhcpinfo.name
				dbfs.saveDeviceInfo(mac, dhcpinfo.name, "", dhcpinfo.ip)
			end
			
			local wifi = wifiDeviceDict[mac]
			
			item["online"] = false
			if wf == 0 and nil ~= im then
				item["online"] = true
			end
			if wifi ~= nil then
				item["online"] = true
				item["speed"] = wifi.rxspeed
				local time = wifi.time
				item["time"] = time
				local rx = wifi.rx
				local tx = wifi.tx
				item["upload"] = tx
				item["download"] = rx
				if wifi.wifiIndex == 1 then
					item["type"] = "2.4G"
				elseif wifi.wifiIndex == 2 then
					item["type"] = "5G"
				end
			end
			if nil == item["type"] or false == item["online"] then
				item["type"] = "unknown"
			end
		end
	end

	require "MZLog".log(3, debug.getinfo(1).currentline)
	require "MZLog".log(3, item)
	require "MZLog".log(3, debug.getinfo(1).currentline)

	return item
end

function nw_get_device_details()
	local mac = luci.http.formvalue("mac")
	local res = get_device_details(mac)
	luci.http.write_json(res)
end

function ww_get_device_details(mac)
	local res = get_device_details(mac)
	return res
end

---------------------wireless channel start--------
function get_wireless_channel()
	local uci = require("luci.model.uci").cursor()
        local channel = uci.get("wireless", "mt7628", "channel")
        local bw = uci.get("wireless", "mt7628", "bw")
        local ret = {}
        ret["channel"] = channel
        ret["extch"] = bw
        return ret
end

function nw_get_wireless_channel()
        local ret = get_wireless_channel()
        luci.http.write_json(ret)
end

function ww_get_wireless_channel()
        local ret = get_wireless_channel()
        return cjson.encode(ret)
end

function set_wireless_channel(channel, extch)
	local res = false
        local uci = require("luci.model.uci").cursor()
	local c = tonumber(channel)
	
        if c >= 0 and c <= 13 then
		res = uci.set("wireless", "mt7628", "channel", c)
		if extch == "1" or extch == "0" then
                	res = uci.set("wireless", "mt7628", "bw", extch)
                end
        end
        uci.commit("wireless")
	fork_restart_wifi()
        return res
end

function nw_set_wireless_channel(channel, extch)
        local channel = luci.http.formvalue("channel")
        local extch = luci.http.formvalue("extch")
        local res = set_wireless_channel(channel, extch)
        local ret = {}
        ret["result"] = res
        luci.http.write_json(ret)
end

function ww_set_wireless_channel(channel, extch)
        local res = set_wireless_channel(channel, extch)
        local ret = {}
        ret["result"] = res
        return ret
end
---------------------wireless channel end----------

---------------------led start---------------------
function get_led()
	local led_status = is_led_on()
        local ret = {}
        ret["status"] = led_status
        return ret
end

function nw_get_led()
        local ret = get_led()
        luci.http.write_json(ret)
end

function ww_get_led()
        local ret = get_led()
        return cjson.encode(ret)
end

function set_led(status)
	local res = false
	local cmd = [[/etc/init.d/mtkleds ]]
	local leds_status = is_led_on()
	if "on" == status and "off" == leds_status then
		cmd = cmd.."start"
		exec_cmd_in_sh(cmd)
		res = true
	elseif "off" == status and "on" == leds_status then
		cmd = cmd.."stop"
		exec_cmd_in_sh(cmd)
		res = true
	end
        return res
end

function nw_set_led(status)
        local status = luci.http.formvalue("status")
        local res = set_led(status)
        local ret = {}
        ret["result"] = res
        luci.http.write_json(ret)
end

function ww_set_led(status)
        local res = set_led(status)
        local ret = {}
        ret["result"] = res
        return ret
end

function is_led_on()
	local cmd = [[ps | grep mtkleds.sh]]
	local lu = require("luci.util")
	local ledstr = lu.exec(cmd)
	local index = string.find(ledstr, "/usr/bin/mtkleds.sh")
	if nil ~= index then
		return "on"
	else
		return "off"
	end
end
----------------------led end----------------------

----------------------speed limit start------------
function get_speed_limit_dict()
	local dict = {}
	local slfile = io.open("/tmp/speedlimit", "r")
	if nil ~= slfile then
		for line in slfile:lines() do
			local speed = {}
			local sl = strsplit(line, " ")
			local mac = string.lower(sl[1])
			speed["mac"] = mac
			speed["rx"] = sl[2]
			speed["tx"] = sl[3]
			dict[mac] = speed
		end
		slfile:close()
	end
	return dict
end

function dict_to_file(dict)
	local slfile = io.open("/tmp/speedlimit", "w")
	if nil == next(dict) then
		slfile:write("")
		slfile:close()
		return
	end
	local count = 0
	for k,v in pairs(dict) do
		count = count + 1
		if nil ~= v then
			if #dict == count then
				slfile:write(v["mac"].." "..v["rx"].." "..v["tx"])
			else
				slfile:write(v["mac"].." "..v["rx"].." "..v["tx"].."\n")
			end
		end
	end
	slfile:close()
end

function set_speed_limit(mac, rx, tx)
	mac = string.lower(mac)
	local existSpeedLimitDict = get_speed_limit_dict()
	local edit = existSpeedLimitDict[mac]
	rx = tonumber(rx)
	tx = tonumber(tx)
	if nil ~= edit and -1 == rx and -1 == tx then
		existSpeedLimitDict[mac] = nil
		dict_to_file(existSpeedLimitDict)
		if nil ~= next(existSpeedLimitDict) then
			lue("netshaping.sh /tmp/speedlimit")
		else
			lue("netshaping.sh")			
		end
		return true
	end
	if nil == edit then
		edit = {}
	end
	edit["mac"] = mac
	edit["rx"] = rx
	edit["tx"] = tx
	existSpeedLimitDict[mac] = edit
	dict_to_file(existSpeedLimitDict)
	lue("netshaping.sh /tmp/speedlimit")
	return true
end

function nw_set_speed_limit()
	local mac = luci.http.formvalue("mac")
	local rx = luci.http.formvalue("rx")
	local tx = luci.http.formvalue("tx")
        local res = set_speed_limit(mac, rx, tx)
        local ret = {}
        ret["result"] = res
        luci.http.write_json(ret)
end

function ww_set_speed_limit(mac, rx, tx)
        local res = set_speed_limit(mac, rx, tx)
        local ret = {}
        ret["result"] = res
        return ret
end

function get_speed_limit(mac)
	mac = string.lower(mac)
	local existSpeedLimitDict = get_speed_limit_dict()
	local edit = existSpeedLimitDict[mac]
	local rx = -1
	local tx = -1
	if nil ~= edit then
		rx = tonumber(edit["rx"])
		tx = tonumber(edit["tx"])
	end
        local ret = {}
        ret["rx"] = rx
        ret["tx"] = tx
        return ret
end

function nw_get_speed_limit()
	local mac = luci.http.formvalue("mac")
        local ret = get_speed_limit(mac)
        luci.http.write_json(ret)
end

function ww_get_speed_limit(mac)
        local ret = get_speed_limit(mac)
        return cjson.encode(ret)
end

----------------------speed limit end--------------

function is_wan_connected()
	local lu = require("luci.util")
	local cmd = "ping -W 2 -c 1 www.baidu.com > /dev/null ;echo -n $?"
	local pingresult = lu.exec(cmd)

	local res = {}
	if pingresult == "0" then
		res["result"] = true
	else
		res["result"] = false

	end

	return res
end