multitask

--[[Multitask library
By Konlab (Green)
please check dependencies when removing parts of code!
]]
--this is a default table for user events
local usrEvents = {
terminate = true,
key = true,
key_up = true,
char = true,
paste = true,
}
--this is the default table for mouse events that need translation
local mouseEvents = {
mouse_click = true,
mouse_drag = true,
mouse_up = true,
mouse_scroll = true,
}
--dependency: none
--Checktypes: checks types in vars and if it's not the types in the table called types errors at lvl with generated error message
local function checkTypes(vars,types,lvl)
    lvl = lvl or 3
    for k,v in pairs(vars) do
        if type(types[k])=="string" and type(v) ~= types[k] then
            error(table.concat(types,", ").." expected",lvl)
        end
    end
end
--dependency: none
--Delegate: returns new delegate
function delegate()
	return setmetatable({func = {},
	add = function(self,func)
		if self and func then
			self.func[#self.func+1] = func
		else
			error("Self, Function expected, got "..type(self)..", "..type(func),2)
		end
	end,
	sub = function(self,func)
		if self and func then
			for i=1,#self.func do
				local v = self.func[i]
				if v == func then
					table.remove(self.func,i)
				end
			end
		else
			error("Self, Function expected, got "..type(self)..", "..type(func),2)
		end
	end,
	},
	{__call = function(tbl,...)
		if type(tbl.func) == "table" then
			local c,r = 0,{}
			for k,v in pairs(tbl.func) do
				if type(v) == "function" then
					c = c+1
					r[c] = {pcall(v,...)}
				end
			end
			return c,r
		end
	end,
	__add = function(self,func)
		self:add(func)
	end,
	__sub = function(self,func)
		self:sub(func)
	end,
	})
end
--Event: creates an event from the delegate
function event(del)
	return {
		add = function(func)
			del.func[#del.func+1] = func
		end,
		sub = function(func)
			local limit = #del.func
			for i=1,limit do
				if del.func[i] == func then
					table.remove(del.func,i)
				end
			end
		end,
		}
end
--dependecy: checkTypes
--New thread: returns a layer 1 thread table from func
function newThread(func)
    checkTypes({func},{"function"})
    local t = {
    	    co = coroutine.create(func),
    	    cresume = function(self,...)
    	        return coroutine.resume(self.co,...)
    	    end,
    	    cstatus = function(self)
    	        return coroutine.status(self.co)
    	    end,
    }
	t.resume = t.cresume --set resume to this layer
	t.status = t.cstatus --set status to this layer
	return t
end
--dependency newThread
--New CC Thread: layer 2, works with event types
function newCCThread(func)
	local t
	if type(func) == "table" and func.resume and func.status then
		t = func
	else
		checkTypes({func},{"function"})
		t = newThread(func)
	end
	local parent = {
		resume = t.resume,
		status = t.status,
	}
    t.filter = nil
    t.ccresume = function(self,event,...)
        if event == self.filter or self.filter == nil or event == "terminate" then
            local ok,info = parent.resume(self,event,...)
            if ok then
                self.filter = info
                return true,info
            else
                return false,info
            end
        end
        return nil
    end
	t.resume = t.ccresume --set resume to this layer
    return t
end
--dependency: newCCThread
--New pausable: layer 3, returns pausable thread table that can be continued later, has custom event queueing
function newPausable(func)
    local t
	if type(func) == "table" and func.resume and func.status then
		t = func
	else
		checkTypes({func},{"function"})
		t = newCCThread(func)
	end
	local parent = {
		resume = t.resume,
		status = t.status,
	}
    t.events = {}
    t.paused = false
    t.presume = function(self,event,...)
        if self.paused then
            self.events[#self.events + 1] = {event,...}
			return true
        else
            return parent.resume(self,event,...)
        end
    end
    t.clearEvents = function(self)
        for i=1,#self.events do
            parent.resume(self,unpack(self.events[i]))
        end
        self.events = {}
    end
    t.setPause = function(self,pause)
        self.paused = pause
        if not pause then
            self:clearEvents()
        end
    end
	t.resume = t.presume --set resume to this layer
    return t
end
--dependency: newPausable
--New Adv Thread: layer 4, adds random things to the thread table, like messages and data
function newAdvThread(func)
	local t
	if type(func) == "table" and func.resume and func.status then
		t = func
	else
		checkTypes({func},{"function"})
		t = newPausable(func)
	end
	t.msgs = {}
	t.data = {}
	return t
end
--dependency: newAdvThread
--New Windowed: layer 5, works with windows and redirects
function newWindowed(func,win)
    local t
	if type(func) == "table" and func.resume and func.status then
		t = func
	else
		checkTypes({func},{"function"})
		t = newAdvThread(func)
	end
	local parent = {
		resume = t.resume,
		status = t.status,
	}
	t.used = false
    t.win = win
    t.term = t.win
    t.wresume = function(self,event,...)
		local w = term.current()
        term.redirect(self.term)
        local t = {parent.resume(self,event,...)}
        self.term = term.current()
		term.redirect(w)
		return unpack(t)
    end
	t.resume = t.wresume --set resume to this layer
    return t
end
--In these systems indexes WILL change, please use identifiers instead!
--Please make sure func generates something continueable
--new Basic System generates a layer 1 and 2 thread system with function for converting not compatible types of func
function newBasicSystem(func,...)
	local args = {...}
	local threads = {}
	local thr
	for k,v in pairs(args) do
		if type(v) == "function" then
			thr = func(v)
			thr.id = k
			threads[#threads+1] = thr
		elseif type(v) == "table" and v.ccresume and v.status then
			v.id = k
			threads[#threads+1] = v
		end
	end
	return {
		threads = threads,
		anyended = false,
		allended = false,
		count = #threads,
		running = nil,
		tEnded = {}, --the t stands for table because ended is a function
		maxID = #threads + 1,
		onKill = delegate(),
		onAdd = delegate(),
		kill = function(self,i)
			local thr = self.threads[i]
			if thr then
				self.onKill(i) -- call onKill delegate
				self.tEnded[thr.id] = true --add this id to ended list
				table.remove(self.threads,i) --kill
				self.anyended = true --modify info
				local c = #self.threads
				self.count = c
				if c == 0 then
					self.allended = true
				end
				return true
			end
			return false
		end,
		resume = function(self,event)
			checkTypes({self,event},{"table","table"})
			local limit = #self.threads
			if limit == 0 then --check if threads is empty
				return false
			end
			local toKill = {}
			local v
			for i=1,limit do
				v = self.threads[i]
				if v then
					if v:status() == "suspended" then
						self.running = i
						local ok,err = v:resume(unpack(event))
						self.running = nil
						if not ok then error(err,0) end
					end
					if v:status() == "dead" then
						toKill[#toKill + 1] = i
					end
				end
			end
			if #toKill > 0 then
				for i=1,#toKill do
					local k = toKill[i]
					self:kill(k)
				end
			end
			return true
		end,
		add = function(self,thr)
			if type(thr) == "function" then
				thr = func(thr)
			end
			checkTypes({self,thr},{"table","table"})
			self.onAdd()
			local i = #self.threads+1
			local id = self.maxID
			thr.id = id
			self.maxID = id + 1
			self.threads[i] = thr
			self.count = i
			self.allended = false
			local ok,err = self.threads[i]:resume{}
			if not ok then error(err,0) end
			return id
		end,
		alive = function(self,i)
			checkTypes({self,i},{"table","number"})
			local thr = self.threads[i]
			return thr and thr:status() == "suspended" or false
		end,
		getID = function(self,i)
			local thr = self.threads[i]
			return thr and thr.id
		end,
		findIndex = function(self,id)
			local v
			for i=1,#self.threads do
				v = self.threads[i]
				if v and v.id == id then
					return i
				end
			end
			return false
		end,
		ended = function(self,id)
			return self.tEnded[id] or false
		end,
	}
end
--dependency: newBasicSystem and newThread
--new C Thread System creates a thread system with layer 1
function newCThreadSystem(...)
	return newBasicSystem(newThread,...)
end
--dependecy: newBasicSystem and newCCThread
--new CC Thread System creates a thread system with layer 2
function newCCThreadSystem(...)
	return newBasicSystem(newCCThread,...)
end
--dependancy: newBasicSystem
--new Pausable system wf (with func: function for converting input functions to threads)
function newPausableSystemWF(func,...)
	local t = newBasicSystem(func,...)
	t.setPause = function(self,i,bool)
		checkTypes({self,i,bool},{"table","number","boolean"})
		local thr = self.threads[i]
		if thr and thr.setPause then
			thr:setPause(bool)
		else
			return nil
		end
	end
	t.getPause = function(self,i)
		checkTypes({self,i},{"table","number"})
		local thr = self.threads[i]
		if thr and type(thr.paused) == "boolean" then
			return thr.paused
		else
			return nil
		end
	end
	t.queueEventAsync = function(self,i,eventdata)
		checkTypes({self,i,eventdata},{"table","number","table"})
		local thr = self.threads[i]
		if thr and thr.events then
			thr.events[#thr.events+1] = eventdata
			return true
		else
			return nil
		end
	end
	t.queueEventSync = function(self,i,eventdata)
		checkTypes({self,i,eventdata},{"table","number","table"})
		local ok = self:queueEventAsync(i,eventdata)
		local thr = self.threads[i]
		if ok and thr and type(thr.paused) == "boolean" and not thr.paused then
			thr:setPause(false) --simulate unpausing so he receives his events
			return true
		end
	end
	return t
end
--dependancy: newPausable and newPausableSystemWF
--new Pausable System returns a layer 3 thread system
function newPausableSystem(...)
	return newPausableSystemWF(newPausable,...)
end
--Advanced systems have changing IDs becuase you have data to identify threads
--dependancy: newPausableSystemWF
--new Adavnced System wf (see newPausableSystemWF)
function newAdvancedSystemWF(func,...)
	local t = newPausableSystemWF(func,...)
	t.setData = function(self,i,key,value)
		checkTypes({self,i},{"table","number"})
		local thr = self.threads[i]
		if thr and thr.data then
			thr.data[key] = value
			return true
		end
		return false
	end
	t.getData = function(self,i,key)
		checkTypes({self,i},{"table","number"})
		local thr = self.threads[i]
		if thr and thr.data then
			return thr.data[key]
		end
		return nil
	end
	t.addMessage = function(self,i,msg)
		checkTypes({self,i,msg},{"table","number","table"})
		local thr = self.threads[i]
		if thr and thr.msgs then
			thr.msgs[#thr.msgs+1] = msg
		end
	end
	t.viewMessage = function(self,i)
		checkTypes({self,i},{"table","number"})
		local thr = self.threads[i]
		if thr and thr.msgs then
			return thr.msgs[1]
		end
		return false
	end
	t.getMessage = function(self,i)
		checkTypes({self,i},{"table","number"})
		local msg = self:viewMessage(i)
		if msg then --We don't need more checks, only remove it
			table.remove(self.threads[i].msgs,1)
		end
		return msg or false
	end
	t.viewMessages = function(self,i)
		checkTypes({self,i},{"table","number"})
		local thr = self.threads[i]
		if thr and thr.msgs then
			local t = {} --just a simple copy function, msgs will not have recursion or metatables, so it's enough
			for k,v in pairs(thr.msgs) do
				t[k] = v
			end
			return t
		end
		return false
	end
	t.getMessages = function(self,i)
		checkTypes({self,i},{"table","number"})
		local msgs = self:viewMessages(i)
		if msgs then
			self.threads[i].msgs = {}
		end
		return msgs or false
	end
	return t
end
--dependancy: newAdvThread and newAdvancedSystemWF
--returns a layer 4 thread system
function newAdvancedSystem(...)
	return newAdvancedSystemWF(newAdvThread,...)
end
--dependancy: newAdvancedSystemWF
function newWindowedSystemWF(func,ue,me)
	ue = ue or usrEvents
	me = me or mouseEvents
	local t = newAdvancedSystemWF(func)
	t.ue = ue --user events
	t.me = me --mouse events
	t.resume = function(self,event)
			checkTypes({self,event},{"table","table"})
			local limit = #self.threads
			if limit == 0 then --check if threads is empty
				return false
			end
			local toRun = {}
			local ename = event[1]
			if ename and self.ue[ename] then
				if self.threads[self.selected] then
					toRun[1] = self.selected
				end
			elseif ename and self.me[ename] then
				local v = self.threads[self.selected]
				if v and v.win then
					--translate mouse events
					local wx,wy = v.win.getPosition()
					local ww,wh = v.win.getSize()
					local x,y = event[3],event[4]
					if x > wx and x < wx + ww and y > wy and y < wy + wh then --event is in the window's bounds
						event[3],event[4] = x-wx,y-wy
						toRun[1] = self.selected
					end
				end
			else
				local v
				for i=1,limit do
					v = self.threads[i]
					if v then
						if v:status() == "suspended" then
							toRun[#toRun+1] = i
						end
					end
				end
			end
			local toKill = {}
			if #toRun > 1 then
				local k,v
				for i=1,#toRun do
					k = toRun[i]
					v = self.threads[k]
					if v and v:status() == "suspended" then
						self.running = k
						local ok,err = v:resume(unpack(event))
						self.running = nil
						if not ok then error(err,0) end
					end
					if v and v:status() == "dead" then
						toKill[#toKill + 1] = i
					end
				end
			end
			for i=1,#toKill do
				self:killWindowed(i)
			end
			return true
		end
	t.addWindowed = function(self,func,win)
		if type(func) == "function" and win then
			func = newWindowed(func,win)
		end
		checkTypes({self,func},{"table","table"})
		return self:add(func)
	end
	t.killWindowed = function(self,i)
		local v = self.threads[i]
		if v and v.used then
			t:kill(i)
		else
			v.co = coroutine.create(coroutine.yield)
		end
	end
	t.getWindow = function(self,i)
		checkTypes({self,i},{"table","number"})
		local thr = self.threads[i]
		if thr then
			return thr.win
		end
		return false
	end
	t.selected = nil
	t.select = function(self,i)
		if self.threads[self.selected] then
			self.threads[self.selected].win.setVisible(false)
		end
		self.selected = i
		local thr = self.threads[self.selected]
		if thr then
			thr.win.setVisible(true)
			thr.used = true
		end
	end
	return t
end
--dependancy: newWindowedSystemWF and newWindowed
function newWindowedSystem()
	return newWindowedSystemWF(newWindowed)
end

--TODO: finally finish windowed and documentation
--TODO: finish and test myshell
	--todo: fix name == nil in myshell

--TODO: add more comments to code - this won't disappear until a long time :( im lazy