require "ui/geometry"
require "ui/device"
require "ui/inputevent"
require "ui/widget"
require "ui/screen"
require "settings" -- for DEBUG(), TODO: put DEBUG() somewhere else


-- initialize the input handling

Input:init()


-- there is only one instance of this
UIManager = {
	-- change this to set refresh type for next refresh
	refresh_type = 1, -- defaults to 1 initially and will be set to 1 after each refresh

	_running = true,
	_window_stack = {},
	_execution_stack = {},
	_dirty = {}
}

-- register & show a widget
function UIManager:show(widget, x, y)
	-- put widget on top of stack
	table.insert(self._window_stack, {x = x or 0, y = y or 0, widget = widget})
	-- and schedule it to be painted
	self:setDirty(widget)
	-- tell the widget that it is shown now
	widget:handleEvent(Event:new("Show"))
end

-- unregister a widget
function UIManager:close(widget)
	local dirty = false
	for i = #self._window_stack, 1, -1 do
		if self._window_stack[i].widget == widget then
			table.remove(self._window_stack, i)
			dirty = true
			break
		end
	end
	if dirty then
		-- schedule remaining widgets to be painted
		for i = 1, #self._window_stack do
			self:setDirty(self._window_stack[i].widget)
		end
	end
end

-- schedule an execution task
function UIManager:schedule(time, action)
	table.insert(self._execution_stack, { time = time, action = action })
end

-- schedule task in a certain amount of seconds (fractions allowed) from now
function UIManager:scheduleIn(seconds, action)
	local when = { util.gettime() }
	local s = math.floor(seconds)
	local usecs = (seconds - s) * 1000000
	when[1] = when[1] + s
	when[2] = when[2] + usecs
	if when[2] > 1000000 then
		when[1] = when[1] + 1
		when[2] = when[2] - 1000000
	end
	self:schedule(when, action)
end

-- register a widget to be repainted
function UIManager:setDirty(widget, refresh_type)
	if not refresh_type then
		refresh_type = "full"
	elseif refresh_type == 0 then
		refresh_type = "full"
	elseif refresh_type == 1 then
		refresh_type = "partial"
	end
	self._dirty[widget] = refresh_type
end

-- signal to quit
function UIManager:quit()
	self._running = false
end

-- transmit an event to registered widgets
function UIManager:sendEvent(event)
	-- top level widget has first access to the event
	local consumed = self._window_stack[#self._window_stack].widget:handleEvent(event)

	-- if the event is not consumed, always-active widgets can access it
	for _, widget in ipairs(self._window_stack) do
		if consumed then
			break
		end
		if widget.widget.is_always_active then
			consumed = widget.widget:handleEvent(event)
		end
	end
end

-- this is the main loop of the UI controller
-- it is intended to manage input events and delegate
-- them to dialogs
function UIManager:run()
	self._running = true
	while self._running do
		local now = { util.gettime() }

		-- check if we have timed events in our queue and search next one
		local wait_until = nil
		local all_tasks_checked
		repeat
			all_tasks_checked = true
			for i = #self._execution_stack, 1, -1 do
				local task = self._execution_stack[i]
				if not task.time
					or task.time[1] < now[1]
					or task.time[1] == now[1] and task.time[2] < now[2] then
					-- task is pending to be executed right now. do it.
					task.action()
					-- and remove from table
					table.remove(self._execution_stack, i)
					-- start loop again, since new tasks might be on the
					-- queue now
					all_tasks_checked = false
				elseif not wait_until
					or wait_until[1] > task.time[1]
					or wait_until[1] == task.time[1] and wait_until[2] > task.time[2] then
					-- task is to be run in the future _and_ is scheduled
					-- earlier than the tasks we looked at already
					-- so adjust to the currently examined task instead.
					wait_until = task.time
				end
			end
		until all_tasks_checked

		--DEBUG("---------------------------------------------------")
		--DEBUG("exec stack", self._execution_stack)
		--DEBUG("window stack", self._window_stack)
		--DEBUG("dirty stack", self._dirty)
		--DEBUG("---------------------------------------------------")

		-- stop when we have no window to show (bug)
		if #self._window_stack == 0 then
			error("no dialog left to show, would loop endlessly")
		end

		-- repaint dirty widgets
		local dirty = false
		local update_area = Geom:new{}
		for _, widget in ipairs(self._window_stack) do
			if self._dirty[widget.widget] then
				widget_dimen = widget.widget:getSize()
				if widget_dimen then
					widget_area = Geom:new{
										x = widget.x, y = widget.y,
										w = widget_dimen.w, h = widget_dimen.h}
					update_area = update_area:combine(widget_area)
				end
				widget.widget:paintTo(Screen.fb.bb, widget.x, widget.y)
				if self._dirty[widget.widget] == "full" then
					self.refresh_type = 0
				end
				-- and remove from list after painting
				self._dirty[widget.widget] = nil
				-- trigger repaint
				dirty = true
			end
		end
		-- @TODO make use of update_area on refresh  19.06 2012 (houqp)
		--DEBUG(update_area)

		if dirty then
			-- refresh FB
			Screen.fb:refresh(self.refresh_type) -- TODO: refresh explicitly only repainted area
			-- reset refresh_type
			self.refresh_type = 1
		end

		-- wait for next event
		-- note that we will skip that if in the meantime we have tasks that are ready to run
		local input_event = nil
		if not wait_until then
			-- no pending task, wait endlessly
			input_event = Input:waitEvent()
		elseif wait_until[1] > now[1]
		or wait_until[1] == now[1] and wait_until[2] > now[2] then
			local wait_for = { s = wait_until[1] - now[1], us = wait_until[2] - now[2] }
			if wait_for.us < 0 then
				wait_for.s = wait_for.s - 1
				wait_for.us = 1000000 + wait_for.us
			end
			-- wait until next task is pending
			input_event = Input:waitEvent(wait_for.us, wait_for.s)
		end

		-- delegate input_event to handler
		if input_event then
			self:sendEvent(input_event)
		end
	end
end