lws

local unpack = unpack or table.unpack

local function saveDimensions(proc)
	--saves window dimensions when closing windows
	if proc.path and proc.windows and #proc.windows > 0 then
		local wInfo = {}
		if proc.windows[#proc.windows].maximized then
			wInfo.x = proc.windows[#proc.windows].normalSize.x
			wInfo.y = proc.windows[#proc.windows].normalSize.y
			wInfo.w = proc.windows[#proc.windows].normalSize.w
			wInfo.h = proc.windows[#proc.windows].normalSize.h
		else
			wInfo.x = proc.windows[#proc.windows].x
			wInfo.y = proc.windows[#proc.windows].y
			wInfo.w = proc.windows[#proc.windows].w
			wInfo.h = proc.windows[#proc.windows].h
		end
		wInfo.max = tostring(proc.windows[#proc.windows].maximized)
		local lines = {}
		if fs.exists(fs.combine(LyqydOS.folderPath, ".lyqwin")) then
			local dimsFile = io.open(fs.combine(LyqydOS.folderPath, ".lyqwin"), "r")
			if dimsFile then
				for line in dimsFile:lines() do
					if string.match(line, "%d+,%d+,%d+,%d+,%a+,(.*)") ~= proc.path then
						table.insert(lines, line)
					end
				end
				dimsFile:close()
			end
		end
		table.insert(lines, wInfo.x..","..wInfo.y..","..wInfo.w..","..wInfo.h..","..wInfo.max..","..proc.path)

		winDims = io.open(fs.combine(LyqydOS.folderPath, ".lyqwin"), "w")
		if winDims then
			for _, line in ipairs(lines) do
				winDims:write(line.."\n")
			end
			winDims:close()
		end
	end
end

local function windowAction(pID, win)
	--index 2 should be the pID and 3 should be the window, forward compat for child windows.
	if process.list[process.focus] then
		local parent = process.focus
		local proc = process.list[parent]
		local lwsProc = process.getFromName("lws")
		local thisProc = process.this()
		local x, y
		if win.minimized then
			x, y = 1, 2
		else
			x, y = win.x, win.y + 1
		end
		local lwsWin = window.new(15, 9, x, y, "Action Menu", process.compositor:newBuffer(process.id()))
		thisProc:addWindow(lwsWin)
		lwsWin:setMode("ephemeral")
		lwsWin:setType("menu")
		lwsWin:setTheme(LyqydOS.window.theme)
		process.focus = process.id()
		local _old = term.redirect(lwsWin.redirect)
		local success, selection = pcall(menu.select, {"Restore", "Move", "Resize", "Minimize", "Maximize", "Close", "Cancel"})
		if _old then
			term.redirect(_old)
		else
			term.restore()
		end
		thisProc:removeWindow(lwsWin)

		if success then
			if selection == 1 then
				--restore
				if win.maximized then
					win:restore()
					proc:queue("window_resize")
					proc:queue("term_resize")
				elseif win.minimized then
					win:unMinimize()
					proc:toFront(win)
					win:draw()
				end
			elseif selection == 2 then
				--move
				while true do
					e, p1, p2, p3 = os.pullEvent()
					if e == "key" then
						if p1 == 200 then
							--up
							win:move(win.x, win.y - 1)
							win:draw()
						elseif p1 == 203 then
							--left
							win:move(win.x - 1, win.y)
							win:draw()
						elseif p1 == 205 then
							--right
							win:move(win.x + 1, win.y)
							win:draw()
						elseif p1 == 208 then
							--down
							win:move(win.x, win.y + 1)
							win:draw()
						elseif p1 == 28 then
							--enter
							break
						end
					elseif e == "mouse_click" and p1 == 1 then
						--mouse click
						win:move(p2, p3)
						win:draw()
						break
					end
				end
			elseif selection == 3 then
				--resize
				win.maximized = false
				while true do
					e, p1 = os.pullEvent()
					if e == "key" then
						if p1 == 200 then
							--up
							win:resize(win.w, win.h - 1)
							proc:queue("window_resize")
							proc:queue("term_resize")
						elseif p1 == 203 then
							--left
							win:resize(win.w - 1, win.h)
							proc:queue("window_resize")
							proc:queue("term_resize")
						elseif p1 == 205 then
							--right
							win:resize(win.w + 1, win.h)
							proc:queue("window_resize")
							proc:queue("term_resize")
						elseif p1 == 208 then
							--down
							win:resize(win.w, win.h + 1)
							proc:queue("window_resize")
							proc:queue("term_resize")
						elseif p1 == 28 then
							--enter
							break
						end
					end
				end
			elseif selection == 4 then
				--minimize
				if not win.minimized then
					win:minimize()
					--also move the window to the bottom of the buffer stack.
					proc:toBack()
					win:draw()
				end
			elseif selection == 5 then
				--maximize
				if not win.maximized then
					win:maximize()
					if win.minimized then win:unMinimize() end
					proc:queue("window_resize")
					proc:queue("term_resize")
				end
			elseif selection == 6 then
				--close
				proc:queue("window_close", win)
				if win.closable then
					lwsProc:queue("close_window", pID, win)
				end
			end
			process.focus = parent
		end
	end
end

local function windowSelect()
	local oldFocus = process.focus
	local lws = process.id()
	local lwsProc = process.list[lws]
	local lwsWin = window.new(19, 11, 1, 1, "Select Window", process.compositor:newBuffer(lws))
	lwsProc:addWindow(lwsWin)
	lwsWin:setMode("ephemeral")
	lwsWin:setTheme(LyqydOS.window.theme)
	lwsWin:setType("menu")
	process.focus = lws
	local _old = term.redirect(lwsWin.redirect)
	local pList, menuList = {}, {}
	for pID, proc in ipairs(process.list) do
		if proc and proc.windows and proc.windows.selectable and #proc.windows > 0 then
			table.insert(pList, pID)
			table.insert(menuList, proc.windows[#proc.windows].caption)
		end
	end
	--removes self from list of running programs.
	table.remove(menuList)
	table.remove(pList)
	table.insert(menuList, "Cancel")
	local success, selection = pcall(menu.select, menuList)
	if _old then
		term.redirect(_old)
	else
		term.restore()
	end
	lwsProc:removeWindow(lwsWin)
	if success then
		if pList[selection] then
			process.focus = pList[selection]
			local proc = process.list[process.focus]
			local win = proc.windows[#proc.windows]
			if win.minimized then win:unMinimize() end
			proc:toFront()
		else
			process.focus = oldFocus
		end
	end
end

local function findWindow(x, y)
	for i = #process.compositor.bufferStack, 1, -1 do
		for pID, proc in ipairs(process.list) do
			if proc and proc.windows then
				for j = #proc.windows, 1, -1 do
					local win = proc.windows[j]
					if win.target.buffer == process.compositor.bufferStack[i] and not win.minimized then
						if x >= win.x and x <= win.x + win.w - 1 and y >= win.y and y <= win.y + win.h - 1 then
							return pID, proc, j, win
						end
					end
				end
			end
		end
	end
end

local lws = process.id()
local lwsProc = process.list[lws]
local watchMouseDragging = false
local mouseStartX = nil
local mouseStartY = nil
local mouseDragAction = nil
--injection magic table, localized here for use later.
local procTable = getmetatable(process.this()).__index
local oldPcheck, oldPkill, oldPremove, oldPsetup, oldPpost
process.addHook({"char"})
process.addHook({"key"})
--process.addHook({"key", 61})
--process.addHook({"key", 62})
process.addHook({"key_up"})
process.addHook({"mouse_click"})
process.addHook({"mouse_drag"})
process.addHook({"mouse_scroll"})
process.addHook({"mouse_up"})

do
	if LyqydOS.shell and LyqydOS.shell.multishell then
		LyqydOS.shell.multishell.getTitle = function(n)
			if process.list[n] and process.list[n].windows and #process.list[n].windows >= 1 then
				return process.list[n].windows[#process.list[n].windows].caption
			end
		end

		LyqydOS.shell.multishell.setTitle = function(n, title)
			if process.list[n] and process.list[n].windows and #process.list[n].windows >= 1 then
				process.list[n].windows[#process.list[n].windows].caption = title
			end
		end

		LyqydOS.shell.multishell.getCount = function()
			return #process.list
		end

		LyqydOS.shell.multishell.launch = function(env, path, ...)
			local focus = process.focus
			local args = {...}
			local startProcess = process.id()
			if path then
				local w, h, x, y, max = 19, 9, 1, 1, "false"
				windowDimensions = {}
				winDims = io.open(fs.combine(LyqydOS.folderPath, ".lyqwin"), "r")
				if winDims then
					for line in winDims:lines() do
						if string.match(line, "%d+,%d+,%d+,%d+,%a+,(.*)") == path then
							x, y, w, h, max = string.match(line, "(%d+),(%d+),(%d+),(%d+),(%a+),")
							break
						end
					end
					winDims:close()
				end
				local win = window.new(w, h, x, y, fs.getName(path), process.compositor:newBuffer(#process.list + 1))
				if process.compositor.target.isColor() then
					win:setType("window")
				end
				win:setTheme(LyqydOS.window.theme)
				if max == "true" then win:maximize() end
				process.new(function() os.run(env, shell.resolveProgram("lsh"), path, unpack(args)) end, shell.resolveProgram("lsh"), nil, win)
				if coroutine.status(process.list[process.focus].thread) == "dead" then
					process.getFromName("lws"):queue("close_window", process.focus)
					process.focus = startProcess
				end
				if focus then
					process.focus = focus
				end
			end
		end

		LyqydOS.shell.multishell.getCurrent = function()
			return process.id()
		end

		LyqydOS.shell.multishell.getFocus = function()
			return process.focus
		end

		LyqydOS.shell.multishell.setFocus = function(n)
			process.focus = n
		end

		LyqydOS.shell.shell.openTab = function(...)
			local env = {shell = LyqydOS.shell.shell, multishell = LyqydOS.shell.multishell}
			local command = table.concat({...}, " ")
			local args = {}
			for match in string.gmatch(command, "[^ \t]+") do
				table.insert(args, match)
			end
			local path = table.remove(args, 1)
			LyqydOS.shell.multishell.launch(env, path, unpack(args))
		end

		LyqydOS.shell.shell.switchTab = function(n)
			LyqydOS.shell.multishell.setFocus(n)
		end
	end
	do
		function process.getWindow()
			if process.active and process.list[process.active] and process.list[process.active].windows and #process.list[process.active].windows >= 1 then
				return process.list[process.active].windows[#process.list[process.active].windows]
			else
				return nil, "No window!"
			end
		end

		function process.nextWindow(default)
			local nextBuf = process.compositor.bufferStack[#process.compositor.bufferStack]
			for pID, proc in ipairs(process.list) do
				if proc then
					for i = 1, #proc.windows do
						if proc.windows[i].target.buffer == nextBuf then
							return pID
						end
					end
				end
			end
			return default
		end

		--injection magic.
		function procTable.addWindow(self, win)
			local newWindow = true
			for i = 1, #self.windows do
				if self.windows[i] == win then
					newWindow = false
					break
				end
			end
			if newWindow then
				table.insert(self.windows, win)
			end
		end

		function procTable.removeWindow(self, win)
			local winFound = false
			for i = 1, #self.windows do
				if self.windows[i] == win then
					table.remove(self.windows, i)
					winFound = true
					break
				end
			end
			if winFound then
				win:destroy()
			end
		end

		function procTable.toFront(self, win)
			--win is optional, if not specified will maintain order of windows.
			if win then
				for i = 1, #self.windows do
					if self.windows[i] == win then
						table.insert(self.windows, table.remove(self.windows, i))
						break
					end
				end
			end
			for i = 1, #self.windows do
				for j = 1, #process.compositor.bufferStack do
					if process.compositor.bufferStack[j] == self.windows[i].target.buffer then
						process.compositor:toFront(j)
						break
					end
				end
			end
		end

		function procTable.toBack(self, win)
			--win is optional, will move that window to behind the rest of them, as well as moving the whole set to the bottom of the stack.
			if #self.windows >= 1 then
				if win then
					for i = 1, #self.windows do
						if self.windows[i] == win then
							table.insert(self.windows, 1, table.remove(self.windows, i))
							break
						end
					end
				end

				for i = 1, #self.windows do
					for j = 1, #process.compositor.bufferStack do
						if self.windows[i].target.buffer == process.compositor.bufferStack[j] then
							process.compositor:toBack(j)
							break
						end
					end
				end
			end

			process.focus = process.next()
			if process.list[process.focus] then
				process.list[process.focus]:toFront()
			end
		end

		--localized above to allow resetting later.
		oldPcheck = procTable.check

		function procTable.check(self)
			if not oldPcheck(self) then lwsProc:queue("close_window", self.id); return false end
			if self.windows then
				for i = 1, #self.windows do
					if self.windows[i].mode == "ephemeral" and (i < #self.windows or self.id ~= process.focus) then
						--kill the individual window
						lwsProc:resume({"close_window", self.id, self.windows[i]})
					end
				end
			end
			return true
		end

		--localized above to allow resetting later,
		oldPkill = procTable.kill

		function procTable.kill(self)
			if self.windows then
				for _, win in ipairs(self.windows) do
					if win.destroy then
						win:destroy()
					end
				end
			end
			return oldPkill(self)
		end

		oldPremove = procTable.remove

		function procTable.remove(self)
			oldPremove(self)
			if process.focus then
				process.list[process.focus]:toFront()
			end
		end

		oldPsetup = procTable.setup

		function procTable.setup(self, path, redirect, ...)
			local args = {...}
			self.windows = {
				selectable = true,
			}

			if args[1] then
				table.insert(self.windows, args[1])
				self.redirect = args[1].redirect
				process.focus = #process.list
			elseif redirect then
				self.redirect = redirect
			else
				self.redirect = process.nullRedirect
			end

			return oldPsetup(self, unpack(args))
		end

		oldPpost = procTable.post

		function procTable.post(self, ...)
			if self.windows then
				for _, win in ipairs(self.windows) do
					win:draw()
				end
			end
			return oldPpost(self, ...)
		end
	end
end

while true do
	local event = {os.pullEventRaw()}
	if event[1] == "key" then
		if event[2] == 61 then
			if process.focus and process.list[process.focus] then
				lwsProc:queue("select_window")
			end
		elseif event[2] == 62 then
			if process.focus and process.list[process.focus] then
				lwsProc:queue("window_action", process.focus, process.list[process.focus].windows[#process.list[process.focus].windows])
			end
		elseif not process.eventHooks.key[event[2]] then
			if process.focus and process.list[process.focus] then
				process.list[process.focus]:resume(event)
			end
		end
	elseif event[1] == "key_up" or event[1] == "char" and not process.eventHooks[event[1]][event[2]] then
		if process.focus and process.list[process.focus] then
			process.list[process.focus]:resume(event)
		end
	elseif event[1] == "mouse_click" then
		watchMouseDragging = false
		local windowFound = false
		local pID, proc, winNum, win = findWindow(event[3], event[4])
		if pID and proc and win then
			if process.focus ~= pID then
				process.focus = pID
				proc:toFront(win)
			elseif winNum < #proc.windows then
				local modalFound = false
				for k = #proc.windows, 1, -1 do
					if proc.windows[k].mode == "modal" then
						modalFound = true
						break
					elseif proc.windows[k].mode == "normal" then
						break
					end
				end
				if not modalFound then
					--no modal window active in this application, so move window to top.
					proc:toFront(win)
				end
			end
			local x, y = event[3] - win.x, event[4] - win.y
			if win.borderless then
				--mouse click, resume.
				x = x + 1
				y = y + 1
				if x > 0 and x < win.w + 1 and y > 0 and y < win.h + 1 then
					event[3], event[4] = x, y
					proc:resume(event)
				end
			else
				if x > 0 and x < win.w - 1 and y > 0 and y < win.h - 1 then
					--mouse click resume
					event[3], event[4] = x, y
					proc:resume(event)
				elseif y == 0 and event[2] == 2 then
					--right click on window title bar, open window menu.
					if win.mode ~= "ephemeral" then
						lwsProc:queue("window_action", pID, win)
					end
				elseif (win.windowType == "modal" or win.windowType == "window") and y == 0 and event[2] == 1 then
					local function findTransformedX(position)
						if position < 0 then
							return win.w + position
						elseif position > 0 then
							return position - 1
						end
					end
					if x == findTransformedX(win.decorations.closePos) then
						--close window
						proc:queue("window_close", win)
						if win.closable then
							lwsProc:queue("close_window", pID, win)
						end
					elseif win.windowType == "window" then
						if x == findTransformedX(win.decorations.minPos) then
							--minimize
							win:minimize()
							local allMin = true
							for k = 1, #proc.windows do
								if proc.windows[k].minimized == false then
									allMin = false
								end
							end
							if allMin then
								proc:toBack()
							end
							win:draw()
						elseif x == findTransformedX(win.decorations.maxPos) then
							if win.resizable then
								if win.maximized then
									win:restore()
									proc:queue("window_resize")
									proc:queue("term_resize")
									win:draw()
								else
									win:maximize()
									proc:queue("window_resize")
									proc:queue("term_resize")
									win:draw()
								end
							end
						else
							watchMouseDragging = true
							mouseDragAction = "move"
							mouseStartX = event[3]
							mouseStartY = event[4]
						end
					else
						watchMouseDragging = true
						mouseDragAction = "move"
						mouseStartX = event[3]
						mouseStartY = event[4]
					end
				elseif y == 0 and event[2] == 1 and win.windowType ~= "menu" and not proc.special then
					--clicked on titlebar, set variables to see if we drag.
					watchMouseDragging = true
					mouseDragAction = "move"
					mouseStartX = event[3]
					mouseStartY = event[4]
				elseif x == win.w - 1 and y == win.h - 1 and event[2] == 1 and not proc.special then
					--clicked on lower right corner, resize.
					watchMouseDragging = true
					mouseDragAction = "resize"
					mouseStartX = event[3]
					mouseStartY = event[4]
				end
			end
		end
	elseif event[1] == "mouse_drag" then
		--mouse is dragging, see if we need to do something with windows.
		if watchMouseDragging then
			local proc = process.list[process.focus]
			if mouseDragAction == "move" then
				proc.windows[#proc.windows]:move(proc.windows[#proc.windows].x + (event[3] - mouseStartX), proc.windows[#proc.windows].y + (event[4] - mouseStartY))
				mouseStartX = event[3]
				mouseStartY = event[4]
				proc.windows[#proc.windows]:draw()
			elseif mouseDragAction == "resize" then
				proc.windows[#proc.windows]:resize(proc.windows[#proc.windows].w + (event[3] - mouseStartX), proc.windows[#proc.windows].h + (event[4] - mouseStartY))
				mouseStartX = event[3]
				mouseStartY = event[4]
				proc.windows[#proc.windows].maximized = false
				proc:queue("window_resize")
				proc:queue("term_resize")
			end
		else
			local pID, proc, winNum, win = findWindow(event[3], event[4])
			if pID and proc and winNum and win then
				event[3] = event[3] - win.x
				event[4] = event[4] - win.y
				if event[3] > 0 and event[3] < win.w - 1 and event[4] > 0 and event[4] < win.h - 1 then
					proc:resume(event)
				end
			end
		end
	elseif event[1] == "mouse_scroll" then
		local pID, proc, winNum, win = findWindow(event[3], event[4])
		if pID and proc and winNum and win then
			event[3] = event[3] - win.x
			event[4] = event[4] - win.y
			if event[3] > 0 and event[3] < win.w - 1 and event[4] > 0 and event[4] < win.h - 1 then
				proc:resume(event)
			end
		end
	elseif event[1] == "mouse_up" then
		local pID, proc, winNum, win = findWindow(event[3], event[4])
		if pID and proc and winNum and win then
			event[3] = event[3] - win.x
			event[4] = event[4] - win.y
			if event[3] > 0 and event[3] < win.w - 1 and event[4] > 0 and event[4] < win.h - 1 then
				proc:resume(event)
			end
		end
	elseif event[1] == "window_action" then
		process.new(function() windowAction(event[2], event[3]) end, "lwsa")
	elseif event[1] == "select_window" then
		process.new(windowSelect, "lwss")
	elseif event[1] == "close_window" then
		--index 2 is pID, index 3 is window index.
		if process.list[event[2]] and process.list[event[2]].windows then
			local proc = process.list[event[2]]
			if event[3] then
				if #proc.windows == 1 then
					saveDimensions(proc)
					proc:kill()
				else
					proc:removeWindow(event[3])
					event[3]:destroy()
				end
			else
				saveDimensions(proc)
				proc:kill()
			end
		end
	elseif event[1] == "service_stop" then
		process.removeHook({"char"})
		process.removeHook({"key"})
		--process.removeHook({"key", 61})
		--process.removeHook({"key", 62})
		process.removeHook({"key_up"})
		process.removeHook({"mouse_click"})
		process.removeHook({"mouse_drag"})
		process.removeHook({"mouse_scroll"})
		process.removeHook({"mouse_up"})
		--clean up injected methods:
		procTable.addWindow = nil
		procTable.removeWindow = nil
		procTable.toFront = nil
		procTable.toBack = nil
		procTable.check = oldPcheck
		procTable.kill = oldPkill
		procTable.setup = oldPsetup
		procTable.post = oldPpost
		return
	elseif event[1] == "start_program" then
		--2, program path
		--3, start in background
		local focus
		if event[3] then
			focus = process.focus
		end
		local args = {}
		for match in string.gmatch( event[2], "[^ \t]+" ) do
			table.insert( args, match )
		end
		local startProcess = process.id()
		shell.setDir("")
		path = shell.resolveProgram(table.remove(args, 1))
		if path then
			local w, h, x, y, max = 19, 9, 1, 1, "false"
			windowDimensions = {}
			winDims = io.open(fs.combine(LyqydOS.folderPath, ".lyqwin"), "r")
			if winDims then
				for line in winDims:lines() do
					if string.match(line, "%d+,%d+,%d+,%d+,%a+,(.*)") == path then
						x, y, w, h, max = string.match(line, "(%d+),(%d+),(%d+),(%d+),(%a+),")
						break
					end
				end
				winDims:close()
			end
			local win = window.new(w, h, x, y, fs.getName(path), process.compositor:newBuffer(#process.list + 1))
			if process.compositor.target.isColor() then
				win:setType("window")
			end
			win:setTheme(LyqydOS.window.theme)
			if max == "true" then win:maximize() end
			process.new(function() shell.run("lsh", path, unpack(args)) end, shell.resolveProgram("lsh"), nil, win)
			if coroutine.status(process.list[process.focus].thread) == "dead" then
				lwsProc:queue("close_window", process.focus)
				process.focus = startProcess
			end
			win.deferDraw = true
			if focus then
				process.focus = focus
			end
		end
	end
end