local tOption = { ... }

if not (#tOption == 1 or #tOption == 2 and tOption[2] == "load") then
	error("Usage: [FNAME] <lib file>")
end

--local lib
if type(tOption[1]) == "table" then
	lib = tOption[1]
elseif type(tOption[1]) == "string" then
	if fs.exists(tOption[1]) then
		local f = loadfile(tOption[1])

		if not f then
			error("Unable to load lib")
		end

		bOk, vResult = pcall( f )

		if bOk then
			lib = vResult

			if type(lib) ~= "table" then
				error("Lib returned wrong format")
			end
		else
			error(vResult)
		end
	else
		error("File not found")
	end
else
	error("Wrong format")
end

----------------------------------------------------------------

command = { }
local privEnv = {
	cRoutines = { }
}

local tCoroutine = { }
local lastCoroutineID = 0

local tServer = { }
local lastServerID = 0

local nPColor, nWColor, nEColor, nSTColor
if term.isColor() then
	nPColor = colors.lime
	nWColor = colors.white
	nEColor = colors.red
	nSTColor = colors.orange
else
	nPColor = colors.lightGrey
	nWColor = colors.white
	nEColor = colors.white
	nSTColor = colors.lightGrey
end

local bRunning = true

-- lib.sniff.run()

--[[

server:
{

}

user:
{
	nID,        -- Intern userID
	nAuthID,    -- Auth ID
	sUsername,  -- Username
	nPort,      -- Port
	cRoutines   -- Table of coroutine s
]

]]

----------------------------------------------------------------
-- Command list for autoComplete

local commandComplete
do
	local allPorts = function()
		-- local tResult = { }
		-- for i=0, 65535 do
			-- table.insert(tResult, tostring( i ))
		-- end
		-- return tResult
		return {
			"65535",
			"65533"
		}
	end

	local getServerIDs = function()
		local tResult = { }
		for _, server in pairs(tServer) do
			table.insert(tResult, tostring( server.nID ))
		end
		return tResult
	end

	local getSides = function()
		return {
			"top", "bottom",
			"left", "right",
			"back", "front"
		}
	end

	local getUserIDs = function(sID)
		local tResult = { }
		for _, user in pairs(tServer[sID].user) do
			table.insert(tResult, tostring( user.nID ))
		end
		return tResult
	end

	-- For each add to table and insert to function if fself / tself

	commandComplete = {
		add = {
			server = {
				tself = {
					fself = getServerIDs
				}
			},
			user = {
				tself = {
					fself = getServerIDs,
					tself = {
						fself = getUserIDs
					}
				}
			}
		},
		chat = {
			public = {
				tself = {
					fself = getServerIDs,
					tself = {
						fself = getUserIDs
					}
				}
			},
			private = {
				tself = {
					fself = getServerIDs,
					tself = {
						fself = getUserIDs
					}
				}
			}
		},
		check = {
			modem = {
				tself = {
					fself = getSides
				}
			}
		},
		dos = {
			server = {
				tself = {
					fself = getServerIDs
				}
			},
			user = {
				tself = {
					fself = getServerIDs,
					tself = {
						fself = getUserIDs
					}
				}
			}
		},
		find = {
			server = { },
			user = {
				tself = {
					fself = getServerIDs
				}
			}
		},
		flood = {
			start = true,
			stop = true,
			server = {
				tself = {
					fself = getServerIDs
				}
			},
			user = {
				tself = {
					fself = getServerIDs,
					tself = {
						fself = getUserIDs
					}
				}
			}
		},
		forward = {
		},
		get = {
			modem = true,
			server = {
				tself = {
					fself = getServerIDs
				}
			},
			user = {
				tself = {
					fself = getServerIDs,
					tself = {
						fself = getUserIDs
					}
				}
			}
		},
		help = {
			tself = {
				fself = function()
					local _, h = term.getSize()

					local tAllc = { }
					for sCommand in pairs(command) do
						table.insert(tAllc, sCommand)
					end

					local tResult = { }
					local nlPage = #tAllc / (h - 2)
					nlPage = nlPage - (nlPage % 1) + 1
					for nIter = 1, nlPage do
						table.insert(tResult, nIter)
					end
					return tResult
				end
			}
		},
		hijack = {

		},
		interact = {
			server = {
				tself = {
					fself = getServerIDs
				}
			},
			user = {
				tself = {
					fself = getServerIDs,
					tself = {
						fself = getUserIDs
					}
				}
			}
		},
		kick = {
			tself = {
				fself = getServerIDs,
				tself = {
					fself = getUserIDs
				}
			}
		},
		kill = {
			server = {
				tself = {
					fself = getServerIDs
				}
			},
			user = {
				tself = {
					fself = getServerIDs,
					tself = {
						fself = getUserIDs
					}
				}
			}
		},
		list = {
			server = true,
			user = {
				tself = {
					fself = getServerIDs
				}
			}
		},
		new = {
			croutine = {
				userMSave = {
					tself = {
						fself = getServerIDs,
						tself = {
							fself = getUserIDs
						}
					}
				},
				userPing = {
					tself = {
						fself = getServerIDs,
						tself = {
							fself = getUserIDs
						}
					}
				}
			},
			server = {

			},
			user = {
				tself = {
					fself = getServerIDs,
					tself = {
						fself = allPorts
					}
				}
			}
		},
		remove = {
			server = {
				tself = {
					fself = getServerIDs
				}
			},
			user = {
				tself = {
					fself = getServerIDs,
					tself = {
						fself = getUserIDs
					}
				}
			}
		},
		routines = {
			server = {
				tself = {
					fself = getServerIDs
				}
			},
			user = {
				tself = {
					fself = getServerIDs,
					tself = {
						fself = getUserIDs
					}
				}
			}
		},
		scan = {
			server = {
				all = {
					start = true,
					stop = true
				},
				tself = {
					fself = getServerIDs,
					start = true,
					stop = true
				}
			},
			user = {
				tself = {
					all = {
						start = true,
						stop = true
					},
					fself = getServerIDs,
					tself = {
						fself = getUserIDs,
						start = true,
						stop = true
					}
				}
			}
		},
		set = {
			modem = {
				tself = {
					fself = getSides
				}
			},
			server = {
				tself = {
					fself = getServerIDs,
					nPort = true,
					sHostname = true
				}
			},
			user = {
				tself = {
					fself = getServerIDs,
					tself = {
						fself = getUserIDs,
						nAuthID = true,
						nPort = true,
						sName = true
					}
				}
			}
		},
		unset = {
			server = {
				tself = {
					fself = getServerIDs,
					nPort = true,
					sHostname = true
				}
			},
			user = {
				tself = {
					fself = getServerIDs,
					tself = {
						fself = getUserIDs,
						nAuthID = true,
						nPort = true,
						sName = true
					}
				}
			}
		}
	}
end

----------------------------------------------------------------

command.add = function(sType, p1, p2, p3)
	if sType == "server" then
		local n = tonumber(p1)
		if n == nil then
			return "Port as number expected", true
		end

		if not (n >= 0 and n <= 65535) then
			return "Port is not in range", true
		end

		for _, server in pairs(tServer) do
			if server.nPort == p1 then
				return "Server already exists", true
			end
		end

		lastServerID = lastServerID + 1

		tServer[tostring( lastServerID )] =
		{
			cRoutines = { },
			lastUserID = 0,
			nID = tostring( lastServerID ),
			nPort = p1,
			sHostname = "",
			user = { },
			wTable = { } -- write ing table
		}

		return "Server was added"
	elseif sType == "user" then
		if tServer[ p1 ] then
			local n = tonumber(p2)
			if n == nil then
				return "Port as number expected", true
			end

			if not (n >= 0 and n <= 65535) then
				return "Port is not in range", true
			end

			for _, user in pairs(tServer[p1].user) do
				if user.nPort == p2 then
					return "User already exists", true
				end
			end

			tServer[p1].lastUserID = tServer[p1].lastUserID + 1

			tServer[p1].user[ tostring( tServer[p1].lastUserID ) ] =
			{
				cRoutines = { },
				nAuthID = -1,
				nID = tostring( tServer[p1].lastUserID ),
				nPort = p2,
				sName = "",
				wTable = { } -- write ing table
			}

			return "User was added"
		else
			return "Server not found", true
		end
	else
		return "Option not found", true
	end
end

command.chat = function(sType, p1, p2, p3)
	if sType == "public" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if not tServer[ p1 ].user[ p2 ] then
			return "User not found", true
		end

		if tServer[ p1 ].user[ p2 ].nAuthID == -1 then
			return "No authID selected", true
		end

		if privEnv.modem == nil then
			return "No modem selected", true
		end

		if not p3 then
			return "Message expected", true
		end

		lib.spoof.message(
			peripheral.wrap(privEnv.modem),
			tServer[p1].nPort,
			tServer[p1].user[p2].nPort,
			tServer[p1].user[p2].nPort,
			{
				sType = "chat",
				nUserID = tServer[p1].user[p2].nAuthID,
				sText = p3
			},
			"chat")

		return "Message was sent"
	elseif sType == "private" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if not tServer[ p1 ].user[ p2 ] then
			return "User not found", true
		end

		if tServer[ p1 ].user[ p2 ].nAuthID == -1 then
			return "No authID selected", true
		end

		if privEnv.modem == nil then
			return "No modem selected", true
		end

		lib.spoof.message(
			peripheral.wrap(privEnv.modem),
			tServer[p1].user[p2].nPort,
			tServer[p1].nPort,
			tServer[p1].nPort,
			{
				sType = "text",
				nUserID = tServer[p1].user[p2].nAuthID,
				sText = p3
			},
			"chat")

		return "Message was sent"
	else
		return "Option not found", true
	end
end

command.check = function(sType, p1, p2)
	if sType == "modem" then
		if type(p1) ~= "string" then
			p1 = privEnv.modem
		end

		if type(p1) ~= "string" then
			return "No modem selected", true
		end

		if peripheral.getType(p1) == "modem" then
			if term.isColor() then
				term.setTextColor(colors.green)
			end

			return "Modem is working"
		else
			return "Modem is notre work", true
		end
	elseif sType == "server" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if not privEnv.modem then
			return "No modem selected", true
		end

		local tHosts = lib.scann.lookupHosts(privEnv.modem, "chat")

		local bFound = false
		for _, tHost in pairs(tHosts) do
			if tHost.nRecipient == tonumber( tServer[p1].nPort ) then
				bFound = true
				break
			end
		end

		if bFound then
			return "Server is reachable"
		end

		return "Server is unrechable"
	elseif sType == "user" then
		-- Ping to client and wait for pong

		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if not tServer[ p1 ].user[ p2 ] then
			return "User not found", true
		end

		if tServer[ p1 ].user[ p2 ].nAuthID == -1 then
			return "No authID selected", true
		end

		if privEnv.modem == nil then
			return "No modem selected", true
		end

		local nHost = lib.sniff.addHost(
			tServer[p1].nPort,
			tServer[p1].user[p2].nPort,
			privEnv.modem)

		lib.spoof.message(
			peripheral.wrap(privEnv.modem),
			tServer[p1].user[p2].nPort,
			tServer[p1].nPort,
			tServer[p1].nPort,
			{
				sType = "ping to client",
				nUserID = tServer[p1].user[p2].nAuthID
			},
			"chat")

		local bFound = true
		local nTimer = os.startTimer(2)
		while true do
			local sEvent, vData, nPort, nReplyPort, tMessage, nDistance
				= os.pullEvent()

			if sEvent == "sniff_message" and vData == nHost then
				local message = lib.sniff.parseRednet(tMessage)

				if message
				and tMessage.sProtocol == "chat"
				and message.sType == "pong to server"
				and message.nUserID == tServer[p1].user[p2].nAuthID then
					break
				end
			elseif sEvent == "timer" and vData == nTimer then
				bFound = false
				break
			end
		end

		lib.sniff.removeHost(nHost)

		if bFound then
			if term.isColor() then
				term.setTextColor(colors.green)
			end

			return "User is rechable"
		else
			return "User is unrechable", true
		end
	else
		return "Option not found", true
	end
end

command.dos = function(sType, p1, p2)
	if sType == "server" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if privEnv.modem == nil then
			return "No modem selected", true
		end

		local rPort = math.random(60000, 65532)
		lib.spoof.message(
			peripheral.wrap(privEnv.modem),
			tServer[p1].nPort,
			rPort,
			rPort,
			{
				sType = "login",
				nUserID = true,
				sUsername = true -- Error (Can't concat bool)
			},
			"chat")

		return "Dos was performed"
	elseif sType == "user" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if not tServer[ p1 ].user[ p2 ] then
			return "User not found", true
		end

		if tServer[ p1 ].user[ p2 ].nAuthID == -1 then
			return "No authID selected", true
		end

		if privEnv.modem == nil then
			return "No modem selected", true
		end

		lib.spoof.message(
			peripheral.wrap(privEnv.modem),
			tServer[p1].user[p2].nPort,
			tServer[p1].nPort,
			tServer[p1].nPort,
			{
				sType = "text",
				nUserID = tServer[p1].user[p2].nAuthID,
				sText = true -- Error (Can't concat bool)
			},
			"chat")

		return "Dos was performed"
	else
		return "Option not found", true
	end
end

command.find = function(sType, p1)
	if sType == "server" then -- Add only NEW
		if privEnv.modem == nil then
			return "No modem selected", true
		end

		local tHosts = lib.scann.lookupHosts(privEnv.modem, "chat")

		for _, tHost in pairs(tHosts) do
			command.add("server", tostring( tHost.nRecipient ))
			local tID, bErr = command.get("port", tostring( tHost.nRecipient ))

			if not bErr
			and type(tID) == "table"
			and type(tID.sType) == "string"
			and tID.sType == "server" then
				command.set("server", tID.nID, "sHostname",
					tostring( tHost.sHostname ))
			end
		end

		return #tHosts.." host(s) found"
	elseif sType == "user" then -- Add only NEW
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		local tUser = { }

		local nHost = sniff.addHost(
			tServer[p1].nPort, nil, privEnv.modem)

		local nTimer = os.startTimer(15)
		while true do
			local sEvent, vData, nPort, nReplyPort, tMessage, nDistance
				= os.pullEvent()

			if sEvent == "sniff_message" then
				local message = sniff.parseRednet(tMessage)

				if message
				and tMessage.sProtocol == "chat"
				and type(message.sType) == "string"
				and message.sType == "ping to server" then
					table.insert(tUser, { nReplyPort, tMessage })
				end
			elseif sEvent == "timer" and nTimer == vData then
				break
			end
		end

		sniff.removeHost(nHost)

		for _, aUser in pairs(tUser) do
			command.add("user", p1, aUser[1])
			local tID, bErr = command.get("port", aUser[1])

			if not bErr
			and type(tID) == "table" then
				command.set("user", p1, tID.nID, "nAuthID",
					aUser[2].message.nUserID)
			end
		end

		return #tUser.." user(s) found"
	else
		return "Option not found", true
	end
end

command.flood = function(p1, p2, p3)
	if p1 == "start" then
		if privEnv.modem == nil then
			return "No modem selected", true
		end

		if privEnv.cRoutines.flood then
			return "Flood already exists", true
		end

		local lPort = nil
		if tServer[ p2 ] then
			lPort = tServer[p2].nPort
		end

		privEnv.cRoutines.flood =
		{
			bRunning = true,
			name = "Chat dns flood",
			routine = coroutine.create(function()
				lib.dos.dns_flood(
					privEnv.modem,
					lPort,
					"dns",
					15,
					53824)
			end)
		}

		coroutine.resume(privEnv.cRoutines.flood.routine)

		return "Flood was started"
	elseif p1 == "stop" then
		os.queueEvent("timer", 53824)
		return "Flood was stoped"
	end

	local sType = p1
	p1, p2 = p2, p3
	if sType == "server" then

	elseif sType == "user" then
	else
		return "Option not found", true
	end
end

command.forward = function(sType, p1, p2)

end

command.get = function(sType, p1, p2)
	if sType == "modem" then
		if type(privEnv.modem) ~= "string" then
			return "No modem saved", true
		end

		return privEnv.modem
	elseif sType == "port" then
		local n = tonumber(p1)

		if n and n >= 0 and n <= 65535 then
			for _, server in pairs(tServer) do
				if server.nPort == p1 then
					return {
						nID = server.nID,
						sType = "server"
					}
				end

				for _, user in pairs(server.user) do
					if user.nPort == p1 then
						return {
							nID = user.nID,
							sType = "user"
						}
					end
				end
			end
		else
			return "Port not in range", true
		end
	elseif sType == "server" then
		if tServer[ p1 ] then
			return {
				nID = tServer[p1].nID,
				nPort = tServer[p1].nPort,
				sHostname = tServer[p1].sHostname
			}
		else
			return "Server not found", true
		end
	elseif sType == "user" then
		if tServer[ p1 ] then
			if tServer[ p1 ].user[ p2 ] then
				return {
					nAuthID = tServer[ p1 ].user[ p2 ].nAuthID,
					nID = tServer[ p1 ].user[ p2 ].nID,
					nPort = tServer[ p1 ].user[ p2 ].nPort,
					sName = tServer[ p1 ].user[ p2 ].sName
				}
			else
				return "User not found", true
			end
		else
			return "Server not found", true
		end
	else
		return "Option not found", true
	end
end

command.help = function(sStart)
	if tonumber(sStart) == nil then
		sStart = 1
	end
	local _, h = term.getSize()

	local tAllc = { }
	for sCommand in pairs(command) do
		table.insert(tAllc, sCommand)
	end

	table.sort(tAllc)
	local nlPage = #tAllc / (h - 2)
	nlPage = nlPage - (nlPage % 1) + 1

	local nfPage = (h - 2) * (sStart - 1) + 1

	local nIter = nfPage
	local tResult = { }
	for i = 1, h - 2 do
		table.insert(tResult, tAllc[nIter])
		nIter = nIter + 1
	end

	tResult.Page = sStart.." / "..nlPage

	return tResult
end

command.hijack = function(sType, p1, p2)
	--[[
	user:
	- kick user and create new c R o u t i n e

	  'Server timeout, closing c R o u t i n e . . .'
	  'Server tried to kick you'

	  messages in >> message -> { table }
	]]
	if sType == "server" then

	elseif sType == "user" then
		--[[
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if not tServer[ p1 ].user[ p2 ] then
			return "User not found", true
		end

		if tServer[ p1 ].user[ p2 ].nAuthID == -1 then
			return "No authID selected", true
		end

		if privEnv.modem == nil then
			return "No modem selected", true
		end

		local sMess, bErr = command.kick(p1, p2)
		if bErr then
			return "Error at kicking: "..sMess, true
		end

		sMess, bErr = nil, nil

		sMess, bErr = command.new("croutine", "user", p1, p2)
		if bErr then
			return "Error at creating routine: "..sMess, true
		end

		return "User was successfully hijacked"
		]]
	else
		return "Option not found", true
	end
end

command.interact = function(sType, p1, p2)
	if sType == "server" then
		-- Server shell


	elseif sType == "user" then
		-- User shell
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if not tServer[ p1 ].user[ p2 ] then
			return "User not found", true
		end

		if tServer[ p1 ].user[ p2 ].nAuthID == -1 then
			return "No authID selected", true
		end

		if privEnv.modem == nil then
			return "No modem selected", true
		end

		local bRemove = false
		if not tServer[p1].user[p2].cRoutines.userMSave then
			bRemove = true
			local sMess, bErr = command.new("croutine", "userMSave", p1, p2)

			if bErr then
				return "Error at creating routine: "..sMess, true
			end
		end

		local currentInput = ""
		local getInput = function(input)
			currentInput = input
		end

		local dnPColor, dnWColor, dnEColor
		if term.isColor() then
			dnPColor = colors.orange
			dnWColor = colors.white
			dnEColor = colors.red
		else
			nPColor = colors.lightGrey
			dnWColor = colors.white
			dnEColor = colors.white
		end

		local lastMessageID = 1
		local nTimer = os.startTimer(0.1)
		local native_pullEventRaw = os.pullEventRaw
		os.pullEventRaw = function(...)
			local tEvent = { native_pullEventRaw(...) }

			if tEvent[1] == "timer" and tEvent[2] == nTimer then
				nTimer = os.startTimer(0.1)

				local bNew = false
				if lastMessageID <= #tServer[p1].user[p2].wTable then
					bNew = true
					local w, h = term.getCursorPos()
					term.setCursorPos(1, h)
				end

				for i = lastMessageID, #tServer[p1].user[p2].wTable do
					lastMessageID = lastMessageID + 1
					term.clearLine()
					print(tServer[p1].user[p2].wTable[i])
				end

				if bNew then
					term.clearLine()
					term.setTextColor(dnPColor)
					write("-> ")

					term.setTextColor(dnWColor)
					write(currentInput)
				end
			end

			return table.unpack(tEvent)
		end

		local modem = peripheral.wrap(privEnv.modem)

		local tHistory = { }
		while true do
			term.clearLine()
			term.setTextColor(dnPColor)
			write("-> ")

			term.setTextColor(dnWColor)
			local stCommand = read(nil, tHistory, getInput)
			table.insert(tHistory, stCommand)

			local bFirst = true
			local sCommand = ""
			local tParm = { }
			for sSplit in string.gmatch(stCommand, "[%p%w]+") do
				if bFirst then
					sCommand = string.lower( sSplit )
					bFirst = false
				else
					table.insert(tParm, sSplit)
				end
			end

			local sMess, bErr = "", false
			if string.find(sCommand, "^!") then
				sCommand = string.match(sCommand, ".(.+)")
				if sCommand == "exit" then
					break
				end
			elseif string.find(sCommand, "^?") then
				stCommand = string.match(stCommand, ".(.+)")
				local sMess, bErr = command.chat("private", p1, p2, stCommand)
			else
				if string.find(sCommand, "^:") then
					stCommand = string.match(stCommand, ".(.+)")
				end

				local sMess, bErr = command.chat("public", p1, p2, stCommand)
			end

			if bErr then
				printError(sMess)
			end
		end

		os.pullEventRaw = native_pullEventRaw

		if bRemove then
			tServer[p1].user[p2].cRoutines.userMSave = nil
		end
	else
		return "Option not found", true
	end
end

command.kick = function(sID, uID)
	if not tServer[ sID ] then
		return "Server not found", true
	end

	if not tServer[ sID ].user[ uID ] then
		return "User not found", true
	end

	if tServer[ sID ].user[ uID ].nAuthID == -1 then
		return "No authID selected", true
	end

	if privEnv.modem == nil then
		return "No modem selected", true
	end

	if #tServer[sID].user[uID].cRoutines ~= 0 then
		return "Unable to kick player with routines\n"..
		       "Instead use 'kill'", true
	end

	local modem = peripheral.wrap( privEnv.modem )

	lib.spoof.message(
		modem,
		tServer[sID].user[uID].nPort,
		tServer[sID].nPort,
		tServer[sID].nPort,
		{
			sType = "kick",
			nUserID = tServer[sID].user[uID].nAuthID
		},
		"chat")
end

command.kill = function(sType, p1, p2)
	if sType == "server" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if privEnv.modem == nil then
			return "No modem selected", true
		end

		for nID, user in pairs(tServer[p1].user) do
			if #user.cRoutines > 0 then
				for _, routine in pairs(user.cRoutines) do
					routine.bRunning = false
				end
			else
				command.kick(p1, nID)
			end
		end

		local sPrefix = ""
		if #tServer[p1].cRoutines > 0 then
			sPrefix = "VIRTUAL"

			for _, routine in pairs(tServer[p1].cRoutines) do
				routine.bRunning = false
			end
		else
			sPrefix = "REAL"

			local vResult, bErr command.dos("server", p1)

			if bErr then
				return "Error during dos: "..vResult, true
			end
		end

		tServer[p1] = nil

		return sPrefix.." server was killed"
	elseif sType == "user" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if not tServer[ p1 ].user[ p2 ] then
			return "User not found", true
		end

		if privEnv.modem == nil then
			return "No modem selected", true
		end

		local sPrefix = ""
		if #tServer[p1].user[p2].cRoutines > 0 then
			sPrefix = "VIRTUAL"

			for _, routine in pairs(tServer[p1].user[p2].cRoutines) do
				routine.bRunning = false
			end
		else
			sPrefix = "REAL"

			local vResult, bErr command.dos("user", p1, p2)

			if bErr then
				return "Error during dos: "..vResult, true
			end
		end

		tServer[p1].user[p2] = nil

		return sPrefix.." user was killed"
	else
		return "", true
	end
end

command.list = function(sType, p1)
	if sType == "server" then
		local tResult = { }

		for _, id in pairs(tServer) do
			table.insert(tResult, id.nID)
		end

		return tResult
	elseif sType == "user" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		local tResult = { }

		for _, id in pairs(tServer[p1].user) do
			table.insert(tResult, id.nID)
		end

		return tResult
	else
		return "Option not found", true
	end
end

command.new = function(sType, p1, p2, p3)
	if sType == "croutine" then
		if p1 == "userMSave" then
			if not tServer[ p2 ] then
				return "Server not found", true
			end

			if not tServer[ p2 ].user[ p3 ] then
				return "User not found", true
			end

			if privEnv.modem == nil then
				return "No modem selected", true
			end

			if tServer[ p2 ].user[ p3 ].nAuthID == -1 then
				return "No authID selected", true
			end

			if tServer[p2].user[p3].cRoutines.userMSave then
				return "UserMSave routine already exists for user "..
				       tServer[p2].user[p2].nID, true
			end

			local nHost = lib.sniff.addHost(
				tServer[p2].user[p3].nPort,
				tServer[p2].nPort,
				privEnv.modem)

			tServer[p2].user[p3].cRoutines.userMSave =
			{
				bRunning = true,
				name = "User traffic saver",
				routine = coroutine.create( function()
						local self = tServer[p2].user[p3].cRoutines.userMSave
						local wTable = tServer[p2].user[p3].wTable

						local nServerPort = tServer[p2].nPort
						local nUserID = tServer[p2].user[p3].nAuthID
						local nUserPort = tServer[p2].user[p3].nPort

						local nHost = nHost

						while self.bRunning do
							local sEvent, vData, nPort, nReplyPort, tMessage, nDistance
								= os.pullEvent()

							if sEvent == "sniff_message" and vData == nHost then
								local message = lib.sniff.parseRednet(tMessage)

								if message and tMessage.sProtocol == "chat" then
									if message.sType == "kick" then
										table.insert(wTable, "Kicked by server, closing routine...")
										break
									elseif message.sType == "text" then
										table.insert(wTable, message.sText)
									end
								end
							end
						end

						lib.sniff.removeHost(nHost)
					end)
			}

			coroutine.resume( tServer[p2].user[p3].cRoutines.userMSave.routine )


		elseif p1 == "userPing" then
			--[[

			Split user routine:
				- Reply on ping with pong
				- Save text messages to wTable

			]]

			if not tServer[ p2 ] then
				return "Server not found", true
			end

			if not tServer[ p2 ].user[ p3 ] then
				return "User not found", true
			end

			if privEnv.modem == nil then
				return "No modem selected", true
			end

			if tServer[ p2 ].user[ p3 ].nAuthID == -1 then
				return "No authID selected", true
			end

			if tServer[p2].user[p3].cRoutines.userPing then
				return "UserPing routine already exists for user "..
				       tServer[p2].user[p2].nID, true
			end

			local nHost = lib.sniff.addHost(
				tServer[p2].user[p3].nPort,
				tServer[p2].nPort,
				privEnv.modem)

			tServer[p2].user[p3].cRoutines.userPing =
			{
				bRunning = true,
				name = "User ping-pong with server",
				routine = coroutine.create( function()
						local self = tServer[p2].user[p3].cRoutines.userPing

						local pModem = peripheral.wrap(privEnv.modem)
						local wTable = tServer[p2].user[p3].wTable

						local nServerPort = tServer[p2].nPort
						local nUserID = tServer[p2].user[p3].nAuthID
						local nUserPort = tServer[p2].user[p3].nPort

						local nHost = nHost

						while self.bRunning do
							local sEvent, vData, nPort, nReplyPort, tMessage, nDistance
								= os.pullEvent()

							if sEvent == "sniff_message" and vData == nHost then
								local message = lib.sniff.parseRednet(tMessage)

								if message
								and tMessage.sProtocol == "chat"
								and message.sType == "ping to client" then
									lib.spoof.message(
										pModem,
										nServerPort,
										nUserPort,
										nUserPort,
										{
											sType = "pong to server",
											nUserID = nUserID
										},
										"chat")
								end
							end
						end

						lib.sniff.removeHost(nHost)
					end)
			}

			coroutine.resume( tServer[p2].user[p3].cRoutines.userPing.routine )
		elseif p1 == "server" then
			if not tServer[ p1 ] then
				return "Server not found", true
			end
		else
			return "Sub-option not found", true
		end
	elseif sType == "server" then

	elseif sType == "user" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if privEnv.modem == nil then
			return "No modem selected", true
		end

		if p3 == nil then
			return "Name expected", true
		end

		local vMess, bErr =
			command.add("user", p1, p2)

		if bErr then
			return vMess, true
		end

		local uID = tostring( tServer[p1].lastUserID )
		tServer[p1].user[uID].sName = p3
		tServer[p1].user[uID].nAuthID = math.random(1, 2147483647)

		command.new("croutine", "userPing", p1, uID)
		command.new("croutine", "userMSave", p1, uID)

		lib.spoof.message(
			peripheral.wrap(privEnv.modem),
			tServer[p1].nPort,
			tServer[p1].user[uID].nPort,
			tServer[p1].user[uID].nPort,
			{
				sType = "login",
				nUserID = tServer[p1].user[uID].nAuthID,
				sUsername = p3
			},
			"chat")

		return "New user created", true
	else
		return "Option not found", true
	end
end

command.remove = function(sType, p1, p2)
	if sType == "server" then
		if tServer[ p1 ] then
			tServer[p1] = nil
			return "Server was removed"
		else
			return "Server not found", true
		end
	elseif sType == "user" then
		if tServer[ p1 ] then
			if tServer[ p1 ].user[ p2 ] then
				tServer[p1].user[p2] = nil
				return "User was removed"
			else
				return "User not found", true
			end
		else
			return "Server not found", true
		end
	else
		return "Option not found", true
	end
end

command.scan = function(sType, p1, p2, p3)
	if sType == "server" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if p2 == "start" then

		elseif p2 == "stop" then

		else
			return "Sub-option not found", true
		end
	elseif sType == "user" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if privEnv.modem == nil then
			return "No modem selected", true
		end

		if p2 == "all" then
			if p3 ~= "start" and p3 ~= "stop" then
				return "Sub-option not found", true
			end

			for _, user in pairs(tServer[p1].user) do
				local sMess, bErr = command.scan("user", p1, user.nID, p3)
			end

			return "All scans "..p3.."ed"
		end

		if not tServer[ p1 ].user[ p2 ] then
			return "User not found", true
		end

		if tServer[ p1 ].user[ p2 ].nAuthID == -1 then
			return "No authID selected", true
		end

		if p3 == "start" then
			if  tServer[p1].user[p2].cRoutines.scan
			and tServer[p1].user[p2].cRoutines.scan.bRunning then
				return "Scann already started", true
			end

			print(p1)
			print(p2)

			local nHost = lib.sniff.addHost(
				tServer[p1].user[p2].nPort,
				tServer[p1].nPort,
				privEnv.modem)

			print(nHost)

			tServer[p1].user[p2].cRoutines.scan = {
				bRunning = true,
				name = "User scanner"
			}

			tServer[p1].user[p2].cRoutines.scan.routine = coroutine.create( function()
					local self = tServer[p1].user[p2].cRoutines.scan

					local nServerID = p1
					local nUserID = p2
					local nlHost = nHost

					print(nServerID)
					print(nUserID)

					while self.bRunning do
						local sEvent, vData, nPort, nReplyPort, tMessage, nDistance
							= os.pullEvent()

						if sEvent == "sniff_message" and vData == nlHost then
							local message = lib.sniff.parseRednet(tMessage)

							print("PRE"..vData.."=="..nlHost)

							if message
							and tMessage.sProtocol == "chat"
							and nPort == tServer[nServerID].user[nUserID].nPort then
								if message.sType == "text"
								and string.find(message.sText, "^<.+> .*$") then
									print("SETTING NAME FOR"..nUserID)

									tServer[nServerID].user[nUserID].sName
										= string.match(message.sText, "^<(.+)> .*$")
									tServer[nServerID].user[nUserID].nAuthID
										= message.nUserID

									self.name = self.name.." (finished)"
									break
								end
							end
						end
					end

					lib.sniff.removeHost(nlHost)
				end)

			print("END"..p2)

			coroutine.resume(tServer[p1].user[p2].cRoutines.scan.routine)
		elseif p3 == "stop" then
			if tServer[p1].user[p2].cRoutines.scan == nil
			or tServer[p1].user[p2].cRoutines.scan.bRunning == false then
				return "Scann is not started", true
			end

			tServer[p1].user[p2].cRoutines.scan.bRunning = false
			os.queueEvent("update")
		else
			return "Sub-option not found", true
		end
	else
		return "Option not found", true
	end
end

command.sessions = function(sType, p1, p2)
	if sType == "server" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end


	elseif sType == "user" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if not tServer[ p1 ].user[ p2 ] then
			return "User not found", true
		end

		if tServer[ p1 ].user[ p2 ].nAuthID == -1 then
			return "No authID selected", true
		end

		local tResult = { }
		for _, routine in pairs(tServer[p1].user[p2].cRoutines) do
			table.insert(tResult, routine.name)
		end
		if #tResult == 0 then
			return "No routines found"
		else
			return tResult
		end
	else
		return "Option not found", true
	end

	-- Print current sessions
end

command.set = function(sType, p1, p2, p3, p4)
	if sType == "modem" then
		if type(p1) ~= "string" then
			return "String as side expected", true
		end

		privEnv.modem = p1

		return "Modem side was changed"
	elseif sType == "server" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if p2 == "nPort" then
			local isNumber = tonumber(p3)

			if not isNumber then
				return "Port as number expected", true
			end

			if not (isNumber >= 0 and isNumber <= 65535) then
				return "Port is not in range", true
			end
		end

		if p2 == "nPort"
		or p2 == "sHostname" then
			tServer[p1][p2] = p3
		elseif p2 == "nID" then
			local isNumber = tonumber( p3 )

			if isNumber == nil then
				for _, server in pairs(tServer) do
					if server.nID == p3 then
						return "Number is already taken", true
					end
				end

				tServer[p3] = tServer[p1]
				tServer[p3].nID = p3
				tServer[p1] = nil
			else
				return "Cant change ID to number", true
			end
		else
			return "This value cant be changed", true
		end

		return "Server value was changed"
	elseif sType == "user" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if not tServer[ p1 ].user[ p2 ] then
			return "User not found", true
		end

		if p3 == "nPort" then
			local isNumber = tonumber(p4)

			if not isNumber then
				return "Port as number expected", true
			end

			if not (isNumber >= 0 and isNumber <= 65535) then
				return "Port is not in range", true
			end
		end

		if p3 == "nAuthID"
		or p3 == "nPort"
		or p3 == "sName" then
			tServer[p1].user[p2][p3] = p4
		elseif p3 == "nID" then
			local isNumber = tonumber( p4 )

			if isNumber == nil then
				for _, user in pairs(tServer[p1].user[p2]) do
					if user.nID == p4 then
						return "Number is already taken", true
					end
				end

				tServer[p1].user[p2].nID = p4
			else
				return "Cant change ID to number", true
			end
		else
			return "This value cant be changed", true
		end

		return "User value was changed"
	else
		return "Option not found", true
	end
end

command.unnamned = function(sID1, uID, sID2)
	-- Logout
	-- Login
	-- Forward traffic in both directions


end

command.unset = function(sType, p1, p2)
	if sType == "modem" then
		privEnv.modem = nil

		return "Modem was reseted"
	elseif sType == "server" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		local server = tServer[p1]

		server.lastUserID = 0
		server.sHostname = ""
		server.user = { }

		tServer[p1] = server

		return "Server was reseted"
	elseif sType == "user" then
		if not tServer[ p1 ] then
			return "Server not found", true
		end

		if not tServer[ p1 ].user[ p2 ] then
			return "User not found", true
		end

		local user = tServer[p1].user[p2]

		user.sName = ""
		user.nAuthID = -1

		tServer[p1].user[p2] = user

		return "User was reseted"
	else
		return "Option not found", true
	end
end

----------------------------------------------------------------

--[[

Newer, Better soon

]]

local autoComplete = function(sLine)
	if #sLine > 0 then
		if string.find(sLine, "^[$].*") then
			return shell.complete( string.match(sLine, "^[$](.*)$") )
		end

		sLine = string.match(sLine, "^%s*(.*)$")

		if sLine == nil or #sLine <= 0 then
			return ""
		end

		local tSplit = { }
		for sSplit in string.gmatch(sLine, "[%p%w]+") do
			table.insert(tSplit, sSplit)
		end

		if string.find(sLine, " $") then
			table.insert(tSplit, "")
		end

		local tCurrent = commandComplete
		local fVar = { }
		for nThis, sPart in pairs(tSplit) do
			if sPart == "fself" or sPart == "tself" then
				return ""
			end

			if nThis == #tSplit then
				break
			end

			if tCurrent[sPart] then
				tCurrent = tCurrent[sPart]
			else
				if tCurrent.tself then
					local bFound = false
					for _, sC in pairs(tCurrent.tself.fself( table.unpack(fVar) )) do
						if sC == sPart then
							tCurrent = tCurrent["tself"]
							table.insert(fVar, sC)
							bFound = true
							break
						end
					end

					if not bFound then
						return ""
					end
				else
					return ""
				end
			end
		end

		local sLast = tSplit[#tSplit]
		local tResult = { }
		for sName, sPart in pairs(tCurrent) do
			if sName == "tself" then
				for _, sC in pairs(sPart.fself( table.unpack(fVar) )) do
					if string.find(sC, "^"..sLast) then
						table.insert(tResult, sC)
					end
				end

			elseif sName ~= "tself" and sName ~= "fself" then
				if string.find(sName, "^"..sLast) then
					table.insert(tResult, sName)
				end
			end
		end

		for i, sResult in pairs(tResult) do
			tResult[i] = string.match(sResult, "^"..sLast.."(.*)$")

			if tResult[i] == nil then
				tResult[i] = ""
			end
		end

		table.sort(tResult)

		return tResult
	end
end

----------------------------------------------------------------

console = function()
	local tHistory = { }

	while bRunning do
		term.clearLine()
		term.setTextColor(nPColor)
		write(">> ")

		term.setTextColor(nWColor)
		local stCommand = read(nil, tHistory, autoComplete)
		table.insert(tHistory, stCommand)

		local bFirst = true
		local sCommand = ""
		local tParm = { }
		for sSplit in string.gmatch(stCommand, "[%p%w]+") do
			if bFirst then
				sCommand = string.lower( sSplit )
				bFirst = false
			else
				table.insert(tParm, sSplit)
			end
		end

		if string.find(sCommand, "^[$]") then
			shell.run(
				string.match(sCommand, ".(.+)"),
				table.unpack(tParm))
		elseif sCommand == "exit" then
			bRunning = false
		elseif stCommand ~= "" then
			if command[ sCommand ] then
				local bOk, vResult, bError = pcall(
					command[ sCommand ], table.unpack( tParm ))

				if not bOk or bError then
					term.setTextColor(colors.red)
				end

				if vResult ~= nil then
					if type(vResult) == "table" then
						for sPrefix, sPostfix in pairs(vResult) do
							term.setTextColor(nSTColor)
							write(sPrefix..": ")

							term.setTextColor(nWColor)
							print(sPostfix)
						end
					elseif type(vResult) == "string" then
						print(vResult)
					end
				end

				--[[
				if type(vResult) == "table" then
					vResult = textutils.serialize(vResult)
				end

				if vResult ~= nil then
					print( vResult )
					-- if not bOk then
					--	 os.sleep(15)
					-- end -- Debug >> crash
				end
				]]
			else
				term.setTextColor(nEColor)
				print("Command not found")
			end
		end
	end
end

local fCRun = function()
	while bRunning do
		local tEvent = { os.pullEvent() }

		if tEvent[1] == "terminate" then
			bRunning = false
			return print()
		end

		for _, cRoutine in pairs(privEnv.cRoutines) do
			coroutine.resume( cRoutine.routine, table.unpack(tEvent) )
		end

		for _, sinServer in pairs(tServer) do for _, sinUser in pairs(sinServer.user) do
			for _, cRoutine in pairs(sinUser.cRoutines) do
				coroutine.resume( cRoutine.routine, table.unpack(tEvent) )
			end
		end end

		lib.sniff.parallel()
	end
end

fMPCExit = function()
	for _, cRoutine in pairs(privEnv.cRoutines) do
		cRoutine.bRunning = false
	end

	for _, sinServer in pairs(tServer) do for _, sinUser in pairs(sinServer.user) do
		for _, cRoutine in pairs(sinUser.cRoutines) do
			cRoutine.bRunning = false
		end
	end end

	lib.sniff.removeAllHosts()
	lib.sniff.stop()

	fMPCExit = nil
	command = nil
end

local fConsole
if type(tOption[1]) == "string"
and not (#tOption == 2
and tOption[2] == "load") then
	fConsole = console
else
	return fCRun
end

while bRunning do
	parallel.waitForAny(fConsole, fCRun)
end

fMPCExit()