local M = {}

local awful = require("awful")
local desktop = require("desktop")
local object = require("gears.object")

local Workspace = {}

function Workspace:add_desktop(name, nb_pages)
    idx = #self.desktops + 1
    self.desktops[idx] = desktop.new(idx, name, nb_pages, self.layouts[1])
    return idx
end

function Workspace:_apply_state()
    orig_focus = mouse.screen

    for s = 1, screen.count() do
        if self.screen_state[s] then
            awful.tag.viewnone(s)

            desk = self.screen_state[s].desktop
            page = self.desktops[desk].pages[self.screen_state[s].page]
            awful.tag.setscreen(page, s)
        end
    end
    for s = 1, screen.count() do
        state = self.screen_state[s]
        if state then
            desk_idx = state.desktop
            desk     = self.desktops[desk_idx]
            page_idx = state.page
            page     = desk.pages[page_idx]
            print("workspace displaying: " .. s .. " => " .. desk_idx .. "/" .. page_idx)

            awful.tag.viewonly(page)

            desk:emit_signal("page:view", s, page_idx)
        end
    end

    awful.screen.focus(orig_focus)
end

function Workspace:view(screen, desktop, page_idx)
    print("workspace: " .. screen .. ": view " .. desktop .. "/" .. (page_idx or "nil"))
    -- the page currently displayed on the target screen
    old = {}
    if self.screen_state[screen] then
        old.desk     = self.screen_state[screen].desktop
        old.page_idx = self.screen_state[screen].page
        old.page     = self.desktops[old.desk].pages[page_old_idx]
        print(screen .. " now showing " .. old.desk .. "/" .. old.page_idx)
    end

    -- the page to display on the target screen
    page_idx = self.desktops[desktop]:show(screen, page_idx)
    if page_idx then
        page_new = self.desktops[desktop].pages[page_idx]
    end

    -- the screen on which the new page is currently displayed (if any)
    screen_cur = nil
    if page_new and page_new.selected then
        screen_cur = awful.tag.getscreen(page_new)
        print("page " .. page_idx .. " now displayed on " .. screen_cur)
    end

    if old.page ~= page_new or page_new == nil then
        self.screen_state[screen] = { page = page_idx, desktop = desktop }
        if desktop ~= old.desk then
            self.signals:emit_signal("desktop:view", screen, desktop)
        end

        if screen_cur then
            desk_prev = self.screen_state[screen_cur].desktop
            old.page_idx = self.desktops[old.desk]:show(screen_cur, old.page_idx)

            self.screen_state[screen_cur] = { page = old.page_idx, desktop = old.desk }
            if desk_prev ~= old.desk then
                self.signals:emit_signal("desktop:view", screen_cur, old.desk)
            end
        end


        self:_apply_state()
    end
end

function Workspace:view_relative(offset, screen)
    screen = screen or mouse.screen
    print("view relative " .. offset .. " on " .. screen)

    state = self.screen_state[screen]
    if state then
        desk = state.desktop
        print("state " .. state.page .. " res " .. (state.page + offset) % 10)
        page = 1 + ((state.page - 1 + offset) % #self.desktops[desk].pages)
        print("desk " .. desk .. " " .. #self.desktops[desk].pages)
        print("view relative switch to " .. page)

        self:view(screen, desk, page)
    end
end

function Workspace:move_client(client, desk, page)
    print("move to " .. desk .. "/" .. page)
    awful.client.movetotag(self.desktops[desk].pages[page], client)
end

function Workspace:new(layouts)
    local o = setmetatable({}, self)
    self.__index = self

    o.desktops     = {}
    o.screen_state = {}
    o.layouts      = layouts

    o.signals   = object()
    o.signals:add_signal("desktop:view")

    return o
end

M.Workspace = Workspace

return M