local luaPrint = print

function isScreen(side, id)
	if wrap(side, id) then
		return true
	end
	return false
end

-- "Class" for handler for remote devices (via a wired modem)
local RemoteHandler = {}
RemoteHandler.new = function(side, id)

	local handler = {}
	
	handler.modem = peripheral.wrap(side)
	if handler.modem == nil then return end
	
	handler.side = side
	handler.id = id
	handler.name = "monitor_" .. id
	handler.isHandler = true
	handler.isRemoteHandler = true
	
	handler.clear = 			function() 						handler.modem.callRemote(handler.name, "clear") 				end
	handler.write = 			function(txt) 	return			handler.modem.callRemote(handler.name, "write", txt) 			end
	handler.clearLine = 		function() 						handler.modem.callRemote(handler.name, "clearLine") 			end
	
	handler.getCursorPos = 		function()		local a, b =	handler.modem.callRemote(handler.name, "getCursorPos")			return a, b end
		handler.getCursor = 	handler.getCursorPos
		handler.getCursorXPos =	function()		local a, b =	handler.modem.callRemote(handler.name, "getCursorPos")			return a end
		handler.getCursorX = 	handler.getCursorXPos
		handler.getX =			handler.getCursorXPos
		handler.getCursorYPos =	function()		local a, b =	handler.modem.callRemote(handler.name, "getCursorPos")			return b end
		handler.getCursorY = 	handler.getCursorYPos
		handler.getY =			handler.getCursorYPos
		
	handler.setCursorPos =		function(a, b)					handler.modem.callRemote(handler.name, "setCursorPos", a, b) 	end
		handler.setCursor = 	handler.setCursorPos
		handler.setCursorXPos =	function(x)		local a, b =	handler.modem.callRemote(handler.name, "getCursorPos")
																handler.modem.callRemote(handler.name, "setCursorPos", x, b) 	end
		handler.setCursorX =	handler.setCursorXPos
		handler.setX =			handler.setCursorXPos
		handler.setCursorYPos =	function(y)		local a, b =	handler.modem.callRemote(handler.name, "getCursorPos")
																handler.modem.callRemote(handler.name, "setCursorPos", a, y) 	end
		handler.setCursorY =	handler.setCursorYPos
		handler.setY =			handler.setCursorYPos
		
	handler.setCursorBlink =	function(b)						handler.modem.callRemote(handler.name, "setCursorBlink", b)		end
		handler.setBlink =		handler.setCursorBlink
		
	handler.isColor	=			function()		return			handler.modem.callRemote(handler.name, "isColor")				end		
	
	handler.getSize =			function()		local a, b =	handler.modem.callRemote(handler.name, "getSize")				return a, b end
		handler.getXSize =		function()		local a, b =	handler.modem.callRemote(handler.name, "getSize")				return a end
		handler.getYSize =		function()		local a, b =	handler.modem.callRemote(handler.name, "getSize")				return b end
	
	handler.scroll =			function(n)						handler.modem.callRemote(handler.name, "scroll", n)				end
	handler.setTextScale =		function(s)						handler.modem.callRemote(handler.name, "setTextScale", s)		end
	if handler.isColor() then
		handler.setTextColor = 			function(color)	handler.modem.callRemote(handler.name, "setTextColor", color) 		end
		handler.setBackgroundColor = 	function(color) handler.modem.callRemote(handler.name, "setBackgroundColor", color) end
			handler.setBackColor = 		handler.setBackgroundColor
		handler.setColors =				function(col1, col2) 	if col1 ~= nil then
																	handler.modem.callRemote(handler.name, "setTextColor", col1)
																else
																	handler.modem.callRemote(handler.name, "setTextColor", colours.white)
																end
																if col2 ~= nil then
																	handler.modem.callRemote(handler.name, "setBackgroundColor", col2)
																else
																	handler.modem.callRemote(handler.name, "setBackgroundColor", colours.black)
																end end
	end
	
	-- adding the additional API functions
	handler.reset = 			function()				handler.modem.callRemote(handler.name, "clear") handler.modem.callRemote(handler.name, "setCursorPos", 1, 1) end
	handler.nextLine =			function(scrolling)		nextLine(handler.side, handler.id, scrolling) end
	handler.nextLines =			function(n, scrolling) 	nextLines(n, handler.side, handler.id, scrolling) end
	handler.print =				function(text, scrolling) return print(text, handler.side, handler.id, scrolling) end
	handler.println =			function(text, scrolling) handler.print(text, handler.side, handler.id, scrolling) handler.nextLine(scrolling) return text end
	handler.left =				function(text, scrolling) return left(text, handler.side, handler.id, scrolling) end
	
	return handler
end

-- "Class" for a normal handler (using this add methods that implements the function added by this API)
local Handler = {}
Handler.new = function(side)

	local handler = peripheral.wrap(side)
	if handler == nil then return end
	
	handler.side = side
	
	handler.isHandler = true
	handler.isRemoteHandler = false

	handler.getCursor = handler.getCursorPos
	handler.getCursorXPos = function() local a, b = handler.getCursorPos() return a end
		handler.getCursorX = handler.getCursorXPos
		handler.getX = handler.getCursorXPos
	handler.getCursorYPos = function() local a, b = handler.getCursorPos() return b end
		handler.getCursorY = handler.getCursorYPos
		handler.getY = handler.getCursorYPos
	
	handler.setCursor = handler.setCursorPos
	handler.setCursorXPos = function(x) local a, b = handler.getCursorPos() handler.setCursorPos(x, b) end
		handler.setCursorX = handler.setCursorXPos
		handler.setX = handler.setCursorXPos
	handler.setCursorYPos = function(y) local a, b = handler.getCursorPos() handler.setCursorPos(a, y) end
		handler.setCursorY = handler.setCursorYPos
		handler.setY = handler.setCursorYPos
		
	handler.getXSize = function() local a, b = handler.getSize() return a end
	handler.getYSize = function() local a, b = handler.getSize() return b end
	
	handler.setBlink = handler.setCursorBlink
	
	if handler.isColor() then
		handler.setBackColor = handler.setBackgroundColor
		handler.setColors = function(col1, col2) 	if col1 ~= nil then
														handler.setTextColor(col1)
													else
														handler.setTextColor(colours.white)
													end
													if col2 ~= nil then
														handler.setBackgroundColor(col2)
													else
														handler.setBackgroundColor(colours.black)
													end end
	end
	
	-- adding the additional API functions
	handler.reset = function() handler.clear() handler.setCursorPos(1, 1) end
	handler.nextLine = function(scrolling) nextLine(handler.side, nil, scrolling) end
	handler.nextLines = function(n, scrolling) nextLines(n, handler.side, nil, scrolling) end
	handler.print = function(text, scrolling) return print(text, handler.side, nil, scrolling) end
	handler.println = function(text, scrolling) handler.print(text, handler.side, nil, scrolling) handler.nextLine(scrolling) return text end
	handler.left = function(text, scrolling) return left(text, handler.side, nil, scrolling) end
	
	return handler
end

-- wrap around 'side', if 'side' is a modem, 'id' designate the number id of the monitor targetted (name structure is "monitor_id")
function wrap(side, id)
	if side == nil then
		return term
	elseif peripheral.isPresent(side) then 
		if peripheral.getType(side) == "monitor" then
			return Handler.new(side)
		elseif peripheral.getType(side) == "modem" and id ~= nil then
			local modem = peripheral.wrap(side)
			if modem.isPresentRemote and modem.isPresentRemote("monitor_" .. id) then
				return RemoteHandler.new(side, id)
			end
		end
	end
	luaPrint("wrap: invalid input").crash()
end

--------------------------------------------------------------------------------------------------------------------------
-------------------------------------------REDEFINITION-OF-STANDARD-FUNCTIONS---------------------------------------------
--------------------------------------------------------------------------------------------------------------------------

-- Clear the screen
function clear(side, id)
	wrap(side, id).clear()
end

-- Clear the line at the cursor's position
function clearLine(side, id)
	wrap(side, id).clearLine()
end

-- Write a text at the cursor's position
function write (text, side, id)
	return wrap(side, id).write(text)
end

-- Get the cursor's position
-- getCursorPos, getCursor
-- getCursorXPos, getCursorX, getX
-- getCursorYPos, getCursorY, getY
function getCursorPos(side, id)
	local a, b = wrap(side, id).getCursorPos()
	return a, b
end
getCursor = getCursorPos
function getCursorXPos(side, id)
	local a, b = getCursorPos(side, id)
	return a
end
getCursorX = getCursorXPos
getX = getCursorXPos
function getCursorYPos(side, id)
	local a, b = getCursorPos(side, id)
	return b
end
getCursorY = getCursorYPos
getY = getCursorYPos

-- Set the cursor's position
-- setCursorPos, setCursor
-- setCursorXPos, setCursorX
-- setCursorYPos, setCursorY
function setCursorPos(x, y, side, id)
	wrap(side, id).setCursorPos(x, y)
end
setCursor = setCursorPos
function setCursorXPos(x, side, id)
	local handler = wrap(side, id)
	local a, b = handler.getCursorPos()
	handler.setCursorPos(x, b)
end
setCursorX = setCursorXPos
setX = setCursorXPos
function setCursorYPos(y, side, id)
	local handler = wrap(side, id)
	local a, b = handler.getCursorPos()
	handler.setCursorPos(a, y)
end
setCursorY = setCursorYPos
setY = setCursorYPos

-- Set weither or not the cursor is blinking
-- setCursorBlink, setBlink
function setCursorBlink(b, side, id)
	wrap(side, id).setCursorBlink(b)
end
setBlink = setCursorBlink

-- true if advanced, false if not
function isColor(side, id)
	return wrap(side, id).isColor()
end

-- Get the screen's side
-- getSize
-- getXSize
-- getYSize
function getSize(side, id)
	local a, b = wrap(side, id).getSize()
	return a, b
end
function getXSize(side, id)
	local a, b = wrap(side, id).getCursorPos()
	return a
end
function getYSize(side, id)
	local a, b = wrap(side, id).getCursorPos()
	return b
end

-- Scroll the screen upward
function scroll(n, side, id)
	wrap(side, id).scroll(n)
end

-- Set the scale of the monitor (has no effect on a terminal)
function setTextScale(x, side, id)
	if side ~= nil then
		wrap(side, id).setTextScale(x)
		return true
	end
	return false
end

-- Set the text color (has no effect on a non-advanced screen
function setTextColor(color, side, id)
	local handler = wrap(side, id)
	if handler.isColor() then
		handler.setTextColor(color)
		return true
	end
	return false
end

-- Set the background color (has no effect on a non-advanced screen
function setBackgroundColor(color, side, id)
	local handler = wrap(side, id)
	if handler.isColor() then
		handler.setBackgroundColor(color)
		return true
	end
	return false
end
setBackColor = setBackgroundColor

--------------------------------------------------------------------------------------------------------------------------
--------------------------------------------ADDITIONAL-SIMPLE-FUNCTIONS---------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------

-- clear the screen, then set the cursor back to (1,1)
function reset(side, id)
	
	clear(side, id)
	setCursorPos(1, 1, side, id)
end

-- set the colors of both the background and the text
function setColors(col1, col2, side, id)
	if handler.isColor() then
		if col1 ~= nil then
			handler.setTextColor(col1)
		else
			handler.setTextColor(colours.white)
		end
		if col2 ~= nil then
			handler.setBackgroundColor(col2)
		else
			handler.setBackgroundColor(colours.black)
		end
		return true
	end
	return false
end

-- go to the next line, return the number of lines scrolled
-- if scrolling is true, will scroll the screen if on the last line
function nextLine(side, id, scrolling)
	local x, y = getCursor(side, id)
	local a, b = getSize(side, id)
	if y < b then
		setCursor(1, y+1, side, id)
		return 0
	elseif y == b and scrolling then
		scroll(1, side, id)
		setCursor(1, y, side, id)
		return 1
	end
	setCursor(1, y, side, id)
	return 0
end
-- multilines version
function nextLines(n, side, id, scrolling)
	local x, y = getCursor(side, id)
	local a, b = getSize(side, id)
	if y+n <= b then
		if y+n > 0 then
			setCursor(1, y+n, side, id)
		else
			setCursor(1, 1, side, id)
		end
		return 0
	end
	if  scrolling then
		scroll(y+n-b, side, id)
		setCursor(1, b, side, id)
		return y+n-b
	end
	setCursor(1, b, side, id)
	return 0
end
	
-- print the text given to screen
-- this function recognize the "\n" character and interprete them accordingly (with a new line)
-- see nextLine function for the usage of "scrolling" argument"
function print(text, side, id, scrolling)
	local handler = wrap(side, id)
	for i=1, text:len() do
		if text:sub(i, i) == "\n" then
			handler.nextLine(scrolling)
		else
			handler.write(text:sub(i, i))
		end
	end
	return text
end

-- print the given text and go to the next line
-- this function recognize the "\n" character and interprete them accordingly (with a new line)
-- see nextLine function for the usage of "scrolling" argument"
function println(text, side, id, scrolling)
	local handler = wrap(side, id)
	handler.print(text, scrolling)
	handler.nextLine(scrolling)
	return text
end

--------------------------------------------------------------------------------------------------------------------------
--------------------------------------------ALIGNMENT-AND-SPACE-PARSING-FUNCTIONS-----------------------------------------
--------------------------------------------------------------------------------------------------------------------------

-- return a structured table separating the lines and words
-- the table is an integer array, going from 1 to n, where the line #n is the nth line of the text
-- each line has a table containing an alternance of integers representing an amonth of blank spaces, and of string representing the words
-- 		so an odd index for a line means the number of spaces, while an even number for a word
local function parseWords(str)

	local words = {}
	words[1] = {}
	words[1][1] = 0
	
	local line = 1
	local element = 1
	
	for i=1, str:len() do
		
		local char = str:sub(i, i)
		if char == "\n" then
			line = line+1
			words[line] = {}
			element = 1
			words[line][1] = 0
		elseif char == " " then
			if element/2 == math.floor(element/2) then
				element = element+1
				words[line][element] = 1
			else
				words[line][element] = words[line][element]+1
			end
		else
			if element/2 == math.floor(element/2) then
				words[line][element] = words[line][element] .. char
			else
				element = element+1
				words[line][element] = char
			end
		end
	end

	return words
end

-- insert into an integer array table, value at key, if the value already exists, all the next elements are shifted the the next key
local function table_insert(t, key, value)

	if type(key) ~= "number" then
		return false
	end

	if key > #t then
		t[#t+1] = value
	elseif key < 1 then
		table_append(t, 1, value)
	else
		for i=#t, key-1, -1 do
			t[i+1] = t[i]
		end
		t[key] = value
	end
	return t
end

-- remove elements from the integer array table t, from and including index start, till and including index ending
local function table_remove(t, start, ending)

	if not ending then
		ending = start
		start = 1
	end
	if not start then
		start = 1
		ending = #t
	end
	for i=start, #t do
		if i > ending then
			t[i-ending-1+start] = t[i]
		end
		t[i] = nil
	end
	return t
end

-- return a strict duplicate of the table, reccursively dupplicating tables included as elements
local function table_dupplicate(t)

	local newTable = {}
	for k, e in pairs(t) do
		if type(e) == "table" then
			newTable[k] = table_dupplicate(e)
		else
			newTable[k] = e
		end
	end
	return newTable
end

-- concatenate words from and including index a, till and including index b, at the given line
-- this is to be applied on a table resulting from the above function "parseWords"
local function concat_words(t, line, a, b)

	if not t or type(t) ~= "table" then return "" end
	
	local lineT = t[line]
	
	if not a then a = 1 b = #lineT end
	if not b then b = a a = 1 end
	if b-a <= 0 then return "" end
	
	local str = ""
	for i=a, b do
	
		if i/2 == math.floor(i/2) then
			str = str .. lineT[i]
		elseif lineT[i] > 0 then 
			str = str .. string.rep(" ", lineT[i])
		end
	end
	
	return str
end

-- create a structured table showings lines to print in a screen of a given width
-- ignore_trailing to true indicate that starting and trailing spaces are removed from the result
-- the table is an integer array like the parseWords result
-- each line is made up of 3 elements of indexes {1,2,3}
--		[1] contains the starting spaces
--		[2] contains the line body text
--		[3] contains the trailing spaces
local function parseLines(words, width, ignore_trailing)

	words = table_dupplicate(words)
	local lines = {}
	
	local i=1
	while i <= #words do
	
		lines[i] = {}
	
		local wordsLine = words[i]
		if ignore_trailing then
			wordsLine[1] = 0
			if (#wordsLine)/2 ~= math.floor((#wordsLine)/2) then
				wordsLine[#wordsLine] = 0
			end
		end
		
		local saveJ = nil
		for j=1, #wordsLine do
			saveJ = j
		
			--wrap("back", 0).print("Concatenation of line " .. i .. "\n  until words #" .. j .. ':\n  "' .. concat_words(words, i, j) .. '"\n', true)
			if concat_words(words, i, j):len() > width then
			
				saveJ = -1
			
				if j == 1 then
				--							wrap("back", 0).print("j == 1\n", true)
					lines[i][1] = 0
					lines[i][2] = ""
					lines[i][3] = width
					wordsLine[1] = wordsLine[1] - width
					if ignore_trailing then
						lines[i][3] = 0
						wordsLine[1] = 0
					end
					table_insert(words, i+1, wordsLine)
					break
					
				elseif j == 2 then											
				--							wrap("back", 0).print("j == 2\n", true)

					lines[i][1] = 0
					if wordsLine[1] == 0 then
						lines[i][2] = string.sub(wordsLine[2], 1, width)
						lines[i][3] = 0
						wordsLine[2] = string.sub(wordsLine[2], width+1)
						table_insert(words, i+1, wordsLine)
					else
						lines[i][2] = ""
						lines[i][3] = wordsLine[1]
						if ignore_trailing then
							lines[i][3] = 0
						end
						wordsLine[1] = 0
					end
					table_insert(words, i+1, wordsLine)
					break
				
				elseif j == 3 then
				--							wrap("back", 0).print("j == 3\n", true)
					lines[i][1] = wordsLine[1]
					lines[i][2] = string.rep(" ", wordsLine[1]) .. wordsLine[2]
					lines[i][3] = 0
					table_remove(wordsLine, 2)
					if ignore_trailing then
						lines[i][1] = 0
						wordsLine[1] = 0
					end
					table_insert(words, i+1, wordsLine)
					break
					
				elseif j/2 == math.floor(j/2) then
				--							wrap("back", 0).print("j > 3 and last is odd\n", true)
					lines[i][1] = wordsLine[1]
					lines[i][2] = concat_words(words, i, j-2)
					lines[i][3] = wordsLine[j-1]
					table_remove(wordsLine, j-1)
					table_insert(wordsLine, 1, 0)
					
					if ignore_trailing then
						lines[i][1] = 0
						lines[i][3] = 0
					end
					
					table_insert(words, i+1, wordsLine)
					break
				
				else
				--							wrap("back", 0).print("j > 3 and last is even\n", true)
					lines[i][1] = wordsLine[1]
					lines[i][2] = concat_words(words, i, j-1)
					lines[i][3] = 0
					table_remove(wordsLine, j-1) -- in that case, the issue is with a set of spaces, so it's removed from the list so that the next word is sent away
						wordsLine[1] = 0
					
					if ignore_trailing then
						lines[i][1] = 0
						wordsLine[1] = 0
					end
					
					table_insert(words, i+1, wordsLine)
					break
					
				end
			end
		end
		if not saveJ then
			lines[i][1] = 0
			lines[i][2] = ""
			lines[i][3] = 0
		
		elseif saveJ > 0 then
		
			lines[i][1] = wordsLine[1]
			if (#wordsLine)/2 == math.floor((#wordsLine)/2) then
				lines[i][2] = concat_words(words, i, #wordsLine)
				lines[i][3] = 0
			else
				lines[i][2] = concat_words(words, i, (#wordsLine)-1)
				lines[i][3] = wordsLine[#wordsLine]
			end
			
			if ignore_trailing then
				lines[i][1] = 0
				lines[i][3] = 0
			end

		end
		--wrap("back", 0).print("(" .. lines[i][1] .. ', "' .. lines[i][2] .. '", ' .. lines[i][3] .. ")\n", true)
		i = i+1
	end
	return lines
end

-- print a left-aligned version of the text, parsed with the above functions to send to the next line any overflowing words
-- this function recognize the "\n" character and interprete them accordingly (with a new line)
-- see nextLine function for the usage of "scrolling" argument"
-- if scrolling in disabled, it will only print the lines of text that fits the given space
function left(text, side, id, scrolling)

	local handler = wrap(side, id)
	local width, height = handler.getSize()
	local x, y = handler.getCursor()
	term.clear()
	term.setCursorPos(1, 1)
	local words = parseWords(text)
	local lines = parseLines(words, width)
	
	if x > 1 then
		handler.nextLine(scrolling)
	end
	
	local str = ""
	
	if scrolling then
	
		for i=1, #lines do
			local tmp = string.rep(" ", lines[i][1]) .. lines[i][2]
			handler.write(tmp)
			str = str .. tmp
			if i < #lines then
				handler.nextLine(true)
				str = str .. "\n"
			end
		end
	
	else
	
		for i=y, height do
			if not lines[i-y+1] then
				break
			end
			
			local tmp = string.rep(" ", lines[i-y+1][1]) .. lines[i-y+1][2]
			handler.write(tmp)
			str = str .. tmp
			if i < height then
				handler.nextLine(false)
				str = str .. "\n"
			end
		end
	
	end
	
	return text
end