-- display API 
-- made by akaJag
-- work in progress

function round(num)
	if type(num) ~= "number" then return num end
	if num%1<.5 then num=math.floor(num) end
	if num%1>=.5 then num=math.ceil(num) end
	return num
end

function setupdaterate(class,s)
	class.updaterate = s
end

function getupdaterate(class)
	return class.updaterate
end

function removepixles(class)
	local w,h = class.obj.getSize()
	
	-- check row
	local width = next(class.pixles)
	while width do
		if width > w or width < 0 then
			-- remove row
			local tmpw = width
			width = next(class.pixles,width)
			class.pixles[tmpw] = nil
		else
			-- check column
			local height = next(class.pixles[width])
			while height do
				if height > h or height < 0 then
					-- remove column
					local tmph = height
					height = next(class.pixles[width],height)
					class.pixles[width][tmph] = nil
				else
					-- next iteration
					height = next(class.pixles[width],height)
				end
			end
			-- next iteration
			width = next(class.pixles,width)
		end
	end
end

function fixpixles(class)
	local w,h = class.obj.getSize()
	for width = 1,w do
		if class.pixles[width] == nil then class.pixles[width] = {} end
		for height = 1,h do
			if class.pixles[width][height] == nil then
				class.pixles[width][height] = {sym=" ",bg=colors.black,fg=colors.white}
			end
		end
	end
end

-- returns:
--	(number) update time
function update(class)
	local startupdate = os.clock()
	
	class:removepixles()
	class:fixpixles()
	
	local endupdate = os.clock()
	return endupdate - startupdate
end

function draw(class)
	local startdraw = os.clock()
	
	for w in pairs(class.pixles) do
		for h,pixle in pairs(class.pixles[w]) do
			class.obj.setCursorPos(w,h)
			class.obj.setBackgroundColor(pixle.bg or colors.black)
			class.obj.setTextColor(pixle.fg or colors.white)
			class.obj.write(pixle.sym or " ")
		end
	end
	
	local enddraw = os.clock()
	return enddraw - startdraw
end

-- can be used in a parallel loop
-- dont forget to do prepareloop() before running
-- stop it with stoploop()
function loop(class)
	if not running then return end
	local s = class:update()
	s = s + class:draw()
	sleep(updaterate - s)
end

function prepareloop(class)
	class.looprunning = true
	class.looptime = os.clock()
end

-- returns the time the loop has been on
function stoploop()
	class.looprunning = false
	return os.clock - class.looptime
end

function setcolor(class,fg,bg)
	class.fgcolor = fg or class.fgcolor
	class.bgcolor = bg or class.bgcolor
end

function getcolor(class)
	return class.fgcolor,class.bgcolor
end

function setfgcolor(class,col)
	class.fgcolor = col
end

function getfgcolor(class)
	return class.fgcolor
end

function setbgcolor(class,col)
	class.bgcolor = col
end

function getbgcolor(class)
	return class.bgcolor
end

-- stroke is only used with "line" draw mode
function setstroke(class,var)
	class.stroke=var
end

function getstroke(class)
	return class.stroke
end

-- clears the entire screen
-- bg = only change background, ignore text
function clear(class,bg)
	for w in pairs(class.pixles) do
		for h,pixle in pairs(class.pixles[w]) do
			class.pixles[w][h].bg = class.bgcolor
			if bg ~= true then
				class.pixles[w][h].sym = " "
			end
		end
	end
end

-- trans = transparant option
function write(class,str,x,y,trans)
	x=round(x) y=round(y)
	for count = 1,#str do
		if class.pixles[x+count-1] then
			if class.pixles[x+count-1][y] then
				class.pixles[x+count-1][y].sym = str:sub(count,count)
				class.pixles[x+count-1][y].fg = class.fgcolor
				if trans ~= true then
					class.pixles[x+count-1][y].bg = class.bgcolor
				end
			end
		end
	end
end

function line(class,x1,y1,x2,y2,bg)
	-- Bresenham's algorithm
	local dx = x2 - x1
	if dx < 0 then dx = -dx end
	local dy = y2 - y1
	if dy < 0 then dy = -dy end
	
	local sx,sy
	if x1 < x2 then sx = 1
	else sx = -1 end
	if y1 < y2 then sy = 1
	else sy = -1 end
	
	local err = dx - dy
	
	repeat
		local x,y = round(x1),round(y1)
		if class.pixles[x] then
			if class.pixles[x][y] then
				class.pixles[x][y].bg = class.bgcolor
				if bg ~= true then
					class.pixles[x][y].sym = " "
				end
			end
		end
		
		if x1 == x2 and y1 == y2 then break end
		local e2 = 2*err
		if e2 > -dy then
			err = err - dy
			x1 = x1 + sx
		end
		if e2 < dx then
			err = err + dx
			y1 = y1 + sy
		end
	until false
end

-- supported modes: fill, line
-- bg = only set background color
function rect(class,mode,x1,y1,x2,y2,bg)
	x1=round(x1) y1=round(y1) x2=round(x2) y2=round(y2)
	if mode == "fill" then
		for x = x1,x2 do
			for y = y1,y2 do
				if class.pixles[x] ~= nil then
					if class.pixles[x][y] ~= nil then
						class.pixles[x][y].bg = class.bgcolor
						if bg ~= true then
							class.pixles[x][y].sym = " "
						end
					end
				end
			end
		end
	elseif mode == "line" then
		-- top line
		for x = x1,x2 do
			for y = y1,y1+class.stroke-1 do
				if class.pixles[x] ~= nil then
					if class.pixles[x][y] ~= nil then
						class.pixles[x][y].bg = class.bgcolor
						if bg ~= true then
							class.pixles[x][y].sym = " "
						end
					end
				end
			end
		end
		-- bottom line
		for x = x1,x2 do
			for y = y2-class.stroke+1,y2 do
				if class.pixles[x] ~= nil then
					if class.pixles[x][y] ~= nil then
						class.pixles[x][y].bg = class.bgcolor
						if bg ~= true then
							class.pixles[x][y].sym = " "
						end
					end
				end
			end
		end
		-- right line
		for x = x2-class.stroke+1,x2 do
			for y = y1,y2 do
				if class.pixles[x] ~= nil then
					if class.pixles [x][y] ~= nil then
						class.pixles[x][y].bg = class.bgcolor
						if bg ~= true then
							class.pixles[x][y].sym = " "
						end
					end
				end
			end
		end
		-- left line
		for x = x1,x1+class.stroke-1 do
			for y = y1,y2 do
				if class.pixles[x] ~= nil then
					if class.pixles [x][y] ~= nil then
						class.pixles[x][y].bg = class.bgcolor
						if bg ~= true then
							class.pixles[x][y].sym = " "
						end
					end
				end
			end
		end
	end
end

-- supported modes: fill, line
-- bg = only set background color
function circle(class,mode,x,y,r,bg)
	x=round(x) y=round(y)
	for w in pairs(class.pixles) do
		for h in pairs(class.pixles[w]) do
			-- pythagrias sats
			-- a^2 + b^2 = c^2
			local dis = math.sqrt((w-x)^2 + (h-y)^2)
			if dis <= r then
				if mode == "fill" or
				(mode == "line" and dis >= r-class.stroke) then
					if class.pixles[w] ~= nil then
						if class.pixles[w][h] ~= nil then
							class.pixles[w][h].bg = class.bgcolor
							if bg ~= true then
								class.pixles[w][h].sym = " "
							end
						end
					end
				end
			end
		end
	end
end

local function strtotbl(str)
	local tbl = {}
	for uchar in str:gmatch("([%z\1-\127\194-\244][\128-\191]*)") do
		table.insert(tbl,uchar)
	end
	return tbl
end

local function tbltostr(tbl)
	local str = ""
	for _,value in pairs(tbl) do
		str=str..tostring(value)
	end
end

-- x,y = top left corner of text field
-- w = width of text field
-- l = max lenght of text
-- c = make the text look like a certain character
-- trans = transparent
-- callback = function, gets events as parameters, if returns true then exit
function read(class,x,y,w,l,initstr,c,trans,callback)
	x=round(x) y=round(y) w=round(w) l=round(l)
	if type(l)~="number" then l=-1 end
	if type(initstr)~="string" then initstr="" end
	local running = true
	local text = initstr or ""
	local padding = #text-w
	local cursor = #text
	
	callback = callback or function(ev,p1,p2,p3,p4,p5)
		if ev == "key" and p1 == keys.enter then
			return true
		end
	end
	
	while running do
		-- fix cursor and padding
		if cursor > #text then cursor = #text end
		if cursor < 0 then cursor = 0 end
		if padding > #text-1 then padding = #text-1 end
		if padding < 0 then padding = 0 end
		
		-- drawing
		if trans ~= true then
			class:rect("fill",x,y,x+w,y,false)
		end
		local tbl = strtotbl(text)
		if type(c) == "string" then
			local str = c:rep(math.floor(#tbl/#c)) .. c:sub(1,#tbl%#c)
			class:write(str:sub(padding+1,padding+w+1),x,y,true)
		else
			local count = 0
			for index = padding+1,padding+w+1 do
				if text[index] then
					class:write(text[index],x+count,y,true)
				end
				count = count + 1
			end
		end
		
		class:update()
		class:draw()
		
		if cursor-padding <= w and cursor-padding >= 0 then
			class.obj.setCursorPos(x+cursor-padding,y)
			class.obj.setTextColor(class:getfgcolor())
			class.obj.setCursorBlink(true)
		end
		
		local ev,p1,p2,p3,p4,p5 = os.pullEvent()
		
		class.obj.setCursorBlink(false)
		
		if callback(ev,p1,p2,p3,p4,p5) == true then
			return text,ev,p1,p2,p3,p4,p5
		end
		if ev == "key" then
			if p1 == keys.left then
				-- move left
				cursor = cursor - 1
				if cursor<padding then padding = padding - 1 end
			elseif p1 == keys.right then
				-- move right
				cursor = cursor + 1
				if cursor-padding > w then padding = padding + 1 end
			elseif p1 == keys.backspace then
				-- remove a character
				local num = cursor-1
				if num < 0 then num = 0 end
				text = text:sub(1,num) .. text:sub(cursor+1)
				cursor = cursor - 1
				if cursor<padding then padding = padding - 1 end
			elseif p1 == keys.delete then
				-- remove a character
				text = text:sub(1,cursor) .. text:sub(cursor+2)
			elseif p1 == keys.home then
				cursor = 0
				padding = 0
			elseif p1 == keys["end"] then
				cursor = text:len()
				padding = text:len()-w
			end
		elseif ev == "char" then
			if #text < l or l <= 0 then -- check length limit
				-- add a character
				text = text:sub(1,cursor) .. p1 .. text:sub(cursor+1)
				cursor = cursor + 1
				if cursor-padding > w then padding = padding + 1 end
			end
		elseif (ev == "mouse_click" and class.type == "term")
		or (ev == "monitor_touch" and class.type == "monitor" and p1 == class.path) then
			-- move cursor
			-- x=p2, y=p3
			if p2<x then p2=x end
			if p2>x+w then p2=x+w end
			cursor = p2-x+padding
		elseif ev == "mouse_scroll" then
			-- scrolling left/right
			padding = padding + p1
		end
	end
end

function load(objpath)
	local startload = os.clock()
	
	tobj = {}
	
	-- object variables
	objpath = objpath or "N/A"
	if peripheral.isPresent(objpath)
	and peripheral.getType(objpath) == "monitor" then
		tobj.obj = peripheral.wrap(objpath or "N/A")
		tobj.type = "monitor"
		tobj.path = objpath
		tobj.eventname = "monitor_touch"
	else
		tobj.type = "term"
		tobj.obj = term
		tobj.path = "N/A"
		tobj.eventname = "mouse_click"
	end
	
	-- variables
	tobj.pixles = {}
	tobj.updaterate = 0.2
	tobj.looprunning = false
	tobj.looptime = 0
	tobj.stroke = 1
	tobj.bgcolor = colors.black
	tobj.fgcolor = colors.white
	
	-- misc functions
	tobj.setupdaterate = setupdaterate
	tobj.getupdaterate = getupdaterate
	tobj.removepixles = removepixles
	tobj.fixpixles = fixpixles
	tobj.update = update
	tobj.draw = draw
	tobj.loop = loop
	tobj.prepareloop = prepareloop
	tobj.stoploop = stoploop
	
	-- color functions
	tobj.setcolor = setcolor
	tobj.setfgcolor = setfgcolor
	tobj.setbgcolor = setbgcolor
	tobj.getcolor = getcolor
	tobj.getfgcolor = getfgcolor
	tobj.getbgcolor = getbgcolor
	tobj.setstroke = setstroke
	tobj.getstroke = getstroke
	-- british
	tobj.setcolour = setcolor
	tobj.setfgcolour = setfgcolor
	tobj.setbgcolour = setbgcolor
	tobj.getcolour = getcolor
	tobj.getfgcolour = getfgcolor
	tobj.getbgcolour = getbgcolor
	
	-- drawing functions
	tobj.clear = clear
	tobj.write = write
	tobj.line = line
	tobj.rect = rect
	tobj.circle = circle
	tobj.read = read
	
	tobj:removepixles()
	tobj:fixpixles()
	
	local endload = os.clock()
	return tobj,endload-startload
end