Create a new version of paste:

-- Todo
	-- handle no door
	-- ensure we handle no display
	
local version = 1.01

local DoorConfig = {}
local DoorScreen = {}
local doorSettingsFile = "Door.Settings"
local cabinPresent = false

local displayHandle = nil

--local floorMap = { }

local KeepWaiting = true


-- ######################################################
-- ##  Load the API                                    ##
-- ######################################################

if fs.exists("/rom/apis/ECAPI") then --Check to make sure that the entered API exists
  os.loadAPI("/rom/apis/ECAPI")
  print("ECAPI loaded.")
else
  print("That API does not exist!")
end

-- ######################################################
-- ##  Setup Configuration                             ##
-- ######################################################

local DefaultConfig = {}
DefaultConfig = ECAPI.addConfigOption(DefaultConfig,"Version",version,"Please do not change this.")
DefaultConfig = ECAPI.addConfigOption(DefaultConfig,"Network","","Elevator network name:")
DefaultConfig = ECAPI.addConfigOption(DefaultConfig,"Modem","","Which side is the modem?",'side')
DefaultConfig = ECAPI.addConfigOption(DefaultConfig,"Call","","Which side waits for call input?",'side')
DefaultConfig = ECAPI.addConfigOption(DefaultConfig,"Detect","","Which side detects the Cabin?",'side')
DefaultConfig = ECAPI.addConfigOption(DefaultConfig,"Display","","Which side is the Display monitor?",'side')
DefaultConfig = ECAPI.addConfigOption(DefaultConfig,"Door","","Which side controls the Door?",'side')
DefaultConfig = ECAPI.addConfigOption(DefaultConfig,"Debug","error","What level of debug output?")
DefaultConfig = ECAPI.addConfigOption(DefaultConfig,"Floor","","Which floor is this?",'numeric')
DefaultConfig = ECAPI.addConfigOption(DefaultConfig,"Description","","What description to display?")
DefaultConfig = ECAPI.addConfigOption(DefaultConfig,"FloorPW","","Floor Password:",'pass') 
DefaultConfig = ECAPI.addConfigOption(DefaultConfig,"ConfigPW","","Config. Password:",'pass')   -- note, this is per machine

local function networkName()
	return ECAPI.getConfigOption(DoorConfig,"Network")
end

local function modemSide()
	return ECAPI.getConfigOption(DoorConfig,"Modem")
end

local function callSide()
	return ECAPI.getConfigOption(DoorConfig,"Call")
end

local function detectSide()
	return ECAPI.getConfigOption(DoorConfig,"Detect")
end

local function doorSide()
	return ECAPI.getConfigOption(DoorConfig,"Door")
end

local function displaySide()
	return ECAPI.getConfigOption(DoorConfig,"Display")
end

local function whichFloor()
	return ECAPI.getConfigOption(DoorConfig,"Floor")
end

local function floorDesc()
	return ECAPI.getConfigOption(DoorConfig,"Description")
end


-- ######################################################
-- ##  Terminal Functions                              ##
-- ######################################################

local function termClear()
	ECAPI.printDoorTemplate(DoorConfig)
	DoorScreen = ECAPI.setupScreen(DoorScreen)
	term.setCursorPos(3,18)
	write("Command: ")
end


local function justPrintInfo(DoorScreen,moduleID,sourceID,floorID,newLine)
	local t = "["..ECAPI.padLeft(moduleID,6," ").."]"
	t = t .. "["..ECAPI.padLeft(sourceID,4," ")..":"
	t = t .. ECAPI.padLeft(floorID,2," ").."]: " .. newLine
	
	if (ECAPI.getConfigOption(DoorConfig,"Debug") == "info") then
		DoorScreen = ECAPI.justPrintLine(DoorScreen,t)
	end
	return DoorScreen
end

local function justPrintLine(newLine)
	DoorScreen = ECAPI.justPrintLine(DoorScreen,newLine)
end


-- functions?

local function registerFloor()
	-- Now that we're started, notify the network controller
	ECAPI.openModem(modemSide())
	--password support:
	local pass = ECAPI.getConfigOption(DoorConfig,"FloorPW")
	if (pass == nil) then pass = "" else pass = ECAPI.encrypt(pass,networkName()) end
	-- Descriptions are flagged with a * if it's password protected
	ECAPI.broadcast(networkName(),"addFloor|"..whichFloor().."|"..floorDesc().."|"..pass)
end

local function powerToggle(whichSide,stateStr)
	local state = false
	if string.lower(stateStr) == "true" then
		state = true
	end
	redstone.setOutput(whichSide,state)
end

local function displayFloor(text)
	peripheral.call(displaySide(), "setCursorPos", 1, 1)
	peripheral.call(displaySide(), "setTextScale", 2.2)
	peripheral.call(displaySide(), "write", ECAPI.padLeft(text,3," "))
end

local function displayUp(text)
	peripheral.call(displaySide(), "setTextScale", 2.2)
	peripheral.call(displaySide(), "setCursorPos", 3, 2)
	peripheral.call(displaySide(), "write", text)
end

local function displayDown(text)
	peripheral.call(displaySide(), "setTextScale", 2.2)
	peripheral.call(displaySide(), "setCursorPos", 3, 2)
	peripheral.call(displaySide(), "write", text)
end

local function reconfig(args)
	if (ECAPI.checkPassword(DoorScreen,DoorConfig,"ConfigPW")) then
		local what = args[1]
		if (what == nil) or (what == "") then
			DoorConfig = DefaultConfig
			createNewSettings()
		else
			what = ECAPI.caseCheck(DoorConfig,what)
			if (args[2] == nil) then
				DoorScreen, DoorConfig = ECAPI.getConfigFromUser(DoorScreen, DoorConfig,what)
			else
				DoorConfig = ECAPI.setConfigOption(DoorConfig,what,table.concat(args," ",2))
			end
			-- Make sure to SAVE changes
			ECAPI.table_save(DoorConfig,doorSettingsFile)
			
			-- notify the network's Motor controller
			registerFloor()

			-- Check if the cabin is present at the end of startup
			if (redstone.getInput(callSide()) == true) then
				cabinPresent = true
			end
			
		end
	else
		justPrintLine("Invalid password.")
	end
end

local function sendFloorPW(sendID)
	ECAPI.send(sendID,'floorpw|'..ECAPI.encrypt(ECAPI.getConfigOption(DoorConfig,'FloorPW'),networkName()))
end

-- Control functions

local function openDoor()
	--ECAPI.printLine("open door")
	redstone.setOutput(doorSide(),false)
end

local function closeDoor()
	--ECAPI.printLine("close door")
	redstone.setOutput(doorSide(),true)
end


-- ######################################################
-- ##  Settings Functions                              ##
-- ######################################################

local function createNewSettings()
	DoorConfig = DefaultConfig
	termClear()
	--DoorScreen = ECAPI.printConfig(DoorConfig,DoorScreen)

	-- Confirm settings with the user, then save to file
	DoorScreen = ECAPI.addPrintLine(DoorScreen,"No settings file found.  Setup method:")
	justPrintLine(" 1) Normal Configuration")
	justPrintLine(" 2) Import from Floor")
	local setupMethod = ECAPI.getInput("Which: ")
	if (setupMethod == nil) or (setupMethod == "") then
		setupMethod = 1
	end
	setupMethod = tonumber(setupMethod)
	
	if setupMethod == 1 then

		-- To ensure this code plays nice with multiple elevators, Unique network names are required (as best as can)
		DoorScreen, DoorConfig = ECAPI.getConfigFromUser(DoorScreen,DoorConfig,"Network")
		DoorScreen = ECAPI.printConfig(DoorConfig,DoorScreen,"Network")
		
		-- Confirm modem side
		DoorScreen, DoorConfig = ECAPI.getConfigFromUser(DoorScreen,DoorConfig,"Modem")
		DoorScreen = ECAPI.printConfig(DoorConfig,DoorScreen,"Modem")
		
		-- Confirm call input side
		DoorScreen, DoorConfig = ECAPI.getConfigFromUser(DoorScreen,DoorConfig,"Call")
		DoorScreen = ECAPI.printConfig(DoorConfig,DoorScreen,"Call")
		
		-- Confirm detect input side
		DoorScreen, DoorConfig = ECAPI.getConfigFromUser(DoorScreen,DoorConfig,"Detect")
		DoorScreen = ECAPI.printConfig(DoorConfig,DoorScreen,"Detect")

		-- Confirm display output side
		DoorScreen, DoorConfig = ECAPI.getConfigFromUser(DoorScreen,DoorConfig,"Display")
		DoorScreen = ECAPI.printConfig(DoorConfig,DoorScreen,"Display")
		
		-- Confirm door output side
		DoorScreen, DoorConfig = ECAPI.getConfigFromUser(DoorScreen,DoorConfig,"Door")
		DoorScreen = ECAPI.printConfig(DoorConfig,DoorScreen,"Door")

		-- Confirm floor #
		DoorScreen, DoorConfig = ECAPI.getConfigFromUser(DoorScreen,DoorConfig,"Floor")
		DoorScreen = ECAPI.printConfig(DoorConfig,DoorScreen,"Floor")

		-- Confirm floor description
		DoorScreen, DoorConfig = ECAPI.getConfigFromUser(DoorScreen,DoorConfig,"Description")
		DoorScreen = ECAPI.printConfig(DoorConfig,DoorScreen,"Description")

		-- Debug output level
		DoorScreen, DoorConfig = ECAPI.getConfigFromUser(DoorScreen,DoorConfig,"Debug")
		DoorScreen = ECAPI.printConfig(DoorConfig,DoorScreen,"Debug")
	else
		-- Still need network name, modem side, and new floor #

		-- To ensure this code plays nice with multiple elevators, Unique network names are required (as best as can)
		DoorScreen, DoorConfig = ECAPI.getConfigFromUser(DoorScreen,DoorConfig,"Network")
		DoorScreen = ECAPI.printConfig(DoorConfig,DoorScreen,"Network")
		-- Confirm modem side
		DoorScreen, DoorConfig = ECAPI.getConfigFromUser(DoorScreen,DoorConfig,"Modem")
		DoorScreen = ECAPI.printConfig(DoorConfig,DoorScreen,"Modem")
		-- Confirm floor #
		DoorScreen, DoorConfig = ECAPI.getConfigFromUser(DoorScreen,DoorConfig,"Floor")
		DoorScreen = ECAPI.printConfig(DoorConfig,DoorScreen,"Floor")
		
		-- Now request the info from which floor?
		local sourceFloor = ECAPI.getInput("Source floor? ")
		ECAPI.openModem(modemSide())
		justPrintLine("Broadcasting: setupcopy|"..sourceFloor)
		ECAPI.broadcast(networkName(),"setupcopy|"..sourceFloor)
		
		-- wait until we get the right rednet event
		local setupCopied = false
		local newSetup = { }
		repeat
			local sendID, rawmessage, distance = rednet.receive()
			local packet = ECAPI.explode("|",rawmessage)
			if packet[1] == networkName() then
				if string.lower(packet[2]) ==     'setupdata'       then
					newSetup = textutils.unserialize(packet[3])
					setupCopied = true
				end
			end
		until setupCopied == true

		-- copy the data
		DoorConfig = ECAPI.setConfigOption(DoorConfig,"Call",ECAPI.getConfigOption(newSetup,"Call"))
		DoorConfig = ECAPI.setConfigOption(DoorConfig,"Detect",ECAPI.getConfigOption(newSetup,"Detect"))
		DoorConfig = ECAPI.setConfigOption(DoorConfig,"Display",ECAPI.getConfigOption(newSetup,"Display"))
		DoorConfig = ECAPI.setConfigOption(DoorConfig,"Door",ECAPI.getConfigOption(newSetup,"Door"))
		DoorConfig = ECAPI.setConfigOption(DoorConfig,"Debug",ECAPI.getConfigOption(newSetup,"Debug"))
		DoorConfig = ECAPI.setConfigOption(DoorConfig,"Description",ECAPI.getConfigOption(newSetup,"Description"))
		DoorConfig = ECAPI.setConfigOption(DoorConfig,"FloorPW",ECAPI.getConfigOption(newSetup,"FloorPW"))
		DoorConfig = ECAPI.setConfigOption(DoorConfig,"ConfigPW",ECAPI.getConfigOption(newSetup,"ConfigPW"))
	end
	-- Write to file
	ECAPI.table_save(DoorConfig,doorSettingsFile)
	termClear()
	if (setupMethod == 2) then justPrintLine("Make sure to review CONFIG settings.") end
end

local function startupConfirmation()
	-- Check if there's a settings file
	if fs.exists(doorSettingsFile) then
		termClear()
		DoorConfig = ECAPI.table_load(doorSettingsFile)
		ECAPI.verifyConfig(DefaultConfig,DoorConfig)
		termClear()
		DoorScreen = ECAPI.justPrintLine(DoorScreen,"Settings loaded.")
		os.sleep(0.5)
	else
		createNewSettings()
	end
	-- notify the network's Motor controller
	
	registerFloor()
	-- Check if the cabin is present at the end of startup
	if (redstone.getInput(callSide()) == true) then
		cabinPresent = true
	end
	
	-- Close all doors by default
	closeDoor()
end


-- ######################################################
-- ##  Input Actions                                   ##
-- ######################################################

-- MAX Topic summary: 36 characters
--                    |-----------------------------------|
local helpTopics = {
	["reboot"]		= { "Restart this terminal." ,},
	["clear"]		= { "Refresh the terminal screen." ,},
	["config"] 		= { "Prints the current settings. Will not print",
						"any set passwords." ,},
	["reconfig"]	= { "With no parameters, re-run the whole setup.",
						"RECONFIG [option] to change a single setting",
						"Note: Reconfig can be password protected via",
						"the ConfigPW setting. If this password is",
						"lost, you will need server admin help or be",
						"forced to recreate the terminal." ,},
	["broadcast"]	= { "Manually broadcast <message>",},
	["send"]		= { "Manually send <id> <message>",},
	["power"]		= { "Manually toggle power <side>",},
}

local function printHelp(topic)
	justPrintLine("Help on '"..string.upper(topic).."':")
	local t = helpTopics[topic]
	for _, text in ipairs(t) do
		justPrintLine("  "..text)
	end
end

local commands = {
	["help"] = function (x) 
			if (x[1] ~= nil) then
				printHelp(x[1])
			else
				justPrintLine("Please use HELP [COMMAND]. ? for Command List")
			end
		end,
	["reboot"] = function (x) os.reboot() end,
	["clear"] = function (x) termClear() end,
	["broadcast"] = function (x) 
			DoorScreen = justPrintInfo(DoorScreen,"REDNET",nil,nil,"Broadcast: "..table.concat(x," ",2))
			ECAPI.broadcast(networkName(),table.concat(x," "))
		end,
	["send"] = function (x) 
			DoorScreen = justPrintInfo(DoorScreen,"REDNET",nil,nil,"Send("..tonumber(x[1]).."): "..table.concat(x," ",2))
			ECAPI.send(networkName(),tonumber(x[1]),table.concat(x," ",2)) 
		end,
	
	["config"] = function (x) 
			justPrintLine("Current Configuration:")
			justPrintLine("-------------------------------")
			ECAPI.printConfig(DoorConfig,DoorScreen)
		end,
	["reconfig"] = function (x) reconfig(x) end,

	["power"] = function (x) powerToggle(x[1], x[2]) end,
}


local function printCommands()
	local col = 1
	local row = {}
	for named, _ in pairs(commands) do
		if (col < 5) then row[col] = string.upper(named) end
		col = col + 1
		if (col == 5) then
			justPrintLine(ECAPI.padLeft(row[1],12," ")..ECAPI.padLeft(row[2],12," ")..ECAPI.padLeft(row[3],12," ")..ECAPI.padLeft(row[4],11," "))
			row = {}
			col = 1
		end
	end
	if (col > 1) then
		-- handles 'remainders'
		justPrintLine(ECAPI.padLeft(row[1],12," ")..ECAPI.padLeft(row[2],12," ")..ECAPI.padLeft(row[3],12," ")..ECAPI.padLeft(row[4],11," "))
	end
end

local function processCommands(input)	
	local arg = ECAPI.explode(" ",input)
	local command = arg[1]
	table.remove(arg,1)
	if ECAPI.tableContainsKey(commands, command) then
		commands[command](arg)
	else
		justPrintLine("Unknown command '"..command.."'. Commands are:")
		printCommands()
	end
end


-- ######################################################	
-- ##  Handler Functions                               ##
-- ######################################################

-- User input listener
local function userConsole()
	while KeepWaiting do
		processCommands(ECAPI.getInput("Command:"))
	end
end


-- Redstone listener
local function redstoneListener()
	while KeepWaiting do
		event, param1, param2 = os.pullEvent("redstone")
		
		-- The players have pushed a button
		if event == "redstone" and redstone.getInput(callSide()) == true then
			--ECAPI.printLine("Call detection")
			ECAPI.broadcast(networkName(),"call")
		end
		
		-- if the cabin was not present, and we get a redstone on detect side, it just arrived
		if (event == "redstone") and (redstone.getInput(detectSide()) == true) then
			--ECAPI.printLine("Cabin detection")
			cabinPresent = true
			ECAPI.broadcast(networkName(),"arrival|"..whichFloor())
			displayFloor(whichFloor())
		end
		
		-- if the redstone on the detect side shuts off, the cabin just departed
		if (event == "redstone") and (redstone.getInput(detectSide()) == false) then
			--ECAPI.printLine("Cabin departure")
			cabinPresent = false
			ECAPI.broadcast(networkName(),"departure")
		end
	end
end

-- Rednet listener
local function rednetListener()
	ECAPI.openModem(modemSide())
	while KeepWaiting do
		local sendID, rawmessage, distance = rednet.receive()
		local packet = ECAPI.explode("|",rawmessage)
		if packet[1] == networkName() then
			--ECAPI.printLine("Message received ["..sendID.."]: "..table.concat(packet,"|",2))
			
			if string.lower(packet[2]) ==     'controlreset'       then
				-- If the control computer issues a reset broadcast, re-register with it.
				os.sleep(math.random(2.0,4.0))
				--ECAPI.printLine("Re-registering")
				registerFloor()
				if (redstone.getInput(detectSide()) == true) then
					-- also call out if the cabin is at this level
					ECAPI.broadcast(networkName(),"arrival")
				end
				
			elseif string.lower(packet[2]) == 'opendoor'           then
				--ECAPI.printLine("open door request "..ECAPI.padLeft(packet[3],5,' ').."?"..os.getComputerID())
				if packet[3] == tostring(os.getComputerID()) then
					openDoor()
				else
					closeDoor()
				end
			
			elseif string.lower(packet[2]) == 'closedoor'          then
				closeDoor()
			elseif string.lower(packet[2]) == 'arrival'           then 
				displayFloor(packet[3])
			elseif string.lower(packet[2]) == 'displayup'           then 
				displayUp(packet[3])
			elseif string.lower(packet[2]) == 'displaydown'           then 
				displayDown(packet[3])
			elseif string.lower(packet[2]) == 'locate'           then 
				if (redstone.getInput(detectSide()) == true) then
					-- also call out if the cabin is at this level
					ECAPI.broadcast(networkName(),"arrival")
				end
			elseif string.lower(packet[2]) == 'reboot'           then 
				os.reboot()
			elseif string.lower(packet[2]) == 'sendpw'           then 
				sendFloorPW(sendID)
			elseif string.lower(packet[2]) == 'setupcopy'		then
				if tonumber(packet[3]) == whichFloor() then
					ECAPI.send(networkName(),sendID,'setupdata|'..textutils.serialize(DoorConfig))
				end
			end
		end
	end
end

-- ######################################################
-- ##  Actual Run Program                              ##
-- ######################################################

startupConfirmation()
parallel.waitForAll(userConsole,redstoneListener,rednetListener)
--while KeepWaiting do
--	ECAPI.printLine("")
--	processCommands(ECAPI.getInput("Operation:"))
--end

--startupConfirmation()
--openModem()
--broadcast("addFloor|1")